Theme Assets

assets/vendor/flatpickr/esm/plugins/confirmDate/confirmDate.js

@@ -0,0 +1,68 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { getEventTarget } from "../../utils/dom";
+var defaultConfig = {
+    confirmIcon: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' width='17' height='17' viewBox='0 0 17 17'> <g> </g> <path d='M15.418 1.774l-8.833 13.485-4.918-4.386 0.666-0.746 4.051 3.614 8.198-12.515 0.836 0.548z' fill='#000000' /> </svg>",
+    confirmText: "OK ",
+    showAlways: false,
+    theme: "light",
+};
+function confirmDatePlugin(pluginConfig) {
+    var config = __assign(__assign({}, defaultConfig), pluginConfig);
+    var confirmContainer;
+    var confirmButtonCSSClass = "flatpickr-confirm";
+    return function (fp) {
+        if (fp.config.noCalendar || fp.isMobile)
+            return {};
+        return __assign({ onKeyDown: function (_, __, ___, e) {
+                var eventTarget = getEventTarget(e);
+                var isTargetLastFocusableElement = (!fp.config.time_24hr && eventTarget === fp.amPM) ||
+                    (fp.config.time_24hr &&
+                        ((fp.config.enableSeconds && eventTarget === fp.secondElement) ||
+                            (!fp.config.enableSeconds && eventTarget === fp.minuteElement)));
+                if (fp.config.enableTime &&
+                    e.key === "Tab" &&
+                    isTargetLastFocusableElement) {
+                    e.preventDefault();
+                    confirmContainer.focus();
+                }
+                else if (e.key === "Enter" && eventTarget === confirmContainer)
+                    fp.close();
+            },
+            onReady: function () {
+                confirmContainer = fp._createElement("div", confirmButtonCSSClass + " " + (config.showAlways ? "visible" : "") + " " + config.theme + "Theme", config.confirmText);
+                confirmContainer.tabIndex = -1;
+                confirmContainer.innerHTML += config.confirmIcon;
+                confirmContainer.addEventListener("click", fp.close);
+                fp.calendarContainer.appendChild(confirmContainer);
+                fp.loadedPlugins.push("confirmDate");
+            } }, (!config.showAlways
+            ? {
+                onChange: function (_, dateStr) {
+                    var showCondition = fp.config.enableTime ||
+                        fp.config.mode === "multiple" ||
+                        fp.loadedPlugins.indexOf("monthSelect") !== -1;
+                    var localConfirmContainer = fp.calendarContainer.querySelector("." + confirmButtonCSSClass);
+                    if (!localConfirmContainer)
+                        return;
+                    if (dateStr &&
+                        !fp.config.inline &&
+                        showCondition &&
+                        localConfirmContainer)
+                        return localConfirmContainer.classList.add("visible");
+                    localConfirmContainer.classList.remove("visible");
+                },
+            }
+            : {}));
+    };
+}
+export default confirmDatePlugin;

assets/vendor/flatpickr/esm/plugins/labelPlugin/labelPlugin.js

@@ -0,0 +1,22 @@
+function labelPlugin() {
+    return function (fp) {
+        return {
+            onReady: function () {
+                var id = fp.input.id;
+                if (!id) {
+                    return;
+                }
+                if (fp.mobileInput) {
+                    fp.input.removeAttribute("id");
+                    fp.mobileInput.id = id;
+                }
+                else if (fp.altInput) {
+                    fp.input.removeAttribute("id");
+                    fp.altInput.id = id;
+                }
+                fp.loadedPlugins.push("labelPlugin");
+            },
+        };
+    };
+}
+export default labelPlugin;

assets/vendor/flatpickr/esm/plugins/minMaxTimePlugin.js

