/******/
(() => { // webpackBootstrap
    /******/
    var __webpack_modules__ = ({

        /***/ "./node_modules/alpinejs/dist/module.esm.js":
        /*!**************************************************!*\
  !*** ./node_modules/alpinejs/dist/module.esm.js ***!
  \**************************************************/
        /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

            "use strict";
            __webpack_require__.r(__webpack_exports__);
            /* harmony export */
            __webpack_require__.d(__webpack_exports__, {
                /* harmony export */   "default": () => (/* binding */ module_default)
                /* harmony export */
            });
// packages/alpinejs/src/scheduler.js
            var flushPending = false;
            var flushing = false;
            var queue = [];

            function scheduler(callback) {
                queueJob(callback);
            }

            function queueJob(job) {
                if (!queue.includes(job))
                    queue.push(job);
                queueFlush();
            }

            function dequeueJob(job) {
                let index = queue.indexOf(job);
                if (index !== -1)
                    queue.splice(index, 1);
            }

            function queueFlush() {
                if (!flushing && !flushPending) {
                    flushPending = true;
                    queueMicrotask(flushJobs);
                }
            }

            function flushJobs() {
                flushPending = false;
                flushing = true;
                for (let i = 0; i < queue.length; i++) {
                    queue[i]();
                }
                queue.length = 0;
                flushing = false;
            }

// packages/alpinejs/src/reactivity.js
            var reactive;
            var effect;
            var release;
            var raw;
            var shouldSchedule = true;

            function disableEffectScheduling(callback) {
                shouldSchedule = false;
                callback();
                shouldSchedule = true;
            }

            function setReactivityEngine(engine) {
                reactive = engine.reactive;
                release = engine.release;
                effect = (callback) => engine.effect(callback, {
                    scheduler: (task) => {
                        if (shouldSchedule) {
                            scheduler(task);
                        } else {
                            task();
                        }
                    }
                });
                raw = engine.raw;
            }

            function overrideEffect(override) {
                effect = override;
            }

            function elementBoundEffect(el) {
                let cleanup2 = () => {
                };
                let wrappedEffect = (callback) => {
                    let effectReference = effect(callback);
                    if (!el._x_effects) {
                        el._x_effects = new Set();
                        el._x_runEffects = () => {
                            el._x_effects.forEach((i) => i());
                        };
                    }
                    el._x_effects.add(effectReference);
                    cleanup2 = () => {
                        if (effectReference === void 0)
                            return;
                        el._x_effects.delete(effectReference);
                        release(effectReference);
                    };
                    return effectReference;
                };
                return [wrappedEffect, () => {
                    cleanup2();
                }];
            }

// packages/alpinejs/src/mutation.js
            var onAttributeAddeds = [];
            var onElRemoveds = [];
            var onElAddeds = [];

            function onElAdded(callback) {
                onElAddeds.push(callback);
            }

            function onElRemoved(el, callback) {
                if (typeof callback === "function") {
                    if (!el._x_cleanups)
                        el._x_cleanups = [];
                    el._x_cleanups.push(callback);
                } else {
                    callback = el;
                    onElRemoveds.push(callback);
                }
            }

            function onAttributesAdded(callback) {
                onAttributeAddeds.push(callback);
            }

            function onAttributeRemoved(el, name, callback) {
                if (!el._x_attributeCleanups)
                    el._x_attributeCleanups = {};
                if (!el._x_attributeCleanups[name])
                    el._x_attributeCleanups[name] = [];
                el._x_attributeCleanups[name].push(callback);
            }

            function cleanupAttributes(el, names) {
                if (!el._x_attributeCleanups)
                    return;
                Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
                    if (names === void 0 || names.includes(name)) {
                        value.forEach((i) => i());
                        delete el._x_attributeCleanups[name];
                    }
                });
            }

            var observer = new MutationObserver(onMutate);
            var currentlyObserving = false;

            function startObservingMutations() {
                observer.observe(document, {subtree: true, childList: true, attributes: true, attributeOldValue: true});
                currentlyObserving = true;
            }

            function stopObservingMutations() {
                flushObserver();
                observer.disconnect();
                currentlyObserving = false;
            }

            var recordQueue = [];
            var willProcessRecordQueue = false;

            function flushObserver() {
                recordQueue = recordQueue.concat(observer.takeRecords());
                if (recordQueue.length && !willProcessRecordQueue) {
                    willProcessRecordQueue = true;
                    queueMicrotask(() => {
                        processRecordQueue();
                        willProcessRecordQueue = false;
                    });
                }
            }

            function processRecordQueue() {
                onMutate(recordQueue);
                recordQueue.length = 0;
            }

            function mutateDom(callback) {
                if (!currentlyObserving)
                    return callback();
                stopObservingMutations();
                let result = callback();
                startObservingMutations();
                return result;
            }

            var isCollecting = false;
            var deferredMutations = [];

            function deferMutations() {
                isCollecting = true;
            }

            function flushAndStopDeferringMutations() {
                isCollecting = false;
                onMutate(deferredMutations);
                deferredMutations = [];
            }

            function onMutate(mutations) {
                if (isCollecting) {
                    deferredMutations = deferredMutations.concat(mutations);
                    return;
                }
                let addedNodes = [];
                let removedNodes = [];
                let addedAttributes = new Map();
                let removedAttributes = new Map();
                for (let i = 0; i < mutations.length; i++) {
                    if (mutations[i].target._x_ignoreMutationObserver)
                        continue;
                    if (mutations[i].type === "childList") {
                        mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.push(node));
                        mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.push(node));
                    }
                    if (mutations[i].type === "attributes") {
                        let el = mutations[i].target;
                        let name = mutations[i].attributeName;
                        let oldValue = mutations[i].oldValue;
                        let add2 = () => {
                            if (!addedAttributes.has(el))
                                addedAttributes.set(el, []);
                            addedAttributes.get(el).push({name, value: el.getAttribute(name)});
                        };
                        let remove = () => {
                            if (!removedAttributes.has(el))
                                removedAttributes.set(el, []);
                            removedAttributes.get(el).push(name);
                        };
                        if (el.hasAttribute(name) && oldValue === null) {
                            add2();
                        } else if (el.hasAttribute(name)) {
                            remove();
                            add2();
                        } else {
                            remove();
                        }
                    }
                }
                removedAttributes.forEach((attrs, el) => {
                    cleanupAttributes(el, attrs);
                });
                addedAttributes.forEach((attrs, el) => {
                    onAttributeAddeds.forEach((i) => i(el, attrs));
                });
                for (let node of removedNodes) {
                    if (addedNodes.includes(node))
                        continue;
                    onElRemoveds.forEach((i) => i(node));
                    if (node._x_cleanups) {
                        while (node._x_cleanups.length)
                            node._x_cleanups.pop()();
                    }
                }
                addedNodes.forEach((node) => {
                    node._x_ignoreSelf = true;
                    node._x_ignore = true;
                });
                for (let node of addedNodes) {
                    if (removedNodes.includes(node))
                        continue;
                    if (!node.isConnected)
                        continue;
                    delete node._x_ignoreSelf;
                    delete node._x_ignore;
                    onElAddeds.forEach((i) => i(node));
                    node._x_ignore = true;
                    node._x_ignoreSelf = true;
                }
                addedNodes.forEach((node) => {
                    delete node._x_ignoreSelf;
                    delete node._x_ignore;
                });
                addedNodes = null;
                removedNodes = null;
                addedAttributes = null;
                removedAttributes = null;
            }

// packages/alpinejs/src/scope.js
            function scope(node) {
                return mergeProxies(closestDataStack(node));
            }

            function addScopeToNode(node, data2, referenceNode) {
                node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
                return () => {
                    node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
                };
            }

            function refreshScope(element, scope2) {
                let existingScope = element._x_dataStack[0];
                Object.entries(scope2).forEach(([key, value]) => {
                    existingScope[key] = value;
                });
            }

            function closestDataStack(node) {
                if (node._x_dataStack)
                    return node._x_dataStack;
                if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
                    return closestDataStack(node.host);
                }
                if (!node.parentNode) {
                    return [];
                }
                return closestDataStack(node.parentNode);
            }

            function mergeProxies(objects) {
                let thisProxy = new Proxy({}, {
                    ownKeys: () => {
                        return Array.from(new Set(objects.flatMap((i) => Object.keys(i))));
                    },
                    has: (target, name) => {
                        return objects.some((obj) => obj.hasOwnProperty(name));
                    },
                    get: (target, name) => {
                        return (objects.find((obj) => {
                            if (obj.hasOwnProperty(name)) {
                                let descriptor = Object.getOwnPropertyDescriptor(obj, name);
                                if (descriptor.get && descriptor.get._x_alreadyBound || descriptor.set && descriptor.set._x_alreadyBound) {
                                    return true;
                                }
                                if ((descriptor.get || descriptor.set) && descriptor.enumerable) {
                                    let getter = descriptor.get;
                                    let setter = descriptor.set;
                                    let property = descriptor;
                                    getter = getter && getter.bind(thisProxy);
                                    setter = setter && setter.bind(thisProxy);
                                    if (getter)
                                        getter._x_alreadyBound = true;
                                    if (setter)
                                        setter._x_alreadyBound = true;
                                    Object.defineProperty(obj, name, {
                                        ...property,
                                        get: getter,
                                        set: setter
                                    });
                                }
                                return true;
                            }
                            return false;
                        }) || {})[name];
                    },
                    set: (target, name, value) => {
                        let closestObjectWithKey = objects.find((obj) => obj.hasOwnProperty(name));
                        if (closestObjectWithKey) {
                            closestObjectWithKey[name] = value;
                        } else {
                            objects[objects.length - 1][name] = value;
                        }
                        return true;
                    }
                });
                return thisProxy;
            }

// packages/alpinejs/src/interceptor.js
            function initInterceptors(data2) {
                let isObject2 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
                let recurse = (obj, basePath = "") => {
                    Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, {value, enumerable}]) => {
                        if (enumerable === false || value === void 0)
                            return;
                        let path = basePath === "" ? key : `${basePath}.${key}`;
                        if (typeof value === "object" && value !== null && value._x_interceptor) {
                            obj[key] = value.initialize(data2, path, key);
                        } else {
                            if (isObject2(value) && value !== obj && !(value instanceof Element)) {
                                recurse(value, path);
                            }
                        }
                    });
                };
                return recurse(data2);
            }

            function interceptor(callback, mutateObj = () => {
            }) {
                let obj = {
                    initialValue: void 0,
                    _x_interceptor: true,
                    initialize(data2, path, key) {
                        return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
                    }
                };
                mutateObj(obj);
                return (initialValue) => {
                    if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
                        let initialize = obj.initialize.bind(obj);
                        obj.initialize = (data2, path, key) => {
                            let innerValue = initialValue.initialize(data2, path, key);
                            obj.initialValue = innerValue;
                            return initialize(data2, path, key);
                        };
                    } else {
                        obj.initialValue = initialValue;
                    }
                    return obj;
                };
            }

            function get(obj, path) {
                return path.split(".").reduce((carry, segment) => carry[segment], obj);
            }

            function set(obj, path, value) {
                if (typeof path === "string")
                    path = path.split(".");
                if (path.length === 1)
                    obj[path[0]] = value;
                else if (path.length === 0)
                    throw error;
                else {
                    if (obj[path[0]])
                        return set(obj[path[0]], path.slice(1), value);
                    else {
                        obj[path[0]] = {};
                        return set(obj[path[0]], path.slice(1), value);
                    }
                }
            }

// packages/alpinejs/src/magics.js
            var magics = {};

            function magic(name, callback) {
                magics[name] = callback;
            }

            function injectMagics(obj, el) {
                Object.entries(magics).forEach(([name, callback]) => {
                    Object.defineProperty(obj, `$${name}`, {
                        get() {
                            let [utilities, cleanup2] = getElementBoundUtilities(el);
                            utilities = {interceptor, ...utilities};
                            onElRemoved(el, cleanup2);
                            return callback(el, utilities);
                        },
                        enumerable: false
                    });
                });
                return obj;
            }

// packages/alpinejs/src/utils/error.js
            function tryCatch(el, expression, callback, ...args) {
                try {
                    return callback(...args);
                } catch (e) {
                    handleError(e, el, expression);
                }
            }

            function handleError(error2, el, expression = void 0) {
                Object.assign(error2, {el, expression});
                console.warn(`Alpine Expression Error: ${error2.message}

${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
                setTimeout(() => {
                    throw error2;
                }, 0);
            }

// packages/alpinejs/src/evaluator.js
            var shouldAutoEvaluateFunctions = true;

            function dontAutoEvaluateFunctions(callback) {
                let cache = shouldAutoEvaluateFunctions;
                shouldAutoEvaluateFunctions = false;
                callback();
                shouldAutoEvaluateFunctions = cache;
            }

            function evaluate(el, expression, extras = {}) {
                let result;
                evaluateLater(el, expression)((value) => result = value, extras);
                return result;
            }

            function evaluateLater(...args) {
                return theEvaluatorFunction(...args);
            }

            var theEvaluatorFunction = normalEvaluator;

            function setEvaluator(newEvaluator) {
                theEvaluatorFunction = newEvaluator;
            }

            function normalEvaluator(el, expression) {
                let overriddenMagics = {};
                injectMagics(overriddenMagics, el);
                let dataStack = [overriddenMagics, ...closestDataStack(el)];
                if (typeof expression === "function") {
                    return generateEvaluatorFromFunction(dataStack, expression);
                }
                let evaluator = generateEvaluatorFromString(dataStack, expression, el);
                return tryCatch.bind(null, el, expression, evaluator);
            }

            function generateEvaluatorFromFunction(dataStack, func) {
                return (receiver = () => {
                }, {scope: scope2 = {}, params = []} = {}) => {
                    let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
                    runIfTypeOfFunction(receiver, result);
                };
            }

            var evaluatorMemo = {};

            function generateFunctionFromString(expression, el) {
                if (evaluatorMemo[expression]) {
                    return evaluatorMemo[expression];
                }
                let AsyncFunction = Object.getPrototypeOf(async function () {
                }).constructor;
                let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression) || /^(let|const)\s/.test(expression) ? `(() => { ${expression} })()` : expression;
                const safeAsyncFunction = () => {
                    try {
                        return new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`);
                    } catch (error2) {
                        handleError(error2, el, expression);
                        return Promise.resolve();
                    }
                };
                let func = safeAsyncFunction();
                evaluatorMemo[expression] = func;
                return func;
            }

            function generateEvaluatorFromString(dataStack, expression, el) {
                let func = generateFunctionFromString(expression, el);
                return (receiver = () => {
                }, {scope: scope2 = {}, params = []} = {}) => {
                    func.result = void 0;
                    func.finished = false;
                    let completeScope = mergeProxies([scope2, ...dataStack]);
                    if (typeof func === "function") {
                        let promise = func(func, completeScope).catch((error2) => handleError(error2, el, expression));
                        if (func.finished) {
                            runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
                            func.result = void 0;
                        } else {
                            promise.then((result) => {
                                runIfTypeOfFunction(receiver, result, completeScope, params, el);
                            }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
                        }
                    }
                };
            }

            function runIfTypeOfFunction(receiver, value, scope2, params, el) {
                if (shouldAutoEvaluateFunctions && typeof value === "function") {
                    let result = value.apply(scope2, params);
                    if (result instanceof Promise) {
                        result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
                    } else {
                        receiver(result);
                    }
                } else {
                    receiver(value);
                }
            }

// packages/alpinejs/src/directives.js
            var prefixAsString = "x-";

            function prefix(subject = "") {
                return prefixAsString + subject;
            }

            function setPrefix(newPrefix) {
                prefixAsString = newPrefix;
            }

            var directiveHandlers = {};

            function directive(name, callback) {
                directiveHandlers[name] = callback;
            }

            function directives(el, attributes, originalAttributeOverride) {
                let transformedAttributeMap = {};
                let directives2 = Array.from(attributes).map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
                return directives2.map((directive2) => {
                    return getDirectiveHandler(el, directive2);
                });
            }

            function attributesOnly(attributes) {
                return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
            }

            var isDeferringHandlers = false;
            var directiveHandlerStacks = new Map();
            var currentHandlerStackKey = Symbol();

            function deferHandlingDirectives(callback) {
                isDeferringHandlers = true;
                let key = Symbol();
                currentHandlerStackKey = key;
                directiveHandlerStacks.set(key, []);
                let flushHandlers = () => {
                    while (directiveHandlerStacks.get(key).length)
                        directiveHandlerStacks.get(key).shift()();
                    directiveHandlerStacks.delete(key);
                };
                let stopDeferring = () => {
                    isDeferringHandlers = false;
                    flushHandlers();
                };
                callback(flushHandlers);
                stopDeferring();
            }

            function getElementBoundUtilities(el) {
                let cleanups = [];
                let cleanup2 = (callback) => cleanups.push(callback);
                let [effect3, cleanupEffect] = elementBoundEffect(el);
                cleanups.push(cleanupEffect);
                let utilities = {
                    Alpine: alpine_default,
                    effect: effect3,
                    cleanup: cleanup2,
                    evaluateLater: evaluateLater.bind(evaluateLater, el),
                    evaluate: evaluate.bind(evaluate, el)
                };
                let doCleanup = () => cleanups.forEach((i) => i());
                return [utilities, doCleanup];
            }

            function getDirectiveHandler(el, directive2) {
                let noop = () => {
                };
                let handler3 = directiveHandlers[directive2.type] || noop;
                let [utilities, cleanup2] = getElementBoundUtilities(el);
                onAttributeRemoved(el, directive2.original, cleanup2);
                let fullHandler = () => {
                    if (el._x_ignore || el._x_ignoreSelf)
                        return;
                    handler3.inline && handler3.inline(el, directive2, utilities);
                    handler3 = handler3.bind(handler3, el, directive2, utilities);
                    isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler3) : handler3();
                };
                fullHandler.runCleanups = cleanup2;
                return fullHandler;
            }

            var startingWith = (subject, replacement) => ({name, value}) => {
                if (name.startsWith(subject))
                    name = name.replace(subject, replacement);
                return {name, value};
            };
            var into = (i) => i;

            function toTransformedAttributes(callback = () => {
            }) {
                return ({name, value}) => {
                    let {name: newName, value: newValue} = attributeTransformers.reduce((carry, transform) => {
                        return transform(carry);
                    }, {name, value});
                    if (newName !== name)
                        callback(newName, name);
                    return {name: newName, value: newValue};
                };
            }

            var attributeTransformers = [];

            function mapAttributes(callback) {
                attributeTransformers.push(callback);
            }

            function outNonAlpineAttributes({name}) {
                return alpineAttributeRegex().test(name);
            }

            var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);

            function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
                return ({name, value}) => {
                    let typeMatch = name.match(alpineAttributeRegex());
                    let valueMatch = name.match(/:([a-zA-Z0-9\-:]+)/);
                    let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
                    let original = originalAttributeOverride || transformedAttributeMap[name] || name;
                    return {
                        type: typeMatch ? typeMatch[1] : null,
                        value: valueMatch ? valueMatch[1] : null,
                        modifiers: modifiers.map((i) => i.replace(".", "")),
                        expression: value,
                        original
                    };
                };
            }

            var DEFAULT = "DEFAULT";
            var directiveOrder = [
                "ignore",
                "ref",
                "data",
                "id",
                "bind",
                "init",
                "for",
                "mask",
                "model",
                "modelable",
                "transition",
                "show",
                "if",
                DEFAULT,
                "teleport",
                "element"
            ];

            function byPriority(a, b) {
                let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
                let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
                return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
            }

// packages/alpinejs/src/utils/dispatch.js
            function dispatch(el, name, detail = {}) {
                el.dispatchEvent(new CustomEvent(name, {
                    detail,
                    bubbles: true,
                    composed: true,
                    cancelable: true
                }));
            }

// packages/alpinejs/src/nextTick.js
            var tickStack = [];
            var isHolding = false;

            function nextTick(callback = () => {
            }) {
                queueMicrotask(() => {
                    isHolding || setTimeout(() => {
                        releaseNextTicks();
                    });
                });
                return new Promise((res) => {
                    tickStack.push(() => {
                        callback();
                        res();
                    });
                });
            }

            function releaseNextTicks() {
                isHolding = false;
                while (tickStack.length)
                    tickStack.shift()();
            }

            function holdNextTicks() {
                isHolding = true;
            }

// packages/alpinejs/src/utils/walk.js
            function walk(el, callback) {
                if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
                    Array.from(el.children).forEach((el2) => walk(el2, callback));
                    return;
                }
                let skip = false;
                callback(el, () => skip = true);
                if (skip)
                    return;
                let node = el.firstElementChild;
                while (node) {
                    walk(node, callback, false);
                    node = node.nextElementSibling;
                }
            }

// packages/alpinejs/src/utils/warn.js
            function warn(message, ...args) {
                console.warn(`Alpine Warning: ${message}`, ...args);
            }

// packages/alpinejs/src/lifecycle.js
            function start() {
                if (!document.body)
                    warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
                dispatch(document, "alpine:init");
                dispatch(document, "alpine:initializing");
                startObservingMutations();
                onElAdded((el) => initTree(el, walk));
                onElRemoved((el) => destroyTree(el));
                onAttributesAdded((el, attrs) => {
                    directives(el, attrs).forEach((handle) => handle());
                });
                let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
                Array.from(document.querySelectorAll(allSelectors())).filter(outNestedComponents).forEach((el) => {
                    initTree(el);
                });
                dispatch(document, "alpine:initialized");
            }

            var rootSelectorCallbacks = [];
            var initSelectorCallbacks = [];

            function rootSelectors() {
                return rootSelectorCallbacks.map((fn) => fn());
            }

            function allSelectors() {
                return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
            }

            function addRootSelector(selectorCallback) {
                rootSelectorCallbacks.push(selectorCallback);
            }

            function addInitSelector(selectorCallback) {
                initSelectorCallbacks.push(selectorCallback);
            }

            function closestRoot(el, includeInitSelectors = false) {
                return findClosest(el, (element) => {
                    const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
                    if (selectors.some((selector) => element.matches(selector)))
                        return true;
                });
            }

            function findClosest(el, callback) {
                if (!el)
                    return;
                if (callback(el))
                    return el;
                if (el._x_teleportBack)
                    el = el._x_teleportBack;
                if (!el.parentElement)
                    return;
                return findClosest(el.parentElement, callback);
            }

            function isRoot(el) {
                return rootSelectors().some((selector) => el.matches(selector));
            }

            function initTree(el, walker = walk) {
                deferHandlingDirectives(() => {
                    walker(el, (el2, skip) => {
                        directives(el2, el2.attributes).forEach((handle) => handle());
                        el2._x_ignore && skip();
                    });
                });
            }

            function destroyTree(root) {
                walk(root, (el) => cleanupAttributes(el));
            }

// packages/alpinejs/src/utils/classes.js
            function setClasses(el, value) {
                if (Array.isArray(value)) {
                    return setClassesFromString(el, value.join(" "));
                } else if (typeof value === "object" && value !== null) {
                    return setClassesFromObject(el, value);
                } else if (typeof value === "function") {
                    return setClasses(el, value());
                }
                return setClassesFromString(el, value);
            }

            function setClassesFromString(el, classString) {
                let split = (classString2) => classString2.split(" ").filter(Boolean);
                let missingClasses = (classString2) => classString2.split(" ").filter((i) => !el.classList.contains(i)).filter(Boolean);
                let addClassesAndReturnUndo = (classes) => {
                    el.classList.add(...classes);
                    return () => {
                        el.classList.remove(...classes);
                    };
                };
                classString = classString === true ? classString = "" : classString || "";
                return addClassesAndReturnUndo(missingClasses(classString));
            }

            function setClassesFromObject(el, classObject) {
                let split = (classString) => classString.split(" ").filter(Boolean);
                let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? split(classString) : false).filter(Boolean);
                let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean);
                let added = [];
                let removed = [];
                forRemove.forEach((i) => {
                    if (el.classList.contains(i)) {
                        el.classList.remove(i);
                        removed.push(i);
                    }
                });
                forAdd.forEach((i) => {
                    if (!el.classList.contains(i)) {
                        el.classList.add(i);
                        added.push(i);
                    }
                });
                return () => {
                    removed.forEach((i) => el.classList.add(i));
                    added.forEach((i) => el.classList.remove(i));
                };
            }

// packages/alpinejs/src/utils/styles.js
            function setStyles(el, value) {
                if (typeof value === "object" && value !== null) {
                    return setStylesFromObject(el, value);
                }
                return setStylesFromString(el, value);
            }

            function setStylesFromObject(el, value) {
                let previousStyles = {};
                Object.entries(value).forEach(([key, value2]) => {
                    previousStyles[key] = el.style[key];
                    if (!key.startsWith("--")) {
                        key = kebabCase(key);
                    }
                    el.style.setProperty(key, value2);
                });
                setTimeout(() => {
                    if (el.style.length === 0) {
                        el.removeAttribute("style");
                    }
                });
                return () => {
                    setStyles(el, previousStyles);
                };
            }

            function setStylesFromString(el, value) {
                let cache = el.getAttribute("style", value);
                el.setAttribute("style", value);
                return () => {
                    el.setAttribute("style", cache || "");
                };
            }

            function kebabCase(subject) {
                return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
            }

// packages/alpinejs/src/utils/once.js
            function once(callback, fallback = () => {
            }) {
                let called = false;
                return function () {
                    if (!called) {
                        called = true;
                        callback.apply(this, arguments);
                    } else {
                        fallback.apply(this, arguments);
                    }
                };
            }

// packages/alpinejs/src/directives/x-transition.js
            directive("transition", (el, {value, modifiers, expression}, {evaluate: evaluate2}) => {
                if (typeof expression === "function")
                    expression = evaluate2(expression);
                if (!expression) {
                    registerTransitionsFromHelper(el, modifiers, value);
                } else {
                    registerTransitionsFromClassString(el, expression, value);
                }
            });

            function registerTransitionsFromClassString(el, classString, stage) {
                registerTransitionObject(el, setClasses, "");
                let directiveStorageMap = {
                    enter: (classes) => {
                        el._x_transition.enter.during = classes;
                    },
                    "enter-start": (classes) => {
                        el._x_transition.enter.start = classes;
                    },
                    "enter-end": (classes) => {
                        el._x_transition.enter.end = classes;
                    },
                    leave: (classes) => {
                        el._x_transition.leave.during = classes;
                    },
                    "leave-start": (classes) => {
                        el._x_transition.leave.start = classes;
                    },
                    "leave-end": (classes) => {
                        el._x_transition.leave.end = classes;
                    }
                };
                directiveStorageMap[stage](classString);
            }

            function registerTransitionsFromHelper(el, modifiers, stage) {
                registerTransitionObject(el, setStyles);
                let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
                let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
                let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
                if (modifiers.includes("in") && !doesntSpecify) {
                    modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
                }
                if (modifiers.includes("out") && !doesntSpecify) {
                    modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
                }
                let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
                let wantsOpacity = wantsAll || modifiers.includes("opacity");
                let wantsScale = wantsAll || modifiers.includes("scale");
                let opacityValue = wantsOpacity ? 0 : 1;
                let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
                let delay = modifierValue(modifiers, "delay", 0);
                let origin = modifierValue(modifiers, "origin", "center");
                let property = "opacity, transform";
                let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
                let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
                let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
                if (transitioningIn) {
                    el._x_transition.enter.during = {
                        transformOrigin: origin,
                        transitionDelay: delay,
                        transitionProperty: property,
                        transitionDuration: `${durationIn}s`,
                        transitionTimingFunction: easing
                    };
                    el._x_transition.enter.start = {
                        opacity: opacityValue,
                        transform: `scale(${scaleValue})`
                    };
                    el._x_transition.enter.end = {
                        opacity: 1,
                        transform: `scale(1)`
                    };
                }
                if (transitioningOut) {
                    el._x_transition.leave.during = {
                        transformOrigin: origin,
                        transitionDelay: delay,
                        transitionProperty: property,
                        transitionDuration: `${durationOut}s`,
                        transitionTimingFunction: easing
                    };
                    el._x_transition.leave.start = {
                        opacity: 1,
                        transform: `scale(1)`
                    };
                    el._x_transition.leave.end = {
                        opacity: opacityValue,
                        transform: `scale(${scaleValue})`
                    };
                }
            }

            function registerTransitionObject(el, setFunction, defaultValue = {}) {
                if (!el._x_transition)
                    el._x_transition = {
                        enter: {during: defaultValue, start: defaultValue, end: defaultValue},
                        leave: {during: defaultValue, start: defaultValue, end: defaultValue},
                        in(before = () => {
                        }, after = () => {
                        }) {
                            transition(el, setFunction, {
                                during: this.enter.during,
                                start: this.enter.start,
                                end: this.enter.end
                            }, before, after);
                        },
                        out(before = () => {
                        }, after = () => {
                        }) {
                            transition(el, setFunction, {
                                during: this.leave.during,
                                start: this.leave.start,
                                end: this.leave.end
                            }, before, after);
                        }
                    };
            }

            window.Element.prototype._x_toggleAndCascadeWithTransitions = function (el, value, show, hide) {
                let clickAwayCompatibleShow = () => {
                    document.visibilityState === "visible" ? requestAnimationFrame(show) : setTimeout(show);
                };
                if (value) {
                    if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
                        el._x_transition.enter && (Object.entries(el._x_transition.enter.during).length || Object.entries(el._x_transition.enter.start).length || Object.entries(el._x_transition.enter.end).length) ? el._x_transition.in(show) : clickAwayCompatibleShow();
                    } else {
                        el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
                    }
                    return;
                }
                el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
                    el._x_transition.out(() => {
                    }, () => resolve(hide));
                    el._x_transitioning.beforeCancel(() => reject({isFromCancelledTransition: true}));
                }) : Promise.resolve(hide);
                queueMicrotask(() => {
                    let closest = closestHide(el);
                    if (closest) {
                        if (!closest._x_hideChildren)
                            closest._x_hideChildren = [];
                        closest._x_hideChildren.push(el);
                    } else {
                        queueMicrotask(() => {
                            let hideAfterChildren = (el2) => {
                                let carry = Promise.all([
                                    el2._x_hidePromise,
                                    ...(el2._x_hideChildren || []).map(hideAfterChildren)
                                ]).then(([i]) => i());
                                delete el2._x_hidePromise;
                                delete el2._x_hideChildren;
                                return carry;
                            };
                            hideAfterChildren(el).catch((e) => {
                                if (!e.isFromCancelledTransition)
                                    throw e;
                            });
                        });
                    }
                });
            };

            function closestHide(el) {
                let parent = el.parentNode;
                if (!parent)
                    return;
                return parent._x_hidePromise ? parent : closestHide(parent);
            }

            function transition(el, setFunction, {during, start: start2, end} = {}, before = () => {
            }, after = () => {
            }) {
                if (el._x_transitioning)
                    el._x_transitioning.cancel();
                if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) {
                    before();
                    after();
                    return;
                }
                let undoStart, undoDuring, undoEnd;
                performTransition(el, {
                    start() {
                        undoStart = setFunction(el, start2);
                    },
                    during() {
                        undoDuring = setFunction(el, during);
                    },
                    before,
                    end() {
                        undoStart();
                        undoEnd = setFunction(el, end);
                    },
                    after,
                    cleanup() {
                        undoDuring();
                        undoEnd();
                    }
                });
            }

            function performTransition(el, stages) {
                let interrupted, reachedBefore, reachedEnd;
                let finish = once(() => {
                    mutateDom(() => {
                        interrupted = true;
                        if (!reachedBefore)
                            stages.before();
                        if (!reachedEnd) {
                            stages.end();
                            releaseNextTicks();
                        }
                        stages.after();
                        if (el.isConnected)
                            stages.cleanup();
                        delete el._x_transitioning;
                    });
                });
                el._x_transitioning = {
                    beforeCancels: [],
                    beforeCancel(callback) {
                        this.beforeCancels.push(callback);
                    },
                    cancel: once(function () {
                        while (this.beforeCancels.length) {
                            this.beforeCancels.shift()();
                        }
                        ;
                        finish();
                    }),
                    finish
                };
                mutateDom(() => {
                    stages.start();
                    stages.during();
                });
                holdNextTicks();
                requestAnimationFrame(() => {
                    if (interrupted)
                        return;
                    let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
                    let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
                    if (duration === 0)
                        duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
                    mutateDom(() => {
                        stages.before();
                    });
                    reachedBefore = true;
                    requestAnimationFrame(() => {
                        if (interrupted)
                            return;
                        mutateDom(() => {
                            stages.end();
                        });
                        releaseNextTicks();
                        setTimeout(el._x_transitioning.finish, duration + delay);
                        reachedEnd = true;
                    });
                });
            }

            function modifierValue(modifiers, key, fallback) {
                if (modifiers.indexOf(key) === -1)
                    return fallback;
                const rawValue = modifiers[modifiers.indexOf(key) + 1];
                if (!rawValue)
                    return fallback;
                if (key === "scale") {
                    if (isNaN(rawValue))
                        return fallback;
                }
                if (key === "duration") {
                    let match = rawValue.match(/([0-9]+)ms/);
                    if (match)
                        return match[1];
                }
                if (key === "origin") {
                    if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
                        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
                    }
                }
                return rawValue;
            }

// packages/alpinejs/src/clone.js
            var isCloning = false;

            function skipDuringClone(callback, fallback = () => {
            }) {
                return (...args) => isCloning ? fallback(...args) : callback(...args);
            }

            function clone(oldEl, newEl) {
                if (!newEl._x_dataStack)
                    newEl._x_dataStack = oldEl._x_dataStack;
                isCloning = true;
                dontRegisterReactiveSideEffects(() => {
                    cloneTree(newEl);
                });
                isCloning = false;
            }

            function cloneTree(el) {
                let hasRunThroughFirstEl = false;
                let shallowWalker = (el2, callback) => {
                    walk(el2, (el3, skip) => {
                        if (hasRunThroughFirstEl && isRoot(el3))
                            return skip();
                        hasRunThroughFirstEl = true;
                        callback(el3, skip);
                    });
                };
                initTree(el, shallowWalker);
            }

            function dontRegisterReactiveSideEffects(callback) {
                let cache = effect;
                overrideEffect((callback2, el) => {
                    let storedEffect = cache(callback2);
                    release(storedEffect);
                    return () => {
                    };
                });
                callback();
                overrideEffect(cache);
            }

