/*!
FullCalendar iCalendar Plugin v6.0.3
Docs & License: https://fullcalendar.io/docs/icalendar
(c) 2022 Adam Shaw
*/
FullCalendar.ICalendar = (function (exports, core, internal, ICAL) {
    'use strict';

    function _interopNamespace(e) {
        if (e && e.__esModule) return e;
        var n = Object.create(null);
        if (e) {
            Object.keys(e).forEach(function (k) {
                if (k !== 'default') {
                    var d = Object.getOwnPropertyDescriptor(e, k);
                    Object.defineProperty(n, k, d.get ? d : {
                        enumerable: true,
                        get: function () { return e[k]; }
                    });
                }
            });
        }
        n["default"] = e;
        return n;
    }

    var ICAL__namespace = /*#__PURE__*/_interopNamespace(ICAL);

    /* eslint-disable */
    class IcalExpander {
        constructor(opts) {
            this.maxIterations = opts.maxIterations != null ? opts.maxIterations : 1000;
            this.skipInvalidDates = opts.skipInvalidDates != null ? opts.skipInvalidDates : false;
            this.jCalData = ICAL__namespace.parse(opts.ics);
            this.component = new ICAL__namespace.Component(this.jCalData);
            this.events = this.component.getAllSubcomponents('vevent').map(vevent => new ICAL__namespace.Event(vevent));
            if (this.skipInvalidDates) {
                this.events = this.events.filter((evt) => {
                    try {
                        evt.startDate.toJSDate();
                        evt.endDate.toJSDate();
                        return true;
                    }
                    catch (err) {
                        // skipping events with invalid time
                        return false;
                    }
                });
            }
        }
        between(after, before) {
            function isEventWithinRange(startTime, endTime) {
                return (!after || endTime >= after.getTime()) &&
                    (!before || startTime <= before.getTime());
            }
            function getTimes(eventOrOccurrence) {
                const startTime = eventOrOccurrence.startDate.toJSDate().getTime();
                let endTime = eventOrOccurrence.endDate.toJSDate().getTime();
                // If it is an all day event, the end date is set to 00:00 of the next day
                // So we need to make it be 23:59:59 to compare correctly with the given range
                if (eventOrOccurrence.endDate.isDate && (endTime > startTime)) {
                    endTime -= 1;
                }
                return { startTime, endTime };
            }
            const exceptions = [];
            this.events.forEach((event) => {
                if (event.isRecurrenceException())
                    exceptions.push(event);
            });
            const ret = {
                events: [],
                occurrences: [],
            };
            this.events.filter(e => !e.isRecurrenceException()).forEach((event) => {
                const exdates = [];
                event.component.getAllProperties('exdate').forEach((exdateProp) => {
                    const exdate = exdateProp.getFirstValue();
                    exdates.push(exdate.toJSDate().getTime());
                });
                // Recurring event is handled differently
                if (event.isRecurring()) {
                    const iterator = event.iterator();
                    let next;
                    let i = 0;
                    do {
                        i += 1;
                        next = iterator.next();
                        if (next) {
                            const occurrence = event.getOccurrenceDetails(next);
                            const { startTime, endTime } = getTimes(occurrence);
                            const isOccurrenceExcluded = exdates.indexOf(startTime) !== -1;
                            // TODO check that within same day?
                            const exception = exceptions.find(ex => ex.uid === event.uid && ex.recurrenceId.toJSDate().getTime() === occurrence.startDate.toJSDate().getTime());
                            // We have passed the max date, stop
                            if (before && startTime > before.getTime())
                                break;
                            // Check that we are within our range
                            if (isEventWithinRange(startTime, endTime)) {
                                if (exception) {
                                    ret.events.push(exception);
                                }
                                else if (!isOccurrenceExcluded) {
                                    ret.occurrences.push(occurrence);
                                }
                            }
                        }
                    } while (next && (!this.maxIterations || i < this.maxIterations));
                    return;
                }
                // Non-recurring event:
                const { startTime, endTime } = getTimes(event);
                if (isEventWithinRange(startTime, endTime))
                    ret.events.push(event);
            });
            return ret;
        }
        before(before) {
            return this.between(undefined, before);
        }
        after(after) {
            return this.between(after);
        }
        all() {
            return this.between();
        }
    }

    const eventSourceDef = {
        parseMeta(refined) {
            if (refined.url && refined.format === 'ics') {
                return {
                    url: refined.url,
                    format: 'ics',
                };
            }
            return null;
        },
        fetch(arg, successCallback, errorCallback) {
            let meta = arg.eventSource.meta;
            let { internalState } = meta;
            /*
            NOTE: isRefetch is a HACK. we would do the recurring-expanding in a separate plugin hook,
            but we couldn't leverage built-in allDay-guessing, among other things.
            */
            if (!internalState || arg.isRefetch) {
                internalState = meta.internalState = {
                    response: null,
                    iCalExpanderPromise: fetch(meta.url, { method: 'GET' }).then((response) => {
                        return response.text().then((icsText) => {
                            internalState.response = response;
                            return new IcalExpander({
                                ics: icsText,
                                skipInvalidDates: true,
                            });
                        });
                    }),
                };
            }
            internalState.iCalExpanderPromise.then((iCalExpander) => {
                successCallback({
                    rawEvents: expandICalEvents(iCalExpander, arg.range),
                    response: internalState.response,
                });
            }, errorCallback);
        },
    };
    function expandICalEvents(iCalExpander, range) {
        // expand the range. because our `range` is timeZone-agnostic UTC
        // or maybe because ical.js always produces dates in local time? i forget
        let rangeStart = internal.addDays(range.start, -1);
        let rangeEnd = internal.addDays(range.end, 1);
        let iCalRes = iCalExpander.between(rangeStart, rangeEnd); // end inclusive. will give extra results
        let expanded = [];
        // TODO: instead of using startDate/endDate.toString to communicate allDay,
        // we can query startDate/endDate.isDate. More efficient to avoid formatting/reparsing.
        // single events
        for (let iCalEvent of iCalRes.events) {
            expanded.push(Object.assign(Object.assign({}, buildNonDateProps(iCalEvent)), { start: iCalEvent.startDate.toString(), end: (specifiesEnd(iCalEvent) && iCalEvent.endDate)
                    ? iCalEvent.endDate.toString()
                    : null }));
        }
        // recurring event instances
        for (let iCalOccurence of iCalRes.occurrences) {
            let iCalEvent = iCalOccurence.item;
            expanded.push(Object.assign(Object.assign({}, buildNonDateProps(iCalEvent)), { start: iCalOccurence.startDate.toString(), end: (specifiesEnd(iCalEvent) && iCalOccurence.endDate)
                    ? iCalOccurence.endDate.toString()
                    : null }));
        }
        return expanded;
    }
    function buildNonDateProps(iCalEvent) {
        return {
            title: iCalEvent.summary,
            url: extractEventUrl(iCalEvent),
            extendedProps: {
                location: iCalEvent.location,
                organizer: iCalEvent.organizer,
                description: iCalEvent.description,
            },
        };
    }
    function extractEventUrl(iCalEvent) {
        let urlProp = iCalEvent.component.getFirstProperty('url');
        return urlProp ? urlProp.getFirstValue() : '';
    }
    function specifiesEnd(iCalEvent) {
        return Boolean(iCalEvent.component.getFirstProperty('dtend')) ||
            Boolean(iCalEvent.component.getFirstProperty('duration'));
    }

    var plugin = core.createPlugin({
        name: '@fullcalendar/icalendar',
        eventSourceDefs: [eventSourceDef],
    });

    core.globalPlugins.push(plugin);

    exports["default"] = plugin;

    Object.defineProperty(exports, '__esModule', { value: true });

    return exports;

})({}, FullCalendar, FullCalendar.Internal, ICAL);