@@ -0,0 +1,77 @@
+import { calculateSecondsSinceMidnight, compareDates, compareTimes, createDateFormatter, parseSeconds, } from "../utils/dates";
+function minMaxTimePlugin(config) {
+    if (config === void 0) { config = {}; }
+    var state = {
+        formatDate: createDateFormatter({}),
+        tableDateFormat: config.tableDateFormat || "Y-m-d",
+        defaults: {
+            minTime: undefined,
+            maxTime: undefined,
+        },
+    };
+    function findDateTimeLimit(date) {
+        if (config.table !== undefined) {
+            return config.table[state.formatDate(date, state.tableDateFormat)];
+        }
+        return config.getTimeLimits && config.getTimeLimits(date);
+    }
+    return function (fp) {
+        return {
+            onReady: function () {
+                state.formatDate = this.formatDate;
+                state.defaults = {
+                    minTime: this.config.minTime && state.formatDate(this.config.minTime, "H:i"),
+                    maxTime: this.config.maxTime && state.formatDate(this.config.maxTime, "H:i"),
+                };
+                fp.loadedPlugins.push("minMaxTime");
+            },
+            onChange: function () {
+                var latest = this.latestSelectedDateObj;
+                var matchingTimeLimit = latest && findDateTimeLimit(latest);
+                if (latest && matchingTimeLimit !== undefined) {
+                    this.set(matchingTimeLimit);
+                    fp.config.minTime.setFullYear(latest.getFullYear());
+                    fp.config.maxTime.setFullYear(latest.getFullYear());
+                    fp.config.minTime.setMonth(latest.getMonth());
+                    fp.config.maxTime.setMonth(latest.getMonth());
+                    fp.config.minTime.setDate(latest.getDate());
+                    fp.config.maxTime.setDate(latest.getDate());
+                    if (fp.config.minTime > fp.config.maxTime) {
+                        var minBound = calculateSecondsSinceMidnight(fp.config.minTime.getHours(), fp.config.minTime.getMinutes(), fp.config.minTime.getSeconds());
+                        var maxBound = calculateSecondsSinceMidnight(fp.config.maxTime.getHours(), fp.config.maxTime.getMinutes(), fp.config.maxTime.getSeconds());
+                        var currentTime = calculateSecondsSinceMidnight(latest.getHours(), latest.getMinutes(), latest.getSeconds());
+                        if (currentTime > maxBound && currentTime < minBound) {
+                            var result = parseSeconds(minBound);
+                            fp.setDate(new Date(latest.getTime()).setHours(result[0], result[1], result[2]), false);
+                        }
+                    }
+                    else {
+                        if (compareDates(latest, fp.config.maxTime, false) > 0) {
+                            fp.setDate(new Date(latest.getTime()).setHours(fp.config.maxTime.getHours(), fp.config.maxTime.getMinutes(), fp.config.maxTime.getSeconds(), fp.config.maxTime.getMilliseconds()), false);
+                        }
+                        else if (compareDates(latest, fp.config.minTime, false) < 0) {
+                            fp.setDate(new Date(latest.getTime()).setHours(fp.config.minTime.getHours(), fp.config.minTime.getMinutes(), fp.config.minTime.getSeconds(), fp.config.minTime.getMilliseconds()), false);
+                        }
+                    }
+                }
+                else {
+                    var newMinMax = state.defaults || {
+                        minTime: undefined,
+                        maxTime: undefined,
+                    };
+                    this.set(newMinMax);
+                    if (!latest)
+                        return;
+                    var _a = fp.config, minTime = _a.minTime, maxTime = _a.maxTime;
+                    if (minTime && compareTimes(latest, minTime) < 0) {
+                        fp.setDate(new Date(latest.getTime()).setHours(minTime.getHours(), minTime.getMinutes(), minTime.getSeconds(), minTime.getMilliseconds()), false);
+                    }
+                    else if (maxTime && compareTimes(latest, maxTime) > 0) {
+                        fp.setDate(new Date(latest.getTime()).setHours(maxTime.getHours(), maxTime.getMinutes(), maxTime.getSeconds(), maxTime.getMilliseconds()));
+                    }
+                }
+            },
+        };
+    };
+}
+export default minMaxTimePlugin;

assets/vendor/flatpickr/esm/plugins/momentPlugin.js