// packages/alpinejs/src/utils/bind.js
            function bind(el, name, value, modifiers = []) {
                if (!el._x_bindings)
                    el._x_bindings = reactive({});
                el._x_bindings[name] = value;
                name = modifiers.includes("camel") ? camelCase(name) : name;
                switch (name) {
                    case "value":
                        bindInputValue(el, value);
                        break;
                    case "style":
                        bindStyles(el, value);
                        break;
                    case "class":
                        bindClasses(el, value);
                        break;
                    default:
                        bindAttribute(el, name, value);
                        break;
                }
            }

            function bindInputValue(el, value) {
                if (el.type === "radio") {
                    if (el.attributes.value === void 0) {
                        el.value = value;
                    }
                    if (window.fromModel) {
                        el.checked = checkedAttrLooseCompare(el.value, value);
                    }
                } else if (el.type === "checkbox") {
                    if (Number.isInteger(value)) {
                        el.value = value;
                    } else if (!Number.isInteger(value) && !Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {
                        el.value = String(value);
                    } else {
                        if (Array.isArray(value)) {
                            el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
                        } else {
                            el.checked = !!value;
                        }
                    }
                } else if (el.tagName === "SELECT") {
                    updateSelect(el, value);
                } else {
                    if (el.value === value)
                        return;
                    el.value = value;
                }
            }

            function bindClasses(el, value) {
                if (el._x_undoAddedClasses)
                    el._x_undoAddedClasses();
                el._x_undoAddedClasses = setClasses(el, value);
            }

            function bindStyles(el, value) {
                if (el._x_undoAddedStyles)
                    el._x_undoAddedStyles();
                el._x_undoAddedStyles = setStyles(el, value);
            }

            function bindAttribute(el, name, value) {
                if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
                    el.removeAttribute(name);
                } else {
                    if (isBooleanAttr(name))
                        value = name;
                    setIfChanged(el, name, value);
                }
            }

            function setIfChanged(el, attrName, value) {
                if (el.getAttribute(attrName) != value) {
                    el.setAttribute(attrName, value);
                }
            }

            function updateSelect(el, value) {
                const arrayWrappedValue = [].concat(value).map((value2) => {
                    return value2 + "";
                });
                Array.from(el.options).forEach((option) => {
                    option.selected = arrayWrappedValue.includes(option.value);
                });
            }

            function camelCase(subject) {
                return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
            }

            function checkedAttrLooseCompare(valueA, valueB) {
                return valueA == valueB;
            }

            function isBooleanAttr(attrName) {
                const booleanAttributes = [
                    "disabled",
                    "checked",
                    "required",
                    "readonly",
                    "hidden",
                    "open",
                    "selected",
                    "autofocus",
                    "itemscope",
                    "multiple",
                    "novalidate",
                    "allowfullscreen",
                    "allowpaymentrequest",
                    "formnovalidate",
                    "autoplay",
                    "controls",
                    "loop",
                    "muted",
                    "playsinline",
                    "default",
                    "ismap",
                    "reversed",
                    "async",
                    "defer",
                    "nomodule"
                ];
                return booleanAttributes.includes(attrName);
            }

            function attributeShouldntBePreservedIfFalsy(name) {
                return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
            }

            function getBinding(el, name, fallback) {
                if (el._x_bindings && el._x_bindings[name] !== void 0)
                    return el._x_bindings[name];
                let attr = el.getAttribute(name);
                if (attr === null)
                    return typeof fallback === "function" ? fallback() : fallback;
                if (isBooleanAttr(name)) {
                    return !![name, "true"].includes(attr);
                }
                if (attr === "")
                    return true;
                return attr;
            }

// packages/alpinejs/src/utils/debounce.js
            function debounce(func, wait) {
                var timeout;
                return function () {
                    var context = this, args = arguments;
                    var later = function () {
                        timeout = null;
                        func.apply(context, args);
                    };
                    clearTimeout(timeout);
                    timeout = setTimeout(later, wait);
                };
            }

// packages/alpinejs/src/utils/throttle.js
            function throttle(func, limit) {
                let inThrottle;
                return function () {
                    let context = this, args = arguments;
                    if (!inThrottle) {
                        func.apply(context, args);
                        inThrottle = true;
                        setTimeout(() => inThrottle = false, limit);
                    }
                };
            }

// packages/alpinejs/src/plugin.js
            function plugin(callback) {
                callback(alpine_default);
            }

// packages/alpinejs/src/store.js
            var stores = {};
            var isReactive = false;

            function store(name, value) {
                if (!isReactive) {
                    stores = reactive(stores);
                    isReactive = true;
                }
                if (value === void 0) {
                    return stores[name];
                }
                stores[name] = value;
                if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
                    stores[name].init();
                }
                initInterceptors(stores[name]);
            }

            function getStores() {
                return stores;
            }

// packages/alpinejs/src/binds.js
            var binds = {};

            function bind2(name, object) {
                binds[name] = typeof object !== "function" ? () => object : object;
            }

            function injectBindingProviders(obj) {
                Object.entries(binds).forEach(([name, callback]) => {
                    Object.defineProperty(obj, name, {
                        get() {
                            return (...args) => {
                                return callback(...args);
                            };
                        }
                    });
                });
                return obj;
            }

// packages/alpinejs/src/datas.js
            var datas = {};

            function data(name, callback) {
                datas[name] = callback;
            }

            function injectDataProviders(obj, context) {
                Object.entries(datas).forEach(([name, callback]) => {
                    Object.defineProperty(obj, name, {
                        get() {
                            return (...args) => {
                                return callback.bind(context)(...args);
                            };
                        },
                        enumerable: false
                    });
                });
                return obj;
            }

// packages/alpinejs/src/alpine.js
            var Alpine = {
                get reactive() {
                    return reactive;
                },
                get release() {
                    return release;
                },
                get effect() {
                    return effect;
                },
                get raw() {
                    return raw;
                },
                version: "3.10.0",
                flushAndStopDeferringMutations,
                dontAutoEvaluateFunctions,
                disableEffectScheduling,
                setReactivityEngine,
                closestDataStack,
                skipDuringClone,
                addRootSelector,
                addInitSelector,
                addScopeToNode,
                deferMutations,
                mapAttributes,
                evaluateLater,
                setEvaluator,
                mergeProxies,
                findClosest,
                closestRoot,
                interceptor,
                transition,
                setStyles,
                mutateDom,
                directive,
                throttle,
                debounce,
                evaluate,
                initTree,
                nextTick,
                prefixed: prefix,
                prefix: setPrefix,
                plugin,
                magic,
                store,
                start,
                clone,
                bound: getBinding,
                $data: scope,
                data,
                bind: bind2
            };
            var alpine_default = Alpine;

// node_modules/@vue/shared/dist/shared.esm-bundler.js
            function makeMap(str, expectsLowerCase) {
                const map = Object.create(null);
                const list = str.split(",");
                for (let i = 0; i < list.length; i++) {
                    map[list[i]] = true;
                }
                return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
            }

            var PatchFlagNames = {
                [1]: `TEXT`,
                [2]: `CLASS`,
                [4]: `STYLE`,
                [8]: `PROPS`,
                [16]: `FULL_PROPS`,
                [32]: `HYDRATE_EVENTS`,
                [64]: `STABLE_FRAGMENT`,
                [128]: `KEYED_FRAGMENT`,
                [256]: `UNKEYED_FRAGMENT`,
                [512]: `NEED_PATCH`,
                [1024]: `DYNAMIC_SLOTS`,
                [2048]: `DEV_ROOT_FRAGMENT`,
                [-1]: `HOISTED`,
                [-2]: `BAIL`
            };
            var slotFlagsText = {
                [1]: "STABLE",
                [2]: "DYNAMIC",
                [3]: "FORWARDED"
            };
            var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
            var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
            var EMPTY_OBJ = false ? 0 : {};
            var EMPTY_ARR = false ? 0 : [];
            var extend = Object.assign;
            var hasOwnProperty = Object.prototype.hasOwnProperty;
            var hasOwn = (val, key) => hasOwnProperty.call(val, key);
            var isArray = Array.isArray;
            var isMap = (val) => toTypeString(val) === "[object Map]";
            var isString = (val) => typeof val === "string";
            var isSymbol = (val) => typeof val === "symbol";
            var isObject = (val) => val !== null && typeof val === "object";
            var objectToString = Object.prototype.toString;
            var toTypeString = (value) => objectToString.call(value);
            var toRawType = (value) => {
                return toTypeString(value).slice(8, -1);
            };
            var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
            var cacheStringFunction = (fn) => {
                const cache = Object.create(null);
                return (str) => {
                    const hit = cache[str];
                    return hit || (cache[str] = fn(str));
                };
            };
            var camelizeRE = /-(\w)/g;
            var camelize = cacheStringFunction((str) => {
                return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
            });
            var hyphenateRE = /\B([A-Z])/g;
            var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
            var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
            var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
            var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);

// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
            var targetMap = new WeakMap();
            var effectStack = [];
            var activeEffect;
            var ITERATE_KEY = Symbol(false ? 0 : "");
            var MAP_KEY_ITERATE_KEY = Symbol(false ? 0 : "");

            function isEffect(fn) {
                return fn && fn._isEffect === true;
            }

            function effect2(fn, options = EMPTY_OBJ) {
                if (isEffect(fn)) {
                    fn = fn.raw;
                }
                const effect3 = createReactiveEffect(fn, options);
                if (!options.lazy) {
                    effect3();
                }
                return effect3;
            }

            function stop(effect3) {
                if (effect3.active) {
                    cleanup(effect3);
                    if (effect3.options.onStop) {
                        effect3.options.onStop();
                    }
                    effect3.active = false;
                }
            }

            var uid = 0;

            function createReactiveEffect(fn, options) {
                const effect3 = function reactiveEffect() {
                    if (!effect3.active) {
                        return fn();
                    }
                    if (!effectStack.includes(effect3)) {
                        cleanup(effect3);
                        try {
                            enableTracking();
                            effectStack.push(effect3);
                            activeEffect = effect3;
                            return fn();
                        } finally {
                            effectStack.pop();
                            resetTracking();
                            activeEffect = effectStack[effectStack.length - 1];
                        }
                    }
                };
                effect3.id = uid++;
                effect3.allowRecurse = !!options.allowRecurse;
                effect3._isEffect = true;
                effect3.active = true;
                effect3.raw = fn;
                effect3.deps = [];
                effect3.options = options;
                return effect3;
            }

            function cleanup(effect3) {
                const {deps} = effect3;
                if (deps.length) {
                    for (let i = 0; i < deps.length; i++) {
                        deps[i].delete(effect3);
                    }
                    deps.length = 0;
                }
            }

            var shouldTrack = true;
            var trackStack = [];

            function pauseTracking() {
                trackStack.push(shouldTrack);
                shouldTrack = false;
            }

            function enableTracking() {
                trackStack.push(shouldTrack);
                shouldTrack = true;
            }

            function resetTracking() {
                const last = trackStack.pop();
                shouldTrack = last === void 0 ? true : last;
            }

            function track(target, type, key) {
                if (!shouldTrack || activeEffect === void 0) {
                    return;
                }
                let depsMap = targetMap.get(target);
                if (!depsMap) {
                    targetMap.set(target, depsMap = new Map());
                }
                let dep = depsMap.get(key);
                if (!dep) {
                    depsMap.set(key, dep = new Set());
                }
                if (!dep.has(activeEffect)) {
                    dep.add(activeEffect);
                    activeEffect.deps.push(dep);
                    if (false) {
                    }
                }
            }

            function trigger(target, type, key, newValue, oldValue, oldTarget) {
                const depsMap = targetMap.get(target);
                if (!depsMap) {
                    return;
                }
                const effects = new Set();
                const add2 = (effectsToAdd) => {
                    if (effectsToAdd) {
                        effectsToAdd.forEach((effect3) => {
                            if (effect3 !== activeEffect || effect3.allowRecurse) {
                                effects.add(effect3);
                            }
                        });
                    }
                };
                if (type === "clear") {
                    depsMap.forEach(add2);
                } else if (key === "length" && isArray(target)) {
                    depsMap.forEach((dep, key2) => {
                        if (key2 === "length" || key2 >= newValue) {
                            add2(dep);
                        }
                    });
                } else {
                    if (key !== void 0) {
                        add2(depsMap.get(key));
                    }
                    switch (type) {
                        case "add":
                            if (!isArray(target)) {
                                add2(depsMap.get(ITERATE_KEY));
                                if (isMap(target)) {
                                    add2(depsMap.get(MAP_KEY_ITERATE_KEY));
                                }
                            } else if (isIntegerKey(key)) {
                                add2(depsMap.get("length"));
                            }
                            break;
                        case "delete":
                            if (!isArray(target)) {
                                add2(depsMap.get(ITERATE_KEY));
                                if (isMap(target)) {
                                    add2(depsMap.get(MAP_KEY_ITERATE_KEY));
                                }
                            }
                            break;
                        case "set":
                            if (isMap(target)) {
                                add2(depsMap.get(ITERATE_KEY));
                            }
                            break;
                    }
                }
                const run = (effect3) => {
                    if (false) {
                    }
                    if (effect3.options.scheduler) {
                        effect3.options.scheduler(effect3);
                    } else {
                        effect3();
                    }
                };
                effects.forEach(run);
            }

            var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
            var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
            var get2 = /* @__PURE__ */ createGetter();
            var shallowGet = /* @__PURE__ */ createGetter(false, true);
            var readonlyGet = /* @__PURE__ */ createGetter(true);
            var shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
            var arrayInstrumentations = {};
            ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
                const method = Array.prototype[key];
                arrayInstrumentations[key] = function (...args) {
                    const arr = toRaw(this);
                    for (let i = 0, l = this.length; i < l; i++) {
                        track(arr, "get", i + "");
                    }
                    const res = method.apply(arr, args);
                    if (res === -1 || res === false) {
                        return method.apply(arr, args.map(toRaw));
                    } else {
                        return res;
                    }
                };
            });
            ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
                const method = Array.prototype[key];
                arrayInstrumentations[key] = function (...args) {
                    pauseTracking();
                    const res = method.apply(this, args);
                    resetTracking();
                    return res;
                };
            });

            function createGetter(isReadonly = false, shallow = false) {
                return function get3(target, key, receiver) {
                    if (key === "__v_isReactive") {
                        return !isReadonly;
                    } else if (key === "__v_isReadonly") {
                        return isReadonly;
                    } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
                        return target;
                    }
                    const targetIsArray = isArray(target);
                    if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
                        return Reflect.get(arrayInstrumentations, key, receiver);
                    }
                    const res = Reflect.get(target, key, receiver);
                    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
                        return res;
                    }
                    if (!isReadonly) {
                        track(target, "get", key);
                    }
                    if (shallow) {
                        return res;
                    }
                    if (isRef(res)) {
                        const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
                        return shouldUnwrap ? res.value : res;
                    }
                    if (isObject(res)) {
                        return isReadonly ? readonly(res) : reactive2(res);
                    }
                    return res;
                };
            }

            var set2 = /* @__PURE__ */ createSetter();
            var shallowSet = /* @__PURE__ */ createSetter(true);

            function createSetter(shallow = false) {
                return function set3(target, key, value, receiver) {
                    let oldValue = target[key];
                    if (!shallow) {
                        value = toRaw(value);
                        oldValue = toRaw(oldValue);
                        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
                            oldValue.value = value;
                            return true;
                        }
                    }
                    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
                    const result = Reflect.set(target, key, value, receiver);
                    if (target === toRaw(receiver)) {
                        if (!hadKey) {
                            trigger(target, "add", key, value);
                        } else if (hasChanged(value, oldValue)) {
                            trigger(target, "set", key, value, oldValue);
                        }
                    }
                    return result;
                };
            }

            function deleteProperty(target, key) {
                const hadKey = hasOwn(target, key);
                const oldValue = target[key];
                const result = Reflect.deleteProperty(target, key);
                if (result && hadKey) {
                    trigger(target, "delete", key, void 0, oldValue);
                }
                return result;
            }

            function has(target, key) {
                const result = Reflect.has(target, key);
                if (!isSymbol(key) || !builtInSymbols.has(key)) {
                    track(target, "has", key);
                }
                return result;
            }

            function ownKeys(target) {
                track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
                return Reflect.ownKeys(target);
            }

            var mutableHandlers = {
                get: get2,
                set: set2,
                deleteProperty,
                has,
                ownKeys
            };
            var readonlyHandlers = {
                get: readonlyGet,
                set(target, key) {
                    if (false) {
                    }
                    return true;
                },
                deleteProperty(target, key) {
                    if (false) {
                    }
                    return true;
                }
            };
            var shallowReactiveHandlers = extend({}, mutableHandlers, {
                get: shallowGet,
                set: shallowSet
            });
            var shallowReadonlyHandlers = extend({}, readonlyHandlers, {
                get: shallowReadonlyGet
            });
            var toReactive = (value) => isObject(value) ? reactive2(value) : value;
            var toReadonly = (value) => isObject(value) ? readonly(value) : value;
            var toShallow = (value) => value;
            var getProto = (v) => Reflect.getPrototypeOf(v);

            function get$1(target, key, isReadonly = false, isShallow = false) {
                target = target["__v_raw"];
                const rawTarget = toRaw(target);
                const rawKey = toRaw(key);
                if (key !== rawKey) {
                    !isReadonly && track(rawTarget, "get", key);
                }
                !isReadonly && track(rawTarget, "get", rawKey);
                const {has: has2} = getProto(rawTarget);
                const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
                if (has2.call(rawTarget, key)) {
                    return wrap(target.get(key));
                } else if (has2.call(rawTarget, rawKey)) {
                    return wrap(target.get(rawKey));
                } else if (target !== rawTarget) {
                    target.get(key);
                }
            }

            function has$1(key, isReadonly = false) {
                const target = this["__v_raw"];
                const rawTarget = toRaw(target);
                const rawKey = toRaw(key);
                if (key !== rawKey) {
                    !isReadonly && track(rawTarget, "has", key);
                }
                !isReadonly && track(rawTarget, "has", rawKey);
                return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
            }

            function size(target, isReadonly = false) {
                target = target["__v_raw"];
                !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
                return Reflect.get(target, "size", target);
            }

            function add(value) {
                value = toRaw(value);
                const target = toRaw(this);
                const proto = getProto(target);
                const hadKey = proto.has.call(target, value);
                if (!hadKey) {
                    target.add(value);
                    trigger(target, "add", value, value);
                }
                return this;
            }

            function set$1(key, value) {
                value = toRaw(value);
                const target = toRaw(this);
                const {has: has2, get: get3} = getProto(target);
                let hadKey = has2.call(target, key);
                if (!hadKey) {
                    key = toRaw(key);
                    hadKey = has2.call(target, key);
                } else if (false) {
                }
                const oldValue = get3.call(target, key);
                target.set(key, value);
                if (!hadKey) {
                    trigger(target, "add", key, value);
                } else if (hasChanged(value, oldValue)) {
                    trigger(target, "set", key, value, oldValue);
                }
                return this;
            }

            function deleteEntry(key) {
                const target = toRaw(this);
                const {has: has2, get: get3} = getProto(target);
                let hadKey = has2.call(target, key);
                if (!hadKey) {
                    key = toRaw(key);
                    hadKey = has2.call(target, key);
                } else if (false) {
                }
                const oldValue = get3 ? get3.call(target, key) : void 0;
                const result = target.delete(key);
                if (hadKey) {
                    trigger(target, "delete", key, void 0, oldValue);
                }
                return result;
            }

            function clear() {
                const target = toRaw(this);
                const hadItems = target.size !== 0;
                const oldTarget = false ? 0 : void 0;
                const result = target.clear();
                if (hadItems) {
                    trigger(target, "clear", void 0, void 0, oldTarget);
                }
                return result;
            }

            function createForEach(isReadonly, isShallow) {
                return function forEach(callback, thisArg) {
                    const observed = this;
                    const target = observed["__v_raw"];
                    const rawTarget = toRaw(target);
                    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
                    !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
                    return target.forEach((value, key) => {
                        return callback.call(thisArg, wrap(value), wrap(key), observed);
                    });
                };
            }

            function createIterableMethod(method, isReadonly, isShallow) {
                return function (...args) {
                    const target = this["__v_raw"];
                    const rawTarget = toRaw(target);
                    const targetIsMap = isMap(rawTarget);
                    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
                    const isKeyOnly = method === "keys" && targetIsMap;
                    const innerIterator = target[method](...args);
                    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
                    !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
                    return {
                        next() {
                            const {value, done} = innerIterator.next();
                            return done ? {value, done} : {
                                value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
                                done
                            };
                        },
                        [Symbol.iterator]() {
                            return this;
                        }
                    };
                };
            }

            function createReadonlyMethod(type) {
                return function (...args) {
                    if (false) {
                    }
                    return type === "delete" ? false : this;
                };
            }

            var mutableInstrumentations = {
                get(key) {
                    return get$1(this, key);
                },
                get size() {
                    return size(this);
                },
                has: has$1,
                add,
                set: set$1,
                delete: deleteEntry,
                clear,
                forEach: createForEach(false, false)
            };
            var shallowInstrumentations = {
                get(key) {
                    return get$1(this, key, false, true);
                },
                get size() {
                    return size(this);
                },
                has: has$1,
                add,
                set: set$1,
                delete: deleteEntry,
                clear,
                forEach: createForEach(false, true)
            };
            var readonlyInstrumentations = {
                get(key) {
                    return get$1(this, key, true);
                },
                get size() {
                    return size(this, true);
                },
                has(key) {
                    return has$1.call(this, key, true);
                },
                add: createReadonlyMethod("add"),
                set: createReadonlyMethod("set"),
                delete: createReadonlyMethod("delete"),
                clear: createReadonlyMethod("clear"),
                forEach: createForEach(true, false)
            };
            var shallowReadonlyInstrumentations = {
                get(key) {
                    return get$1(this, key, true, true);
                },
                get size() {
                    return size(this, true);
                },
                has(key) {
                    return has$1.call(this, key, true);
                },
                add: createReadonlyMethod("add"),
                set: createReadonlyMethod("set"),
                delete: createReadonlyMethod("delete"),
                clear: createReadonlyMethod("clear"),
                forEach: createForEach(true, true)
            };
            var iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
            iteratorMethods.forEach((method) => {
                mutableInstrumentations[method] = createIterableMethod(method, false, false);
                readonlyInstrumentations[method] = createIterableMethod(method, true, false);
                shallowInstrumentations[method] = createIterableMethod(method, false, true);
                shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
            });

            function createInstrumentationGetter(isReadonly, shallow) {
                const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
                return (target, key, receiver) => {
                    if (key === "__v_isReactive") {
                        return !isReadonly;
                    } else if (key === "__v_isReadonly") {
                        return isReadonly;
                    } else if (key === "__v_raw") {
                        return target;
                    }
                    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
                };
            }

            var mutableCollectionHandlers = {
                get: createInstrumentationGetter(false, false)
            };
            var shallowCollectionHandlers = {
                get: createInstrumentationGetter(false, true)
            };
            var readonlyCollectionHandlers = {
                get: createInstrumentationGetter(true, false)
            };
            var shallowReadonlyCollectionHandlers = {
                get: createInstrumentationGetter(true, true)
            };
            var reactiveMap = new WeakMap();
            var shallowReactiveMap = new WeakMap();
            var readonlyMap = new WeakMap();
            var shallowReadonlyMap = new WeakMap();

            function targetTypeMap(rawType) {
                switch (rawType) {
                    case "Object":
                    case "Array":
                        return 1;
                    case "Map":
                    case "Set":
                    case "WeakMap":
                    case "WeakSet":
                        return 2;
                    default:
                        return 0;
                }
            }

            function getTargetType(value) {
                return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
            }

            function reactive2(target) {
                if (target && target["__v_isReadonly"]) {
                    return target;
                }
                return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
            }

            function readonly(target) {
                return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
            }

            function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
                if (!isObject(target)) {
                    if (false) {
                    }
                    return target;
                }
                if (target["__v_raw"] && !(isReadonly && target["__v_isReactive"])) {
                    return target;
                }
                const existingProxy = proxyMap.get(target);
                if (existingProxy) {
                    return existingProxy;
                }
                const targetType = getTargetType(target);
                if (targetType === 0) {
                    return target;
                }
                const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
                proxyMap.set(target, proxy);
                return proxy;
            }

            function toRaw(observed) {
                return observed && toRaw(observed["__v_raw"]) || observed;
            }

            function isRef(r) {
                return Boolean(r && r.__v_isRef === true);
            }

// packages/alpinejs/src/magics/$nextTick.js
            magic("nextTick", () => nextTick);

// packages/alpinejs/src/magics/$dispatch.js
            magic("dispatch", (el) => dispatch.bind(dispatch, el));

// packages/alpinejs/src/magics/$watch.js
            magic("watch", (el, {evaluateLater: evaluateLater2, effect: effect3}) => (key, callback) => {
                let evaluate2 = evaluateLater2(key);
                let firstTime = true;
                let oldValue;
                let effectReference = effect3(() => evaluate2((value) => {
                    JSON.stringify(value);
                    if (!firstTime) {
                        queueMicrotask(() => {
                            callback(value, oldValue);
                            oldValue = value;
                        });
                    } else {
                        oldValue = value;
                    }
                    firstTime = false;
                }));
                el._x_effects.delete(effectReference);
            });

// packages/alpinejs/src/magics/$store.js
            magic("store", getStores);

// packages/alpinejs/src/magics/$data.js
            magic("data", (el) => scope(el));

// packages/alpinejs/src/magics/$root.js
            magic("root", (el) => closestRoot(el));

// packages/alpinejs/src/magics/$refs.js
            magic("refs", (el) => {
                if (el._x_refs_proxy)
                    return el._x_refs_proxy;
                el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
                return el._x_refs_proxy;
            });

            function getArrayOfRefObject(el) {
                let refObjects = [];
                let currentEl = el;
                while (currentEl) {
                    if (currentEl._x_refs)
                        refObjects.push(currentEl._x_refs);
                    currentEl = currentEl.parentNode;
                }
                return refObjects;
            }

// packages/alpinejs/src/ids.js
            var globalIdMemo = {};

            function findAndIncrementId(name) {
                if (!globalIdMemo[name])
                    globalIdMemo[name] = 0;
                return ++globalIdMemo[name];
            }

            function closestIdRoot(el, name) {
                return findClosest(el, (element) => {
                    if (element._x_ids && element._x_ids[name])
                        return true;
                });
            }

            function setIdRoot(el, name) {
                if (!el._x_ids)
                    el._x_ids = {};
                if (!el._x_ids[name])
                    el._x_ids[name] = findAndIncrementId(name);
            }

// packages/alpinejs/src/magics/$id.js
            magic("id", (el) => (name, key = null) => {
                let root = closestIdRoot(el, name);
                let id = root ? root._x_ids[name] : findAndIncrementId(name);
                return key ? `${name}-${id}-${key}` : `${name}-${id}`;
            });

// packages/alpinejs/src/magics/$el.js
            magic("el", (el) => el);