@@ -0,0 +1,47 @@
+import { getEventTarget } from "../utils/dom";
+function momentPlugin(config) {
+    var moment = config.moment;
+    return function (fp) {
+        function captureIncrement(e) {
+            var event = e;
+            event.stopPropagation();
+            var date = moment(fp.selectedDates[0]);
+            var input = getEventTarget(event);
+            var unit = Array.from(input.classList)
+                .filter(function (name) { return name.startsWith("flatpickr-"); })
+                .map(function (name) { return name.substring(10); })[0];
+            var step = parseFloat(input.getAttribute("step"));
+            date.add(step * event.delta, unit);
+            fp.setDate(date.toDate());
+        }
+        return {
+            parseDate: function (datestr, format) {
+                return moment(datestr, format, true).toDate();
+            },
+            formatDate: function (date, format) {
+                var momentDate = moment(date);
+                if (typeof fp.config.locale === "string") {
+                    momentDate.locale(fp.config.locale);
+                }
+                return momentDate.format(format);
+            },
+            onReady: function () {
+                [fp.hourElement, fp.minuteElement, fp.secondElement].forEach(function (element) {
+                    return element &&
+                        element.addEventListener("increment", captureIncrement, {
+                            capture: true,
+                        });
+                });
+            },
+            onDestroy: function () {
+                [fp.hourElement, fp.minuteElement, fp.secondElement].forEach(function (element) {
+                    return element &&
+                        element.removeEventListener("increment", captureIncrement, {
+                            capture: true,
+                        });
+                });
+            },
+        };
+    };
+}
+export default momentPlugin;

assets/vendor/flatpickr/esm/plugins/monthSelect/index.js