// packages/alpinejs/src/magics/index.js
            warnMissingPluginMagic("Focus", "focus", "focus");
            warnMissingPluginMagic("Persist", "persist", "persist");

            function warnMissingPluginMagic(name, magicName, slug) {
                magic(magicName, (el) => warn(`You can't use [$${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
            }

// packages/alpinejs/src/directives/x-modelable.js
            directive("modelable", (el, {expression}, {effect: effect3, evaluateLater: evaluateLater2}) => {
                let func = evaluateLater2(expression);
                let innerGet = () => {
                    let result;
                    func((i) => result = i);
                    return result;
                };
                let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
                let innerSet = (val) => evaluateInnerSet(() => {
                }, {scope: {__placeholder: val}});
                let initialValue = innerGet();
                innerSet(initialValue);
                queueMicrotask(() => {
                    if (!el._x_model)
                        return;
                    el._x_removeModelListeners["default"]();
                    let outerGet = el._x_model.get;
                    let outerSet = el._x_model.set;
                    effect3(() => innerSet(outerGet()));
                    effect3(() => outerSet(innerGet()));
                });
            });

// packages/alpinejs/src/directives/x-teleport.js
            directive("teleport", (el, {expression}, {cleanup: cleanup2}) => {
                if (el.tagName.toLowerCase() !== "template")
                    warn("x-teleport can only be used on a <template> tag", el);
                let target = document.querySelector(expression);
                if (!target)
                    warn(`Cannot find x-teleport element for selector: "${expression}"`);
                let clone2 = el.content.cloneNode(true).firstElementChild;
                el._x_teleport = clone2;
                clone2._x_teleportBack = el;
                if (el._x_forwardEvents) {
                    el._x_forwardEvents.forEach((eventName) => {
                        clone2.addEventListener(eventName, (e) => {
                            e.stopPropagation();
                            el.dispatchEvent(new e.constructor(e.type, e));
                        });
                    });
                }
                addScopeToNode(clone2, {}, el);
                mutateDom(() => {
                    target.appendChild(clone2);
                    initTree(clone2);
                    clone2._x_ignore = true;
                });
                cleanup2(() => clone2.remove());
            });

// packages/alpinejs/src/directives/x-ignore.js
            var handler = () => {
            };
            handler.inline = (el, {modifiers}, {cleanup: cleanup2}) => {
                modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
                cleanup2(() => {
                    modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
                });
            };
            directive("ignore", handler);

// packages/alpinejs/src/directives/x-effect.js
            directive("effect", (el, {expression}, {effect: effect3}) => effect3(evaluateLater(el, expression)));

// packages/alpinejs/src/utils/on.js
            function on(el, event, modifiers, callback) {
                let listenerTarget = el;
                let handler3 = (e) => callback(e);
                let options = {};
                let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
                if (modifiers.includes("dot"))
                    event = dotSyntax(event);
                if (modifiers.includes("camel"))
                    event = camelCase2(event);
                if (modifiers.includes("passive"))
                    options.passive = true;
                if (modifiers.includes("capture"))
                    options.capture = true;
                if (modifiers.includes("window"))
                    listenerTarget = window;
                if (modifiers.includes("document"))
                    listenerTarget = document;
                if (modifiers.includes("prevent"))
                    handler3 = wrapHandler(handler3, (next, e) => {
                        e.preventDefault();
                        next(e);
                    });
                if (modifiers.includes("stop"))
                    handler3 = wrapHandler(handler3, (next, e) => {
                        e.stopPropagation();
                        next(e);
                    });
                if (modifiers.includes("self"))
                    handler3 = wrapHandler(handler3, (next, e) => {
                        e.target === el && next(e);
                    });
                if (modifiers.includes("away") || modifiers.includes("outside")) {
                    listenerTarget = document;
                    handler3 = wrapHandler(handler3, (next, e) => {
                        if (el.contains(e.target))
                            return;
                        if (e.target.isConnected === false)
                            return;
                        if (el.offsetWidth < 1 && el.offsetHeight < 1)
                            return;
                        if (el._x_isShown === false)
                            return;
                        next(e);
                    });
                }
                if (modifiers.includes("once")) {
                    handler3 = wrapHandler(handler3, (next, e) => {
                        next(e);
                        listenerTarget.removeEventListener(event, handler3, options);
                    });
                }
                handler3 = wrapHandler(handler3, (next, e) => {
                    if (isKeyEvent(event)) {
                        if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {
                            return;
                        }
                    }
                    next(e);
                });
                if (modifiers.includes("debounce")) {
                    let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
                    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
                    handler3 = debounce(handler3, wait);
                }
                if (modifiers.includes("throttle")) {
                    let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
                    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
                    handler3 = throttle(handler3, wait);
                }
                listenerTarget.addEventListener(event, handler3, options);
                return () => {
                    listenerTarget.removeEventListener(event, handler3, options);
                };
            }

            function dotSyntax(subject) {
                return subject.replace(/-/g, ".");
            }

            function camelCase2(subject) {
                return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
            }

            function isNumeric(subject) {
                return !Array.isArray(subject) && !isNaN(subject);
            }

            function kebabCase2(subject) {
                return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
            }

            function isKeyEvent(event) {
                return ["keydown", "keyup"].includes(event);
            }

            function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
                let keyModifiers = modifiers.filter((i) => {
                    return !["window", "document", "prevent", "stop", "once"].includes(i);
                });
                if (keyModifiers.includes("debounce")) {
                    let debounceIndex = keyModifiers.indexOf("debounce");
                    keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
                }
                if (keyModifiers.length === 0)
                    return false;
                if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0]))
                    return false;
                const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
                const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
                keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
                if (selectedSystemKeyModifiers.length > 0) {
                    const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
                        if (modifier === "cmd" || modifier === "super")
                            modifier = "meta";
                        return e[`${modifier}Key`];
                    });
                    if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
                        if (keyToModifiers(e.key).includes(keyModifiers[0]))
                            return false;
                    }
                }
                return true;
            }

            function keyToModifiers(key) {
                if (!key)
                    return [];
                key = kebabCase2(key);
                let modifierToKeyMap = {
                    ctrl: "control",
                    slash: "/",
                    space: "-",
                    spacebar: "-",
                    cmd: "meta",
                    esc: "escape",
                    up: "arrow-up",
                    down: "arrow-down",
                    left: "arrow-left",
                    right: "arrow-right",
                    period: ".",
                    equal: "="
                };
                modifierToKeyMap[key] = key;
                return Object.keys(modifierToKeyMap).map((modifier) => {
                    if (modifierToKeyMap[modifier] === key)
                        return modifier;
                }).filter((modifier) => modifier);
            }

// packages/alpinejs/src/directives/x-model.js
            directive("model", (el, {modifiers, expression}, {effect: effect3, cleanup: cleanup2}) => {
                let evaluate2 = evaluateLater(el, expression);
                let assignmentExpression = `${expression} = rightSideOfExpression($event, ${expression})`;
                let evaluateAssignment = evaluateLater(el, assignmentExpression);
                var event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) || modifiers.includes("lazy") ? "change" : "input";
                let assigmentFunction = generateAssignmentFunction(el, modifiers, expression);
                let removeListener = on(el, event, modifiers, (e) => {
                    evaluateAssignment(() => {
                    }, {
                        scope: {
                            $event: e,
                            rightSideOfExpression: assigmentFunction
                        }
                    });
                });
                if (!el._x_removeModelListeners)
                    el._x_removeModelListeners = {};
                el._x_removeModelListeners["default"] = removeListener;
                cleanup2(() => el._x_removeModelListeners["default"]());
                let evaluateSetModel = evaluateLater(el, `${expression} = __placeholder`);
                el._x_model = {
                    get() {
                        let result;
                        evaluate2((value) => result = value);
                        return result;
                    },
                    set(value) {
                        evaluateSetModel(() => {
                        }, {scope: {__placeholder: value}});
                    }
                };
                el._x_forceModelUpdate = () => {
                    evaluate2((value) => {
                        if (value === void 0 && expression.match(/\./))
                            value = "";
                        window.fromModel = true;
                        mutateDom(() => bind(el, "value", value));
                        delete window.fromModel;
                    });
                };
                effect3(() => {
                    if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el))
                        return;
                    el._x_forceModelUpdate();
                });
            });

            function generateAssignmentFunction(el, modifiers, expression) {
                if (el.type === "radio") {
                    mutateDom(() => {
                        if (!el.hasAttribute("name"))
                            el.setAttribute("name", expression);
                    });
                }
                return (event, currentValue) => {
                    return mutateDom(() => {
                        if (event instanceof CustomEvent && event.detail !== void 0) {
                            return event.detail || event.target.value;
                        } else if (el.type === "checkbox") {
                            if (Array.isArray(currentValue)) {
                                let newValue = modifiers.includes("number") ? safeParseNumber(event.target.value) : event.target.value;
                                return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
                            } else {
                                return event.target.checked;
                            }
                        } else if (el.tagName.toLowerCase() === "select" && el.multiple) {
                            return modifiers.includes("number") ? Array.from(event.target.selectedOptions).map((option) => {
                                let rawValue = option.value || option.text;
                                return safeParseNumber(rawValue);
                            }) : Array.from(event.target.selectedOptions).map((option) => {
                                return option.value || option.text;
                            });
                        } else {
                            let rawValue = event.target.value;
                            return modifiers.includes("number") ? safeParseNumber(rawValue) : modifiers.includes("trim") ? rawValue.trim() : rawValue;
                        }
                    });
                };
            }

            function safeParseNumber(rawValue) {
                let number = rawValue ? parseFloat(rawValue) : null;
                return isNumeric2(number) ? number : rawValue;
            }

            function checkedAttrLooseCompare2(valueA, valueB) {
                return valueA == valueB;
            }

            function isNumeric2(subject) {
                return !Array.isArray(subject) && !isNaN(subject);
            }

// packages/alpinejs/src/directives/x-cloak.js
            directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));

// packages/alpinejs/src/directives/x-init.js
            addInitSelector(() => `[${prefix("init")}]`);
            directive("init", skipDuringClone((el, {expression}, {evaluate: evaluate2}) => {
                if (typeof expression === "string") {
                    return !!expression.trim() && evaluate2(expression, {}, false);
                }
                return evaluate2(expression, {}, false);
            }));

// packages/alpinejs/src/directives/x-text.js
            directive("text", (el, {expression}, {effect: effect3, evaluateLater: evaluateLater2}) => {
                let evaluate2 = evaluateLater2(expression);
                effect3(() => {
                    evaluate2((value) => {
                        mutateDom(() => {
                            el.textContent = value;
                        });
                    });
                });
            });

// packages/alpinejs/src/directives/x-html.js
            directive("html", (el, {expression}, {effect: effect3, evaluateLater: evaluateLater2}) => {
                let evaluate2 = evaluateLater2(expression);
                effect3(() => {
                    evaluate2((value) => {
                        mutateDom(() => {
                            el.innerHTML = value;
                            el._x_ignoreSelf = true;
                            initTree(el);
                            delete el._x_ignoreSelf;
                        });
                    });
                });
            });

// packages/alpinejs/src/directives/x-bind.js
            mapAttributes(startingWith(":", into(prefix("bind:"))));
            directive("bind", (el, {value, modifiers, expression, original}, {effect: effect3}) => {
                if (!value) {
                    return applyBindingsObject(el, expression, original, effect3);
                }
                if (value === "key")
                    return storeKeyForXFor(el, expression);
                let evaluate2 = evaluateLater(el, expression);
                effect3(() => evaluate2((result) => {
                    if (result === void 0 && expression.match(/\./))
                        result = "";
                    mutateDom(() => bind(el, value, result, modifiers));
                }));
            });

            function applyBindingsObject(el, expression, original, effect3) {
                let bindingProviders = {};
                injectBindingProviders(bindingProviders);
                let getBindings = evaluateLater(el, expression);
                let cleanupRunners = [];
                while (cleanupRunners.length)
                    cleanupRunners.pop()();
                getBindings((bindings) => {
                    let attributes = Object.entries(bindings).map(([name, value]) => ({name, value}));
                    let staticAttributes = attributesOnly(attributes);
                    attributes = attributes.map((attribute) => {
                        if (staticAttributes.find((attr) => attr.name === attribute.name)) {
                            return {
                                name: `x-bind:${attribute.name}`,
                                value: `"${attribute.value}"`
                            };
                        }
                        return attribute;
                    });
                    directives(el, attributes, original).map((handle) => {
                        cleanupRunners.push(handle.runCleanups);
                        handle();
                    });
                }, {scope: bindingProviders});
            }

            function storeKeyForXFor(el, expression) {
                el._x_keyExpression = expression;
            }

// packages/alpinejs/src/directives/x-data.js
            addRootSelector(() => `[${prefix("data")}]`);
            directive("data", skipDuringClone((el, {expression}, {cleanup: cleanup2}) => {
                expression = expression === "" ? "{}" : expression;
                let magicContext = {};
                injectMagics(magicContext, el);
                let dataProviderContext = {};
                injectDataProviders(dataProviderContext, magicContext);
                let data2 = evaluate(el, expression, {scope: dataProviderContext});
                if (data2 === void 0)
                    data2 = {};
                injectMagics(data2, el);
                let reactiveData = reactive(data2);
                initInterceptors(reactiveData);
                let undo = addScopeToNode(el, reactiveData);
                reactiveData["init"] && evaluate(el, reactiveData["init"]);
                cleanup2(() => {
                    reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
                    undo();
                });
            }));

// packages/alpinejs/src/directives/x-show.js
            directive("show", (el, {modifiers, expression}, {effect: effect3}) => {
                let evaluate2 = evaluateLater(el, expression);
                if (!el._x_doHide)
                    el._x_doHide = () => {
                        mutateDom(() => el.style.display = "none");
                    };
                if (!el._x_doShow)
                    el._x_doShow = () => {
                        mutateDom(() => {
                            if (el.style.length === 1 && el.style.display === "none") {
                                el.removeAttribute("style");
                            } else {
                                el.style.removeProperty("display");
                            }
                        });
                    };
                let hide = () => {
                    el._x_doHide();
                    el._x_isShown = false;
                };
                let show = () => {
                    el._x_doShow();
                    el._x_isShown = true;
                };
                let clickAwayCompatibleShow = () => setTimeout(show);
                let toggle = once((value) => value ? show() : hide(), (value) => {
                    if (typeof el._x_toggleAndCascadeWithTransitions === "function") {
                        el._x_toggleAndCascadeWithTransitions(el, value, show, hide);
                    } else {
                        value ? clickAwayCompatibleShow() : hide();
                    }
                });
                let oldValue;
                let firstTime = true;
                effect3(() => evaluate2((value) => {
                    if (!firstTime && value === oldValue)
                        return;
                    if (modifiers.includes("immediate"))
                        value ? clickAwayCompatibleShow() : hide();
                    toggle(value);
                    oldValue = value;
                    firstTime = false;
                }));
            });

// packages/alpinejs/src/directives/x-for.js
            directive("for", (el, {expression}, {effect: effect3, cleanup: cleanup2}) => {
                let iteratorNames = parseForExpression(expression);
                let evaluateItems = evaluateLater(el, iteratorNames.items);
                let evaluateKey = evaluateLater(el, el._x_keyExpression || "index");
                el._x_prevKeys = [];
                el._x_lookup = {};
                effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey));
                cleanup2(() => {
                    Object.values(el._x_lookup).forEach((el2) => el2.remove());
                    delete el._x_prevKeys;
                    delete el._x_lookup;
                });
            });

            function loop(el, iteratorNames, evaluateItems, evaluateKey) {
                let isObject2 = (i) => typeof i === "object" && !Array.isArray(i);
                let templateEl = el;
                evaluateItems((items) => {
                    if (isNumeric3(items) && items >= 0) {
                        items = Array.from(Array(items).keys(), (i) => i + 1);
                    }
                    if (items === void 0)
                        items = [];
                    let lookup = el._x_lookup;
                    let prevKeys = el._x_prevKeys;
                    let scopes = [];
                    let keys = [];
                    if (isObject2(items)) {
                        items = Object.entries(items).map(([key, value]) => {
                            let scope2 = getIterationScopeVariables(iteratorNames, value, key, items);
                            evaluateKey((value2) => keys.push(value2), {scope: {index: key, ...scope2}});
                            scopes.push(scope2);
                        });
                    } else {
                        for (let i = 0; i < items.length; i++) {
                            let scope2 = getIterationScopeVariables(iteratorNames, items[i], i, items);
                            evaluateKey((value) => keys.push(value), {scope: {index: i, ...scope2}});
                            scopes.push(scope2);
                        }
                    }
                    let adds = [];
                    let moves = [];
                    let removes = [];
                    let sames = [];
                    for (let i = 0; i < prevKeys.length; i++) {
                        let key = prevKeys[i];
                        if (keys.indexOf(key) === -1)
                            removes.push(key);
                    }
                    prevKeys = prevKeys.filter((key) => !removes.includes(key));
                    let lastKey = "template";
                    for (let i = 0; i < keys.length; i++) {
                        let key = keys[i];
                        let prevIndex = prevKeys.indexOf(key);
                        if (prevIndex === -1) {
                            prevKeys.splice(i, 0, key);
                            adds.push([lastKey, i]);
                        } else if (prevIndex !== i) {
                            let keyInSpot = prevKeys.splice(i, 1)[0];
                            let keyForSpot = prevKeys.splice(prevIndex - 1, 1)[0];
                            prevKeys.splice(i, 0, keyForSpot);
                            prevKeys.splice(prevIndex, 0, keyInSpot);
                            moves.push([keyInSpot, keyForSpot]);
                        } else {
                            sames.push(key);
                        }
                        lastKey = key;
                    }
                    for (let i = 0; i < removes.length; i++) {
                        let key = removes[i];
                        if (!!lookup[key]._x_effects) {
                            lookup[key]._x_effects.forEach(dequeueJob);
                        }
                        lookup[key].remove();
                        lookup[key] = null;
                        delete lookup[key];
                    }
                    for (let i = 0; i < moves.length; i++) {
                        let [keyInSpot, keyForSpot] = moves[i];
                        let elInSpot = lookup[keyInSpot];
                        let elForSpot = lookup[keyForSpot];
                        let marker = document.createElement("div");
                        mutateDom(() => {
                            elForSpot.after(marker);
                            elInSpot.after(elForSpot);
                            elForSpot._x_currentIfEl && elForSpot.after(elForSpot._x_currentIfEl);
                            marker.before(elInSpot);
                            elInSpot._x_currentIfEl && elInSpot.after(elInSpot._x_currentIfEl);
                            marker.remove();
                        });
                        refreshScope(elForSpot, scopes[keys.indexOf(keyForSpot)]);
                    }
                    for (let i = 0; i < adds.length; i++) {
                        let [lastKey2, index] = adds[i];
                        let lastEl = lastKey2 === "template" ? templateEl : lookup[lastKey2];
                        if (lastEl._x_currentIfEl)
                            lastEl = lastEl._x_currentIfEl;
                        let scope2 = scopes[index];
                        let key = keys[index];
                        let clone2 = document.importNode(templateEl.content, true).firstElementChild;
                        addScopeToNode(clone2, reactive(scope2), templateEl);
                        mutateDom(() => {
                            lastEl.after(clone2);
                            initTree(clone2);
                        });
                        if (typeof key === "object") {
                            warn("x-for key cannot be an object, it must be a string or an integer", templateEl);
                        }
                        lookup[key] = clone2;
                    }
                    for (let i = 0; i < sames.length; i++) {
                        refreshScope(lookup[sames[i]], scopes[keys.indexOf(sames[i])]);
                    }
                    templateEl._x_prevKeys = keys;
                });
            }

            function parseForExpression(expression) {
                let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
                let stripParensRE = /^\s*\(|\)\s*$/g;
                let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
                let inMatch = expression.match(forAliasRE);
                if (!inMatch)
                    return;
                let res = {};
                res.items = inMatch[2].trim();
                let item = inMatch[1].replace(stripParensRE, "").trim();
                let iteratorMatch = item.match(forIteratorRE);
                if (iteratorMatch) {
                    res.item = item.replace(forIteratorRE, "").trim();
                    res.index = iteratorMatch[1].trim();
                    if (iteratorMatch[2]) {
                        res.collection = iteratorMatch[2].trim();
                    }
                } else {
                    res.item = item;
                }
                return res;
            }

            function getIterationScopeVariables(iteratorNames, item, index, items) {
                let scopeVariables = {};
                if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) {
                    let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
                    names.forEach((name, i) => {
                        scopeVariables[name] = item[i];
                    });
                } else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") {
                    let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim());
                    names.forEach((name) => {
                        scopeVariables[name] = item[name];
                    });
                } else {
                    scopeVariables[iteratorNames.item] = item;
                }
                if (iteratorNames.index)
                    scopeVariables[iteratorNames.index] = index;
                if (iteratorNames.collection)
                    scopeVariables[iteratorNames.collection] = items;
                return scopeVariables;
            }

            function isNumeric3(subject) {
                return !Array.isArray(subject) && !isNaN(subject);
            }

// packages/alpinejs/src/directives/x-ref.js
            function handler2() {
            }

            handler2.inline = (el, {expression}, {cleanup: cleanup2}) => {
                let root = closestRoot(el);
                if (!root._x_refs)
                    root._x_refs = {};
                root._x_refs[expression] = el;
                cleanup2(() => delete root._x_refs[expression]);
            };
            directive("ref", handler2);

// packages/alpinejs/src/directives/x-if.js
            directive("if", (el, {expression}, {effect: effect3, cleanup: cleanup2}) => {
                let evaluate2 = evaluateLater(el, expression);
                let show = () => {
                    if (el._x_currentIfEl)
                        return el._x_currentIfEl;
                    let clone2 = el.content.cloneNode(true).firstElementChild;
                    addScopeToNode(clone2, {}, el);
                    mutateDom(() => {
                        el.after(clone2);
                        initTree(clone2);
                    });
                    el._x_currentIfEl = clone2;
                    el._x_undoIf = () => {
                        walk(clone2, (node) => {
                            if (!!node._x_effects) {
                                node._x_effects.forEach(dequeueJob);
                            }
                        });
                        clone2.remove();
                        delete el._x_currentIfEl;
                    };
                    return clone2;
                };
                let hide = () => {
                    if (!el._x_undoIf)
                        return;
                    el._x_undoIf();
                    delete el._x_undoIf;
                };
                effect3(() => evaluate2((value) => {
                    value ? show() : hide();
                }));
                cleanup2(() => el._x_undoIf && el._x_undoIf());
            });

// packages/alpinejs/src/directives/x-id.js
            directive("id", (el, {expression}, {evaluate: evaluate2}) => {
                let names = evaluate2(expression);
                names.forEach((name) => setIdRoot(el, name));
            });

// packages/alpinejs/src/directives/x-on.js
            mapAttributes(startingWith("@", into(prefix("on:"))));
            directive("on", skipDuringClone((el, {value, modifiers, expression}, {cleanup: cleanup2}) => {
                let evaluate2 = expression ? evaluateLater(el, expression) : () => {
                };
                if (el.tagName.toLowerCase() === "template") {
                    if (!el._x_forwardEvents)
                        el._x_forwardEvents = [];
                    if (!el._x_forwardEvents.includes(value))
                        el._x_forwardEvents.push(value);
                }
                let removeListener = on(el, value, modifiers, (e) => {
                    evaluate2(() => {
                    }, {scope: {$event: e}, params: [e]});
                });
                cleanup2(() => removeListener());
            }));

// packages/alpinejs/src/directives/index.js
            warnMissingPluginDirective("Collapse", "collapse", "collapse");
            warnMissingPluginDirective("Intersect", "intersect", "intersect");
            warnMissingPluginDirective("Focus", "trap", "focus");
            warnMissingPluginDirective("Mask", "mask", "mask");

            function warnMissingPluginDirective(name, directiveName2, slug) {
                directive(directiveName2, (el) => warn(`You can't use [x-${directiveName2}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
            }

// packages/alpinejs/src/index.js
            alpine_default.setEvaluator(normalEvaluator);
            alpine_default.setReactivityEngine({reactive: reactive2, effect: effect2, release: stop, raw: toRaw});
            var src_default = alpine_default;

// packages/alpinejs/builds/module.js
            var module_default = src_default;


            /***/
        }),

        /***/ "./resources/js/custom-datatable.js":
        /*!******************************************!*\
  !*** ./resources/js/custom-datatable.js ***!
  \******************************************/
        /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

            "use strict";


            var jsrender = __webpack_require__(/*! jsrender */ "./node_modules/jsrender/jsrender.js");

            window.handleSearchDatatable = function (tbl) {
                var filterSearch = document.querySelector('[data-datatable-filter="search"]');
                filterSearch.addEventListener('keyup', function (e) {
                    tbl.search(e.target.value).draw();
                });
                filterSearch.addEventListener('search', function (e) {
                    tbl.search(e.target.value).draw();
                });
            };

            $.extend($.fn.dataTable.defaults, {
                'paging': true,
                'info': true,
                'ordering': true,
                'autoWidth': false,
                'dom': '<"top"i>rt<"bottom"flp><"clear">',
                'language': {
                    'search': '',
                    'sSearch': 'Search',
                    'lengthMenu': '_MENU_'
                },
                "preDrawCallback": function preDrawCallback() {
                    customSearch();
                }
            });
            /* Default class modification */

            $.extend($.fn.dataTable.ext.classes, {
                sLengthSelect: "form-select"
            });

            function customSearch() {
                $('.dataTables_filter input').addClass("form-control");
                $('.dataTables_filter input').attr("placeholder", "Search");
            }

            window.prepareTemplateRender = function (templateSelector, data) {
                var template = jsrender.templates(templateSelector);
                return template.render(data);
            };

            /***/
        }),

        /***/ "./node_modules/jsrender/jsrender.js":
        /*!*******************************************!*\
  !*** ./node_modules/jsrender/jsrender.js ***!
  \*******************************************/
        /***/ ((module) => {

            /*! JsRender v1.0.11: http://jsviews.com/#jsrender */
            /*! **VERSION FOR WEB** (For NODE.JS see http://jsviews.com/download/jsrender-node.js) */
            /*
 * Best-of-breed templating in browser or on Node.js.
 * Does not require jQuery, or HTML DOM
 * Integrates with JsViews (http://jsviews.com/#jsviews)
 *
 * Copyright 2021, Boris Moore
 * Released under the MIT License.
 */

//jshint -W018, -W041, -W120

            (function (factory, global) {
                // global var is the this object, which is window when running in the usual browser environment
                var $ = global.jQuery;

                if (true) { // CommonJS e.g. Browserify
                    module.exports = $
                        ? factory(global, $)
                        : function ($) { // If no global jQuery, take optional jQuery passed as parameter: require('jsrender')(jQuery)
                            if ($ && !$.fn) {
                                throw "Provide jQuery or null";
                            }
                            return factory(global, $);
                        };
                } else {
                }
            }(
// factory (for jsrender.js)
                function (global, $) {
                    "use strict";

//========================== Top-level vars ==========================

// global var is the this object, which is window when running in the usual browser environment
                    var setGlobals = $ === false; // Only set globals if script block in browser (not AMD and not CommonJS)

                    $ = $ && $.fn ? $ : global.jQuery; // $ is jQuery passed in by CommonJS loader (Browserify), or global jQuery.

                    var versionNumber = "v1.0.11",
                        jsvStoreName, rTag, rTmplString, topView, $views, $expando,
                        _ocp = "_ocp",      // Observable contextual parameter

                        $isFunction, $isArray, $templates, $converters, $helpers, $tags, $sub, $subSettings,
                        $subSettingsAdvanced, $viewsSettings,
                        delimOpenChar0, delimOpenChar1, delimCloseChar0, delimCloseChar1, linkChar, setting,
                        baseOnError,

                        isRenderCall,
                        rNewLine = /[ \t]*(\r\n|\n|\r)/g,
                        rUnescapeQuotes = /\\(['"\\])/g, // Unescape quotes and trim
                        rEscapeQuotes = /['"\\]/g, // Escape quotes and \ character
                        rBuildHash = /(?:\x08|^)(onerror:)?(?:(~?)(([\w$.]+):)?([^\x08]+))\x08(,)?([^\x08]+)/gi,
                        rTestElseIf = /^if\s/,
                        rFirstElem = /<(\w+)[>\s]/,
                        rAttrEncode = /[\x00`><"'&=]/g, // Includes > encoding since rConvertMarkers in JsViews does not skip > characters in attribute strings
                        rIsHtml = /[\x00`><\"'&=]/,
                        rHasHandlers = /^on[A-Z]|^convert(Back)?$/,
                        rWrappedInViewMarker = /^\#\d+_`[\s\S]*\/\d+_`$/,
                        rHtmlEncode = rAttrEncode,
                        rDataEncode = /[&<>]/g,
                        rDataUnencode = /&(amp|gt|lt);/g,
                        rBracketQuote = /\[['"]?|['"]?\]/g,
                        viewId = 0,
                        charEntities = {
                            "&": "&amp;",
                            "<": "&lt;",
                            ">": "&gt;",
                            "\x00": "&#0;",
                            "'": "&#39;",
                            '"': "&#34;",
                            "`": "&#96;",
                            "=": "&#61;"
                        },
                        charsFromEntities = {
                            amp: "&",
                            gt: ">",
                            lt: "<"
                        },
                        HTML = "html",
                        OBJECT = "object",
                        tmplAttr = "data-jsv-tmpl",
                        jsvTmpl = "jsvTmpl",
                        indexStr = "For #index in nested block use #getIndex().",
                        cpFnStore = {},     // Compiled furnctions for computed values in template expressions (properties, methods, helpers)
                        $render = {},

                        jsr = global.jsrender,
                        jsrToJq = jsr && $ && !$.render, // JsRender already loaded, without jQuery. but we will re-load it now to attach to jQuery

                        jsvStores = {
                            template: {
                                compile: compileTmpl
                            },
                            tag: {
                                compile: compileTag
                            },
                            viewModel: {
                                compile: compileViewModel
                            },
                            helper: {},
                            converter: {}
                        };

                    // views object ($.views if jQuery is loaded, jsrender.views if no jQuery, e.g. in Node.js)
                    $views = {
                        jsviews: versionNumber,
                        sub: {
                            // subscription, e.g. JsViews integration
                            rPath: /^(!*?)(?:null|true|false|\d[\d.]*|([\w$]+|\.|~([\w$]+)|#(view|([\w$]+))?)([\w$.^]*?)(?:[.[^]([\w$]+)\]?)?)$/g,
                            //        not                               object     helper    view  viewProperty pathTokens      leafToken

                            rPrm: /(\()(?=\s*\()|(?:([([])\s*)?(?:(\^?)(~?[\w$.^]+)?\s*((\+\+|--)|\+|-|~(?![\w$])|&&|\|\||===|!==|==|!=|<=|>=|[<>%*:?\/]|(=))\s*|(!*?(@)?[#~]?[\w$.^]+)([([])?)|(,\s*)|(?:(\()\s*)?\\?(?:(')|("))|(?:\s*(([)\]])(?=[.^]|\s*$|[^([])|[)\]])([([]?))|(\s+)/g,
                            //   lftPrn0           lftPrn         bound     path               operator     err                                          eq      path2 late            prn      comma  lftPrn2          apos quot        rtPrn  rtPrnDot                  prn2     space

                            View: View,
                            Err: JsViewsError,
                            tmplFn: tmplFn,
                            parse: parseParams,
                            extend: $extend,
                            extendCtx: extendCtx,
                            syntaxErr: syntaxError,
                            onStore: {
                                template: function (name, item) {
                                    if (item === null) {
                                        delete $render[name];
                                    } else if (name) {
                                        $render[name] = item;
                                    }
                                }
                            },
                            addSetting: addSetting,
                            settings: {
                                allowCode: false
                            },
                            advSet: noop, // Update advanced settings
                            _thp: tagHandlersFromProps,
                            _gm: getMethod,
                            _tg: function () {
                            }, // Constructor for tagDef
                            _cnvt: convertVal,
                            _tag: renderTag,
                            _er: error,
                            _err: onRenderError,
                            _cp: retVal, // Get observable contextual parameters (or properties) ~foo=expr. In JsRender, simply returns val.
                            _sq: function (token) {
                                if (token === "constructor") {
                                    syntaxError("");
                                }
                                return token;
                            }
                        },
                        settings: {
                            delimiters: $viewsDelimiters,
                            advanced: function (value) {
                                return value
                                    ? (
                                        $extend($subSettingsAdvanced, value),
                                            $sub.advSet(),
                                            $viewsSettings
                                    )
                                    : $subSettingsAdvanced;
                            }
                        },
                        map: dataMap // If jsObservable loaded first, use that definition of dataMap
                    };

                    function getDerivedMethod(baseMethod, method) {
                        return function () {
                            var ret,
                                tag = this,
                                prevBase = tag.base;

                            tag.base = baseMethod; // Within method call, calling this.base will call the base method
                            ret = method.apply(tag, arguments); // Call the method
                            tag.base = prevBase; // Replace this.base to be the base method of the previous call, for chained calls
                            return ret;
                        };
                    }

                    function getMethod(baseMethod, method) {
                        // For derived methods (or handlers declared declaratively as in {{:foo onChange=~fooChanged}} replace by a derived method, to allow using this.base(...)
                        // or this.baseApply(arguments) to call the base implementation. (Equivalent to this._super(...) and this._superApply(arguments) in jQuery UI)
                        if ($isFunction(method)) {
                            method = getDerivedMethod(
                                !baseMethod
                                    ? noop // no base method implementation, so use noop as base method
                                    : baseMethod._d
                                    ? baseMethod // baseMethod is a derived method, so use it
                                    : getDerivedMethod(noop, baseMethod), // baseMethod is not derived so make its base method be the noop method
                                method
                            );
                            method._d = (baseMethod && baseMethod._d || 0) + 1; // Add flag for derived method (incremented for derived of derived...)
                        }
                        return method;
                    }

                    function tagHandlersFromProps(tag, tagCtx) {
                        var prop,
                            props = tagCtx.props;
                        for (prop in props) {
                            if (rHasHandlers.test(prop) && !(tag[prop] && tag[prop].fix)) { // Don't override handlers with fix expando (used in datepicker and spinner)
                                tag[prop] = prop !== "convert" ? getMethod(tag.constructor.prototype[prop], props[prop]) : props[prop];
                                // Copy over the onFoo props, convert and convertBack from tagCtx.props to tag (overrides values in tagDef).
                                // Note: unsupported scenario: if handlers are dynamically added ^onFoo=expression this will work, but dynamically removing will not work.
                            }
                        }
                    }

                    function retVal(val) {
                        return val;
                    }

                    function noop() {
                        return "";
                    }

                    function dbgBreak(val) {
                        // Usage examples: {{dbg:...}}, {{:~dbg(...)}}, {{dbg .../}}, {^{for ... onAfterLink=~dbg}} etc.
                        try {
                            console.log("JsRender dbg breakpoint: " + val);
                            throw "dbg breakpoint"; // To break here, stop on caught exceptions.
                        } catch (e) {
                        }
                        return this.base ? this.baseApply(arguments) : val;
                    }

                    function JsViewsError(message) {
                        // Error exception type for JsViews/JsRender
                        // Override of $.views.sub.Error is possible
                        this.name = ($.link ? "JsViews" : "JsRender") + " Error";
                        this.message = message || this.name;
                    }

                    function $extend(target, source) {
                        if (target) {
                            for (var name in source) {
                                target[name] = source[name];
                            }
                            return target;
                        }
                    }

                    (JsViewsError.prototype = new Error()).constructor = JsViewsError;

//========================== Top-level functions ==========================

//===================
// views.delimiters
//===================

                    /**
                     * Set the tag opening and closing delimiters and 'link' character. Default is "{{", "}}" and "^"
                     * openChars, closeChars: opening and closing strings, each with two characters
                     * $.views.settings.delimiters(...)
                     *
                     * @param {string}   openChars
                     * @param {string}   [closeChars]
                     * @param {string}   [link]
                     * @returns {Settings}
                     *
                     * Get delimiters
                     * delimsArray = $.views.settings.delimiters()
                     *
                     * @returns {string[]}
                     */
                    function $viewsDelimiters(openChars, closeChars, link) {
                        if (!openChars) {
                            return $subSettings.delimiters;
                        }
                        if ($isArray(openChars)) {
                            return $viewsDelimiters.apply($views, openChars);
                        }
                        linkChar = link ? link[0] : linkChar;
                        if (!/^(\W|_){5}$/.test(openChars + closeChars + linkChar)) {
                            error("Invalid delimiters"); // Must be non-word characters, and openChars and closeChars must each be length 2
                        }
                        delimOpenChar0 = openChars[0];
                        delimOpenChar1 = openChars[1];
                        delimCloseChar0 = closeChars[0];
                        delimCloseChar1 = closeChars[1];

                        $subSettings.delimiters = [delimOpenChar0 + delimOpenChar1, delimCloseChar0 + delimCloseChar1, linkChar];

                        // Escape the characters - since they could be regex special characters
                        openChars = "\\" + delimOpenChar0 + "(\\" + linkChar + ")?\\" + delimOpenChar1; // Default is "{^{"
                        closeChars = "\\" + delimCloseChar0 + "\\" + delimCloseChar1;                   // Default is "}}"
                        // Build regex with new delimiters
                        //          [tag    (followed by / space or })  or cvtr+colon or html or code] followed by space+params then convertBack?
                        rTag = "(?:(\\w+(?=[\\/\\s\\" + delimCloseChar0 + "]))|(\\w+)?(:)|(>)|(\\*))\\s*((?:[^\\"
                            + delimCloseChar0 + "]|\\" + delimCloseChar0 + "(?!\\" + delimCloseChar1 + "))*?)";

                        // Make rTag available to JsViews (or other components) for parsing binding expressions
                        $sub.rTag = "(?:" + rTag + ")";
                        //                        { ^? {   tag+params slash?  or closingTag                                                   or comment
                        rTag = new RegExp("(?:" + openChars + rTag + "(\\/)?|\\" + delimOpenChar0 + "(\\" + linkChar + ")?\\" + delimOpenChar1 + "(?:(?:\\/(\\w+))\\s*|!--[\\s\\S]*?--))" + closeChars, "g");

                        // Default:  bind     tagName         cvt   cln html code    params            slash   bind2         closeBlk  comment
                        //      /(?:{(\^)?{(?:(\w+(?=[\/\s}]))|(\w+)?(:)|(>)|(\*))\s*((?:[^}]|}(?!}))*?)(\/)?|{(\^)?{(?:(?:\/(\w+))\s*|!--[\s\S]*?--))}}

                        $sub.rTmpl = new RegExp("^\\s|\\s$|<.*>|([^\\\\]|^)[{}]|" + openChars + ".*" + closeChars);
                        // $sub.rTmpl looks for initial or final white space, html tags or { or } char not preceded by \\, or JsRender tags {{xxx}}.
                        // Each of these strings are considered NOT to be jQuery selectors
                        return $viewsSettings;
                    }

//=========
// View.get
//=========

                    function getView(inner, type) { //view.get(inner, type)
                        if (!type && inner !== true) {
                            // view.get(type)
                            type = inner;
                            inner = undefined;
                        }

                        var views, i, l, found,
                            view = this,
                            root = type === "root";
                        // view.get("root") returns view.root, view.get() returns view.parent, view.get(true) returns view.views[0].

                        if (inner) {
                            // Go through views - this one, and all nested ones, depth-first - and return first one with given type.
                            // If type is undefined, i.e. view.get(true), return first child view.
                            found = type && view.type === type && view;
                            if (!found) {
                                views = view.views;
                                if (view._.useKey) {
                                    for (i in views) {
                                        if (found = type ? views[i].get(inner, type) : views[i]) {
                                            break;
                                        }
                                    }
                                } else {
                                    for (i = 0, l = views.length; !found && i < l; i++) {
                                        found = type ? views[i].get(inner, type) : views[i];
                                    }
                                }
                            }
                        } else if (root) {
                            // Find root view. (view whose parent is top view)
                            found = view.root;
                        } else if (type) {
                            while (view && !found) {
                                // Go through views - this one, and all parent ones - and return first one with given type.
                                found = view.type === type ? view : undefined;
                                view = view.parent;
                            }
                        } else {
                            found = view.parent;
                        }
                        return found || undefined;
                    }

                    function getNestedIndex() {
                        var view = this.get("item");
                        return view ? view.index : undefined;
                    }

                    getNestedIndex.depends = function () {
                        return [this.get("item"), "index"];
                    };

                    function getIndex() {
                        return this.index;
                    }

                    getIndex.depends = "index";

//==================
// View.ctxPrm, etc.
//==================

                    /* Internal private: view._getOb() */
                    function getPathObject(ob, path, ltOb, fn) {
                        // Iterate through path to late paths: @a.b.c paths
                        // Return "" (or noop if leaf is a function @a.b.c(...) ) if intermediate object not yet available
                        var prevOb, tokens, l,
                            i = 0;
                        if (ltOb === 1) {
                            fn = 1;
                            ltOb = undefined;
                        }
                        // Paths like ^a^b^c or ~^a^b^c will not throw if an object in path is undefined.
                        if (path) {
                            tokens = path.split(".");
                            l = tokens.length;

                            for (; ob && i < l; i++) {
                                prevOb = ob;
                                ob = tokens[i] ? ob[tokens[i]] : ob;
                            }
                        }
                        if (ltOb) {
                            ltOb.lt = ltOb.lt || i < l; // If i < l there was an object in the path not yet available
                        }
                        return ob === undefined
                            ? fn ? noop : ""
                            : fn ? function () {
                                return ob.apply(prevOb, arguments);
                            } : ob;
                    }

                    function contextParameter(key, value, get) {
                        // Helper method called as view.ctxPrm(key) for helpers or template parameters ~foo - from compiled template or from context callback
                        var wrapped, deps, res, obsCtxPrm, tagElse, callView, newRes,
                            storeView = this,
                            isUpdate = !isRenderCall && arguments.length > 1,
                            store = storeView.ctx;
                        if (key) {
                            if (!storeView._) { // tagCtx.ctxPrm() call
                                tagElse = storeView.index;
                                storeView = storeView.tag;
                            }
                            callView = storeView;
                            if (store && store.hasOwnProperty(key) || (store = $helpers).hasOwnProperty(key)) {
                                res = store[key];
                                if (key === "tag" || key === "tagCtx" || key === "root" || key === "parentTags") {
                                    return res;
                                }
                            } else {
                                store = undefined;
                            }
                            if (!isRenderCall && storeView.tagCtx || storeView.linked) { // Data-linked view, or tag instance
                                if (!res || !res._cxp) {
                                    // Not a contextual parameter
                                    // Set storeView to tag (if this is a tag.ctxPrm() call) or to root view ("data" view of linked template)
                                    storeView = storeView.tagCtx || $isFunction(res)
                                        ? storeView // Is a tag, not a view, or is a computed contextual parameter, so scope to the callView, no the 'scope view'
                                        : (storeView = storeView.scope || storeView,
                                        !storeView.isTop && storeView.ctx.tag // If this view is in a tag, set storeView to the tag
                                        || storeView);
                                    if (res !== undefined && storeView.tagCtx) {
                                        // If storeView is a tag, but the contextual parameter has been set at at higher level (e.g. helpers)...
                                        storeView = storeView.tagCtx.view.scope; // then move storeView to the outer level (scope of tag container view)
                                    }
                                    store = storeView._ocps;
                                    res = store && store.hasOwnProperty(key) && store[key] || res;
                                    if (!(res && res._cxp) && (get || isUpdate)) {
                                        // Create observable contextual parameter
                                        (store || (storeView._ocps = storeView._ocps || {}))[key]
                                            = res
                                            = [{
                                            _ocp: res, // The observable contextual parameter value
                                            _vw: callView,
                                            _key: key
                                        }];
                                        res._cxp = {
                                            path: _ocp,
                                            ind: 0,
                                            updateValue: function (val, path) {
                                                $.observable(res[0]).setProperty(_ocp, val); // Set the value (res[0]._ocp)
                                                return this;
                                            }
                                        };
                                    }
                                }
                                if (obsCtxPrm = res && res._cxp) {
                                    // If this helper resource is an observable contextual parameter
                                    if (arguments.length > 2) {
                                        deps = res[1] ? $sub._ceo(res[1].deps) : [_ocp]; // fn deps (with any exprObs cloned using $sub._ceo)
                                        deps.unshift(res[0]); // view
                                        deps._cxp = obsCtxPrm;
                                        // In a context callback for a contextual param, we set get = true, to get ctxPrm [view, dependencies...] array - needed for observe call
                                        return deps;
                                    }
                                    tagElse = obsCtxPrm.tagElse;
                                    newRes = res[1] // linkFn for compiled expression
                                        ? obsCtxPrm.tag && obsCtxPrm.tag.cvtArgs
                                            ? obsCtxPrm.tag.cvtArgs(tagElse, 1)[obsCtxPrm.ind] // = tag.bndArgs() - for tag contextual parameter
                                            : res[1](res[0].data, res[0], $sub) // = fn(data, view, $sub) for compiled binding expression
                                        : res[0]._ocp; // Observable contextual parameter (uninitialized, or initialized as static expression, so no path dependencies)
                                    if (isUpdate) {
                                        $sub._ucp(key, value, storeView, obsCtxPrm); // Update observable contextual parameter
                                        return storeView;
                                    }
                                    res = newRes;
                                }
                            }
                            if (res && $isFunction(res)) {
                                // If a helper is of type function we will wrap it, so if called with no this pointer it will be called with the
                                // view as 'this' context. If the helper ~foo() was in a data-link expression, the view will have a 'temporary' linkCtx property too.
                                // Note that helper functions on deeper paths will have specific this pointers, from the preceding path.
                                // For example, ~util.foo() will have the ~util object as 'this' pointer
                                wrapped = function () {
                                    return res.apply((!this || this === global) ? callView : this, arguments);
                                };
                                $extend(wrapped, res); // Attach same expandos (if any) to the wrapped function
                            }
                            return wrapped || res;
                        }
                    }

                    /* Internal private: view._getTmpl() */
                    function getTemplate(tmpl) {
                        return tmpl && (tmpl.fn
                            ? tmpl
                            : this.getRsc("templates", tmpl) || $templates(tmpl)); // not yet compiled
                    }

//==============
// views._cnvt
//==============

                    function convertVal(converter, view, tagCtx, onError) {
                        // Called from compiled template code for {{:}}
                        // self is template object or linkCtx object
                        var tag, linkCtx, value, argsLen, bindTo,
                            // If tagCtx is an integer, then it is the key for the compiled function to return the boundTag tagCtx
                            boundTag = typeof tagCtx === "number" && view.tmpl.bnds[tagCtx - 1];

                        if (onError === undefined && boundTag && boundTag._lr) { // lateRender
                            onError = "";
                        }
                        if (onError !== undefined) {
                            tagCtx = onError = {props: {}, args: [onError]};
                        } else if (boundTag) {
                            tagCtx = boundTag(view.data, view, $sub);
                        }
                        boundTag = boundTag._bd && boundTag;
                        if (converter || boundTag) {
                            linkCtx = view._lc; // For data-link="{cvt:...}"... See onDataLinkedTagChange
                            tag = linkCtx && linkCtx.tag;
                            tagCtx.view = view;
                            if (!tag) {
                                tag = $extend(new $sub._tg(), {
                                    _: {
                                        bnd: boundTag,
                                        unlinked: true,
                                        lt: tagCtx.lt // If a late path @some.path has not returned @some object, mark tag as late
                                    },
                                    inline: !linkCtx,
                                    tagName: ":",
                                    convert: converter,
                                    onArrayChange: true,
                                    flow: true,
                                    tagCtx: tagCtx,
                                    tagCtxs: [tagCtx],
                                    _is: "tag"
                                });
                                argsLen = tagCtx.args.length;
                                if (argsLen > 1) {
                                    bindTo = tag.bindTo = [];
                                    while (argsLen--) {
                                        bindTo.unshift(argsLen); // Bind to all the arguments - generate bindTo array: [0,1,2...]
                                    }
                                }
                                if (linkCtx) {
                                    linkCtx.tag = tag;
                                    tag.linkCtx = linkCtx;
                                }
                                tagCtx.ctx = extendCtx(tagCtx.ctx, (linkCtx ? linkCtx.view : view).ctx);
                                tagHandlersFromProps(tag, tagCtx);
                            }
                            tag._er = onError && value;
                            tag.ctx = tagCtx.ctx || tag.ctx || {};
                            tagCtx.ctx = undefined;
                            value = tag.cvtArgs()[0]; // If there is a convertBack but no convert, converter will be "true"
                            tag._er = onError && value;
                        } else {
                            value = tagCtx.args[0];
                        }

                        // Call onRender (used by JsViews if present, to add binding annotations around rendered content)
                        value = boundTag && view._.onRender
                            ? view._.onRender(value, view, tag)
                            : value;
                        return value != undefined ? value : "";
                    }

                    function convertArgs(tagElse, bound) { // tag.cvtArgs() or tag.cvtArgs(tagElse?, true?)
                        var l, key, boundArgs, args, bindFrom, tag, converter,
                            tagCtx = this;

                        if (tagCtx.tagName) {
                            tag = tagCtx;
                            tagCtx = (tag.tagCtxs || [tagCtx])[tagElse || 0];
                            if (!tagCtx) {
                                return;
                            }
                        } else {
                            tag = tagCtx.tag;
                        }

                        bindFrom = tag.bindFrom;
                        args = tagCtx.args;

                        if ((converter = tag.convert) && "" + converter === converter) {
                            converter = converter === "true"
                                ? undefined
                                : (tagCtx.view.getRsc("converters", converter) || error("Unknown converter: '" + converter + "'"));
                        }

                        if (converter && !bound) { // If there is a converter, use a copy of the tagCtx.args array for rendering, and replace the args[0] in
                            args = args.slice(); // the copied array with the converted value. But we do not modify the value of tag.tagCtx.args[0] (the original args array)
                        }
                        if (bindFrom) { // Get the values of the boundArgs
                            boundArgs = [];
                            l = bindFrom.length;
                            while (l--) {
                                key = bindFrom[l];
                                boundArgs.unshift(argOrProp(tagCtx, key));
                            }
                            if (bound) {
                                args = boundArgs; // Call to bndArgs() - returns the boundArgs
                            }
                        }
                        if (converter) {
                            converter = converter.apply(tag, boundArgs || args);
                            if (converter === undefined) {
                                return args; // Returning undefined from a converter is equivalent to not having a converter.
                            }
                            bindFrom = bindFrom || [0];
                            l = bindFrom.length;
                            if (!$isArray(converter) || (converter.arg0 !== false && (l === 1 || converter.length !== l || converter.arg0))) {
                                converter = [converter]; // Returning converter as first arg, even if converter value is an array
                                bindFrom = [0];
                                l = 1;
                            }
                            if (bound) {        // Call to bndArgs() - so apply converter to all boundArgs
                                args = converter; // The array of values returned from the converter
                            } else {            // Call to cvtArgs()
                                while (l--) {
                                    key = bindFrom[l];
                                    if (+key === key) {
                                        args[key] = converter[l];
                                    }
                                }
                            }
                        }
                        return args;
                    }

                    function argOrProp(context, key) {
                        context = context[+key === key ? "args" : "props"];
                        return context && context[key];
                    }

                    function convertBoundArgs(tagElse) { // tag.bndArgs()
                        return this.cvtArgs(tagElse, 1);
                    }

//=============
// views.tag
//=============

                    /* view.getRsc() */
                    function getResource(resourceType, itemName) {
                        var res, store,
                            view = this;
                        if ("" + itemName === itemName) {
                            while ((res === undefined) && view) {
                                store = view.tmpl && view.tmpl[resourceType];
                                res = store && store[itemName];
                                view = view.parent;
                            }
                            return res || $views[resourceType][itemName];
                        }
                    }

                    function renderTag(tagName, parentView, tmpl, tagCtxs, isUpdate, onError) {
                        function bindToOrBindFrom(type) {
                            var bindArray = tag[type];

                            if (bindArray !== undefined) {
                                bindArray = $isArray(bindArray) ? bindArray : [bindArray];
                                m = bindArray.length;
                                while (m--) {
                                    key = bindArray[m];
                                    if (!isNaN(parseInt(key))) {
                                        bindArray[m] = parseInt(key); // Convert "0" to 0, etc.
                                    }
                                }
                            }

                            return bindArray || [0];
                        }

                        parentView = parentView || topView;
                        var tag, tagDef, template, tags, attr, parentTag, l, m, n, itemRet, tagCtx, tagCtxCtx, ctxPrm,
                            bindTo, bindFrom, initVal,
                            content, callInit, mapDef, thisMap, args, bdArgs, props, tagDataMap, contentCtx, key,
                            bindFromLength, bindToLength, linkedElement, defaultCtx,
                            i = 0,
                            ret = "",
                            linkCtx = parentView._lc || false, // For data-link="{myTag...}"... See onDataLinkedTagChange
                            ctx = parentView.ctx,
                            parentTmpl = tmpl || parentView.tmpl,
                            // If tagCtxs is an integer, then it is the key for the compiled function to return the boundTag tagCtxs
                            boundTag = typeof tagCtxs === "number" && parentView.tmpl.bnds[tagCtxs - 1];

                        if (tagName._is === "tag") {
                            tag = tagName;
                            tagName = tag.tagName;
                            tagCtxs = tag.tagCtxs;
                            template = tag.template;
                        } else {
                            tagDef = parentView.getRsc("tags", tagName) || error("Unknown tag: {{" + tagName + "}} ");
                            template = tagDef.template;
                        }
                        if (onError === undefined && boundTag && (boundTag._lr = (tagDef.lateRender && boundTag._lr !== false || boundTag._lr))) {
                            onError = ""; // If lateRender, set temporary onError, to skip initial rendering (and render just "")
                        }
                        if (onError !== undefined) {
                            ret += onError;
                            tagCtxs = onError = [{props: {}, args: [], params: {props: {}}}];
                        } else if (boundTag) {
                            tagCtxs = boundTag(parentView.data, parentView, $sub);
                        }

                        l = tagCtxs.length;
                        for (; i < l; i++) {
                            tagCtx = tagCtxs[i];
                            content = tagCtx.tmpl;
                            if (!linkCtx || !linkCtx.tag || i && !linkCtx.tag.inline || tag._er || content && +content === content) {
                                // Initialize tagCtx
                                // For block tags, tagCtx.tmpl is an integer > 0
                                if (content && parentTmpl.tmpls) {
                                    tagCtx.tmpl = tagCtx.content = parentTmpl.tmpls[content - 1]; // Set the tmpl property to the content of the block tag
                                }
                                tagCtx.index = i;
                                tagCtx.ctxPrm = contextParameter;
                                tagCtx.render = renderContent;
                                tagCtx.cvtArgs = convertArgs;
                                tagCtx.bndArgs = convertBoundArgs;
                                tagCtx.view = parentView;
                                tagCtx.ctx = extendCtx(extendCtx(tagCtx.ctx, tagDef && tagDef.ctx), ctx); // Clone and extend parentView.ctx
                            }
                            if (tmpl = tagCtx.props.tmpl) {
                                // If the tmpl property is overridden, set the value (when initializing, or, in case of binding: ^tmpl=..., when updating)
                                tagCtx.tmpl = parentView._getTmpl(tmpl);
                                tagCtx.content = tagCtx.content || tagCtx.tmpl;
                            }

                            if (!tag) {
                                // This will only be hit for initial tagCtx (not for {{else}}) - if the tag instance does not exist yet
                                // If the tag has not already been instantiated, we will create a new instance.
                                // ~tag will access the tag, even within the rendering of the template content of this tag.
                                // From child/descendant tags, can access using ~tag.parent, or ~parentTags.tagName
                                tag = new tagDef._ctr();
                                callInit = !!tag.init;

                                tag.parent = parentTag = ctx && ctx.tag;
                                tag.tagCtxs = tagCtxs;

                                if (linkCtx) {
                                    tag.inline = false;
                                    linkCtx.tag = tag;
                                }
                                tag.linkCtx = linkCtx;
                                if (tag._.bnd = boundTag || linkCtx.fn) {
                                    // Bound if {^{tag...}} or data-link="{tag...}"
                                    tag._.ths = tagCtx.params.props["this"]; // Tag has a this=expr binding, to get javascript reference to tag instance
                                    tag._.lt = tagCtxs.lt; // If a late path @some.path has not returned @some object, mark tag as late
                                    tag._.arrVws = {};
                                } else if (tag.dataBoundOnly) {
                                    error(tagName + " must be data-bound:\n{^{" + tagName + "}}");
                                }
                                //TODO better perf for childTags() - keep child tag.tags array, (and remove child, when disposed)
                                // tag.tags = [];
                            } else if (linkCtx && linkCtx.fn._lr) {
                                callInit = !!tag.init;
                            }
                            tagDataMap = tag.dataMap;

                            tagCtx.tag = tag;
                            if (tagDataMap && tagCtxs) {
                                tagCtx.map = tagCtxs[i].map; // Copy over the compiled map instance from the previous tagCtxs to the refreshed ones
                            }
                            if (!tag.flow) {
                                tagCtxCtx = tagCtx.ctx = tagCtx.ctx || {};

                                // tags hash: tag.ctx.tags, merged with parentView.ctx.tags,
                                tags = tag.parents = tagCtxCtx.parentTags = ctx && extendCtx(tagCtxCtx.parentTags, ctx.parentTags) || {};
                                if (parentTag) {
                                    tags[parentTag.tagName] = parentTag;
                                    //TODO better perf for childTags: parentTag.tags.push(tag);
                                }
                                tags[tag.tagName] = tagCtxCtx.tag = tag;
                                tagCtxCtx.tagCtx = tagCtx;
                            }
                        }
                        if (!(tag._er = onError)) {
                            tagHandlersFromProps(tag, tagCtxs[0]);
                            tag.rendering = {rndr: tag.rendering}; // Provide object for state during render calls to tag and elses. (Used by {{if}} and {{for}}...)
                            for (i = 0; i < l; i++) { // Iterate tagCtx for each {{else}} block
                                tagCtx = tag.tagCtx = tagCtxs[i];
                                props = tagCtx.props;
                                tag.ctx = tagCtx.ctx;

                                if (!i) {
                                    if (callInit) {
                                        tag.init(tagCtx, linkCtx, tag.ctx);
                                        callInit = undefined;
                                    }
                                    if (!tagCtx.args.length && tagCtx.argDefault !== false && tag.argDefault !== false) {
                                        tagCtx.args = args = [tagCtx.view.data]; // Missing first arg defaults to the current data context
                                        tagCtx.params.args = ["#data"];
                                    }

                                    bindTo = bindToOrBindFrom("bindTo");

                                    if (tag.bindTo !== undefined) {
                                        tag.bindTo = bindTo;
                                    }

                                    if (tag.bindFrom !== undefined) {
                                        tag.bindFrom = bindToOrBindFrom("bindFrom");
                                    } else if (tag.bindTo) {
                                        tag.bindFrom = tag.bindTo = bindTo;
                                    }
                                    bindFrom = tag.bindFrom || bindTo;

                                    bindToLength = bindTo.length;
                                    bindFromLength = bindFrom.length;

                                    if (tag._.bnd && (linkedElement = tag.linkedElement)) {
                                        tag.linkedElement = linkedElement = $isArray(linkedElement) ? linkedElement : [linkedElement];

                                        if (bindToLength !== linkedElement.length) {
                                            error("linkedElement not same length as bindTo");
                                        }
                                    }
                                    if (linkedElement = tag.linkedCtxParam) {
                                        tag.linkedCtxParam = linkedElement = $isArray(linkedElement) ? linkedElement : [linkedElement];

                                        if (bindFromLength !== linkedElement.length) {
                                            error("linkedCtxParam not same length as bindFrom/bindTo");
                                        }
                                    }

                                    if (bindFrom) {
                                        tag._.fromIndex = {}; // Hash of bindFrom index which has same path value as bindTo index. fromIndex = tag._.fromIndex[toIndex]
                                        tag._.toIndex = {}; // Hash of bindFrom index which has same path value as bindTo index. fromIndex = tag._.fromIndex[toIndex]
                                        n = bindFromLength;
                                        while (n--) {
                                            key = bindFrom[n];
                                            m = bindToLength;
                                            while (m--) {
                                                if (key === bindTo[m]) {
                                                    tag._.fromIndex[m] = n;
                                                    tag._.toIndex[n] = m;
                                                }
                                            }
                                        }
                                    }

                                    if (linkCtx) {
                                        // Set attr on linkCtx to ensure outputting to the correct target attribute.
                                        // Setting either linkCtx.attr or this.attr in the init() allows per-instance choice of target attrib.
                                        linkCtx.attr = tag.attr = linkCtx.attr || tag.attr || linkCtx._dfAt;
                                    }
                                    attr = tag.attr;
                                    tag._.noVws = attr && attr !== HTML;
                                }
                                args = tag.cvtArgs(i);
                                if (tag.linkedCtxParam) {
                                    bdArgs = tag.cvtArgs(i, 1);
                                    m = bindFromLength;
                                    defaultCtx = tag.constructor.prototype.ctx;
                                    while (m--) {
                                        if (ctxPrm = tag.linkedCtxParam[m]) {
                                            key = bindFrom[m];
                                            initVal = bdArgs[m];
                                            // Create tag contextual parameter
                                            tagCtx.ctx[ctxPrm] = $sub._cp(
                                                defaultCtx && initVal === undefined ? defaultCtx[ctxPrm] : initVal,
                                                initVal !== undefined && argOrProp(tagCtx.params, key),
                                                tagCtx.view,
                                                tag._.bnd && {tag: tag, cvt: tag.convert, ind: m, tagElse: i}
                                            );
                                        }
                                    }
                                }
                                if ((mapDef = props.dataMap || tagDataMap) && (args.length || props.dataMap)) {
                                    thisMap = tagCtx.map;
                                    if (!thisMap || thisMap.src !== args[0] || isUpdate) {
                                        if (thisMap && thisMap.src) {
                                            thisMap.unmap(); // only called if observable map - not when only used in JsRender, e.g. by {{props}}
                                        }
                                        mapDef.map(args[0], tagCtx, thisMap, !tag._.bnd);
                                        thisMap = tagCtx.map;
                                    }
                                    args = [thisMap.tgt];
                                }

                                itemRet = undefined;
                                if (tag.render) {
                                    itemRet = tag.render.apply(tag, args);
                                    if (parentView.linked && itemRet && !rWrappedInViewMarker.test(itemRet)) {
                                        // When a tag renders content from the render method, with data linking then we need to wrap with view markers, if absent,
                                        // to provide a contentView for the tag, which will correctly dispose bindings if deleted. The 'tmpl' for this view will
                                        // be a dumbed-down template which will always return the itemRet string (no matter what the data is). The itemRet string
                                        // is not compiled as template markup, so can include "{{" or "}}" without triggering syntax errors
                                        tmpl = { // 'Dumbed-down' template which always renders 'static' itemRet string
                                            links: []
                                        };
                                        tmpl.render = tmpl.fn = function () {
                                            return itemRet;
                                        };
                                        itemRet = renderWithViews(tmpl, parentView.data, undefined, true, parentView, undefined, undefined, tag);
                                    }
                                }
                                if (!args.length) {
                                    args = [parentView]; // no arguments - (e.g. {{else}}) get data context from view.
                                }
                                if (itemRet === undefined) {
                                    contentCtx = args[0]; // Default data context for wrapped block content is the first argument
                                    if (tag.contentCtx) { // Set tag.contentCtx to true, to inherit parent context, or to a function to provide alternate context.
                                        contentCtx = tag.contentCtx === true ? parentView : tag.contentCtx(contentCtx);
                                    }
                                    itemRet = tagCtx.render(contentCtx, true) || (isUpdate ? undefined : "");
                                }
                                ret = ret
                                    ? ret + (itemRet || "")
                                    : itemRet !== undefined
                                        ? "" + itemRet
                                        : undefined; // If no return value from render, and no template/content tagCtx.render(...), return undefined
                            }
                            tag.rendering = tag.rendering.rndr; // Remove tag.rendering object (if this is outermost render call. (In case of nested calls)
                        }
                        tag.tagCtx = tagCtxs[0];
                        tag.ctx = tag.tagCtx.ctx;

                        if (tag._.noVws && tag.inline) {
                            // inline tag with attr set to "text" will insert HTML-encoded content - as if it was element-based innerText
                            ret = attr === "text"
                                ? $converters.html(ret)
                                : "";
                        }
                        return boundTag && parentView._.onRender
                            // Call onRender (used by JsViews if present, to add binding annotations around rendered content)
                            ? parentView._.onRender(ret, parentView, tag)
                            : ret;
                    }

//=================
// View constructor
//=================

                    function View(context, type, parentView, data, template, key, onRender, contentTmpl) {
                        // Constructor for view object in view hierarchy. (Augmented by JsViews if JsViews is loaded)
                        var views, parentView_, tag, self_,
                            self = this,
                            isArray = type === "array";
                        // If the data is an array, this is an 'array view' with a views array for each child 'item view'
                        // If the data is not an array, this is an 'item view' with a views 'hash' object for any child nested views

                        self.content = contentTmpl;
                        self.views = isArray ? [] : {};
                        self.data = data;
                        self.tmpl = template;
                        self_ = self._ = {
                            key: 0,
                            // ._.useKey is non zero if is not an 'array view' (owning a data array). Use this as next key for adding to child views hash
                            useKey: isArray ? 0 : 1,
                            id: "" + viewId++,
                            onRender: onRender,
                            bnds: {}
                        };
                        self.linked = !!onRender;
                        self.type = type || "top";
                        if (type) {
                            self.cache = {_ct: $subSettings._cchCt}; // Used for caching results of computed properties and helpers (view.getCache)
                        }

                        if (!parentView || parentView.type === "top") {
                            (self.ctx = context || {}).root = self.data;
                        }

                        if (self.parent = parentView) {
                            self.root = parentView.root || self; // view whose parent is top view
                            views = parentView.views;
                            parentView_ = parentView._;
                            self.isTop = parentView_.scp; // Is top content view of a link("#container", ...) call
                            self.scope = (!context.tag || context.tag === parentView.ctx.tag) && !self.isTop && parentView.scope || self;
                            // Scope for contextParams - closest non flow tag ancestor or root view
                            if (parentView_.useKey) {
                                // Parent is not an 'array view'. Add this view to its views object
                                // self._key = is the key in the parent view hash
                                views[self_.key = "_" + parentView_.useKey++] = self;
                                self.index = indexStr;
                                self.getIndex = getNestedIndex;
                            } else if (views.length === (self_.key = self.index = key)) { // Parent is an 'array view'. Add this view to its views array
                                views.push(self); // Adding to end of views array. (Using push when possible - better perf than splice)
                            } else {
                                views.splice(key, 0, self); // Inserting in views array
                            }
                            // If no context was passed in, use parent context
                            // If context was passed in, it should have been merged already with parent context
                            self.ctx = context || parentView.ctx;
                        } else if (type) {
                            self.root = self; // view whose parent is top view
                        }
                    }

                    View.prototype = {
                        get: getView,
                        getIndex: getIndex,
                        ctxPrm: contextParameter,
                        getRsc: getResource,
                        _getTmpl: getTemplate,
                        _getOb: getPathObject,
                        getCache: function (key) { // Get cached value of computed value
                            if ($subSettings._cchCt > this.cache._ct) {
                                this.cache = {_ct: $subSettings._cchCt};
                            }
                            return this.cache[key] !== undefined ? this.cache[key] : (this.cache[key] = cpFnStore[key](this.data, this, $sub));
                        },
                        _is: "view"
                    };

//====================================================
// Registration
//====================================================

                    function compileChildResources(parentTmpl) {
                        var storeName, storeNames, resources;
                        for (storeName in jsvStores) {
                            storeNames = storeName + "s";
                            if (parentTmpl[storeNames]) {
                                resources = parentTmpl[storeNames];        // Resources not yet compiled
                                parentTmpl[storeNames] = {};               // Remove uncompiled resources
                                $views[storeNames](resources, parentTmpl); // Add back in the compiled resources
                            }
                        }
                    }

//===============
// compileTag
//===============

                    function compileTag(name, tagDef, parentTmpl) {
                        var tmpl, baseTag, prop,
                            compiledDef = new $sub._tg();

                        function Tag() {
                            var tag = this;
                            tag._ = {
                                unlinked: true
                            };
                            tag.inline = true;
                            tag.tagName = name;
                        }

                        if ($isFunction(tagDef)) {
                            // Simple tag declared as function. No presenter instantation.
                            tagDef = {
                                depends: tagDef.depends,
                                render: tagDef
                            };
                        } else if ("" + tagDef === tagDef) {
                            tagDef = {template: tagDef};
                        }

                        if (baseTag = tagDef.baseTag) {
                            tagDef.flow = !!tagDef.flow; // Set flow property, so defaults to false even if baseTag has flow=true
                            baseTag = "" + baseTag === baseTag
                                ? (parentTmpl && parentTmpl.tags[baseTag] || $tags[baseTag])
                                : baseTag;
                            if (!baseTag) {
                                error('baseTag: "' + tagDef.baseTag + '" not found');
                            }
                            compiledDef = $extend(compiledDef, baseTag);

                            for (prop in tagDef) {
                                compiledDef[prop] = getMethod(baseTag[prop], tagDef[prop]);
                            }
                        } else {
                            compiledDef = $extend(compiledDef, tagDef);
                        }

                        // Tag declared as object, used as the prototype for tag instantiation (control/presenter)
                        if ((tmpl = compiledDef.template) !== undefined) {
                            compiledDef.template = "" + tmpl === tmpl ? ($templates[tmpl] || $templates(tmpl)) : tmpl;
                        }
                        (Tag.prototype = compiledDef).constructor = compiledDef._ctr = Tag;

                        if (parentTmpl) {
                            compiledDef._parentTmpl = parentTmpl;
                        }
                        return compiledDef;
                    }

                    function baseApply(args) {
                        // In derived method (or handler declared declaratively as in {{:foo onChange=~fooChanged}} can call base method,
                        // using this.baseApply(arguments) (Equivalent to this._superApply(arguments) in jQuery UI)
                        return this.base.apply(this, args);
                    }

//===============
// compileTmpl
//===============

                    function compileTmpl(name, tmpl, parentTmpl, options) {
                        // tmpl is either a template object, a selector for a template script block, or the name of a compiled template

                        //==== nested functions ====
                        function lookupTemplate(value) {
                            // If value is of type string - treat as selector, or name of compiled template
                            // Return the template object, if already compiled, or the markup string
                            var currentName, tmpl;
                            if (("" + value === value) || value.nodeType > 0 && (elem = value)) {
                                if (!elem) {
                                    if (/^\.?\/[^\\:*?"<>]*$/.test(value)) {
                                        // value="./some/file.html" (or "/some/file.html")
                                        // If the template is not named, use "./some/file.html" as name.
                                        if (tmpl = $templates[name = name || value]) {
                                            value = tmpl;
                                        } else {
                                            // BROWSER-SPECIFIC CODE (not on Node.js):
                                            // Look for server-generated script block with id "./some/file.html"
                                            elem = document.getElementById(value);
                                        }
                                    } else if (value.charAt(0) === "#") {
                                        elem = document.getElementById(value.slice(1));
                                    } else if ($.fn && !$sub.rTmpl.test(value)) {
                                        try {
                                            elem = $(value, document)[0]; // if jQuery is loaded, test for selector returning elements, and get first element
                                        } catch (e) {
                                        }
                                    }// END BROWSER-SPECIFIC CODE
                                } //BROWSER-SPECIFIC CODE
                                if (elem) {
                                    if (elem.tagName !== "SCRIPT") {
                                        error(value + ": Use script block, not " + elem.tagName);
                                    }
                                    if (options) {
                                        // We will compile a new template using the markup in the script element
                                        value = elem.innerHTML;
                                    } else {
                                        // We will cache a single copy of the compiled template, and associate it with the name
                                        // (renaming from a previous name if there was one).
                                        currentName = elem.getAttribute(tmplAttr);
                                        if (currentName) {
                                            if (currentName !== jsvTmpl) {
                                                value = $templates[currentName];
                                                delete $templates[currentName];
                                            } else if ($.fn) {
                                                value = $.data(elem)[jsvTmpl]; // Get cached compiled template
                                            }
                                        }
                                        if (!currentName || !value) { // Not yet compiled, or cached version lost
                                            name = name || ($.fn ? jsvTmpl : value);
                                            value = compileTmpl(name, elem.innerHTML, parentTmpl, options);
                                        }
                                        value.tmplName = name = name || currentName;
                                        if (name !== jsvTmpl) {
                                            $templates[name] = value;
                                        }
                                        elem.setAttribute(tmplAttr, name);
                                        if ($.fn) {
                                            $.data(elem, jsvTmpl, value);
                                        }
                                    }
                                } // END BROWSER-SPECIFIC CODE
                                elem = undefined;
                            } else if (!value.fn) {
                                value = undefined;
                                // If value is not a string. HTML element, or compiled template, return undefined
                            }
                            return value;
                        }

                        var elem, compiledTmpl,
                            tmplOrMarkup = tmpl = tmpl || "";
                        $sub._html = $converters.html;

                        //==== Compile the template ====
                        if (options === 0) {
                            options = undefined;
                            tmplOrMarkup = lookupTemplate(tmplOrMarkup); // Top-level compile so do a template lookup
                        }

                        // If options, then this was already compiled from a (script) element template declaration.
                        // If not, then if tmpl is a template object, use it for options
                        options = options || (tmpl.markup
                                ? tmpl.bnds
                                    ? $extend({}, tmpl)
                                    : tmpl
                                : {}
                        );

                        options.tmplName = options.tmplName || name || "unnamed";
                        if (parentTmpl) {
                            options._parentTmpl = parentTmpl;
                        }
                        // If tmpl is not a markup string or a selector string, then it must be a template object
                        // In that case, get it from the markup property of the object
                        if (!tmplOrMarkup && tmpl.markup && (tmplOrMarkup = lookupTemplate(tmpl.markup)) && tmplOrMarkup.fn) {
                            // If the string references a compiled template object, need to recompile to merge any modified options
                            tmplOrMarkup = tmplOrMarkup.markup;
                        }
                        if (tmplOrMarkup !== undefined) {
                            if (tmplOrMarkup.render || tmpl.render) {
                                // tmpl is already compiled, so use it
                                if (tmplOrMarkup.tmpls) {
                                    compiledTmpl = tmplOrMarkup;
                                }
                            } else {
                                // tmplOrMarkup is a markup string, not a compiled template
                                // Create template object
                                tmpl = tmplObject(tmplOrMarkup, options);
                                // Compile to AST and then to compiled function
                                tmplFn(tmplOrMarkup.replace(rEscapeQuotes, "\\$&"), tmpl);
                            }
                            if (!compiledTmpl) {
                                compiledTmpl = $extend(function () {
                                    return compiledTmpl.render.apply(compiledTmpl, arguments);
                                }, tmpl);

                                compileChildResources(compiledTmpl);
                            }
                            return compiledTmpl;
                        }
                    }

//==== /end of function compileTmpl ====

//=================
// compileViewModel
//=================

                    function getDefaultVal(defaultVal, data) {
                        return $isFunction(defaultVal)
                            ? defaultVal.call(data)
                            : defaultVal;
                    }

                    function addParentRef(ob, ref, parent) {
                        Object.defineProperty(ob, ref, {
                            value: parent,
                            configurable: true
                        });
                    }

                    function compileViewModel(name, type) {
                        var i, constructor, parent,
                            viewModels = this,
                            getters = type.getters,
                            extend = type.extend,
                            id = type.id,
                            proto = $.extend({
                                _is: name || "unnamed",
                                unmap: unmap,
                                merge: merge
                            }, extend),
                            args = "",
                            cnstr = "",
                            getterCount = getters ? getters.length : 0,
                            $observable = $.observable,
                            getterNames = {};

                        function JsvVm(args) {
                            constructor.apply(this, args);
                        }

                        function vm() {
                            return new JsvVm(arguments);
                        }

                        function iterate(data, action) {
                            var getterType, defaultVal, prop, ob, parentRef,
                                j = 0;
                            for (; j < getterCount; j++) {
                                prop = getters[j];
                                getterType = undefined;
                                if (prop + "" !== prop) {
                                    getterType = prop;
                                    prop = getterType.getter;
                                    parentRef = getterType.parentRef;
                                }
                                if ((ob = data[prop]) === undefined && getterType && (defaultVal = getterType.defaultVal) !== undefined) {
                                    ob = getDefaultVal(defaultVal, data);
                                }
                                action(ob, getterType && viewModels[getterType.type], prop, parentRef);
                            }
                        }

                        function map(data) {
                            data = data + "" === data
                                ? JSON.parse(data) // Accept JSON string
                                : data;            // or object/array
                            var l, prop, childOb, parentRef,
                                j = 0,
                                ob = data,
                                arr = [];

                            if ($isArray(data)) {
                                data = data || [];
                                l = data.length;
                                for (; j < l; j++) {
                                    arr.push(this.map(data[j]));
                                }
                                arr._is = name;
                                arr.unmap = unmap;
                                arr.merge = merge;
                                return arr;
                            }

                            if (data) {
                                iterate(data, function (ob, viewModel) {
                                    if (viewModel) { // Iterate to build getters arg array (value, or mapped value)
                                        ob = viewModel.map(ob);
                                    }
                                    arr.push(ob);
                                });
                                ob = this.apply(this, arr); // Instantiate this View Model, passing getters args array to constructor
                                j = getterCount;
                                while (j--) {
                                    childOb = arr[j];
                                    parentRef = getters[j].parentRef;
                                    if (parentRef && childOb && childOb.unmap) {
                                        if ($isArray(childOb)) {
                                            l = childOb.length;
                                            while (l--) {
                                                addParentRef(childOb[l], parentRef, ob);
                                            }
                                        } else {
                                            addParentRef(childOb, parentRef, ob);
                                        }
                                    }
                                }
                                for (prop in data) { // Copy over any other properties. that are not get/set properties
                                    if (prop !== $expando && !getterNames[prop]) {
                                        ob[prop] = data[prop];
                                    }
                                }
                            }
                            return ob;
                        }

                        function merge(data, parent, parentRef) {
                            data = data + "" === data
                                ? JSON.parse(data) // Accept JSON string
                                : data;            // or object/array

                            var j, l, m, prop, mod, found, assigned, ob, newModArr, childOb,
                                k = 0,
                                model = this;

                            if ($isArray(model)) {
                                assigned = {};
                                newModArr = [];
                                l = data.length;
                                m = model.length;
                                for (; k < l; k++) {
                                    ob = data[k];
                                    found = false;
                                    for (j = 0; j < m && !found; j++) {
                                        if (assigned[j]) {
                                            continue;
                                        }
                                        mod = model[j];

                                        if (id) {
                                            assigned[j] = found = id + "" === id
                                                ? (ob[id] && (getterNames[id] ? mod[id]() : mod[id]) === ob[id])
                                                : id(mod, ob);
                                        }
                                    }
                                    if (found) {
                                        mod.merge(ob);
                                        newModArr.push(mod);
                                    } else {
                                        newModArr.push(childOb = vm.map(ob));
                                        if (parentRef) {
                                            addParentRef(childOb, parentRef, parent);
                                        }
                                    }
                                }
                                if ($observable) {
                                    $observable(model).refresh(newModArr, true);
                                } else {
                                    model.splice.apply(model, [0, model.length].concat(newModArr));
                                }
                                return;
                            }
                            iterate(data, function (ob, viewModel, getter, parentRef) {
                                if (viewModel) {
                                    model[getter]().merge(ob, model, parentRef); // Update typed property
                                } else if (model[getter]() !== ob) {
                                    model[getter](ob); // Update non-typed property
                                }
                            });
                            for (prop in data) {
                                if (prop !== $expando && !getterNames[prop]) {
                                    model[prop] = data[prop];
                                }
                            }
                        }

                        function unmap() {
                            var ob, prop, getterType, arr, value,
                                k = 0,
                                model = this;

                            function unmapArray(modelArr) {
                                var arr = [],
                                    i = 0,
                                    l = modelArr.length;
                                for (; i < l; i++) {
                                    arr.push(modelArr[i].unmap());
                                }
                                return arr;
                            }

                            if ($isArray(model)) {
                                return unmapArray(model);
                            }
                            ob = {};
                            for (; k < getterCount; k++) {
                                prop = getters[k];
                                getterType = undefined;
                                if (prop + "" !== prop) {
                                    getterType = prop;
                                    prop = getterType.getter;
                                }
                                value = model[prop]();
                                ob[prop] = getterType && value && viewModels[getterType.type]
                                    ? $isArray(value)
                                        ? unmapArray(value)
                                        : value.unmap()
                                    : value;
                            }
                            for (prop in model) {
                                if (model.hasOwnProperty(prop) && (prop.charAt(0) !== "_" || !getterNames[prop.slice(1)]) && prop !== $expando && !$isFunction(model[prop])) {
                                    ob[prop] = model[prop];
                                }
                            }
                            return ob;
                        }

                        JsvVm.prototype = proto;

                        for (i = 0; i < getterCount; i++) {
                            (function (getter) {
                                getter = getter.getter || getter;
                                getterNames[getter] = i + 1;
                                var privField = "_" + getter;

                                args += (args ? "," : "") + getter;
                                cnstr += "this." + privField + " = " + getter + ";\n";
                                proto[getter] = proto[getter] || function (val) {
                                    if (!arguments.length) {
                                        return this[privField]; // If there is no argument, use as a getter
                                    }
                                    if ($observable) {
                                        $observable(this).setProperty(getter, val);
                                    } else {
                                        this[privField] = val;
                                    }
                                };

                                if ($observable) {
                                    proto[getter].set = proto[getter].set || function (val) {
                                        this[privField] = val; // Setter called by observable property change
                                    };
                                }
                            })(getters[i]);
                        }

                        // Constructor for new viewModel instance.
                        cnstr = new Function(args, cnstr);

                        constructor = function () {
                            cnstr.apply(this, arguments);
                            // Pass additional parentRef str and parent obj to have a parentRef pointer on instance
                            if (parent = arguments[getterCount + 1]) {
                                addParentRef(this, arguments[getterCount], parent);
                            }
                        };

                        constructor.prototype = proto;
                        proto.constructor = constructor;

                        vm.map = map;
                        vm.getters = getters;
                        vm.extend = extend;
                        vm.id = id;
                        return vm;
                    }

                    function tmplObject(markup, options) {
                        // Template object constructor
                        var htmlTag,
                            wrapMap = $subSettingsAdvanced._wm || {}, // Only used in JsViews. Otherwise empty: {}
                            tmpl = {
                                tmpls: [],
                                links: {}, // Compiled functions for link expressions
                                bnds: [],
                                _is: "template",
                                render: renderContent
                            };

                        if (options) {
                            tmpl = $extend(tmpl, options);
                        }

                        tmpl.markup = markup;
                        if (!tmpl.htmlTag) {
                            // Set tmpl.tag to the top-level HTML tag used in the template, if any...
                            htmlTag = rFirstElem.exec(markup);
                            tmpl.htmlTag = htmlTag ? htmlTag[1].toLowerCase() : "";
                        }
                        htmlTag = wrapMap[tmpl.htmlTag];
                        if (htmlTag && htmlTag !== wrapMap.div) {
                            // When using JsViews, we trim templates which are inserted into HTML contexts where text nodes are not rendered (i.e. not 'Phrasing Content').
                            // Currently not trimmed for <li> tag. (Not worth adding perf cost)
                            tmpl.markup = $.trim(tmpl.markup);
                        }

                        return tmpl;
                    }

//==============
// registerStore
//==============

                    /**
                     * Internal. Register a store type (used for template, tags, helpers, converters)
                     */
                    function registerStore(storeName, storeSettings) {

                        /**
                         * Generic store() function to register item, named item, or hash of items
                         * Also used as hash to store the registered items
                         * Used as implementation of $.templates(), $.views.templates(), $.views.tags(), $.views.helpers() and $.views.converters()
                         *
                         * @param {string|hash} name         name - or selector, in case of $.templates(). Or hash of items
                         * @param {any}         [item]       (e.g. markup for named template)
                         * @param {template}    [parentTmpl] For item being registered as private resource of template
                         * @returns {any|$.views} item, e.g. compiled template - or $.views in case of registering hash of items
                         */
                        function theStore(name, item, parentTmpl) {
                            // The store is also the function used to add items to the store. e.g. $.templates, or $.views.tags

                            // For store of name 'thing', Call as:
                            //    $.views.things(items[, parentTmpl]),
                            // or $.views.things(name[, item, parentTmpl])

                            var compile, itemName, thisStore, cnt,
                                onStore = $sub.onStore[storeName];

                            if (name && typeof name === OBJECT && !name.nodeType && !name.markup && !name.getTgt && !(storeName === "viewModel" && name.getters || name.extend)) {
                                // Call to $.views.things(items[, parentTmpl]),

                                // Adding items to the store
                                // If name is a hash, then item is parentTmpl. Iterate over hash and call store for key.
                                for (itemName in name) {
                                    theStore(itemName, name[itemName], item);
                                }
                                return item || $views;
                            }
                            // Adding a single unnamed item to the store
                            if (name && "" + name !== name) { // name must be a string
                                parentTmpl = item;
                                item = name;
                                name = undefined;
                            }
                            thisStore = parentTmpl
                                ? storeName === "viewModel"
                                    ? parentTmpl
                                    : (parentTmpl[storeNames] = parentTmpl[storeNames] || {})
                                : theStore;
                            compile = storeSettings.compile;

                            if (item === undefined) {
                                item = compile ? name : thisStore[name];
                                name = undefined;
                            }
                            if (item === null) {
                                // If item is null, delete this entry
                                if (name) {
                                    delete thisStore[name];
                                }
                            } else {
                                if (compile) {
                                    item = compile.call(thisStore, name, item, parentTmpl, 0) || {};
                                    item._is = storeName; // Only do this for compiled objects (tags, templates...)
                                }
                                if (name) {
                                    thisStore[name] = item;
                                }
                            }
                            if (onStore) {
                                // e.g. JsViews integration
                                onStore(name, item, parentTmpl, compile);
                            }
                            return item;
                        }

                        var storeNames = storeName + "s";
                        $views[storeNames] = theStore;
                    }

                    /**
                     * Add settings such as:
                     * $.views.settings.allowCode(true)
                     * @param {boolean} value
                     * @returns {Settings}
                     *
                     * allowCode = $.views.settings.allowCode()
                     * @returns {boolean}
                     */
                    function addSetting(st) {
                        $viewsSettings[st] = $viewsSettings[st] || function (value) {
                            return arguments.length
                                ? ($subSettings[st] = value, $viewsSettings)
                                : $subSettings[st];
                        };
                    }

//========================
// dataMap for render only
//========================

                    function dataMap(mapDef) {
                        function Map(source, options) {
                            this.tgt = mapDef.getTgt(source, options);
                            options.map = this;
                        }

                        if ($isFunction(mapDef)) {
                            // Simple map declared as function
                            mapDef = {
                                getTgt: mapDef
                            };
                        }

                        if (mapDef.baseMap) {
                            mapDef = $extend($extend({}, mapDef.baseMap), mapDef);
                        }

                        mapDef.map = function (source, options) {
                            return new Map(source, options);
                        };
                        return mapDef;
                    }

//==============
// renderContent
//==============

                    /** Render the template as a string, using the specified data and helpers/context
                     * $("#tmpl").render(), tmpl.render(), tagCtx.render(), $.render.namedTmpl()
                     *
                     * @param {any}        data
                     * @param {hash}       [context]           helpers or context
                     * @param {boolean}    [noIteration]
                     * @param {View}       [parentView]        internal
                     * @param {string}     [key]               internal
                     * @param {function}   [onRender]          internal
                     * @returns {string}   rendered template   internal
                     */
                    function renderContent(data, context, noIteration, parentView, key, onRender) {
                        var i, l, tag, tmpl, tagCtx, isTopRenderCall, prevData, prevIndex,
                            view = parentView,
                            result = "";

                        if (context === true) {
                            noIteration = context; // passing boolean as second param - noIteration
                            context = undefined;
                        } else if (typeof context !== OBJECT) {
                            context = undefined; // context must be a boolean (noIteration) or a plain object
                        }

                        if (tag = this.tag) {
                            // This is a call from renderTag or tagCtx.render(...)
                            tagCtx = this;
                            view = view || tagCtx.view;
                            tmpl = view._getTmpl(tag.template || tagCtx.tmpl);
                            if (!arguments.length) {
                                data = tag.contentCtx && $isFunction(tag.contentCtx)
                                    ? data = tag.contentCtx(data)
                                    : view; // Default data context for wrapped block content is the first argument
                            }
                        } else {
                            // This is a template.render(...) call
                            tmpl = this;
                        }

                        if (tmpl) {
                            if (!parentView && data && data._is === "view") {
                                view = data; // When passing in a view to render or link (and not passing in a parent view) use the passed-in view as parentView
                            }

                            if (view && data === view) {
                                // Inherit the data from the parent view.
                                data = view.data;
                            }

                            isTopRenderCall = !view;
                            isRenderCall = isRenderCall || isTopRenderCall;
                            if (isTopRenderCall) {
                                (context = context || {}).root = data; // Provide ~root as shortcut to top-level data.
                            }
                            if (!isRenderCall || $subSettingsAdvanced.useViews || tmpl.useViews || view && view !== topView) {
                                result = renderWithViews(tmpl, data, context, noIteration, view, key, onRender, tag);
                            } else {
                                if (view) { // In a block
                                    prevData = view.data;
                                    prevIndex = view.index;
                                    view.index = indexStr;
                                } else {
                                    view = topView;
                                    prevData = view.data;
                                    view.data = data;
                                    view.ctx = context;
                                }
                                if ($isArray(data) && !noIteration) {
                                    // Create a view for the array, whose child views correspond to each data item. (Note: if key and parentView are passed in
                                    // along with parent view, treat as insert -e.g. from view.addViews - so parentView is already the view item for array)
                                    for (i = 0, l = data.length; i < l; i++) {
                                        view.index = i;
                                        view.data = data[i];
                                        result += tmpl.fn(data[i], view, $sub);
                                    }
                                } else {
                                    view.data = data;
                                    result += tmpl.fn(data, view, $sub);
                                }
                                view.data = prevData;
                                view.index = prevIndex;
                            }
                            if (isTopRenderCall) {
                                isRenderCall = undefined;
                            }
                        }
                        return result;
                    }

                    function renderWithViews(tmpl, data, context, noIteration, view, key, onRender, tag) {
                        // Render template against data as a tree of subviews (nested rendered template instances), or as a string (top-level template).
                        // If the data is the parent view, treat as noIteration, re-render with the same data context.
                        // tmpl can be a string (e.g. rendered by a tag.render() method), or a compiled template.
                        var i, l, newView, childView, itemResult, swapContent, contentTmpl, outerOnRender, tmplName,
                            itemVar, newCtx, tagCtx, noLinking,
                            result = "";

                        if (tag) {
                            // This is a call from renderTag or tagCtx.render(...)
                            tmplName = tag.tagName;
                            tagCtx = tag.tagCtx;
                            context = context ? extendCtx(context, tag.ctx) : tag.ctx;

                            if (tmpl === view.content) { // {{xxx tmpl=#content}}
                                contentTmpl = tmpl !== view.ctx._wrp // We are rendering the #content
                                    ? view.ctx._wrp // #content was the tagCtx.props.tmpl wrapper of the block content - so within this view, #content will now be the view.ctx._wrp block content
                                    : undefined; // #content was the view.ctx._wrp block content - so within this view, there is no longer any #content to wrap.
                            } else if (tmpl !== tagCtx.content) {
                                if (tmpl === tag.template) { // Rendering {{tag}} tag.template, replacing block content.
                                    contentTmpl = tagCtx.tmpl; // Set #content to block content (or wrapped block content if tagCtx.props.tmpl is set)
                                    context._wrp = tagCtx.content; // Pass wrapped block content to nested views
                                } else { // Rendering tagCtx.props.tmpl wrapper
                                    contentTmpl = tagCtx.content || view.content; // Set #content to wrapped block content
                                }
                            } else {
                                contentTmpl = view.content; // Nested views inherit same wrapped #content property
                            }

                            if (tagCtx.props.link === false) {
                                // link=false setting on block tag
                                // We will override inherited value of link by the explicit setting link=false taken from props
                                // The child views of an unlinked view are also unlinked. So setting child back to true will not have any effect.
                                context = context || {};
                                context.link = false;
                            }
                        }

                        if (view) {
                            onRender = onRender || view._.onRender;
                            noLinking = context && context.link === false;

                            if (noLinking && view._.nl) {
                                onRender = undefined;
                            }

                            context = extendCtx(context, view.ctx);
                            tagCtx = !tag && view.tag
                                ? view.tag.tagCtxs[view.tagElse]
                                : tagCtx;
                        }

                        if (itemVar = tagCtx && tagCtx.props.itemVar) {
                            if (itemVar[0] !== "~") {
                                syntaxError("Use itemVar='~myItem'");
                            }
                            itemVar = itemVar.slice(1);
                        }

                        if (key === true) {
                            swapContent = true;
                            key = 0;
                        }

                        // If link===false, do not call onRender, so no data-linking marker nodes
                        if (onRender && tag && tag._.noVws) {
                            onRender = undefined;
                        }
                        outerOnRender = onRender;
                        if (onRender === true) {
                            // Used by view.refresh(). Don't create a new wrapper view.
                            outerOnRender = undefined;
                            onRender = view._.onRender;
                        }
                        // Set additional context on views created here, (as modified context inherited from the parent, and to be inherited by child views)
                        context = tmpl.helpers
                            ? extendCtx(tmpl.helpers, context)
                            : context;

                        newCtx = context;
                        if ($isArray(data) && !noIteration) {
                            // Create a view for the array, whose child views correspond to each data item. (Note: if key and view are passed in
                            // along with parent view, treat as insert -e.g. from view.addViews - so view is already the view item for array)
                            newView = swapContent
                                ? view
                                : (key !== undefined && view)
                                || new View(context, "array", view, data, tmpl, key, onRender, contentTmpl);
                            newView._.nl = noLinking;
                            if (view && view._.useKey) {
                                // Parent is not an 'array view'
                                newView._.bnd = !tag || tag._.bnd && tag; // For array views that are data bound for collection change events, set the
                                // view._.bnd property to true for top-level link() or data-link="{for}", or to the tag instance for a data-bound tag, e.g. {^{for ...}}
                                newView.tag = tag;
                            }
                            for (i = 0, l = data.length; i < l; i++) {
                                // Create a view for each data item.
                                childView = new View(newCtx, "item", newView, data[i], tmpl, (key || 0) + i, onRender, newView.content);
                                if (itemVar) {
                                    (childView.ctx = $extend({}, newCtx))[itemVar] = $sub._cp(data[i], "#data", childView);
                                }
                                itemResult = tmpl.fn(data[i], childView, $sub);
                                result += newView._.onRender ? newView._.onRender(itemResult, childView) : itemResult;
                            }
                        } else {
                            // Create a view for singleton data object. The type of the view will be the tag name, e.g. "if" or "mytag" except for
                            // "item", "array" and "data" views. A "data" view is from programmatic render(object) against a 'singleton'.
                            newView = swapContent ? view : new View(newCtx, tmplName || "data", view, data, tmpl, key, onRender, contentTmpl);

                            if (itemVar) {
                                (newView.ctx = $extend({}, newCtx))[itemVar] = $sub._cp(data, "#data", newView);
                            }

                            newView.tag = tag;
                            newView._.nl = noLinking;
                            result += tmpl.fn(data, newView, $sub);
                        }
                        if (tag) {
                            newView.tagElse = tagCtx.index;
                            tagCtx.contentView = newView;
                        }
                        return outerOnRender ? outerOnRender(result, newView) : result;
                    }

//===========================
// Build and compile template
//===========================

// Generate a reusable function that will serve to render a template against data
// (Compile AST then build template function)

                    function onRenderError(e, view, fallback) {
                        var message = fallback !== undefined
                            ? $isFunction(fallback)
                                ? fallback.call(view.data, e, view)
                                : fallback || ""
                            : "{Error: " + (e.message || e) + "}";

                        if ($subSettings.onError && (fallback = $subSettings.onError.call(view.data, e, fallback && message, view)) !== undefined) {
                            message = fallback; // There is a settings.debugMode(handler) onError override. Call it, and use return value (if any) to replace message
                        }
                        return view && !view._lc ? $converters.html(message) : message; // For data-link=\"{... onError=...}"... See onDataLinkedTagChange
                    }

                    function error(message) {
                        throw new $sub.Err(message);
                    }

                    function syntaxError(message) {
                        error("Syntax error\n" + message);
                    }

                    function tmplFn(markup, tmpl, isLinkExpr, convertBack, hasElse) {
                        // Compile markup to AST (abtract syntax tree) then build the template function code from the AST nodes
                        // Used for compiling templates, and also by JsViews to build functions for data link expressions

                        //==== nested functions ====
                        function pushprecedingContent(shift) {
                            shift -= loc;
                            if (shift) {
                                content.push(markup.substr(loc, shift).replace(rNewLine, "\\n"));
                            }
                        }

                        function blockTagCheck(tagName, block) {
                            if (tagName) {
                                tagName += '}}';
                                //			'{{include}} block has {{/for}} with no open {{for}}'
                                syntaxError((
                                    block
                                        ? '{{' + block + '}} block has {{/' + tagName + ' without {{' + tagName
                                        : 'Unmatched or missing {{/' + tagName) + ', in template:\n' + markup);
                            }
                        }

                        function parseTag(all, bind, tagName, converter, colon, html, codeTag, params, slash, bind2, closeBlock, index) {
                            /*

     bind     tagName         cvt   cln html code    params            slash   bind2         closeBlk  comment
/(?:{(\^)?{(?:(\w+(?=[\/\s}]))|(\w+)?(:)|(>)|(\*))\s*((?:[^}]|}(?!}))*?)(\/)?|{(\^)?{(?:(?:\/(\w+))\s*|!--[\s\S]*?--))}}/g

(?:
  {(\^)?{            bind
  (?:
    (\w+             tagName
      (?=[\/\s}])
    )
    |
    (\w+)?(:)        converter colon
    |
    (>)              html
    |
    (\*)             codeTag
  )
  \s*
  (                  params
    (?:[^}]|}(?!}))*?
  )
  (\/)?              slash
  |
  {(\^)?{            bind2
  (?:
    (?:\/(\w+))\s*   closeBlock
    |
    !--[\s\S]*?--    comment
  )
)
}}/g

*/
                            if (codeTag && bind || slash && !tagName || params && params.slice(-1) === ":" || bind2) {
                                syntaxError(all);
                            }

                            // Build abstract syntax tree (AST): [tagName, converter, params, content, hash, bindings, contentMarkup]
                            if (html) {
                                colon = ":";
                                converter = HTML;
                            }
                            slash = slash || isLinkExpr && !hasElse;

                            var late, openTagName, isLateOb,
                                pathBindings = (bind || isLinkExpr) && [[]], // pathBindings is an array of arrays for arg bindings and a hash of arrays for prop bindings
                                props = "",
                                args = "",
                                ctxProps = "",
                                paramsArgs = "",
                                paramsProps = "",
                                paramsCtxProps = "",
                                onError = "",
                                useTrigger = "",
                                // Block tag if not self-closing and not {{:}} or {{>}} (special case) and not a data-link expression
                                block = !slash && !colon;

                            //==== nested helper function ====
                            tagName = tagName || (params = params || "#data", colon); // {{:}} is equivalent to {{:#data}}
                            pushprecedingContent(index);
                            loc = index + all.length; // location marker - parsed up to here
                            if (codeTag) {
                                if (allowCode) {
                                    content.push(["*", "\n" + params.replace(/^:/, "ret+= ").replace(rUnescapeQuotes, "$1") + ";\n"]);
                                }
                            } else if (tagName) {
                                if (tagName === "else") {
                                    if (rTestElseIf.test(params)) {
                                        syntaxError('For "{{else if expr}}" use "{{else expr}}"');
                                    }
                                    pathBindings = current[9] && [[]];
                                    current[10] = markup.substring(current[10], index); // contentMarkup for block tag
                                    openTagName = current[11] || current[0] || syntaxError("Mismatched: " + all);
                                    // current[0] is tagName, but for {{else}} nodes, current[11] is tagName of preceding open tag
                                    current = stack.pop();
                                    content = current[2];
                                    block = true;
                                }
                                if (params) {
                                    // remove newlines from the params string, to avoid compiled code errors for unterminated strings
                                    parseParams(params.replace(rNewLine, " "), pathBindings, tmpl, isLinkExpr)
                                        .replace(rBuildHash, function (all, onerror, isCtxPrm, key, keyToken, keyValue, arg, param) {
                                            if (key === "this:") {
                                                keyValue = "undefined"; // this=some.path is always a to parameter (one-way), so don't need to compile/evaluate some.path initialization
                                            }
                                            if (param) {
                                                isLateOb = isLateOb || param[0] === "@";
                                            }
                                            key = "'" + keyToken + "':";
                                            if (arg) {
                                                args += isCtxPrm + keyValue + ",";
                                                paramsArgs += "'" + param + "',";
                                            } else if (isCtxPrm) { // Contextual parameter, ~foo=expr
                                                ctxProps += key + 'j._cp(' + keyValue + ',"' + param + '",view),';
                                                // Compiled code for evaluating tagCtx on a tag will have: ctx:{'foo':j._cp(compiledExpr, "expr", view)}
                                                paramsCtxProps += key + "'" + param + "',";
                                            } else if (onerror) {
                                                onError += keyValue;
                                            } else {
                                                if (keyToken === "trigger") {
                                                    useTrigger += keyValue;
                                                }
                                                if (keyToken === "lateRender") {
                                                    late = param !== "false"; // Render after first pass
                                                }
                                                props += key + keyValue + ",";
                                                paramsProps += key + "'" + param + "',";
                                                hasHandlers = hasHandlers || rHasHandlers.test(keyToken);
                                            }
                                            return "";
                                        }).slice(0, -1);
                                }

                                if (pathBindings && pathBindings[0]) {
                                    pathBindings.pop(); // Remove the binding that was prepared for next arg. (There is always an extra one ready).
                                }

                                newNode = [
                                    tagName,
                                    converter || !!convertBack || hasHandlers || "",
                                    block && [],
                                    parsedParam(paramsArgs || (tagName === ":" ? "'#data'," : ""), paramsProps, paramsCtxProps), // {{:}} equivalent to {{:#data}}
                                    parsedParam(args || (tagName === ":" ? "data," : ""), props, ctxProps),
                                    onError,
                                    useTrigger,
                                    late,
                                    isLateOb,
                                    pathBindings || 0
                                ];
                                content.push(newNode);
                                if (block) {
                                    stack.push(current);
                                    current = newNode;
                                    current[10] = loc; // Store current location of open tag, to be able to add contentMarkup when we reach closing tag
                                    current[11] = openTagName; // Used for checking syntax (matching close tag)
                                }
                            } else if (closeBlock) {
                                blockTagCheck(closeBlock !== current[0] && closeBlock !== current[11] && closeBlock, current[0]); // Check matching close tag name
                                current[10] = markup.substring(current[10], index); // contentMarkup for block tag
                                current = stack.pop();
                            }
                            blockTagCheck(!current && closeBlock);
                            content = current[2];
                        }

                        //==== /end of nested functions ====

                        var i, result, newNode, hasHandlers, bindings,
                            allowCode = $subSettings.allowCode || tmpl && tmpl.allowCode
                                || $viewsSettings.allowCode === true, // include direct setting of settings.allowCode true for backward compat only
                            astTop = [],
                            loc = 0,
                            stack = [],
                            content = astTop,
                            current = [, , astTop];

                        if (allowCode && tmpl._is) {
                            tmpl.allowCode = allowCode;
                        }

//TODO	result = tmplFnsCache[markup]; // Only cache if template is not named and markup length < ...,
//and there are no bindings or subtemplates?? Consider standard optimization for data-link="a.b.c"
//		if (result) {
//			tmpl.fn = result;
//		} else {

//		result = markup;
                        if (isLinkExpr) {
                            if (convertBack !== undefined) {
                                markup = markup.slice(0, -convertBack.length - 2) + delimCloseChar0;
                            }
                            markup = delimOpenChar0 + markup + delimCloseChar1;
                        }

                        blockTagCheck(stack[0] && stack[0][2].pop()[0]);
                        // Build the AST (abstract syntax tree) under astTop
                        markup.replace(rTag, parseTag);

                        pushprecedingContent(markup.length);

                        if (loc = astTop[astTop.length - 1]) {
                            blockTagCheck("" + loc !== loc && (+loc[10] === loc[10]) && loc[0]);
                        }
//			result = tmplFnsCache[markup] = buildCode(astTop, tmpl);
//		}

                        if (isLinkExpr) {
                            result = buildCode(astTop, markup, isLinkExpr);
                            bindings = [];
                            i = astTop.length;
                            while (i--) {
                                bindings.unshift(astTop[i][9]); // With data-link expressions, pathBindings array for tagCtx[i] is astTop[i][9]
                            }
                            setPaths(result, bindings);
                        } else {
                            result = buildCode(astTop, tmpl);
                        }
                        return result;
                    }

                    function setPaths(fn, pathsArr) {
                        var key, paths,
                            i = 0,
                            l = pathsArr.length;
                        fn.deps = [];
                        fn.paths = []; // The array of path binding (array/dictionary)s for each tag/else block's args and props
                        for (; i < l; i++) {
                            fn.paths.push(paths = pathsArr[i]);
                            for (key in paths) {
                                if (key !== "_jsvto" && paths.hasOwnProperty(key) && paths[key].length && !paths[key].skp) {
                                    fn.deps = fn.deps.concat(paths[key]); // deps is the concatenation of the paths arrays for the different bindings
                                }
                            }
                        }
                    }

                    function parsedParam(args, props, ctx) {
                        return [args.slice(0, -1), props.slice(0, -1), ctx.slice(0, -1)];
                    }

                    function paramStructure(paramCode, paramVals) {
                        return '\n\tparams:{args:[' + paramCode[0] + '],\n\tprops:{' + paramCode[1] + '}'
                            + (paramCode[2] ? ',\n\tctx:{' + paramCode[2] + '}' : "")
                            + '},\n\targs:[' + paramVals[0] + '],\n\tprops:{' + paramVals[1] + '}'
                            + (paramVals[2] ? ',\n\tctx:{' + paramVals[2] + '}' : "");
                    }

                    function parseParams(params, pathBindings, tmpl, isLinkExpr) {

                        function parseTokens(all, lftPrn0, lftPrn, bound, path, operator, err, eq, path2, late, prn,
                                             comma, lftPrn2, apos, quot, rtPrn, rtPrnDot, prn2, space, index, full) {
                            // /(\()(?=\s*\()|(?:([([])\s*)?(?:(\^?)(~?[\w$.^]+)?\s*((\+\+|--)|\+|-|~(?![\w$])|&&|\|\||===|!==|==|!=|<=|>=|[<>%*:?\/]|(=))\s*|(!*?(@)?[#~]?[\w$.^]+)([([])?)|(,\s*)|(?:(\()\s*)?\\?(?:(')|("))|(?:\s*(([)\]])(?=[.^]|\s*$|[^([])|[)\]])([([]?))|(\s+)/g,
                            //lftPrn0           lftPrn         bound     path               operator     err                                          eq      path2 late            prn      comma  lftPrn2          apos quot        rtPrn  rtPrnDot                  prn2     space
                            // (left paren? followed by (path? followed by operator) or (path followed by paren?)) or comma or apos or quot or right paren or space

                            function parsePath(allPath, not, object, helper, view, viewProperty, pathTokens, leafToken) {
                                // /^(!*?)(?:null|true|false|\d[\d.]*|([\w$]+|\.|~([\w$]+)|#(view|([\w$]+))?)([\w$.^]*?)(?:[.[^]([\w$]+)\]?)?)$/g,
                                //    not                               object     helper    view  viewProperty pathTokens      leafToken
                                subPath = object === ".";
                                if (object) {
                                    path = path.slice(not.length);
                                    if (/^\.?constructor$/.test(leafToken || path)) {
                                        syntaxError(allPath);
                                    }
                                    if (!subPath) {
                                        allPath = (late // late path @a.b.c: not throw on 'property of undefined' if a undefined, and will use _getOb() after linking to resolve late.
                                                ? (isLinkExpr ? '' : '(ltOb.lt=ltOb.lt||') + '(ob='
                                                : ""
                                            )
                                            + (helper
                                                ? 'view.ctxPrm("' + helper + '")'
                                                : view
                                                    ? "view"
                                                    : "data")
                                            + (late
                                                    ? ')===undefined' + (isLinkExpr ? '' : ')') + '?"":view._getOb(ob,"'
                                                    : ""
                                            )
                                            + (leafToken
                                                ? (viewProperty
                                                    ? "." + viewProperty
                                                    : helper
                                                        ? ""
                                                        : (view ? "" : "." + object)
                                            ) + (pathTokens || "")
                                                : (leafToken = helper ? "" : view ? viewProperty || "" : object, ""));
                                        allPath = allPath + (leafToken ? "." + leafToken : "");

                                        allPath = not + (allPath.slice(0, 9) === "view.data"
                                            ? allPath.slice(5) // convert #view.data... to data...
                                            : allPath)
                                            + (late
                                                    ? (isLinkExpr ? '"' : '",ltOb') + (prn ? ',1)' : ')')
                                                    : ""
                                            );
                                    }
                                    if (bindings) {
                                        binds = named === "_linkTo" ? (bindto = pathBindings._jsvto = pathBindings._jsvto || []) : bndCtx.bd;
                                        if (theOb = subPath && binds[binds.length - 1]) {
                                            if (theOb._cpfn) { // Computed property exprOb
                                                while (theOb.sb) {
                                                    theOb = theOb.sb;
                                                }
                                                if (theOb.prm) {
                                                    if (theOb.bnd) {
                                                        path = "^" + path.slice(1);
                                                    }
                                                    theOb.sb = path;
                                                    theOb.bnd = theOb.bnd || path[0] === "^";
                                                }
                                            }
                                        } else {
                                            binds.push(path);
                                        }
                                        if (prn && !subPath) {
                                            pathStart[fnDp] = ind;
                                            compiledPathStart[fnDp] = compiledPath[fnDp].length;
                                        }
                                    }
                                }
                                return allPath;
                            }

                            //bound = bindings && bound;
                            if (bound && !eq) {
                                path = bound + path; // e.g. some.fn(...)^some.path - so here path is "^some.path"
                            }
                            operator = operator || "";
                            lftPrn2 = lftPrn2 || "";
                            lftPrn = lftPrn || lftPrn0 || lftPrn2;
                            path = path || path2;

                            if (late && (late = !/\)|]/.test(full[index - 1]))) {
                                path = path.slice(1).split(".").join("^"); // Late path @z.b.c. Use "^" rather than "." to ensure that deep binding will be used
                            }
                            // Could do this - but not worth perf cost?? :-
                            // if (!path.lastIndexOf("#data.", 0)) { path = path.slice(6); } // If path starts with "#data.", remove that.
                            prn = prn || prn2 || "";
                            var expr, binds, theOb, newOb, subPath, lftPrnFCall, ret,
                                ind = index;

                            if (!aposed && !quoted) {
                                if (err) {
                                    syntaxError(params);
                                }
                                if (rtPrnDot && bindings) {
                                    // This is a binding to a path in which an object is returned by a helper/data function/expression, e.g. foo()^x.y or (a?b:c)^x.y
                                    // We create a compiled function to get the object instance (which will be called when the dependent data of the subexpression changes,
                                    // to return the new object, and trigger re-binding of the subsequent path)
                                    expr = pathStart[fnDp - 1];
                                    if (full.length - 1 > ind - (expr || 0)) { // We need to compile a subexpression
                                        expr = $.trim(full.slice(expr, ind + all.length));
                                        binds = bindto || bndStack[fnDp - 1].bd;
                                        // Insert exprOb object, to be used during binding to return the computed object
                                        theOb = binds[binds.length - 1];
                                        if (theOb && theOb.prm) {
                                            while (theOb.sb && theOb.sb.prm) {
                                                theOb = theOb.sb;
                                            }
                                            newOb = theOb.sb = {path: theOb.sb, bnd: theOb.bnd};
                                        } else {
                                            binds.push(newOb = {path: binds.pop()}); // Insert exprOb object, to be used during binding to return the computed object
                                        }
                                        if (theOb && theOb.sb === newOb) {
                                            compiledPath[fnDp] = compiledPath[fnDp - 1].slice(theOb._cpPthSt) + compiledPath[fnDp];
                                            compiledPath[fnDp - 1] = compiledPath[fnDp - 1].slice(0, theOb._cpPthSt);
                                        }
                                        newOb._cpPthSt = compiledPathStart[fnDp - 1];
                                        newOb._cpKey = expr;

                                        compiledPath[fnDp] += full.slice(prevIndex, index);
                                        prevIndex = index;

                                        newOb._cpfn = cpFnStore[expr] = cpFnStore[expr] || // Compiled function for computed value: get from store, or compile and store
                                            new Function("data,view,j", // Compiled function for computed value in template
                                                "//" + expr + "\nvar v;\nreturn ((v=" + compiledPath[fnDp] + (rtPrn === "]" ? ")]" : rtPrn) + ")!=null?v:null);");

                                        compiledPath[fnDp - 1] += (fnCall[prnDp] && $subSettingsAdvanced.cache ? "view.getCache(\"" + expr.replace(rEscapeQuotes, "\\$&") + "\"" : compiledPath[fnDp]);

                                        newOb.prm = bndCtx.bd;
                                        newOb.bnd = newOb.bnd || newOb.path && newOb.path.indexOf("^") >= 0;
                                    }
                                    compiledPath[fnDp] = "";
                                }
                                if (prn === "[") {
                                    prn = "[j._sq(";
                                }
                                if (lftPrn === "[") {
                                    lftPrn = "[j._sq(";
                                }
                            }
                            ret = (aposed
                                    // within single-quoted string
                                    ? (aposed = !apos, (aposed ? all : lftPrn2 + '"'))
                                    : quoted
                                        // within double-quoted string
                                        ? (quoted = !quot, (quoted ? all : lftPrn2 + '"'))
                                        :
                                        (
                                            (lftPrn
                                                ? (
                                                    prnStack[++prnDp] = true,
                                                        prnInd[prnDp] = 0,
                                                    bindings && (
                                                        pathStart[fnDp++] = ind++,
                                                            bndCtx = bndStack[fnDp] = {bd: []},
                                                            compiledPath[fnDp] = "",
                                                            compiledPathStart[fnDp] = 1
                                                    ),
                                                        lftPrn) // Left paren, (not a function call paren)
                                                : "")
                                            + (space
                                                ? (prnDp
                                                        ? "" // A space within parens or within function call parens, so not a separator for tag args
                                                        // New arg or prop - so insert backspace \b (\x08) as separator for named params, used subsequently by rBuildHash, and prepare new bindings array
                                                        : (paramIndex = full.slice(paramIndex, ind), named
                                                        ? (named = boundName = bindto = false, "\b")
                                                        : "\b,") + paramIndex + (paramIndex = ind + all.length, bindings && pathBindings.push(bndCtx.bd = []), "\b")
                                                )
                                                : eq
                                                    // named param. Remove bindings for arg and create instead bindings array for prop
                                                    ? (fnDp && syntaxError(params), bindings && pathBindings.pop(), named = "_" + path, boundName = bound, paramIndex = ind + all.length,
                                                    bindings && ((bindings = bndCtx.bd = pathBindings[named] = []), bindings.skp = !bound), path + ':')
                                                    : path
                                                        // path
                                                        ? (path.split("^").join(".").replace($sub.rPath, parsePath)
                                                            + (prn || operator)
                                                        )
                                                        : operator
                                                            // operator
                                                            ? operator
                                                            : rtPrn
                                                                // function
                                                                ? rtPrn === "]" ? ")]" : ")"
                                                                : comma
                                                                    ? (fnCall[prnDp] || syntaxError(params), ",") // We don't allow top-level literal arrays or objects
                                                                    : lftPrn0
                                                                        ? ""
                                                                        : (aposed = apos, quoted = quot, '"')
                                            ))
                            );

                            if (!aposed && !quoted) {
                                if (rtPrn) {
                                    fnCall[prnDp] = false;
                                    prnDp--;
                                }
                            }

                            if (bindings) {
                                if (!aposed && !quoted) {
                                    if (rtPrn) {
                                        if (prnStack[prnDp + 1]) {
                                            bndCtx = bndStack[--fnDp];
                                            prnStack[prnDp + 1] = false;
                                        }
                                        prnStart = prnInd[prnDp + 1];
                                    }
                                    if (prn) {
                                        prnInd[prnDp + 1] = compiledPath[fnDp].length + (lftPrn ? 1 : 0);
                                        if (path || rtPrn) {
                                            bndCtx = bndStack[++fnDp] = {bd: []};
                                            prnStack[prnDp + 1] = true;
                                        }
                                    }
                                }

                                compiledPath[fnDp] = (compiledPath[fnDp] || "") + full.slice(prevIndex, index);
                                prevIndex = index + all.length;

                                if (!aposed && !quoted) {
                                    if (lftPrnFCall = lftPrn && prnStack[prnDp + 1]) {
                                        compiledPath[fnDp - 1] += lftPrn;
                                        compiledPathStart[fnDp - 1]++;
                                    }
                                    if (prn === "(" && subPath && !newOb) {
                                        compiledPath[fnDp] = compiledPath[fnDp - 1].slice(prnStart) + compiledPath[fnDp];
                                        compiledPath[fnDp - 1] = compiledPath[fnDp - 1].slice(0, prnStart);
                                    }
                                }
                                compiledPath[fnDp] += lftPrnFCall ? ret.slice(1) : ret;
                            }

                            if (!aposed && !quoted && prn) {
                                prnDp++;
                                if (path && prn === "(") {
                                    fnCall[prnDp] = true;
                                }
                            }

                            if (!aposed && !quoted && prn2) {
                                if (bindings) {
                                    compiledPath[fnDp] += prn;
                                }
                                ret += prn;
                            }
                            return ret;
                        }

                        var named, bindto, boundName, result,
                            quoted, // boolean for string content in double quotes
                            aposed, // or in single quotes
                            bindings = pathBindings && pathBindings[0], // bindings array for the first arg
                            bndCtx = {bd: bindings},
                            bndStack = {0: bndCtx},
                            paramIndex = 0, // list,
                            // The following are used for tracking path parsing including nested paths, such as "a.b(c^d + (e))^f", and chained computed paths such as
                            // "a.b().c^d().e.f().g" - which has four chained paths, "a.b()", "^c.d()", ".e.f()" and ".g"
                            prnDp = 0,     // For tracking paren depth (not function call parens)
                            fnDp = 0,      // For tracking depth of function call parens
                            prnInd = {},   // We are in a function call
                            prnStart = 0,  // tracks the start of the current path such as c^d() in the above example
                            prnStack = {}, // tracks parens which are not function calls, and so are associated with new bndStack contexts
                            fnCall = {},   // We are in a function call
                            pathStart = {},// tracks the start of the current path such as c^d() in the above example
                            compiledPathStart = {0: 0},
                            compiledPath = {0: ""},
                            prevIndex = 0;

                        if (params[0] === "@") {
                            params = params.replace(rBracketQuote, ".");
                        }
                        result = (params + (tmpl ? " " : "")).replace($sub.rPrm, parseTokens);

                        if (bindings) {
                            result = compiledPath[0];
                        }

                        return !prnDp && result || syntaxError(params); // Syntax error if unbalanced parens in params expression
                    }

                    function buildCode(ast, tmpl, isLinkExpr) {
                        // Build the template function code from the AST nodes, and set as property on the passed-in template object
                        // Used for compiling templates, and also by JsViews to build functions for data link expressions
                        var i, node, tagName, converter, tagCtx, hasTag, hasEncoder, getsVal, hasCnvt, useCnvt,
                            tmplBindings, pathBindings, params, boundOnErrStart,
                            boundOnErrEnd, tagRender, nestedTmpls, tmplName, nestedTmpl, tagAndElses, content, markup,
                            nextIsElse, oldCode, isElse, isGetVal, tagCtxFn,
                            onError, tagStart, trigger, lateRender, retStrOpen, retStrClose,
                            tmplBindingKey = 0,
                            useViews = $subSettingsAdvanced.useViews || tmpl.useViews || tmpl.tags || tmpl.templates || tmpl.helpers || tmpl.converters,
                            code = "",
                            tmplOptions = {},
                            l = ast.length;

                        if ("" + tmpl === tmpl) {
                            tmplName = isLinkExpr ? 'data-link="' + tmpl.replace(rNewLine, " ").slice(1, -1) + '"' : tmpl;
                            tmpl = 0;
                        } else {
                            tmplName = tmpl.tmplName || "unnamed";
                            if (tmpl.allowCode) {
                                tmplOptions.allowCode = true;
                            }
                            if (tmpl.debug) {
                                tmplOptions.debug = true;
                            }
                            tmplBindings = tmpl.bnds;
                            nestedTmpls = tmpl.tmpls;
                        }
                        for (i = 0; i < l; i++) {
                            // AST nodes: [0: tagName, 1: converter, 2: content, 3: params, 4: code, 5: onError, 6: trigger, 7:pathBindings, 8: contentMarkup]
                            node = ast[i];

                            // Add newline for each callout to t() c() etc. and each markup string
                            if ("" + node === node) {
                                // a markup string to be inserted
                                code += '+"' + node + '"';
                            } else {
                                // a compiled tag expression to be inserted
                                tagName = node[0];
                                if (tagName === "*") {
                                    // Code tag: {{* }}
                                    code += ";\n" + node[1] + "\nret=ret";
                                } else {
                                    converter = node[1];
                                    content = !isLinkExpr && node[2];
                                    tagCtx = paramStructure(node[3], params = node[4]);
                                    trigger = node[6];
                                    lateRender = node[7];
                                    if (node[8]) { // latePath @a.b.c or @~a.b.c
                                        retStrOpen = "\nvar ob,ltOb={},ctxs=";
                                        retStrClose = ";\nctxs.lt=ltOb.lt;\nreturn ctxs;";
                                    } else {
                                        retStrOpen = "\nreturn ";
                                        retStrClose = "";
                                    }
                                    markup = node[10] && node[10].replace(rUnescapeQuotes, "$1");
                                    if (isElse = tagName === "else") {
                                        if (pathBindings) {
                                            pathBindings.push(node[9]);
                                        }
                                    } else {
                                        onError = node[5] || $subSettings.debugMode !== false && "undefined"; // If debugMode not false, set default onError handler on tag to "undefined" (see onRenderError)
                                        if (tmplBindings && (pathBindings = node[9])) { // Array of paths, or false if not data-bound
                                            pathBindings = [pathBindings];
                                            tmplBindingKey = tmplBindings.push(1); // Add placeholder in tmplBindings for compiled function
                                        }
                                    }
                                    useViews = useViews || params[1] || params[2] || pathBindings || /view.(?!index)/.test(params[0]);
                                    // useViews is for perf optimization. For render() we only use views if necessary - for the more advanced scenarios.
                                    // We use views if there are props, contextual properties or args with #... (other than #index) - but you can force
                                    // using the full view infrastructure, (and pay a perf price) by opting in: Set useViews: true on the template, manually...
                                    if (isGetVal = tagName === ":") {
                                        if (converter) {
                                            tagName = converter === HTML ? ">" : converter + tagName;
                                        }
                                    } else {
                                        if (content) { // TODO optimize - if content.length === 0 or if there is a tmpl="..." specified - set content to null / don't run this compilation code - since content won't get used!!
                                            // Create template object for nested template
                                            nestedTmpl = tmplObject(markup, tmplOptions);
                                            nestedTmpl.tmplName = tmplName + "/" + tagName;
                                            // Compile to AST and then to compiled function
                                            nestedTmpl.useViews = nestedTmpl.useViews || useViews;
                                            buildCode(content, nestedTmpl);
                                            useViews = nestedTmpl.useViews;
                                            nestedTmpls.push(nestedTmpl);
                                        }

                                        if (!isElse) {
                                            // This is not an else tag.
                                            tagAndElses = tagName;
                                            useViews = useViews || tagName && (!$tags[tagName] || !$tags[tagName].flow);
                                            // Switch to a new code string for this bound tag (and its elses, if it has any) - for returning the tagCtxs array
                                            oldCode = code;
                                            code = "";
                                        }
                                        nextIsElse = ast[i + 1];
                                        nextIsElse = nextIsElse && nextIsElse[0] === "else";
                                    }
                                    tagStart = onError ? ";\ntry{\nret+=" : "\n+";
                                    boundOnErrStart = "";
                                    boundOnErrEnd = "";

                                    if (isGetVal && (pathBindings || trigger || converter && converter !== HTML || lateRender)) {
                                        // For convertVal we need a compiled function to return the new tagCtx(s)
                                        tagCtxFn = new Function("data,view,j", "// " + tmplName + " " + (++tmplBindingKey) + " " + tagName
                                            + retStrOpen + "{" + tagCtx + "};" + retStrClose);
                                        tagCtxFn._er = onError;
                                        tagCtxFn._tag = tagName;
                                        tagCtxFn._bd = !!pathBindings; // data-linked tag {^{.../}}
                                        tagCtxFn._lr = lateRender;

                                        if (isLinkExpr) {
                                            return tagCtxFn;
                                        }

                                        setPaths(tagCtxFn, pathBindings);
                                        tagRender = 'c("' + converter + '",view,';
                                        useCnvt = true;
                                        boundOnErrStart = tagRender + tmplBindingKey + ",";
                                        boundOnErrEnd = ")";
                                    }
                                    code += (isGetVal
                                        ? (isLinkExpr ? (onError ? "try{\n" : "") + "return " : tagStart) + (useCnvt // Call _cnvt if there is a converter: {{cnvt: ... }} or {^{cnvt: ... }}
                                            ? (useCnvt = undefined, useViews = hasCnvt = true, tagRender + (tagCtxFn
                                                ? ((tmplBindings[tmplBindingKey - 1] = tagCtxFn), tmplBindingKey) // Store the compiled tagCtxFn in tmpl.bnds, and pass the key to convertVal()
                                                : "{" + tagCtx + "}") + ")")
                                            : tagName === ">"
                                                ? (hasEncoder = true, "h(" + params[0] + ")")
                                                : (getsVal = true, "((v=" + params[0] + ')!=null?v:' + (isLinkExpr ? 'null)' : '"")'))
                                        // Non strict equality so data-link="title{:expr}" with expr=null/undefined removes title attribute
                                    )
                                        : (hasTag = true, "\n{view:view,content:false,tmpl:" // Add this tagCtx to the compiled code for the tagCtxs to be passed to renderTag()
                                        + (content ? nestedTmpls.length : "false") + "," // For block tags, pass in the key (nestedTmpls.length) to the nested content template
                                        + tagCtx + "},"));

                                    if (tagAndElses && !nextIsElse) {
                                        // This is a data-link expression or an inline tag without any elses, or the last {{else}} of an inline tag
                                        // We complete the code for returning the tagCtxs array
                                        code = "[" + code.slice(0, -1) + "]";
                                        tagRender = 't("' + tagAndElses + '",view,this,';
                                        if (isLinkExpr || pathBindings) {
                                            // This is a bound tag (data-link expression or inline bound tag {^{tag ...}}) so we store a compiled tagCtxs function in tmp.bnds
                                            code = new Function("data,view,j", " // " + tmplName + " " + tmplBindingKey + " " + tagAndElses + retStrOpen + code
                                                + retStrClose);
                                            code._er = onError;
                                            code._tag = tagAndElses;
                                            if (pathBindings) {
                                                setPaths(tmplBindings[tmplBindingKey - 1] = code, pathBindings);
                                            }
                                            code._lr = lateRender;
                                            if (isLinkExpr) {
                                                return code; // For a data-link expression we return the compiled tagCtxs function
                                            }
                                            boundOnErrStart = tagRender + tmplBindingKey + ",undefined,";
                                            boundOnErrEnd = ")";
                                        }

                                        // This is the last {{else}} for an inline tag.
                                        // For a bound tag, pass the tagCtxs fn lookup key to renderTag.
                                        // For an unbound tag, include the code directly for evaluating tagCtxs array
                                        code = oldCode + tagStart + tagRender + (pathBindings && tmplBindingKey || code) + ")";
                                        pathBindings = 0;
                                        tagAndElses = 0;
                                    }
                                    if (onError && !nextIsElse) {
                                        useViews = true;
                                        code += ';\n}catch(e){ret' + (isLinkExpr ? "urn " : "+=") + boundOnErrStart + 'j._err(e,view,' + onError + ')' + boundOnErrEnd + ';}' + (isLinkExpr ? "" : '\nret=ret');
                                    }
                                }
                            }
                        }
                        // Include only the var references that are needed in the code
                        code = "// " + tmplName
                            + (tmplOptions.debug ? "\ndebugger;" : "")
                            + "\nvar v"
                            + (hasTag ? ",t=j._tag" : "")                // has tag
                            + (hasCnvt ? ",c=j._cnvt" : "")              // converter
                            + (hasEncoder ? ",h=j._html" : "")           // html converter
                            + (isLinkExpr
                                ? (node[8] // late @... path?
                                    ? ", ob"
                                    : ""
                            ) + ";\n"
                                : ',ret=""')
                            + code
                            + (isLinkExpr ? "\n" : ";\nreturn ret;");

                        try {
                            code = new Function("data,view,j", code);
                        } catch (e) {
                            syntaxError("Compiled template code:\n\n" + code + '\n: "' + (e.message || e) + '"');
                        }
                        if (tmpl) {
                            tmpl.fn = code;
                            tmpl.useViews = !!useViews;
                        }
                        return code;
                    }

//==========
// Utilities
//==========

// Merge objects, in particular contexts which inherit from parent contexts
                    function extendCtx(context, parentContext) {
                        // Return copy of parentContext, unless context is defined and is different, in which case return a new merged context
                        // If neither context nor parentContext are defined, return undefined
                        return context && context !== parentContext
                            ? (parentContext
                                ? $extend($extend({}, parentContext), context)
                                : context)
                            : parentContext && $extend({}, parentContext);
                    }

                    function getTargetProps(source, tagCtx) {
                        // this pointer is theMap - which has tagCtx.props too
                        // arguments: tagCtx.args.
                        var key, prop,
                            map = tagCtx.map,
                            propsArr = map && map.propsArr;

                        if (!propsArr) { // map.propsArr is the full array of {key:..., prop:...} objects
                            propsArr = [];
                            if (typeof source === OBJECT || $isFunction(source)) {
                                for (key in source) {
                                    prop = source[key];
                                    if (key !== $expando && source.hasOwnProperty(key) && (!tagCtx.props.noFunctions || !$.isFunction(prop))) {
                                        propsArr.push({key: key, prop: prop});
                                    }
                                }
                            }
                            if (map) {
                                map.propsArr = map.options && propsArr; // If bound {^{props}} and not isRenderCall, store propsArr on map (map.options is defined only for bound, && !isRenderCall)
                            }
                        }
                        return getTargetSorted(propsArr, tagCtx); // Obtains map.tgt, by filtering, sorting and splicing the full propsArr
                    }

                    function getTargetSorted(value, tagCtx) {
                        // getTgt
                        var mapped, start, end,
                            tag = tagCtx.tag,
                            props = tagCtx.props,
                            propParams = tagCtx.params.props,
                            filter = props.filter,
                            sort = props.sort,
                            directSort = sort === true,
                            step = parseInt(props.step),
                            reverse = props.reverse ? -1 : 1;

                        if (!$isArray(value)) {
                            return value;
                        }
                        if (directSort || sort && "" + sort === sort) {
                            // Temporary mapped array holds objects with index and sort-value
                            mapped = value.map(function (item, i) {
                                item = directSort ? item : getPathObject(item, sort);
                                return {i: i, v: "" + item === item ? item.toLowerCase() : item};
                            });
                            // Sort mapped array
                            mapped.sort(function (a, b) {
                                return a.v > b.v ? reverse : a.v < b.v ? -reverse : 0;
                            });
                            // Map to new array with resulting order
                            value = mapped.map(function (item) {
                                return value[item.i];
                            });
                        } else if ((sort || reverse < 0) && !tag.dataMap) {
                            value = value.slice(); // Clone array first if not already a new array
                        }
                        if ($isFunction(sort)) {
                            value = value.sort(function () { // Wrap the sort function to provide tagCtx as 'this' pointer
                                return sort.apply(tagCtx, arguments);
                            });
                        }
                        if (reverse < 0 && (!sort || $isFunction(sort))) { // Reverse result if not already reversed in sort
                            value = value.reverse();
                        }

                        if (value.filter && filter) { // IE8 does not support filter
                            value = value.filter(filter, tagCtx);
                            if (tagCtx.tag.onFilter) {
                                tagCtx.tag.onFilter(tagCtx);
                            }
                        }

                        if (propParams.sorted) {
                            mapped = (sort || reverse < 0) ? value : value.slice();
                            if (tag.sorted) {
                                $.observable(tag.sorted).refresh(mapped); // Note that this might cause the start and end props to be modified - e.g. by pager tag control
                            } else {
                                tagCtx.map.sorted = mapped;
                            }
                        }

                        start = props.start; // Get current value - after possible changes triggered by tag.sorted refresh() above
                        end = props.end;
                        if (propParams.start && start === undefined || propParams.end && end === undefined) {
                            start = end = 0;
                        }
                        if (!isNaN(start) || !isNaN(end)) { // start or end specified, but not the auto-create Number array scenario of {{for start=xxx end=yyy}}
                            start = +start || 0;
                            end = end === undefined || end > value.length ? value.length : +end;
                            value = value.slice(start, end);
                        }
                        if (step > 1) {
                            start = 0;
                            end = value.length;
                            mapped = [];
                            for (; start < end; start += step) {
                                mapped.push(value[start]);
                            }
                            value = mapped;
                        }
                        if (propParams.paged && tag.paged) {
                            $observable(tag.paged).refresh(value);
                        }

                        return value;
                    }

                    /** Render the template as a string, using the specified data and helpers/context
                     * $("#tmpl").render()
                     *
                     * @param {any}        data
                     * @param {hash}       [helpersOrContext]
                     * @param {boolean}    [noIteration]
                     * @returns {string}   rendered template
                     */
                    function $fnRender(data, context, noIteration) {
                        var tmplElem = this.jquery && (this[0] || error('Unknown template')), // Targeted element not found for jQuery template selector such as "#myTmpl"
                            tmpl = tmplElem.getAttribute(tmplAttr);

                        return renderContent.call(tmpl && $.data(tmplElem)[jsvTmpl] || $templates(tmplElem),
                            data, context, noIteration);
                    }

//========================== Register converters ==========================

                    function getCharEntity(ch) {
                        // Get character entity for HTML, Attribute and optional data encoding
                        return charEntities[ch] || (charEntities[ch] = "&#" + ch.charCodeAt(0) + ";");
                    }

                    function getCharFromEntity(match, token) {
                        // Get character from HTML entity, for optional data unencoding
                        return charsFromEntities[token] || "";
                    }

                    function htmlEncode(text) {
                        // HTML encode: Replace < > & ' " ` etc. by corresponding entities.
                        return text != undefined ? rIsHtml.test(text) && ("" + text).replace(rHtmlEncode, getCharEntity) || text : "";
                    }

                    function dataEncode(text) {
                        // Encode just < > and & - intended for 'safe data' along with {{:}} rather than {{>}}
                        return "" + text === text ? text.replace(rDataEncode, getCharEntity) : text;
                    }

                    function dataUnencode(text) {
                        // Unencode just < > and & - intended for 'safe data' along with {{:}} rather than {{>}}
                        return "" + text === text ? text.replace(rDataUnencode, getCharFromEntity) : text;
                    }

//========================== Initialize ==========================

                    $sub = $views.sub;
                    $viewsSettings = $views.settings;

                    if (!(jsr || $ && $.render)) {
                        // JsRender/JsViews not already loaded (or loaded without jQuery, and we are now moving from jsrender namespace to jQuery namepace)
                        for (jsvStoreName in jsvStores) {
                            registerStore(jsvStoreName, jsvStores[jsvStoreName]);
                        }

                        $converters = $views.converters;
                        $helpers = $views.helpers;
                        $tags = $views.tags;

                        $sub._tg.prototype = {
                            baseApply: baseApply,
                            cvtArgs: convertArgs,
                            bndArgs: convertBoundArgs,
                            ctxPrm: contextParameter
                        };

                        topView = $sub.topView = new View();

                        //BROWSER-SPECIFIC CODE
                        if ($) {

                            ////////////////////////////////////////////////////////////////////////////////////////////////
                            // jQuery (= $) is loaded

                            $.fn.render = $fnRender;
                            $expando = $.expando;
                            if ($.observable) {
                                if (versionNumber !== (versionNumber = $.views.jsviews)) {
                                    // Different version of jsRender was loaded
                                    throw "jquery.observable.js requires jsrender.js " + versionNumber;
                                }
                                $extend($sub, $.views.sub); // jquery.observable.js was loaded before jsrender.js
                                $views.map = $.views.map;
                            }

                        } else {
                            ////////////////////////////////////////////////////////////////////////////////////////////////
                            // jQuery is not loaded.

                            $ = {};

                            if (setGlobals) {
                                global.jsrender = $; // We are loading jsrender.js from a script element, not AMD or CommonJS, so set global
                            }

                            // Error warning if jsrender.js is used as template engine on Node.js (e.g. Express or Hapi...)
                            // Use jsrender-node.js instead...
                            $.renderFile = $.__express = $.compile = function () {
                                throw "Node.js: use npm jsrender, or jsrender-node.js";
                            };

                            //END BROWSER-SPECIFIC CODE
                            $.isFunction = function (ob) {
                                return typeof ob === "function";
                            };

                            $.isArray = Array.isArray || function (obj) {
                                return ({}.toString).call(obj) === "[object Array]";
                            };

                            $sub._jq = function (jq) { // private method to move from JsRender APIs from jsrender namespace to jQuery namespace
                                if (jq !== $) {
                                    $extend(jq, $); // map over from jsrender namespace to jQuery namespace
                                    $ = jq;
                                    $.fn.render = $fnRender;
                                    delete $.jsrender;
                                    $expando = $.expando;
                                }
                            };

                            $.jsrender = versionNumber;
                        }
                        $subSettings = $sub.settings;
                        $subSettings.allowCode = false;
                        $isFunction = $.isFunction;
                        $.render = $render;
                        $.views = $views;
                        $.templates = $templates = $views.templates;

                        for (setting in $subSettings) {
                            addSetting(setting);
                        }

                        /**
                         * $.views.settings.debugMode(true)
                         * @param {boolean} debugMode
                         * @returns {Settings}
                         *
                         * debugMode = $.views.settings.debugMode()
                         * @returns {boolean}
                         */
                        ($viewsSettings.debugMode = function (debugMode) {
                            return debugMode === undefined
                                ? $subSettings.debugMode
                                : (
                                    $subSettings._clFns && $subSettings._clFns(), // Clear linkExprStore (cached compiled expressions), since debugMode setting affects compilation for expressions
                                        $subSettings.debugMode = debugMode,
                                        $subSettings.onError = debugMode + "" === debugMode
                                            ? function () {
                                                return debugMode;
                                            }
                                            : $isFunction(debugMode)
                                                ? debugMode
                                                : undefined,
                                        $viewsSettings);
                        })(false); // jshint ignore:line

                        $subSettingsAdvanced = $subSettings.advanced = {
                            cache: true, // By default use cached values of computed values (Otherwise, set advanced cache setting to false)
                            useViews: false,
                            _jsv: false // For global access to JsViews store
                        };

                        //========================== Register tags ==========================

                        $tags({
                            "if": {
                                render: function (val) {
                                    // This function is called once for {{if}} and once for each {{else}}.
                                    // We will use the tag.rendering object for carrying rendering state across the calls.
                                    // If not done (a previous block has not been rendered), look at expression for this block and render the block if expression is truthy
                                    // Otherwise return ""
                                    var self = this,
                                        tagCtx = self.tagCtx,
                                        ret = (self.rendering.done || !val && (tagCtx.args.length || !tagCtx.index))
                                            ? ""
                                            : (self.rendering.done = true,
                                                self.selected = tagCtx.index,
                                                undefined); // Test is satisfied, so render content on current context
                                    return ret;
                                },
                                contentCtx: true, // Inherit parent view data context
                                flow: true
                            },
                            "for": {
                                sortDataMap: dataMap(getTargetSorted),
                                init: function (val, cloned) {
                                    this.setDataMap(this.tagCtxs);
                                },
                                render: function (val) {
                                    // This function is called once for {{for}} and once for each {{else}}.
                                    // We will use the tag.rendering object for carrying rendering state across the calls.
                                    var value, filter, srtField, isArray, i, sorted, end, step,
                                        self = this,
                                        tagCtx = self.tagCtx,
                                        range = tagCtx.argDefault === false,
                                        props = tagCtx.props,
                                        iterate = range || tagCtx.args.length, // Not final else and not auto-create range
                                        result = "",
                                        done = 0;

                                    if (!self.rendering.done) {
                                        value = iterate ? val : tagCtx.view.data; // For the final else, defaults to current data without iteration.

                                        if (range) {
                                            range = props.reverse ? "unshift" : "push";
                                            end = +props.end;
                                            step = +props.step || 1;
                                            value = []; // auto-create integer array scenario of {{for start=xxx end=yyy}}
                                            for (i = +props.start || 0; (end - i) * step > 0; i += step) {
                                                value[range](i);
                                            }
                                        }
                                        if (value !== undefined) {
                                            isArray = $isArray(value);
                                            result += tagCtx.render(value, !iterate || props.noIteration);
                                            // Iterates if data is an array, except on final else - or if noIteration property
                                            // set to true. (Use {{include}} to compose templates without array iteration)
                                            done += isArray ? value.length : 1;
                                        }
                                        if (self.rendering.done = done) {
                                            self.selected = tagCtx.index;
                                        }
                                        // If nothing was rendered we will look at the next {{else}}. Otherwise, we are done.
                                    }
                                    return result;
                                },
                                setDataMap: function (tagCtxs) {
                                    var tagCtx, props, paramsProps,
                                        self = this,
                                        l = tagCtxs.length;
                                    while (l--) {
                                        tagCtx = tagCtxs[l];
                                        props = tagCtx.props;
                                        paramsProps = tagCtx.params.props;
                                        tagCtx.argDefault = props.end === undefined || tagCtx.args.length > 0; // Default to #data except for auto-create range scenario {{for start=xxx end=yyy step=zzz}}
                                        props.dataMap = (tagCtx.argDefault !== false && $isArray(tagCtx.args[0]) &&
                                            (paramsProps.sort || paramsProps.start || paramsProps.end || paramsProps.step || paramsProps.filter || paramsProps.reverse
                                                || props.sort || props.start || props.end || props.step || props.filter || props.reverse))
                                            && self.sortDataMap;
                                    }
                                },
                                flow: true
                            },
                            props: {
                                baseTag: "for",
                                dataMap: dataMap(getTargetProps),
                                init: noop, // Don't execute the base init() of the "for" tag
                                flow: true
                            },
                            include: {
                                flow: true
                            },
                            "*": {
                                // {{* code... }} - Ignored if template.allowCode and $.views.settings.allowCode are false. Otherwise include code in compiled template
                                render: retVal,
                                flow: true
                            },
                            ":*": {
                                // {{:* returnedExpression }} - Ignored if template.allowCode and $.views.settings.allowCode are false. Otherwise include code in compiled template
                                render: retVal,
                                flow: true
                            },
                            dbg: $helpers.dbg = $converters.dbg = dbgBreak // Register {{dbg/}}, {{dbg:...}} and ~dbg() to throw and catch, as breakpoints for debugging.
                        });

                        $converters({
                            html: htmlEncode,
                            attr: htmlEncode, // Includes > encoding since rConvertMarkers in JsViews does not skip > characters in attribute strings
                            encode: dataEncode,
                            unencode: dataUnencode, // Includes > encoding since rConvertMarkers in JsViews does not skip > characters in attribute strings
                            url: function (text) {
                                // URL encoding helper.
                                return text != undefined ? encodeURI("" + text) : text === null ? text : ""; // null returns null, e.g. to remove attribute. undefined returns ""
                            }
                        });
                    }
//========================== Define default delimiters ==========================
                    $subSettings = $sub.settings;
                    $isArray = ($ || jsr).isArray;
                    $viewsSettings.delimiters("{{", "}}", "^");

                    if (jsrToJq) { // Moving from jsrender namespace to jQuery namepace - copy over the stored items (templates, converters, helpers...)
                        jsr.views.sub._jq($);
                    }
                    return $ || jsr;
                }, window));


            /***/
        }),

        /***/ "./node_modules/sweetalert/dist/sweetalert.min.js":
        /*!********************************************************!*\
  !*** ./node_modules/sweetalert/dist/sweetalert.min.js ***!
  \********************************************************/
        /***/ (function (module) {

            !function (t, e) {
                true ? module.exports = e() : 0
            }(this, function () {
                return function (t) {
                    function e(o) {
                        if (n[o]) return n[o].exports;
                        var r = n[o] = {i: o, l: !1, exports: {}};
                        return t[o].call(r.exports, r, r.exports, e), r.l = !0, r.exports
                    }

                    var n = {};
                    return e.m = t, e.c = n, e.d = function (t, n, o) {
                        e.o(t, n) || Object.defineProperty(t, n, {configurable: !1, enumerable: !0, get: o})
                    }, e.n = function (t) {
                        var n = t && t.__esModule ? function () {
                            return t.default
                        } : function () {
                            return t
                        };
                        return e.d(n, "a", n), n
                    }, e.o = function (t, e) {
                        return Object.prototype.hasOwnProperty.call(t, e)
                    }, e.p = "", e(e.s = 8)
                }([function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = "swal-button";
                    e.CLASS_NAMES = {
                        MODAL: "swal-modal",
                        OVERLAY: "swal-overlay",
                        SHOW_MODAL: "swal-overlay--show-modal",
                        MODAL_TITLE: "swal-title",
                        MODAL_TEXT: "swal-text",
                        ICON: "swal-icon",
                        ICON_CUSTOM: "swal-icon--custom",
                        CONTENT: "swal-content",
                        FOOTER: "swal-footer",
                        BUTTON_CONTAINER: "swal-button-container",
                        BUTTON: o,
                        CONFIRM_BUTTON: o + "--confirm",
                        CANCEL_BUTTON: o + "--cancel",
                        DANGER_BUTTON: o + "--danger",
                        BUTTON_LOADING: o + "--loading",
                        BUTTON_LOADER: o + "__loader"
                    }, e.default = e.CLASS_NAMES
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0}), e.getNode = function (t) {
                        var e = "." + t;
                        return document.querySelector(e)
                    }, e.stringToNode = function (t) {
                        var e = document.createElement("div");
                        return e.innerHTML = t.trim(), e.firstChild
                    }, e.insertAfter = function (t, e) {
                        var n = e.nextSibling;
                        e.parentNode.insertBefore(t, n)
                    }, e.removeNode = function (t) {
                        t.parentElement.removeChild(t)
                    }, e.throwErr = function (t) {
                        throw t = t.replace(/ +(?= )/g, ""), "SweetAlert: " + (t = t.trim())
                    }, e.isPlainObject = function (t) {
                        if ("[object Object]" !== Object.prototype.toString.call(t)) return !1;
                        var e = Object.getPrototypeOf(t);
                        return null === e || e === Object.prototype
                    }, e.ordinalSuffixOf = function (t) {
                        var e = t % 10, n = t % 100;
                        return 1 === e && 11 !== n ? t + "st" : 2 === e && 12 !== n ? t + "nd" : 3 === e && 13 !== n ? t + "rd" : t + "th"
                    }
                }, function (t, e, n) {
                    "use strict";

                    function o(t) {
                        for (var n in t) e.hasOwnProperty(n) || (e[n] = t[n])
                    }

                    Object.defineProperty(e, "__esModule", {value: !0}), o(n(25));
                    var r = n(26);
                    e.overlayMarkup = r.default, o(n(27)), o(n(28)), o(n(29));
                    var i = n(0), a = i.default.MODAL_TITLE, s = i.default.MODAL_TEXT, c = i.default.ICON,
                        l = i.default.FOOTER;
                    e.iconMarkup = '\n  <div class="' + c + '"></div>', e.titleMarkup = '\n  <div class="' + a + '"></div>\n', e.textMarkup = '\n  <div class="' + s + '"></div>', e.footerMarkup = '\n  <div class="' + l + '"></div>\n'
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1);
                    e.CONFIRM_KEY = "confirm", e.CANCEL_KEY = "cancel";
                    var r = {visible: !0, text: null, value: null, className: "", closeModal: !0},
                        i = Object.assign({}, r, {visible: !1, text: "Cancel", value: null}),
                        a = Object.assign({}, r, {text: "OK", value: !0});
                    e.defaultButtonList = {cancel: i, confirm: a};
                    var s = function (t) {
                        switch (t) {
                            case e.CONFIRM_KEY:
                                return a;
                            case e.CANCEL_KEY:
                                return i;
                            default:
                                var n = t.charAt(0).toUpperCase() + t.slice(1);
                                return Object.assign({}, r, {text: n, value: t})
                        }
                    }, c = function (t, e) {
                        var n = s(t);
                        return !0 === e ? Object.assign({}, n, {visible: !0}) : "string" == typeof e ? Object.assign({}, n, {
                            visible: !0,
                            text: e
                        }) : o.isPlainObject(e) ? Object.assign({visible: !0}, n, e) : Object.assign({}, n, {visible: !1})
                    }, l = function (t) {
                        for (var e = {}, n = 0, o = Object.keys(t); n < o.length; n++) {
                            var r = o[n], a = t[r], s = c(r, a);
                            e[r] = s
                        }
                        return e.cancel || (e.cancel = i), e
                    }, u = function (t) {
                        var n = {};
                        switch (t.length) {
                            case 1:
                                n[e.CANCEL_KEY] = Object.assign({}, i, {visible: !1});
                                break;
                            case 2:
                                n[e.CANCEL_KEY] = c(e.CANCEL_KEY, t[0]), n[e.CONFIRM_KEY] = c(e.CONFIRM_KEY, t[1]);
                                break;
                            default:
                                o.throwErr("Invalid number of 'buttons' in array (" + t.length + ").\n      If you want more than 2 buttons, you need to use an object!")
                        }
                        return n
                    };
                    e.getButtonListOpts = function (t) {
                        var n = e.defaultButtonList;
                        return "string" == typeof t ? n[e.CONFIRM_KEY] = c(e.CONFIRM_KEY, t) : Array.isArray(t) ? n = u(t) : o.isPlainObject(t) ? n = l(t) : !0 === t ? n = u([!0, !0]) : !1 === t ? n = u([!1, !1]) : void 0 === t && (n = e.defaultButtonList), n
                    }
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(2), i = n(0), a = i.default.MODAL, s = i.default.OVERLAY, c = n(30), l = n(31),
                        u = n(32), f = n(33);
                    e.injectElIntoModal = function (t) {
                        var e = o.getNode(a), n = o.stringToNode(t);
                        return e.appendChild(n), n
                    };
                    var d = function (t) {
                        t.className = a, t.textContent = ""
                    }, p = function (t, e) {
                        d(t);
                        var n = e.className;
                        n && t.classList.add(n)
                    };
                    e.initModalContent = function (t) {
                        var e = o.getNode(a);
                        p(e, t), c.default(t.icon), l.initTitle(t.title), l.initText(t.text), f.default(t.content), u.default(t.buttons, t.dangerMode)
                    };
                    var m = function () {
                        var t = o.getNode(s), e = o.stringToNode(r.modalMarkup);
                        t.appendChild(e)
                    };
                    e.default = m
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(3), r = {isOpen: !1, promise: null, actions: {}, timer: null}, i = Object.assign({}, r);
                    e.resetState = function () {
                        i = Object.assign({}, r)
                    }, e.setActionValue = function (t) {
                        if ("string" == typeof t) return a(o.CONFIRM_KEY, t);
                        for (var e in t) a(e, t[e])
                    };
                    var a = function (t, e) {
                        i.actions[t] || (i.actions[t] = {}), Object.assign(i.actions[t], {value: e})
                    };
                    e.setActionOptionsFor = function (t, e) {
                        var n = (void 0 === e ? {} : e).closeModal, o = void 0 === n || n;
                        Object.assign(i.actions[t], {closeModal: o})
                    }, e.default = i
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(3), i = n(0), a = i.default.OVERLAY, s = i.default.SHOW_MODAL,
                        c = i.default.BUTTON, l = i.default.BUTTON_LOADING, u = n(5);
                    e.openModal = function () {
                        o.getNode(a).classList.add(s), u.default.isOpen = !0
                    };
                    var f = function () {
                        o.getNode(a).classList.remove(s), u.default.isOpen = !1
                    };
                    e.onAction = function (t) {
                        void 0 === t && (t = r.CANCEL_KEY);
                        var e = u.default.actions[t], n = e.value;
                        if (!1 === e.closeModal) {
                            var i = c + "--" + t;
                            o.getNode(i).classList.add(l)
                        } else f();
                        u.default.promise.resolve(n)
                    }, e.getState = function () {
                        var t = Object.assign({}, u.default);
                        return delete t.promise, delete t.timer, t
                    }, e.stopLoading = function () {
                        for (var t = document.querySelectorAll("." + c), e = 0; e < t.length; e++) {
                            t[e].classList.remove(l)
                        }
                    }
                }, function (t, e) {
                    var n;
                    n = function () {
                        return this
                    }();
                    try {
                        n = n || Function("return this")() || (0, eval)("this")
                    } catch (t) {
                        "object" == typeof window && (n = window)
                    }
                    t.exports = n
                }, function (t, e, n) {
                    (function (e) {
                        t.exports = e.sweetAlert = n(9)
                    }).call(e, n(7))
                }, function (t, e, n) {
                    (function (e) {
                        t.exports = e.swal = n(10)
                    }).call(e, n(7))
                }, function (t, e, n) {
                    "undefined" != typeof window && n(11), n(16);
                    var o = n(23).default;
                    t.exports = o
                }, function (t, e, n) {
                    var o = n(12);
                    "string" == typeof o && (o = [[t.i, o, ""]]);
                    var r = {insertAt: "top"};
                    r.transform = void 0;
                    n(14)(o, r);
                    o.locals && (t.exports = o.locals)
                }, function (t, e, n) {
                    e = t.exports = n(13)(void 0), e.push([t.i, '.swal-icon--error{border-color:#f27474;-webkit-animation:animateErrorIcon .5s;animation:animateErrorIcon .5s}.swal-icon--error__x-mark{position:relative;display:block;-webkit-animation:animateXMark .5s;animation:animateXMark .5s}.swal-icon--error__line{position:absolute;height:5px;width:47px;background-color:#f27474;display:block;top:37px;border-radius:2px}.swal-icon--error__line--left{-webkit-transform:rotate(45deg);transform:rotate(45deg);left:17px}.swal-icon--error__line--right{-webkit-transform:rotate(-45deg);transform:rotate(-45deg);right:16px}@-webkit-keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@keyframes animateErrorIcon{0%{-webkit-transform:rotateX(100deg);transform:rotateX(100deg);opacity:0}to{-webkit-transform:rotateX(0deg);transform:rotateX(0deg);opacity:1}}@-webkit-keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}@keyframes animateXMark{0%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}50%{-webkit-transform:scale(.4);transform:scale(.4);margin-top:26px;opacity:0}80%{-webkit-transform:scale(1.15);transform:scale(1.15);margin-top:-6px}to{-webkit-transform:scale(1);transform:scale(1);margin-top:0;opacity:1}}.swal-icon--warning{border-color:#f8bb86;-webkit-animation:pulseWarning .75s infinite alternate;animation:pulseWarning .75s infinite alternate}.swal-icon--warning__body{width:5px;height:47px;top:10px;border-radius:2px;margin-left:-2px}.swal-icon--warning__body,.swal-icon--warning__dot{position:absolute;left:50%;background-color:#f8bb86}.swal-icon--warning__dot{width:7px;height:7px;border-radius:50%;margin-left:-4px;bottom:-11px}@-webkit-keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}@keyframes pulseWarning{0%{border-color:#f8d486}to{border-color:#f8bb86}}.swal-icon--success{border-color:#a5dc86}.swal-icon--success:after,.swal-icon--success:before{content:"";border-radius:50%;position:absolute;width:60px;height:120px;background:#fff;-webkit-transform:rotate(45deg);transform:rotate(45deg)}.swal-icon--success:before{border-radius:120px 0 0 120px;top:-7px;left:-33px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:60px 60px;transform-origin:60px 60px}.swal-icon--success:after{border-radius:0 120px 120px 0;top:-11px;left:30px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-transform-origin:0 60px;transform-origin:0 60px;-webkit-animation:rotatePlaceholder 4.25s ease-in;animation:rotatePlaceholder 4.25s ease-in}.swal-icon--success__ring{width:80px;height:80px;border:4px solid hsla(98,55%,69%,.2);border-radius:50%;box-sizing:content-box;position:absolute;left:-4px;top:-4px;z-index:2}.swal-icon--success__hide-corners{width:5px;height:90px;background-color:#fff;padding:1px;position:absolute;left:28px;top:8px;z-index:1;-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}.swal-icon--success__line{height:5px;background-color:#a5dc86;display:block;border-radius:2px;position:absolute;z-index:2}.swal-icon--success__line--tip{width:25px;left:14px;top:46px;-webkit-transform:rotate(45deg);transform:rotate(45deg);-webkit-animation:animateSuccessTip .75s;animation:animateSuccessTip .75s}.swal-icon--success__line--long{width:47px;right:8px;top:38px;-webkit-transform:rotate(-45deg);transform:rotate(-45deg);-webkit-animation:animateSuccessLong .75s;animation:animateSuccessLong .75s}@-webkit-keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@keyframes rotatePlaceholder{0%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}5%{-webkit-transform:rotate(-45deg);transform:rotate(-45deg)}12%{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}to{-webkit-transform:rotate(-405deg);transform:rotate(-405deg)}}@-webkit-keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@keyframes animateSuccessTip{0%{width:0;left:1px;top:19px}54%{width:0;left:1px;top:19px}70%{width:50px;left:-8px;top:37px}84%{width:17px;left:21px;top:48px}to{width:25px;left:14px;top:45px}}@-webkit-keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}@keyframes animateSuccessLong{0%{width:0;right:46px;top:54px}65%{width:0;right:46px;top:54px}84%{width:55px;right:0;top:35px}to{width:47px;right:8px;top:38px}}.swal-icon--info{border-color:#c9dae1}.swal-icon--info:before{width:5px;height:29px;bottom:17px;border-radius:2px;margin-left:-2px}.swal-icon--info:after,.swal-icon--info:before{content:"";position:absolute;left:50%;background-color:#c9dae1}.swal-icon--info:after{width:7px;height:7px;border-radius:50%;margin-left:-3px;top:19px}.swal-icon{width:80px;height:80px;border-width:4px;border-style:solid;border-radius:50%;padding:0;position:relative;box-sizing:content-box;margin:20px auto}.swal-icon:first-child{margin-top:32px}.swal-icon--custom{width:auto;height:auto;max-width:100%;border:none;border-radius:0}.swal-icon img{max-width:100%;max-height:100%}.swal-title{color:rgba(0,0,0,.65);font-weight:600;text-transform:none;position:relative;display:block;padding:13px 16px;font-size:27px;line-height:normal;text-align:center;margin-bottom:0}.swal-title:first-child{margin-top:26px}.swal-title:not(:first-child){padding-bottom:0}.swal-title:not(:last-child){margin-bottom:13px}.swal-text{font-size:16px;position:relative;float:none;line-height:normal;vertical-align:top;text-align:left;display:inline-block;margin:0;padding:0 10px;font-weight:400;color:rgba(0,0,0,.64);max-width:calc(100% - 20px);overflow-wrap:break-word;box-sizing:border-box}.swal-text:first-child{margin-top:45px}.swal-text:last-child{margin-bottom:45px}.swal-footer{text-align:right;padding-top:13px;margin-top:13px;padding:13px 16px;border-radius:inherit;border-top-left-radius:0;border-top-right-radius:0}.swal-button-container{margin:5px;display:inline-block;position:relative}.swal-button{background-color:#7cd1f9;color:#fff;border:none;box-shadow:none;border-radius:5px;font-weight:600;font-size:14px;padding:10px 24px;margin:0;cursor:pointer}.swal-button:not([disabled]):hover{background-color:#78cbf2}.swal-button:active{background-color:#70bce0}.swal-button:focus{outline:none;box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(43,114,165,.29)}.swal-button[disabled]{opacity:.5;cursor:default}.swal-button::-moz-focus-inner{border:0}.swal-button--cancel{color:#555;background-color:#efefef}.swal-button--cancel:not([disabled]):hover{background-color:#e8e8e8}.swal-button--cancel:active{background-color:#d7d7d7}.swal-button--cancel:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(116,136,150,.29)}.swal-button--danger{background-color:#e64942}.swal-button--danger:not([disabled]):hover{background-color:#df4740}.swal-button--danger:active{background-color:#cf423b}.swal-button--danger:focus{box-shadow:0 0 0 1px #fff,0 0 0 3px rgba(165,43,43,.29)}.swal-content{padding:0 20px;margin-top:20px;font-size:medium}.swal-content:last-child{margin-bottom:20px}.swal-content__input,.swal-content__textarea{-webkit-appearance:none;background-color:#fff;border:none;font-size:14px;display:block;box-sizing:border-box;width:100%;border:1px solid rgba(0,0,0,.14);padding:10px 13px;border-radius:2px;transition:border-color .2s}.swal-content__input:focus,.swal-content__textarea:focus{outline:none;border-color:#6db8ff}.swal-content__textarea{resize:vertical}.swal-button--loading{color:transparent}.swal-button--loading~.swal-button__loader{opacity:1}.swal-button__loader{position:absolute;height:auto;width:43px;z-index:2;left:50%;top:50%;-webkit-transform:translateX(-50%) translateY(-50%);transform:translateX(-50%) translateY(-50%);text-align:center;pointer-events:none;opacity:0}.swal-button__loader div{display:inline-block;float:none;vertical-align:baseline;width:9px;height:9px;padding:0;border:none;margin:2px;opacity:.4;border-radius:7px;background-color:hsla(0,0%,100%,.9);transition:background .2s;-webkit-animation:swal-loading-anim 1s infinite;animation:swal-loading-anim 1s infinite}.swal-button__loader div:nth-child(3n+2){-webkit-animation-delay:.15s;animation-delay:.15s}.swal-button__loader div:nth-child(3n+3){-webkit-animation-delay:.3s;animation-delay:.3s}@-webkit-keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}@keyframes swal-loading-anim{0%{opacity:.4}20%{opacity:.4}50%{opacity:1}to{opacity:.4}}.swal-overlay{position:fixed;top:0;bottom:0;left:0;right:0;text-align:center;font-size:0;overflow-y:auto;background-color:rgba(0,0,0,.4);z-index:10000;pointer-events:none;opacity:0;transition:opacity .3s}.swal-overlay:before{content:" ";display:inline-block;vertical-align:middle;height:100%}.swal-overlay--show-modal{opacity:1;pointer-events:auto}.swal-overlay--show-modal .swal-modal{opacity:1;pointer-events:auto;box-sizing:border-box;-webkit-animation:showSweetAlert .3s;animation:showSweetAlert .3s;will-change:transform}.swal-modal{width:478px;opacity:0;pointer-events:none;background-color:#fff;text-align:center;border-radius:5px;position:static;margin:20px auto;display:inline-block;vertical-align:middle;-webkit-transform:scale(1);transform:scale(1);-webkit-transform-origin:50% 50%;transform-origin:50% 50%;z-index:10001;transition:opacity .2s,-webkit-transform .3s;transition:transform .3s,opacity .2s;transition:transform .3s,opacity .2s,-webkit-transform .3s}@media (max-width:500px){.swal-modal{width:calc(100% - 20px)}}@-webkit-keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}@keyframes showSweetAlert{0%{-webkit-transform:scale(1);transform:scale(1)}1%{-webkit-transform:scale(.5);transform:scale(.5)}45%{-webkit-transform:scale(1.05);transform:scale(1.05)}80%{-webkit-transform:scale(.95);transform:scale(.95)}to{-webkit-transform:scale(1);transform:scale(1)}}', ""])
                }, function (t, e) {
                    function n(t, e) {
                        var n = t[1] || "", r = t[3];
                        if (!r) return n;
                        if (e && "function" == typeof btoa) {
                            var i = o(r);
                            return [n].concat(r.sources.map(function (t) {
                                return "/*# sourceURL=" + r.sourceRoot + t + " */"
                            })).concat([i]).join("\n")
                        }
                        return [n].join("\n")
                    }

                    function o(t) {
                        return "/*# sourceMappingURL=data:application/json;charset=utf-8;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(t)))) + " */"
                    }

                    t.exports = function (t) {
                        var e = [];
                        return e.toString = function () {
                            return this.map(function (e) {
                                var o = n(e, t);
                                return e[2] ? "@media " + e[2] + "{" + o + "}" : o
                            }).join("")
                        }, e.i = function (t, n) {
                            "string" == typeof t && (t = [[null, t, ""]]);
                            for (var o = {}, r = 0; r < this.length; r++) {
                                var i = this[r][0];
                                "number" == typeof i && (o[i] = !0)
                            }
                            for (r = 0; r < t.length; r++) {
                                var a = t[r];
                                "number" == typeof a[0] && o[a[0]] || (n && !a[2] ? a[2] = n : n && (a[2] = "(" + a[2] + ") and (" + n + ")"), e.push(a))
                            }
                        }, e
                    }
                }, function (t, e, n) {
                    function o(t, e) {
                        for (var n = 0; n < t.length; n++) {
                            var o = t[n], r = m[o.id];
                            if (r) {
                                r.refs++;
                                for (var i = 0; i < r.parts.length; i++) r.parts[i](o.parts[i]);
                                for (; i < o.parts.length; i++) r.parts.push(u(o.parts[i], e))
                            } else {
                                for (var a = [], i = 0; i < o.parts.length; i++) a.push(u(o.parts[i], e));
                                m[o.id] = {id: o.id, refs: 1, parts: a}
                            }
                        }
                    }

                    function r(t, e) {
                        for (var n = [], o = {}, r = 0; r < t.length; r++) {
                            var i = t[r], a = e.base ? i[0] + e.base : i[0], s = i[1], c = i[2], l = i[3],
                                u = {css: s, media: c, sourceMap: l};
                            o[a] ? o[a].parts.push(u) : n.push(o[a] = {id: a, parts: [u]})
                        }
                        return n
                    }

                    function i(t, e) {
                        var n = v(t.insertInto);
                        if (!n) throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
                        var o = w[w.length - 1];
                        if ("top" === t.insertAt) o ? o.nextSibling ? n.insertBefore(e, o.nextSibling) : n.appendChild(e) : n.insertBefore(e, n.firstChild), w.push(e); else {
                            if ("bottom" !== t.insertAt) throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
                            n.appendChild(e)
                        }
                    }

                    function a(t) {
                        if (null === t.parentNode) return !1;
                        t.parentNode.removeChild(t);
                        var e = w.indexOf(t);
                        e >= 0 && w.splice(e, 1)
                    }

                    function s(t) {
                        var e = document.createElement("style");
                        return t.attrs.type = "text/css", l(e, t.attrs), i(t, e), e
                    }

                    function c(t) {
                        var e = document.createElement("link");
                        return t.attrs.type = "text/css", t.attrs.rel = "stylesheet", l(e, t.attrs), i(t, e), e
                    }

                    function l(t, e) {
                        Object.keys(e).forEach(function (n) {
                            t.setAttribute(n, e[n])
                        })
                    }

                    function u(t, e) {
                        var n, o, r, i;
                        if (e.transform && t.css) {
                            if (!(i = e.transform(t.css))) return function () {
                            };
                            t.css = i
                        }
                        if (e.singleton) {
                            var l = h++;
                            n = g || (g = s(e)), o = f.bind(null, n, l, !1), r = f.bind(null, n, l, !0)
                        } else t.sourceMap && "function" == typeof URL && "function" == typeof URL.createObjectURL && "function" == typeof URL.revokeObjectURL && "function" == typeof Blob && "function" == typeof btoa ? (n = c(e), o = p.bind(null, n, e), r = function () {
                            a(n), n.href && URL.revokeObjectURL(n.href)
                        }) : (n = s(e), o = d.bind(null, n), r = function () {
                            a(n)
                        });
                        return o(t), function (e) {
                            if (e) {
                                if (e.css === t.css && e.media === t.media && e.sourceMap === t.sourceMap) return;
                                o(t = e)
                            } else r()
                        }
                    }

                    function f(t, e, n, o) {
                        var r = n ? "" : o.css;
                        if (t.styleSheet) t.styleSheet.cssText = x(e, r); else {
                            var i = document.createTextNode(r), a = t.childNodes;
                            a[e] && t.removeChild(a[e]), a.length ? t.insertBefore(i, a[e]) : t.appendChild(i)
                        }
                    }

                    function d(t, e) {
                        var n = e.css, o = e.media;
                        if (o && t.setAttribute("media", o), t.styleSheet) t.styleSheet.cssText = n; else {
                            for (; t.firstChild;) t.removeChild(t.firstChild);
                            t.appendChild(document.createTextNode(n))
                        }
                    }

                    function p(t, e, n) {
                        var o = n.css, r = n.sourceMap, i = void 0 === e.convertToAbsoluteUrls && r;
                        (e.convertToAbsoluteUrls || i) && (o = y(o)), r && (o += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(r)))) + " */");
                        var a = new Blob([o], {type: "text/css"}), s = t.href;
                        t.href = URL.createObjectURL(a), s && URL.revokeObjectURL(s)
                    }

                    var m = {}, b = function (t) {
                        var e;
                        return function () {
                            return void 0 === e && (e = t.apply(this, arguments)), e
                        }
                    }(function () {
                        return window && document && document.all && !window.atob
                    }), v = function (t) {
                        var e = {};
                        return function (n) {
                            return void 0 === e[n] && (e[n] = t.call(this, n)), e[n]
                        }
                    }(function (t) {
                        return document.querySelector(t)
                    }), g = null, h = 0, w = [], y = n(15);
                    t.exports = function (t, e) {
                        if ("undefined" != typeof DEBUG && DEBUG && "object" != typeof document) throw new Error("The style-loader cannot be used in a non-browser environment");
                        e = e || {}, e.attrs = "object" == typeof e.attrs ? e.attrs : {}, e.singleton || (e.singleton = b()), e.insertInto || (e.insertInto = "head"), e.insertAt || (e.insertAt = "bottom");
                        var n = r(t, e);
                        return o(n, e), function (t) {
                            for (var i = [], a = 0; a < n.length; a++) {
                                var s = n[a], c = m[s.id];
                                c.refs--, i.push(c)
                            }
                            if (t) {
                                o(r(t, e), e)
                            }
                            for (var a = 0; a < i.length; a++) {
                                var c = i[a];
                                if (0 === c.refs) {
                                    for (var l = 0; l < c.parts.length; l++) c.parts[l]();
                                    delete m[c.id]
                                }
                            }
                        }
                    };
                    var x = function () {
                        var t = [];
                        return function (e, n) {
                            return t[e] = n, t.filter(Boolean).join("\n")
                        }
                    }()
                }, function (t, e) {
                    t.exports = function (t) {
                        var e = "undefined" != typeof window && window.location;
                        if (!e) throw new Error("fixUrls requires window.location");
                        if (!t || "string" != typeof t) return t;
                        var n = e.protocol + "//" + e.host, o = n + e.pathname.replace(/\/[^\/]*$/, "/");
                        return t.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function (t, e) {
                            var r = e.trim().replace(/^"(.*)"$/, function (t, e) {
                                return e
                            }).replace(/^'(.*)'$/, function (t, e) {
                                return e
                            });
                            if (/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/)/i.test(r)) return t;
                            var i;
                            return i = 0 === r.indexOf("//") ? r : 0 === r.indexOf("/") ? n + r : o + r.replace(/^\.\//, ""), "url(" + JSON.stringify(i) + ")"
                        })
                    }
                }, function (t, e, n) {
                    var o = n(17);
                    "undefined" == typeof window || window.Promise || (window.Promise = o), n(21), String.prototype.includes || (String.prototype.includes = function (t, e) {
                        "use strict";
                        return "number" != typeof e && (e = 0), !(e + t.length > this.length) && -1 !== this.indexOf(t, e)
                    }), Array.prototype.includes || Object.defineProperty(Array.prototype, "includes", {
                        value: function (t, e) {
                            if (null == this) throw new TypeError('"this" is null or not defined');
                            var n = Object(this), o = n.length >>> 0;
                            if (0 === o) return !1;
                            for (var r = 0 | e, i = Math.max(r >= 0 ? r : o - Math.abs(r), 0); i < o;) {
                                if (function (t, e) {
                                    return t === e || "number" == typeof t && "number" == typeof e && isNaN(t) && isNaN(e)
                                }(n[i], t)) return !0;
                                i++
                            }
                            return !1
                        }
                    }), "undefined" != typeof window && function (t) {
                        t.forEach(function (t) {
                            t.hasOwnProperty("remove") || Object.defineProperty(t, "remove", {
                                configurable: !0,
                                enumerable: !0,
                                writable: !0,
                                value: function () {
                                    this.parentNode.removeChild(this)
                                }
                            })
                        })
                    }([Element.prototype, CharacterData.prototype, DocumentType.prototype])
                }, function (t, e, n) {
                    (function (e) {
                        !function (n) {
                            function o() {
                            }

                            function r(t, e) {
                                return function () {
                                    t.apply(e, arguments)
                                }
                            }

                            function i(t) {
                                if ("object" != typeof this) throw new TypeError("Promises must be constructed via new");
                                if ("function" != typeof t) throw new TypeError("not a function");
                                this._state = 0, this._handled = !1, this._value = void 0, this._deferreds = [], f(t, this)
                            }

                            function a(t, e) {
                                for (; 3 === t._state;) t = t._value;
                                if (0 === t._state) return void t._deferreds.push(e);
                                t._handled = !0, i._immediateFn(function () {
                                    var n = 1 === t._state ? e.onFulfilled : e.onRejected;
                                    if (null === n) return void (1 === t._state ? s : c)(e.promise, t._value);
                                    var o;
                                    try {
                                        o = n(t._value)
                                    } catch (t) {
                                        return void c(e.promise, t)
                                    }
                                    s(e.promise, o)
                                })
                            }

                            function s(t, e) {
                                try {
                                    if (e === t) throw new TypeError("A promise cannot be resolved with itself.");
                                    if (e && ("object" == typeof e || "function" == typeof e)) {
                                        var n = e.then;
                                        if (e instanceof i) return t._state = 3, t._value = e, void l(t);
                                        if ("function" == typeof n) return void f(r(n, e), t)
                                    }
                                    t._state = 1, t._value = e, l(t)
                                } catch (e) {
                                    c(t, e)
                                }
                            }

                            function c(t, e) {
                                t._state = 2, t._value = e, l(t)
                            }

                            function l(t) {
                                2 === t._state && 0 === t._deferreds.length && i._immediateFn(function () {
                                    t._handled || i._unhandledRejectionFn(t._value)
                                });
                                for (var e = 0, n = t._deferreds.length; e < n; e++) a(t, t._deferreds[e]);
                                t._deferreds = null
                            }

                            function u(t, e, n) {
                                this.onFulfilled = "function" == typeof t ? t : null, this.onRejected = "function" == typeof e ? e : null, this.promise = n
                            }

                            function f(t, e) {
                                var n = !1;
                                try {
                                    t(function (t) {
                                        n || (n = !0, s(e, t))
                                    }, function (t) {
                                        n || (n = !0, c(e, t))
                                    })
                                } catch (t) {
                                    if (n) return;
                                    n = !0, c(e, t)
                                }
                            }

                            var d = setTimeout;
                            i.prototype.catch = function (t) {
                                return this.then(null, t)
                            }, i.prototype.then = function (t, e) {
                                var n = new this.constructor(o);
                                return a(this, new u(t, e, n)), n
                            }, i.all = function (t) {
                                var e = Array.prototype.slice.call(t);
                                return new i(function (t, n) {
                                    function o(i, a) {
                                        try {
                                            if (a && ("object" == typeof a || "function" == typeof a)) {
                                                var s = a.then;
                                                if ("function" == typeof s) return void s.call(a, function (t) {
                                                    o(i, t)
                                                }, n)
                                            }
                                            e[i] = a, 0 == --r && t(e)
                                        } catch (t) {
                                            n(t)
                                        }
                                    }

                                    if (0 === e.length) return t([]);
                                    for (var r = e.length, i = 0; i < e.length; i++) o(i, e[i])
                                })
                            }, i.resolve = function (t) {
                                return t && "object" == typeof t && t.constructor === i ? t : new i(function (e) {
                                    e(t)
                                })
                            }, i.reject = function (t) {
                                return new i(function (e, n) {
                                    n(t)
                                })
                            }, i.race = function (t) {
                                return new i(function (e, n) {
                                    for (var o = 0, r = t.length; o < r; o++) t[o].then(e, n)
                                })
                            }, i._immediateFn = "function" == typeof e && function (t) {
                                e(t)
                            } || function (t) {
                                d(t, 0)
                            }, i._unhandledRejectionFn = function (t) {
                                "undefined" != typeof console && console && console.warn("Possible Unhandled Promise Rejection:", t)
                            }, i._setImmediateFn = function (t) {
                                i._immediateFn = t
                            }, i._setUnhandledRejectionFn = function (t) {
                                i._unhandledRejectionFn = t
                            }, void 0 !== t && t.exports ? t.exports = i : n.Promise || (n.Promise = i)
                        }(this)
                    }).call(e, n(18).setImmediate)
                }, function (t, e, n) {
                    function o(t, e) {
                        this._id = t, this._clearFn = e
                    }

                    var r = Function.prototype.apply;
                    e.setTimeout = function () {
                        return new o(r.call(setTimeout, window, arguments), clearTimeout)
                    }, e.setInterval = function () {
                        return new o(r.call(setInterval, window, arguments), clearInterval)
                    }, e.clearTimeout = e.clearInterval = function (t) {
                        t && t.close()
                    }, o.prototype.unref = o.prototype.ref = function () {
                    }, o.prototype.close = function () {
                        this._clearFn.call(window, this._id)
                    }, e.enroll = function (t, e) {
                        clearTimeout(t._idleTimeoutId), t._idleTimeout = e
                    }, e.unenroll = function (t) {
                        clearTimeout(t._idleTimeoutId), t._idleTimeout = -1
                    }, e._unrefActive = e.active = function (t) {
                        clearTimeout(t._idleTimeoutId);
                        var e = t._idleTimeout;
                        e >= 0 && (t._idleTimeoutId = setTimeout(function () {
                            t._onTimeout && t._onTimeout()
                        }, e))
                    }, n(19), e.setImmediate = setImmediate, e.clearImmediate = clearImmediate
                }, function (t, e, n) {
                    (function (t, e) {
                        !function (t, n) {
                            "use strict";

                            function o(t) {
                                "function" != typeof t && (t = new Function("" + t));
                                for (var e = new Array(arguments.length - 1), n = 0; n < e.length; n++) e[n] = arguments[n + 1];
                                var o = {callback: t, args: e};
                                return l[c] = o, s(c), c++
                            }

                            function r(t) {
                                delete l[t]
                            }

                            function i(t) {
                                var e = t.callback, o = t.args;
                                switch (o.length) {
                                    case 0:
                                        e();
                                        break;
                                    case 1:
                                        e(o[0]);
                                        break;
                                    case 2:
                                        e(o[0], o[1]);
                                        break;
                                    case 3:
                                        e(o[0], o[1], o[2]);
                                        break;
                                    default:
                                        e.apply(n, o)
                                }
                            }

                            function a(t) {
                                if (u) setTimeout(a, 0, t); else {
                                    var e = l[t];
                                    if (e) {
                                        u = !0;
                                        try {
                                            i(e)
                                        } finally {
                                            r(t), u = !1
                                        }
                                    }
                                }
                            }

                            if (!t.setImmediate) {
                                var s, c = 1, l = {}, u = !1, f = t.document,
                                    d = Object.getPrototypeOf && Object.getPrototypeOf(t);
                                d = d && d.setTimeout ? d : t, "[object process]" === {}.toString.call(t.process) ? function () {
                                    s = function (t) {
                                        e.nextTick(function () {
                                            a(t)
                                        })
                                    }
                                }() : function () {
                                    if (t.postMessage && !t.importScripts) {
                                        var e = !0, n = t.onmessage;
                                        return t.onmessage = function () {
                                            e = !1
                                        }, t.postMessage("", "*"), t.onmessage = n, e
                                    }
                                }() ? function () {
                                    var e = "setImmediate$" + Math.random() + "$", n = function (n) {
                                        n.source === t && "string" == typeof n.data && 0 === n.data.indexOf(e) && a(+n.data.slice(e.length))
                                    };
                                    t.addEventListener ? t.addEventListener("message", n, !1) : t.attachEvent("onmessage", n), s = function (n) {
                                        t.postMessage(e + n, "*")
                                    }
                                }() : t.MessageChannel ? function () {
                                    var t = new MessageChannel;
                                    t.port1.onmessage = function (t) {
                                        a(t.data)
                                    }, s = function (e) {
                                        t.port2.postMessage(e)
                                    }
                                }() : f && "onreadystatechange" in f.createElement("script") ? function () {
                                    var t = f.documentElement;
                                    s = function (e) {
                                        var n = f.createElement("script");
                                        n.onreadystatechange = function () {
                                            a(e), n.onreadystatechange = null, t.removeChild(n), n = null
                                        }, t.appendChild(n)
                                    }
                                }() : function () {
                                    s = function (t) {
                                        setTimeout(a, 0, t)
                                    }
                                }(), d.setImmediate = o, d.clearImmediate = r
                            }
                        }("undefined" == typeof self ? void 0 === t ? this : t : self)
                    }).call(e, n(7), n(20))
                }, function (t, e) {
                    function n() {
                        throw new Error("setTimeout has not been defined")
                    }

                    function o() {
                        throw new Error("clearTimeout has not been defined")
                    }

                    function r(t) {
                        if (u === setTimeout) return setTimeout(t, 0);
                        if ((u === n || !u) && setTimeout) return u = setTimeout, setTimeout(t, 0);
                        try {
                            return u(t, 0)
                        } catch (e) {
                            try {
                                return u.call(null, t, 0)
                            } catch (e) {
                                return u.call(this, t, 0)
                            }
                        }
                    }

                    function i(t) {
                        if (f === clearTimeout) return clearTimeout(t);
                        if ((f === o || !f) && clearTimeout) return f = clearTimeout, clearTimeout(t);
                        try {
                            return f(t)
                        } catch (e) {
                            try {
                                return f.call(null, t)
                            } catch (e) {
                                return f.call(this, t)
                            }
                        }
                    }

                    function a() {
                        b && p && (b = !1, p.length ? m = p.concat(m) : v = -1, m.length && s())
                    }

                    function s() {
                        if (!b) {
                            var t = r(a);
                            b = !0;
                            for (var e = m.length; e;) {
                                for (p = m, m = []; ++v < e;) p && p[v].run();
                                v = -1, e = m.length
                            }
                            p = null, b = !1, i(t)
                        }
                    }

                    function c(t, e) {
                        this.fun = t, this.array = e
                    }

                    function l() {
                    }

                    var u, f, d = t.exports = {};
                    !function () {
                        try {
                            u = "function" == typeof setTimeout ? setTimeout : n
                        } catch (t) {
                            u = n
                        }
                        try {
                            f = "function" == typeof clearTimeout ? clearTimeout : o
                        } catch (t) {
                            f = o
                        }
                    }();
                    var p, m = [], b = !1, v = -1;
                    d.nextTick = function (t) {
                        var e = new Array(arguments.length - 1);
                        if (arguments.length > 1) for (var n = 1; n < arguments.length; n++) e[n - 1] = arguments[n];
                        m.push(new c(t, e)), 1 !== m.length || b || r(s)
                    }, c.prototype.run = function () {
                        this.fun.apply(null, this.array)
                    }, d.title = "browser", d.browser = !0, d.env = {}, d.argv = [], d.version = "", d.versions = {}, d.on = l, d.addListener = l, d.once = l, d.off = l, d.removeListener = l, d.removeAllListeners = l, d.emit = l, d.prependListener = l, d.prependOnceListener = l, d.listeners = function (t) {
                        return []
                    }, d.binding = function (t) {
                        throw new Error("process.binding is not supported")
                    }, d.cwd = function () {
                        return "/"
                    }, d.chdir = function (t) {
                        throw new Error("process.chdir is not supported")
                    }, d.umask = function () {
                        return 0
                    }
                }, function (t, e, n) {
                    "use strict";
                    n(22).polyfill()
                }, function (t, e, n) {
                    "use strict";

                    function o(t, e) {
                        if (void 0 === t || null === t) throw new TypeError("Cannot convert first argument to object");
                        for (var n = Object(t), o = 1; o < arguments.length; o++) {
                            var r = arguments[o];
                            if (void 0 !== r && null !== r) for (var i = Object.keys(Object(r)), a = 0, s = i.length; a < s; a++) {
                                var c = i[a], l = Object.getOwnPropertyDescriptor(r, c);
                                void 0 !== l && l.enumerable && (n[c] = r[c])
                            }
                        }
                        return n
                    }

                    function r() {
                        Object.assign || Object.defineProperty(Object, "assign", {
                            enumerable: !1,
                            configurable: !0,
                            writable: !0,
                            value: o
                        })
                    }

                    t.exports = {assign: o, polyfill: r}
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(24), r = n(6), i = n(5), a = n(36), s = function () {
                        for (var t = [], e = 0; e < arguments.length; e++) t[e] = arguments[e];
                        if ("undefined" != typeof window) {
                            var n = a.getOpts.apply(void 0, t);
                            return new Promise(function (t, e) {
                                i.default.promise = {resolve: t, reject: e}, o.default(n), setTimeout(function () {
                                    r.openModal()
                                })
                            })
                        }
                    };
                    s.close = r.onAction, s.getState = r.getState, s.setActionValue = i.setActionValue, s.stopLoading = r.stopLoading, s.setDefaults = a.setDefaults, e.default = s
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(0), i = r.default.MODAL, a = n(4), s = n(34), c = n(35), l = n(1);
                    e.init = function (t) {
                        o.getNode(i) || (document.body || l.throwErr("You can only use SweetAlert AFTER the DOM has loaded!"), s.default(), a.default()), a.initModalContent(t), c.default(t)
                    }, e.default = e.init
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(0), r = o.default.MODAL;
                    e.modalMarkup = '\n  <div class="' + r + '" role="dialog" aria-modal="true"></div>', e.default = e.modalMarkup
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(0), r = o.default.OVERLAY,
                        i = '<div \n    class="' + r + '"\n    tabIndex="-1">\n  </div>';
                    e.default = i
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(0), r = o.default.ICON;
                    e.errorIconMarkup = function () {
                        var t = r + "--error", e = t + "__line";
                        return '\n    <div class="' + t + '__x-mark">\n      <span class="' + e + " " + e + '--left"></span>\n      <span class="' + e + " " + e + '--right"></span>\n    </div>\n  '
                    }, e.warningIconMarkup = function () {
                        var t = r + "--warning";
                        return '\n    <span class="' + t + '__body">\n      <span class="' + t + '__dot"></span>\n    </span>\n  '
                    }, e.successIconMarkup = function () {
                        var t = r + "--success";
                        return '\n    <span class="' + t + "__line " + t + '__line--long"></span>\n    <span class="' + t + "__line " + t + '__line--tip"></span>\n\n    <div class="' + t + '__ring"></div>\n    <div class="' + t + '__hide-corners"></div>\n  '
                    }
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(0), r = o.default.CONTENT;
                    e.contentMarkup = '\n  <div class="' + r + '">\n\n  </div>\n'
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(0), r = o.default.BUTTON_CONTAINER, i = o.default.BUTTON, a = o.default.BUTTON_LOADER;
                    e.buttonMarkup = '\n  <div class="' + r + '">\n\n    <button\n      class="' + i + '"\n    ></button>\n\n    <div class="' + a + '">\n      <div></div>\n      <div></div>\n      <div></div>\n    </div>\n\n  </div>\n'
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(4), r = n(2), i = n(0), a = i.default.ICON, s = i.default.ICON_CUSTOM,
                        c = ["error", "warning", "success", "info"], l = {
                            error: r.errorIconMarkup(),
                            warning: r.warningIconMarkup(),
                            success: r.successIconMarkup()
                        }, u = function (t, e) {
                            var n = a + "--" + t;
                            e.classList.add(n);
                            var o = l[t];
                            o && (e.innerHTML = o)
                        }, f = function (t, e) {
                            e.classList.add(s);
                            var n = document.createElement("img");
                            n.src = t, e.appendChild(n)
                        }, d = function (t) {
                            if (t) {
                                var e = o.injectElIntoModal(r.iconMarkup);
                                c.includes(t) ? u(t, e) : f(t, e)
                            }
                        };
                    e.default = d
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(2), r = n(4), i = function (t) {
                        navigator.userAgent.includes("AppleWebKit") && (t.style.display = "none", t.offsetHeight, t.style.display = "")
                    };
                    e.initTitle = function (t) {
                        if (t) {
                            var e = r.injectElIntoModal(o.titleMarkup);
                            e.textContent = t, i(e)
                        }
                    }, e.initText = function (t) {
                        if (t) {
                            var e = document.createDocumentFragment();
                            t.split("\n").forEach(function (t, n, o) {
                                e.appendChild(document.createTextNode(t)), n < o.length - 1 && e.appendChild(document.createElement("br"))
                            });
                            var n = r.injectElIntoModal(o.textMarkup);
                            n.appendChild(e), i(n)
                        }
                    }
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(4), i = n(0), a = i.default.BUTTON, s = i.default.DANGER_BUTTON, c = n(3),
                        l = n(2), u = n(6), f = n(5), d = function (t, e, n) {
                            var r = e.text, i = e.value, d = e.className, p = e.closeModal,
                                m = o.stringToNode(l.buttonMarkup), b = m.querySelector("." + a), v = a + "--" + t;
                            if (b.classList.add(v), d) {
                                (Array.isArray(d) ? d : d.split(" ")).filter(function (t) {
                                    return t.length > 0
                                }).forEach(function (t) {
                                    b.classList.add(t)
                                })
                            }
                            n && t === c.CONFIRM_KEY && b.classList.add(s), b.textContent = r;
                            var g = {};
                            return g[t] = i, f.setActionValue(g), f.setActionOptionsFor(t, {closeModal: p}), b.addEventListener("click", function () {
                                return u.onAction(t)
                            }), m
                        }, p = function (t, e) {
                            var n = r.injectElIntoModal(l.footerMarkup);
                            for (var o in t) {
                                var i = t[o], a = d(o, i, e);
                                i.visible && n.appendChild(a)
                            }
                            0 === n.children.length && n.remove()
                        };
                    e.default = p
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(3), r = n(4), i = n(2), a = n(5), s = n(6), c = n(0), l = c.default.CONTENT,
                        u = function (t) {
                            t.addEventListener("input", function (t) {
                                var e = t.target, n = e.value;
                                a.setActionValue(n)
                            }), t.addEventListener("keyup", function (t) {
                                if ("Enter" === t.key) return s.onAction(o.CONFIRM_KEY)
                            }), setTimeout(function () {
                                t.focus(), a.setActionValue("")
                            }, 0)
                        }, f = function (t, e, n) {
                            var o = document.createElement(e), r = l + "__" + e;
                            o.classList.add(r);
                            for (var i in n) {
                                var a = n[i];
                                o[i] = a
                            }
                            "input" === e && u(o), t.appendChild(o)
                        }, d = function (t) {
                            if (t) {
                                var e = r.injectElIntoModal(i.contentMarkup), n = t.element, o = t.attributes;
                                "string" == typeof n ? f(e, n, o) : e.appendChild(n)
                            }
                        };
                    e.default = d
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(2), i = function () {
                        var t = o.stringToNode(r.overlayMarkup);
                        document.body.appendChild(t)
                    };
                    e.default = i
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(5), r = n(6), i = n(1), a = n(3), s = n(0), c = s.default.MODAL, l = s.default.BUTTON,
                        u = s.default.OVERLAY, f = function (t) {
                            t.preventDefault(), v()
                        }, d = function (t) {
                            t.preventDefault(), g()
                        }, p = function (t) {
                            if (o.default.isOpen) switch (t.key) {
                                case"Escape":
                                    return r.onAction(a.CANCEL_KEY)
                            }
                        }, m = function (t) {
                            if (o.default.isOpen) switch (t.key) {
                                case"Tab":
                                    return f(t)
                            }
                        }, b = function (t) {
                            if (o.default.isOpen) return "Tab" === t.key && t.shiftKey ? d(t) : void 0
                        }, v = function () {
                            var t = i.getNode(l);
                            t && (t.tabIndex = 0, t.focus())
                        }, g = function () {
                            var t = i.getNode(c), e = t.querySelectorAll("." + l), n = e.length - 1, o = e[n];
                            o && o.focus()
                        }, h = function (t) {
                            t[t.length - 1].addEventListener("keydown", m)
                        }, w = function (t) {
                            t[0].addEventListener("keydown", b)
                        }, y = function () {
                            var t = i.getNode(c), e = t.querySelectorAll("." + l);
                            e.length && (h(e), w(e))
                        }, x = function (t) {
                            if (i.getNode(u) === t.target) return r.onAction(a.CANCEL_KEY)
                        }, _ = function (t) {
                            var e = i.getNode(u);
                            e.removeEventListener("click", x), t && e.addEventListener("click", x)
                        }, k = function (t) {
                            o.default.timer && clearTimeout(o.default.timer), t && (o.default.timer = window.setTimeout(function () {
                                return r.onAction(a.CANCEL_KEY)
                            }, t))
                        }, O = function (t) {
                            t.closeOnEsc ? document.addEventListener("keyup", p) : document.removeEventListener("keyup", p), t.dangerMode ? v() : g(), y(), _(t.closeOnClickOutside), k(t.timer)
                        };
                    e.default = O
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = n(3), i = n(37), a = n(38), s = {
                        title: null,
                        text: null,
                        icon: null,
                        buttons: r.defaultButtonList,
                        content: null,
                        className: null,
                        closeOnClickOutside: !0,
                        closeOnEsc: !0,
                        dangerMode: !1,
                        timer: null
                    }, c = Object.assign({}, s);
                    e.setDefaults = function (t) {
                        c = Object.assign({}, s, t)
                    };
                    var l = function (t) {
                        var e = t && t.button, n = t && t.buttons;
                        return void 0 !== e && void 0 !== n && o.throwErr("Cannot set both 'button' and 'buttons' options!"), void 0 !== e ? {confirm: e} : n
                    }, u = function (t) {
                        return o.ordinalSuffixOf(t + 1)
                    }, f = function (t, e) {
                        o.throwErr(u(e) + " argument ('" + t + "') is invalid")
                    }, d = function (t, e) {
                        var n = t + 1, r = e[n];
                        o.isPlainObject(r) || void 0 === r || o.throwErr("Expected " + u(n) + " argument ('" + r + "') to be a plain object")
                    }, p = function (t, e) {
                        var n = t + 1, r = e[n];
                        void 0 !== r && o.throwErr("Unexpected " + u(n) + " argument (" + r + ")")
                    }, m = function (t, e, n, r) {
                        var i = typeof e, a = "string" === i, s = e instanceof Element;
                        if (a) {
                            if (0 === n) return {text: e};
                            if (1 === n) return {text: e, title: r[0]};
                            if (2 === n) return d(n, r), {icon: e};
                            f(e, n)
                        } else {
                            if (s && 0 === n) return d(n, r), {content: e};
                            if (o.isPlainObject(e)) return p(n, r), e;
                            f(e, n)
                        }
                    };
                    e.getOpts = function () {
                        for (var t = [], e = 0; e < arguments.length; e++) t[e] = arguments[e];
                        var n = {};
                        t.forEach(function (e, o) {
                            var r = m(0, e, o, t);
                            Object.assign(n, r)
                        });
                        var o = l(n);
                        n.buttons = r.getButtonListOpts(o), delete n.button, n.content = i.getContentOpts(n.content);
                        var u = Object.assign({}, s, c, n);
                        return Object.keys(u).forEach(function (t) {
                            a.DEPRECATED_OPTS[t] && a.logDeprecation(t)
                        }), u
                    }
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0});
                    var o = n(1), r = {element: "input", attributes: {placeholder: ""}};
                    e.getContentOpts = function (t) {
                        var e = {};
                        return o.isPlainObject(t) ? Object.assign(e, t) : t instanceof Element ? {element: t} : "input" === t ? r : null
                    }
                }, function (t, e, n) {
                    "use strict";
                    Object.defineProperty(e, "__esModule", {value: !0}), e.logDeprecation = function (t) {
                        var n = e.DEPRECATED_OPTS[t], o = n.onlyRename, r = n.replacement, i = n.subOption, a = n.link,
                            s = o ? "renamed" : "deprecated",
                            c = 'SweetAlert warning: "' + t + '" option has been ' + s + ".";
                        if (r) {
                            c += " Please use" + (i ? ' "' + i + '" in ' : " ") + '"' + r + '" instead.'
                        }
                        var l = "https://sweetalert.js.org";
                        c += a ? " More details: " + l + a : " More details: " + l + "/guides/#upgrading-from-1x", console.warn(c)
                    }, e.DEPRECATED_OPTS = {
                        type: {replacement: "icon", link: "/docs/#icon"},
                        imageUrl: {replacement: "icon", link: "/docs/#icon"},
                        customClass: {replacement: "className", onlyRename: !0, link: "/docs/#classname"},
                        imageSize: {},
                        showCancelButton: {replacement: "buttons", link: "/docs/#buttons"},
                        showConfirmButton: {replacement: "button", link: "/docs/#button"},
                        confirmButtonText: {replacement: "button", link: "/docs/#button"},
                        confirmButtonColor: {},
                        cancelButtonText: {replacement: "buttons", link: "/docs/#buttons"},
                        closeOnConfirm: {replacement: "button", subOption: "closeModal", link: "/docs/#button"},
                        closeOnCancel: {replacement: "buttons", subOption: "closeModal", link: "/docs/#buttons"},
                        showLoaderOnConfirm: {replacement: "buttons"},
                        animation: {},
                        inputType: {replacement: "content", link: "/docs/#content"},
                        inputValue: {replacement: "content", link: "/docs/#content"},
                        inputPlaceholder: {replacement: "content", link: "/docs/#content"},
                        html: {replacement: "content", link: "/docs/#content"},
                        allowEscapeKey: {replacement: "closeOnEsc", onlyRename: !0, link: "/docs/#closeonesc"},
                        allowClickOutside: {
                            replacement: "closeOnClickOutside",
                            onlyRename: !0,
                            link: "/docs/#closeonclickoutside"
                        }
                    }
                }])
            });

            /***/
        })

        /******/
    });
    /************************************************************************/
    /******/ 	// The module cache
    /******/
    var __webpack_module_cache__ = {};
    /******/
    /******/ 	// The require function
    /******/
    function __webpack_require__(moduleId) {
        /******/ 		// Check if module is in cache
        /******/
        var cachedModule = __webpack_module_cache__[moduleId];
        /******/
        if (cachedModule !== undefined) {
            /******/
            return cachedModule.exports;
            /******/
        }
        /******/ 		// Create a new module (and put it into the cache)
        /******/
        var module = __webpack_module_cache__[moduleId] = {
            /******/ 			// no module.id needed
            /******/ 			// no module.loaded needed
            /******/            exports: {}
            /******/
        };
        /******/
        /******/ 		// Execute the module function
        /******/
        __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
        /******/
        /******/ 		// Return the exports of the module
        /******/
        return module.exports;
        /******/
    }

    /******/
    /************************************************************************/
    /******/ 	/* webpack/runtime/compat get default export */
    /******/
    (() => {
        /******/ 		// getDefaultExport function for compatibility with non-harmony modules
        /******/
        __webpack_require__.n = (module) => {
            /******/
            var getter = module && module.__esModule ?
                /******/                () => (module['default']) :
                /******/                () => (module);
            /******/
            __webpack_require__.d(getter, {a: getter});
            /******/
            return getter;
            /******/
        };
        /******/
    })();
    /******/
    /******/ 	/* webpack/runtime/define property getters */
    /******/
    (() => {
        /******/ 		// define getter functions for harmony exports
        /******/
        __webpack_require__.d = (exports, definition) => {
            /******/
            for (var key in definition) {
                /******/
                if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
                    /******/
                    Object.defineProperty(exports, key, {enumerable: true, get: definition[key]});
                    /******/
                }
                /******/
            }
            /******/
        };
        /******/
    })();
    /******/
    /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
    /******/
    (() => {
        /******/
        __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
        /******/
    })();
    /******/
    /******/ 	/* webpack/runtime/make namespace object */
    /******/
    (() => {
        /******/ 		// define __esModule on exports
        /******/
        __webpack_require__.r = (exports) => {
            /******/
            if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
                /******/
                Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
                /******/
            }
            /******/
            Object.defineProperty(exports, '__esModule', {value: true});
            /******/
        };
        /******/
    })();
    /******/
    /************************************************************************/
    var __webpack_exports__ = {};
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
    (() => {
        "use strict";
        /*!*********************************!*\
  !*** ./resources/js/plugins.js ***!
  \*********************************/
        __webpack_require__.r(__webpack_exports__);
        /* harmony import */
        var sweetalert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! sweetalert */ "./node_modules/sweetalert/dist/sweetalert.min.js");
        /* harmony import */
        var sweetalert__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(sweetalert__WEBPACK_IMPORTED_MODULE_0__);
        /* harmony import */
        var _custom_datatable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./custom-datatable */ "./resources/js/custom-datatable.js");
        /* harmony import */
        var _custom_datatable__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_custom_datatable__WEBPACK_IMPORTED_MODULE_1__);
        __webpack_require__(/*! alpinejs */ "./node_modules/alpinejs/dist/module.esm.js");


        $.fn.select2.defaults.set('theme', 'bootstrap-5');

        window.initToastr = function (options) {
            var toastrOptions;

            if (!options) {
                // TODO: implement merge here
                toastrOptions = {
                    'closeButton': true,
                    'debug': false,
                    'newestOnTop': false,
                    'progressBar': true,
                    'positionClass': 'toast-top-right',
                    'preventDuplicates': false,
                    'onclick': null,
                    'showDuration': '300',
                    'hideDuration': '1000',
                    'timeOut': '5000',
                    'extendedTimeOut': '1000',
                    'showEasing': 'swing',
                    'hideEasing': 'linear',
                    'showMethod': 'fadeIn',
                    'hideMethod': 'fadeOut'
                };
            }

            toastr.options = toastrOptions;
        }; // File Preview Code Start
// This function converts the image file to bash_encode and previews in a given object


        function IOInitImageUpload(box) {
            var uploadField = box.querySelector('.image-upload');
            uploadField.addEventListener('change', getFile);

            function getFile(e) {
                var file = e.currentTarget.files[0];
                checkType(file);
            } // Preview Image to given component


            function previewImage(file) {
                var thumb = box.querySelector('.previewImage'),
                    reader = new FileReader();

                reader.onload = function (e) {
                    var image = new Image();
                    image.src = e.target.result;

                    image.onload = function () {
                        thumb.style.backgroundImage = 'url(' + e.target.result + ')';
                    };
                };

                reader.readAsDataURL(file);
            } // Check Image Type


            function checkType(file) {
                let ext = file.name.split('.').pop()
                let extensions = ["png", "jpg", "jpeg"];
                if(!extensions.includes(ext)){
                    displayErrorMessage(Lang.get('messages.flash.profile_validation_message'))
                    return false;
                }

                var imageType = /image.*/;

                if (!file.type.match(imageType)) {
                    throw 'File Type is not match.';
                } else if (!file) {
                    throw 'File not found.';
                } else {
                    previewImage(file);
                }
            }
        } // every load initialize the Image component on document load


        window.IOInitImageComponent = function () {
            var imagePicker = document.querySelectorAll('.image-picker'); // if not found the image-picker object its return

            if (!imagePicker) {
                return;
            }

            for (var i = 0; i < imagePicker.length; i++) {
                var box = imagePicker[i];
                IOInitDropEffect(box);
                IOInitImageUpload(box);
            }
        }; // Drop Effect according to the image size


        function IOInitDropEffect(box) {
            var area, drop, areaWidth, areaHeight, maxDistance, dropWidth, dropHeight, x, y; // get clickable area for drop effect

            area = box.querySelector('.previewImage');
            area.addEventListener('click', fireRipple);

            function fireRipple(e) {
                area = e.currentTarget; // create drop

                if (!drop) {
                    drop = document.createElement('span');
                    drop.className = 'drop';
                    this.appendChild(drop);
                } // reset animate class


                drop.className = 'drop'; // calculate dimensions of area (longest side)

                areaWidth = getComputedStyle(this, null).getPropertyValue('width');
                areaHeight = getComputedStyle(this, null).getPropertyValue('height');
                maxDistance = Math.max(parseInt(areaWidth, 10), parseInt(areaHeight, 10)); // set drop dimensions to fill area

                drop.style.width = maxDistance + 'px';
                drop.style.height = maxDistance + 'px'; // calculate dimensions of drop

                dropWidth = getComputedStyle(this, null).getPropertyValue('width');
                dropHeight = getComputedStyle(this, null).getPropertyValue('height'); // calculate relative coordinates of click
                // logic: click coordinates relative to page - parent's position relative to page - half of self height/width to make it controllable from the center

                x = e.pageX - this.offsetLeft - parseInt(dropWidth, 10) / 2;
                y = e.pageY - this.offsetTop - parseInt(dropHeight, 10) / 2 - 30; // position drop and animate

                drop.style.top = y + 'px';
                drop.style.left = x + 'px';
                drop.className += ' animate';
                e.stopPropagation();
            }
        } // File Preview Code End


        window.IOInitSidebar = function () {
            $('.sidebar-btn').click(function () {
                $('#sidebar').toggleClass('collapsed-menu');
                $('body').toggleClass('collapsed-menu');
                $('.aside-submenu').collapse('hide');
            });
            $('#sidebar-overly').click(function () {
                $('#sidebar').toggleClass('collapsed-menu');
                $('body').toggleClass('collapsed-menu');
            });
            $('.header-btn').click(function () {
                $('#nav-header').addClass('show-nav');
                $('body').addClass('show-nav');
            });
            $('#nav-overly').click(function () {
                $('#nav-header').removeClass('show-nav');
                $('body').removeClass('show-nav');
            }); // for horizontal sidebar

            $('.horizontal-menubar').click(function () {
                $('.horizontal-sidebar').toggleClass('collapsed-menu');
                $('body').toggleClass('collapsed-menu');
            });
            $('#horizontal-menubar-overly').click(function () {
                $('.horizontal-sidebar').toggleClass('collapsed-menu');
                $('body').toggleClass('collapsed-menu');
            }); // for responsive sidebar

            $(window).resize(function () {
                if ($(window).width() > 1200) {
                    $('.aside-collapse-btn').click(function () {
                        $('#sidebar').removeClass('collapsed-menu');
                        $('body').removeClass('collapsed-menu');
                    });
                }
            });
        };

        window.IOInitSideBarCollapse = function () {
            $('.aside-item-collapse > ul').hide();
            $('.aside-collapse-btn').click(function () {
                $(this).parent().toggleClass('collapse-submenu').siblings().removeClass('collapse-submenu');
                var $menuItem = $(this).next('.aside-submenu');
                $menuItem.stop(true, true).slideToggle('slow');
                $('.aside-submenu').not($menuItem).slideUp();
            });
            $('.aside-submenu').each(function () {
                var $collapseMenu = $(this);
                $(this).find('li').each(function () {
                    if ($collapseMenu.parent().hasClass('show')) {
                        $collapseMenu.show();
                        $collapseMenu.parents('li').addClass('active collapse-submenu');
                    }
                });
            });
        };


    })();

    /******/
})()
;