@@ -0,0 +1,259 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { monthToStr } from "../../utils/formatting";
+import { clearNode, getEventTarget } from "../../utils/dom";
+var defaultConfig = {
+    shorthand: false,
+    dateFormat: "F Y",
+    altFormat: "F Y",
+    theme: "light",
+};
+function monthSelectPlugin(pluginConfig) {
+    var config = __assign(__assign({}, defaultConfig), pluginConfig);
+    return function (fp) {
+        fp.config.dateFormat = config.dateFormat;
+        fp.config.altFormat = config.altFormat;
+        var self = { monthsContainer: null };
+        function clearUnnecessaryDOMElements() {
+            if (!fp.rContainer)
+                return;
+            clearNode(fp.rContainer);
+            for (var index = 0; index < fp.monthElements.length; index++) {
+                var element = fp.monthElements[index];
+                if (!element.parentNode)
+                    continue;
+                element.parentNode.removeChild(element);
+            }
+        }
+        function build() {
+            if (!fp.rContainer)
+                return;
+            self.monthsContainer = fp._createElement("div", "flatpickr-monthSelect-months");
+            self.monthsContainer.tabIndex = -1;
+            buildMonths();
+            fp.rContainer.appendChild(self.monthsContainer);
+            fp.calendarContainer.classList.add("flatpickr-monthSelect-theme-" + config.theme);
+        }
+        function buildMonths() {
+            if (!self.monthsContainer)
+                return;
+            clearNode(self.monthsContainer);
+            var frag = document.createDocumentFragment();
+            for (var i = 0; i < 12; i++) {
+                var month = fp.createDay("flatpickr-monthSelect-month", new Date(fp.currentYear, i), 0, i);
+                if (month.dateObj.getMonth() === new Date().getMonth() &&
+                    month.dateObj.getFullYear() === new Date().getFullYear())
+                    month.classList.add("today");
+                month.textContent = monthToStr(i, config.shorthand, fp.l10n);
+                month.addEventListener("click", selectMonth);
+                frag.appendChild(month);
+            }
+            self.monthsContainer.appendChild(frag);
+            if (fp.config.minDate &&
+                fp.currentYear === fp.config.minDate.getFullYear())
+                fp.prevMonthNav.classList.add("flatpickr-disabled");
+            else
+                fp.prevMonthNav.classList.remove("flatpickr-disabled");
+            if (fp.config.maxDate &&
+                fp.currentYear === fp.config.maxDate.getFullYear())
+                fp.nextMonthNav.classList.add("flatpickr-disabled");
+            else
+                fp.nextMonthNav.classList.remove("flatpickr-disabled");
+        }
+        function bindEvents() {
+            fp._bind(fp.prevMonthNav, "click", function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+                fp.changeYear(fp.currentYear - 1);
+                selectYear();
+                buildMonths();
+            });
+            fp._bind(fp.nextMonthNav, "click", function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+                fp.changeYear(fp.currentYear + 1);
+                selectYear();
+                buildMonths();
+            });
+            fp._bind(self.monthsContainer, "mouseover", function (e) {
+                if (fp.config.mode === "range")
+                    fp.onMouseOver(getEventTarget(e), "flatpickr-monthSelect-month");
+            });
+        }
+        function setCurrentlySelected() {
+            if (!fp.rContainer)
+                return;
+            if (!fp.selectedDates.length)
+                return;
+            var currentlySelected = fp.rContainer.querySelectorAll(".flatpickr-monthSelect-month.selected");
+            for (var index = 0; index < currentlySelected.length; index++) {
+                currentlySelected[index].classList.remove("selected");
+            }
+            var targetMonth = fp.selectedDates[0].getMonth();
+            var month = fp.rContainer.querySelector(".flatpickr-monthSelect-month:nth-child(" + (targetMonth + 1) + ")");
+            if (month) {
+                month.classList.add("selected");
+            }
+        }
+        function selectYear() {
+            var selectedDate = fp.selectedDates[0];
+            if (selectedDate) {
+                selectedDate = new Date(selectedDate);
+                selectedDate.setFullYear(fp.currentYear);
+                if (fp.config.minDate && selectedDate < fp.config.minDate) {
+                    selectedDate = fp.config.minDate;
+                }
+                if (fp.config.maxDate && selectedDate > fp.config.maxDate) {
+                    selectedDate = fp.config.maxDate;
+                }
+                fp.currentYear = selectedDate.getFullYear();
+            }
+            fp.currentYearElement.value = String(fp.currentYear);
+            if (fp.rContainer) {
+                var months = fp.rContainer.querySelectorAll(".flatpickr-monthSelect-month");
+                months.forEach(function (month) {
+                    month.dateObj.setFullYear(fp.currentYear);
+                    if ((fp.config.minDate && month.dateObj < fp.config.minDate) ||
+                        (fp.config.maxDate && month.dateObj > fp.config.maxDate)) {
+                        month.classList.add("flatpickr-disabled");
+                    }
+                    else {
+                        month.classList.remove("flatpickr-disabled");
+                    }
+                });
+            }
+            setCurrentlySelected();
+        }
+        function selectMonth(e) {
+            e.preventDefault();
+            e.stopPropagation();
+            var eventTarget = getEventTarget(e);
+            if (!(eventTarget instanceof Element))
+                return;
+            if (eventTarget.classList.contains("flatpickr-disabled"))
+                return;
+            if (eventTarget.classList.contains("notAllowed"))
+                return;
+            setMonth(eventTarget.dateObj);
+            if (fp.config.closeOnSelect) {
+                var single = fp.config.mode === "single";
+                var range = fp.config.mode === "range" && fp.selectedDates.length === 2;
+                if (single || range)
+                    fp.close();
+            }
+        }
+        function setMonth(date) {
+            var selectedDate = new Date(fp.currentYear, date.getMonth(), date.getDate());
+            var selectedDates = [];
+            switch (fp.config.mode) {
+                case "single":
+                    selectedDates = [selectedDate];
+                    break;
+                case "multiple":
+                    selectedDates.push(selectedDate);
+                    break;
+                case "range":
+                    if (fp.selectedDates.length === 2) {
+                        selectedDates = [selectedDate];
+                    }
+                    else {
+                        selectedDates = fp.selectedDates.concat([selectedDate]);
+                        selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
+                    }
+                    break;
+            }
+            fp.setDate(selectedDates, true);
+            setCurrentlySelected();
+        }
+        var shifts = {
+            37: -1,
+            39: 1,
+            40: 3,
+            38: -3,
+        };
+        function onKeyDown(_, __, ___, e) {
+            var shouldMove = shifts[e.keyCode] !== undefined;
+            if (!shouldMove && e.keyCode !== 13) {
+                return;
+            }
+            if (!fp.rContainer || !self.monthsContainer)
+                return;
+            var currentlySelected = fp.rContainer.querySelector(".flatpickr-monthSelect-month.selected");
+            var index = Array.prototype.indexOf.call(self.monthsContainer.children, document.activeElement);
+            if (index === -1) {
+                var target = currentlySelected || self.monthsContainer.firstElementChild;
+                target.focus();
+                index = target.$i;
+            }
+            if (shouldMove) {
+                self.monthsContainer.children[(12 + index + shifts[e.keyCode]) % 12].focus();
+            }
+            else if (e.keyCode === 13 &&
+                self.monthsContainer.contains(document.activeElement)) {
+                setMonth(document.activeElement.dateObj);
+            }
+        }
+        function closeHook() {
+            var _a;
+            if (((_a = fp.config) === null || _a === void 0 ? void 0 : _a.mode) === "range" && fp.selectedDates.length === 1)
+                fp.clear(false);
+            if (!fp.selectedDates.length)
+                buildMonths();
+        }
+        function stubCurrentMonth() {
+            config._stubbedCurrentMonth = fp._initialDate.getMonth();
+            fp._initialDate.setMonth(config._stubbedCurrentMonth);
+            fp.currentMonth = config._stubbedCurrentMonth;
+        }
+        function unstubCurrentMonth() {
+            if (!config._stubbedCurrentMonth)
+                return;
+            fp._initialDate.setMonth(config._stubbedCurrentMonth);
+            fp.currentMonth = config._stubbedCurrentMonth;
+            delete config._stubbedCurrentMonth;
+        }
+        function destroyPluginInstance() {
+            if (self.monthsContainer !== null) {
+                var months = self.monthsContainer.querySelectorAll(".flatpickr-monthSelect-month");
+                for (var index = 0; index < months.length; index++) {
+                    months[index].removeEventListener("click", selectMonth);
+                }
+            }
+        }
+        return {
+            onParseConfig: function () {
+                fp.config.enableTime = false;
+            },
+            onValueUpdate: setCurrentlySelected,
+            onKeyDown: onKeyDown,
+            onReady: [
+                stubCurrentMonth,
+                clearUnnecessaryDOMElements,
+                build,
+                bindEvents,
+                setCurrentlySelected,
+                function () {
+                    fp.config.onClose.push(closeHook);
+                    fp.loadedPlugins.push("monthSelect");
+                },
+            ],
+            onDestroy: [
+                unstubCurrentMonth,
+                destroyPluginInstance,
+                function () {
+                    fp.config.onClose = fp.config.onClose.filter(function (hook) { return hook !== closeHook; });
+                },
+            ],
+        };
+    };
+}
+export default monthSelectPlugin;

assets/vendor/flatpickr/esm/plugins/rangePlugin.js

@@ -0,0 +1,154 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+function rangePlugin(config) {
+    if (config === void 0) { config = {}; }
+    return function (fp) {
+        var dateFormat = "", secondInput, _secondInputFocused, _prevDates;
+        var createSecondInput = function () {
+            if (config.input) {
+                secondInput =
+                    config.input instanceof Element
+                        ? config.input
+                        : window.document.querySelector(config.input);
+                if (!secondInput) {
+                    fp.config.errorHandler(new Error("Invalid input element specified"));
+                    return;
+                }
+                if (fp.config.wrap) {
+                    secondInput = secondInput.querySelector("[data-input]");
+                }
+            }
+            else {
+                secondInput = fp._input.cloneNode();
+                secondInput.removeAttribute("id");
+                secondInput._flatpickr = undefined;
+            }
+            if (secondInput.value) {
+                var parsedDate = fp.parseDate(secondInput.value);
+                if (parsedDate)
+                    fp.selectedDates.push(parsedDate);
+            }
+            secondInput.setAttribute("data-fp-omit", "");
+            if (fp.config.clickOpens) {
+                fp._bind(secondInput, ["focus", "click"], function () {
+                    if (fp.selectedDates[1]) {
+                        fp.latestSelectedDateObj = fp.selectedDates[1];
+                        fp._setHoursFromDate(fp.selectedDates[1]);
+                        fp.jumpToDate(fp.selectedDates[1]);
+                    }
+                    _secondInputFocused = true;
+                    fp.isOpen = false;
+                    fp.open(undefined, config.position === "left" ? fp._input : secondInput);
+                });
+                fp._bind(fp._input, ["focus", "click"], function (e) {
+                    e.preventDefault();
+                    fp.isOpen = false;
+                    fp.open();
+                });
+            }
+            if (fp.config.allowInput)
+                fp._bind(secondInput, "keydown", function (e) {
+                    if (e.key === "Enter") {
+                        fp.setDate([fp.selectedDates[0], secondInput.value], true, dateFormat);
+                        secondInput.click();
+                    }
+                });
+            if (!config.input)
+                fp._input.parentNode &&
+                    fp._input.parentNode.insertBefore(secondInput, fp._input.nextSibling);
+        };
+        var plugin = {
+            onParseConfig: function () {
+                fp.config.mode = "range";
+                dateFormat = fp.config.altInput
+                    ? fp.config.altFormat
+                    : fp.config.dateFormat;
+            },
+            onReady: function () {
+                createSecondInput();
+                fp.config.ignoredFocusElements.push(secondInput);
+                if (fp.config.allowInput) {
+                    fp._input.removeAttribute("readonly");
+                    secondInput.removeAttribute("readonly");
+                }
+                else {
+                    secondInput.setAttribute("readonly", "readonly");
+                }
+                fp._bind(fp._input, "focus", function () {
+                    fp.latestSelectedDateObj = fp.selectedDates[0];
+                    fp._setHoursFromDate(fp.selectedDates[0]);
+                    _secondInputFocused = false;
+                    fp.jumpToDate(fp.selectedDates[0]);
+                });
+                if (fp.config.allowInput)
+                    fp._bind(fp._input, "keydown", function (e) {
+                        if (e.key === "Enter")
+                            fp.setDate([fp._input.value, fp.selectedDates[1]], true, dateFormat);
+                    });
+                fp.setDate(fp.selectedDates, false);
+                plugin.onValueUpdate(fp.selectedDates);
+                fp.loadedPlugins.push("range");
+            },
+            onPreCalendarPosition: function () {
+                if (_secondInputFocused) {
+                    fp._positionElement = secondInput;
+                    setTimeout(function () {
+                        fp._positionElement = fp._input;
+                    }, 0);
+                }
+            },
+            onChange: function () {
+                if (!fp.selectedDates.length) {
+                    setTimeout(function () {
+                        if (fp.selectedDates.length)
+                            return;
+                        secondInput.value = "";
+                        _prevDates = [];
+                    }, 10);
+                }
+                if (_secondInputFocused) {
+                    setTimeout(function () {
+                        secondInput.focus();
+                    }, 0);
+                }
+            },
+            onDestroy: function () {
+                if (!config.input)
+                    secondInput.parentNode &&
+                        secondInput.parentNode.removeChild(secondInput);
+            },
+            onValueUpdate: function (selDates) {
+                var _a, _b, _c;
+                if (!secondInput)
+                    return;
+                _prevDates =
+                    !_prevDates || selDates.length >= _prevDates.length
+                        ? __spreadArrays(selDates) : _prevDates;
+                if (_prevDates.length > selDates.length) {
+                    var newSelectedDate = selDates[0];
+                    var newDates = _secondInputFocused
+                        ? [_prevDates[0], newSelectedDate]
+                        : [newSelectedDate, _prevDates[1]];
+                    if (newDates[0].getTime() > newDates[1].getTime()) {
+                        if (_secondInputFocused) {
+                            newDates[0] = newDates[1];
+                        }
+                        else {
+                            newDates[1] = newDates[0];
+                        }
+                    }
+                    fp.setDate(newDates, false);
+                    _prevDates = __spreadArrays(newDates);
+                }
+                _a = fp.selectedDates.map(function (d) { return fp.formatDate(d, dateFormat); }), _b = _a[0], fp._input.value = _b === void 0 ? "" : _b, _c = _a[1], secondInput.value = _c === void 0 ? "" : _c;
+            },
+        };
+        return plugin;
+    };
+}
+export default rangePlugin;

assets/vendor/flatpickr/esm/plugins/scrollPlugin.js

@@ -0,0 +1,72 @@
+import { getEventTarget } from "../utils/dom";
+if (typeof window.CustomEvent !== "function") {
+    var CustomEvent_1 = function (typeArg, eventInitDict) {
+        eventInitDict = eventInitDict || {
+            bubbles: false,
+            cancelable: false,
+            detail: undefined,
+        };
+        var evt = document.createEvent("CustomEvent");
+        evt.initCustomEvent(typeArg, eventInitDict.bubbles, eventInitDict.cancelable, eventInitDict.detail);
+        return evt;
+    };
+    CustomEvent_1.prototype = window.Event.prototype;
+    window.CustomEvent = CustomEvent_1;
+}
+function delta(e) {
+    return Math.max(-1, Math.min(1, e.wheelDelta || -e.deltaY));
+}
+var scroll = function (e) {
+    e.preventDefault();
+    var ev = new CustomEvent("increment", {
+        bubbles: true,
+    });
+    ev.delta = delta(e);
+    getEventTarget(e).dispatchEvent(ev);
+};
+function scrollMonth(fp) {
+    return function (e) {
+        e.preventDefault();
+        var mDelta = delta(e);
+        fp.changeMonth(mDelta);
+    };
+}
+function scrollPlugin() {
+    return function (fp) {
+        var monthScroller = scrollMonth(fp);
+        return {
+            onReady: function () {
+                if (fp.timeContainer) {
+                    fp.timeContainer.addEventListener("wheel", scroll);
+                }
+                if (fp.yearElements) {
+                    fp.yearElements.forEach(function (yearElem) {
+                        return yearElem.addEventListener("wheel", scroll);
+                    });
+                }
+                if (fp.monthElements) {
+                    fp.monthElements.forEach(function (monthElem) {
+                        return monthElem.addEventListener("wheel", monthScroller);
+                    });
+                }
+                fp.loadedPlugins.push("scroll");
+            },
+            onDestroy: function () {
+                if (fp.timeContainer) {
+                    fp.timeContainer.removeEventListener("wheel", scroll);
+                }
+                if (fp.yearElements) {
+                    fp.yearElements.forEach(function (yearElem) {
+                        return yearElem.removeEventListener("wheel", scroll);
+                    });
+                }
+                if (fp.monthElements) {
+                    fp.monthElements.forEach(function (monthElem) {
+                        return monthElem.removeEventListener("wheel", monthScroller);
+                    });
+                }
+            },
+        };
+    };
+}
+export default scrollPlugin;

assets/vendor/flatpickr/esm/plugins/weekSelect/weekSelect.js

@@ -0,0 +1,78 @@
+import { getEventTarget } from "../../utils/dom";
+function weekSelectPlugin() {
+    return function (fp) {
+        function onDayHover(event) {
+            var day = getEventTarget(event);
+            if (!day.classList.contains("flatpickr-day"))
+                return;
+            var days = fp.days.childNodes;
+            var dayIndex = day.$i;
+            var dayIndSeven = dayIndex / 7;
+            var weekStartDay = days[7 * Math.floor(dayIndSeven)]
+                .dateObj;
+            var weekEndDay = days[7 * Math.ceil(dayIndSeven + 0.01) - 1].dateObj;
+            for (var i = days.length; i--;) {
+                var day_1 = days[i];
+                var date = day_1.dateObj;
+                if (date > weekEndDay || date < weekStartDay)
+                    day_1.classList.remove("inRange");
+                else
+                    day_1.classList.add("inRange");
+            }
+        }
+        function highlightWeek() {
+            var selDate = fp.latestSelectedDateObj;
+            if (selDate !== undefined &&
+                selDate.getMonth() === fp.currentMonth &&
+                selDate.getFullYear() === fp.currentYear) {
+                fp.weekStartDay = fp.days.childNodes[7 * Math.floor(fp.selectedDateElem.$i / 7)].dateObj;
+                fp.weekEndDay = fp.days.childNodes[7 * Math.ceil(fp.selectedDateElem.$i / 7 + 0.01) - 1].dateObj;
+            }
+            var days = fp.days.childNodes;
+            for (var i = days.length; i--;) {
+                var date = days[i].dateObj;
+                if (date >= fp.weekStartDay && date <= fp.weekEndDay)
+                    days[i].classList.add("week", "selected");
+            }
+        }
+        function clearHover() {
+            var days = fp.days.childNodes;
+            for (var i = days.length; i--;)
+                days[i].classList.remove("inRange");
+        }
+        function onReady() {
+            if (fp.daysContainer !== undefined)
+                fp.daysContainer.addEventListener("mouseover", onDayHover);
+        }
+        function onDestroy() {
+            if (fp.daysContainer !== undefined)
+                fp.daysContainer.removeEventListener("mouseover", onDayHover);
+        }
+        return {
+            onValueUpdate: highlightWeek,
+            onMonthChange: highlightWeek,
+            onYearChange: highlightWeek,
+            onOpen: highlightWeek,
+            onClose: clearHover,
+            onParseConfig: function () {
+                fp.config.mode = "single";
+                fp.config.enableTime = false;
+                fp.config.dateFormat = fp.config.dateFormat
+                    ? fp.config.dateFormat
+                    : "\\W\\e\\e\\k #W, Y";
+                fp.config.altFormat = fp.config.altFormat
+                    ? fp.config.altFormat
+                    : "\\W\\e\\e\\k #W, Y";
+            },
+            onReady: [
+                onReady,
+                highlightWeek,
+                function () {
+                    fp.loadedPlugins.push("weekSelect");
+                },
+            ],
+            onDestroy: onDestroy,
+        };
+    };
+}
+export default weekSelectPlugin;