unpoly/unpoly.js

Progressive enhancement for HTML

/******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ([
/* 0 */,
/* 1 */
/***/ (() => {

window.up = {
    version: '3.10.2'
};


/***/ }),
/* 2 */
/***/ (() => {

up.mockable = function (originalFn) {
    if (window.jasmine) {
        let name = originalFn.name;
        let obj = { [name]: originalFn };
        let mockableFn = function () {
            return obj[name].apply(this, arguments);
        };
        mockableFn.mock = () => spyOn(obj, name);
        return mockableFn;
    }
    else {
        return originalFn;
    }
};


/***/ }),
/* 3 */
/***/ (() => {

up.util = (function () {
    function noop() {
    }
    function asyncNoop() {
        return Promise.resolve();
    }
    function memoize(func) {
        let cachedValue, cached;
        return function (...args) {
            if (cached) {
                return cachedValue;
            }
            else {
                cached = true;
                return cachedValue = func.apply(this, args);
            }
        };
    }
    function normalizeURL(url, options) {
        options = newOptions(options, { host: 'cross-domain' });
        const parts = parseURL(url);
        let normalized = '';
        if (options.host === 'cross-domain') {
            options.host = isCrossOrigin(parts);
        }
        if (options.host) {
            normalized += parts.protocol + "//" + parts.host;
        }
        let { pathname } = parts;
        if (options.trailingSlash === false && pathname !== '/') {
            pathname = pathname.replace(/\/$/, '');
        }
        normalized += pathname;
        if (options.search !== false) {
            normalized += parts.search;
        }
        if (options.hash !== false) {
            normalized += parts.hash;
        }
        return normalized;
    }
    function matchURLs(leftURL, rightURL, options) {
        return matchableURL(leftURL, options) === matchableURL(rightURL, options);
    }
    function matchableURL(url, options) {
        if (!url)
            return;
        return normalizeURL(url, { hash: false, trailingSlash: false, ...options });
    }
    function matchableURLPatternAtom(patternAtom) {
        if (patternAtom.endsWith('/'))
            return [patternAtom, patternAtom.slice(0, -1)];
        if (patternAtom.includes('/?'))
            return [patternAtom, patternAtom.replace('/?', '?')];
        if (patternAtom.endsWith('/*'))
            return [patternAtom, patternAtom.slice(0, -2), patternAtom.slice(0, -2) + '?*'];
        return patternAtom;
    }
    const APP_PROTOCOL = location.protocol;
    const APP_HOSTNAME = location.hostname;
    function isCrossOrigin(urlOrAnchor) {
        if (isString(urlOrAnchor) && (urlOrAnchor.indexOf('//') === -1)) {
            return false;
        }
        const parts = parseURL(urlOrAnchor);
        return (APP_HOSTNAME !== parts.hostname) || (APP_PROTOCOL !== parts.protocol);
    }
    function parseURL(url) {
        if (url.pathname) {
            return url;
        }
        let link = document.createElement('a');
        link.href = url;
        return link;
    }
    function normalizeMethod(method) {
        return method ? method.toUpperCase() : 'GET';
    }
    function methodAllowsPayload(method) {
        return (method !== 'GET') && (method !== 'HEAD');
    }
    function iteratee(block) {
        if (isString(block)) {
            return item => item[block];
        }
        else {
            return block;
        }
    }
    function map(list, block) {
        if (list.length === 0) {
            return [];
        }
        block = iteratee(block);
        let mapped = [];
        let i = 0;
        for (let item of list) {
            mapped.push(block(item, i++));
        }
        return mapped;
    }
    function mapObject(array, pairer) {
        const merger = function (object, pair) {
            object[pair[0]] = pair[1];
            return object;
        };
        return map(array, pairer).reduce(merger, {});
    }
    function each(array, block) {
        let i = 0;
        for (let item of array) {
            block(item, i++);
        }
    }
    function isNull(object) {
        return object === null;
    }
    function isUndefined(object) {
        return object === undefined;
    }
    const isDefined = negate(isUndefined);
    function isMissing(object) {
        return isUndefined(object) || isNull(object);
    }
    const isGiven = negate(isMissing);
    function isBlank(value) {
        if (isMissing(value)) {
            return true;
        }
        if (isObject(value) && value[isBlank.key]) {
            return value[isBlank.key]();
        }
        if (isString(value) || isList(value)) {
            return value.length === 0;
        }
        if (isOptions(value)) {
            return Object.keys(value).length === 0;
        }
        return false;
    }
    isBlank.key = 'up.util.isBlank';
    function presence(value, tester = isPresent) {
        if (tester(value)) {
            return value;
        }
    }
    const isPresent = negate(isBlank);
    function isFunction(object) {
        return typeof (object) === 'function';
    }
    function isString(object) {
        return (typeof (object) === 'string') || object instanceof String;
    }
    function isBoolean(object) {
        return (typeof (object) === 'boolean') || object instanceof Boolean;
    }
    function isNumber(object) {
        return (typeof (object) === 'number') || object instanceof Number;
    }
    function isOptions(object) {
        return (typeof (object) === 'object') && !isNull(object) && (isUndefined(object.constructor) || (object.constructor === Object));
    }
    function isObject(object) {
        const typeOfResult = typeof (object);
        return ((typeOfResult === 'object') && !isNull(object)) || (typeOfResult === 'function');
    }
    function isElement(object) {
        return object instanceof Element;
    }
    function isTextNode(object) {
        return object instanceof Text;
    }
    function isRegExp(object) {
        return object instanceof RegExp;
    }
    function isError(object) {
        return object instanceof Error;
    }
    function isJQuery(object) {
        return up.browser.canJQuery() && object instanceof jQuery;
    }
    function isElementLike(object) {
        return !!(object && (object.addEventListener || (isJQuery(object) && object[0]?.addEventListener)));
    }
    function isPromise(object) {
        return isObject(object) && isFunction(object.then);
    }
    const { isArray } = Array;
    function isFormData(object) {
        return object instanceof FormData;
    }
    function toArray(value) {
        return isArray(value) ? value : copyArrayLike(value);
    }
    function isList(value) {
        return isArray(value) ||
            isNodeList(value) ||
            isArguments(value) ||
            isJQuery(value) ||
            isHTMLCollection(value);
    }
    function isNodeList(value) {
        return value instanceof NodeList;
    }
    function isHTMLCollection(value) {
        return value instanceof HTMLCollection;
    }
    function isArguments(value) {
        return Object.prototype.toString.call(value) === '[object Arguments]';
    }
    function isAdjacentPosition(value) {
        return /^(before|after)/.test(value);
    }
    function wrapList(value) {
        if (isList(value)) {
            return value;
        }
        else if (isMissing(value)) {
            return [];
        }
        else {
            return [value];
        }
    }
    function copy(value) {
        if (isObject(value) && value[copy.key]) {
            value = value[copy.key]();
        }
        else if (isList(value)) {
            value = copyArrayLike(value);
        }
        else if (isOptions(value)) {
            value = Object.assign({}, value);
        }
        return value;
    }
    function copyArrayLike(arrayLike) {
        return Array.prototype.slice.call(arrayLike);
    }
    copy.key = 'up.util.copy';
    Date.prototype[copy.key] = function () { return new Date(+this); };
    function merge(...sources) {
        return Object.assign({}, ...sources);
    }
    function mergeDefined(...sources) {
        const result = {};
        for (let source of sources) {
            if (source) {
                for (let key in source) {
                    const value = source[key];
                    if (isDefined(value)) {
                        result[key] = value;
                    }
                }
            }
        }
        return result;
    }
    function newOptions(object, defaults) {
        if (defaults) {
            return merge(defaults, object);
        }
        else if (object) {
            return copy(object);
        }
        else {
            return {};
        }
    }
    function parseArgIntoOptions(args, argKey) {
        let [positionalArg, options] = parseArgs(args, 'val', 'options');
        if (isDefined(positionalArg)) {
            options[argKey] = positionalArg;
        }
        return options;
    }
    function findInList(list, tester) {
        tester = iteratee(tester);
        let match;
        for (let element of list) {
            if (tester(element)) {
                match = element;
                break;
            }
        }
        return match;
    }
    function some(list, tester) {
        return !!findResult(list, tester);
    }
    function findResult(list, tester) {
        tester = iteratee(tester);
        let i = 0;
        for (let item of list) {
            const result = tester(item, i++);
            if (result) {
                return result;
            }
        }
    }
    function every(list, tester) {
        tester = iteratee(tester);
        let match = true;
        let i = 0;
        for (let item of list) {
            if (!tester(item, i++)) {
                match = false;
                break;
            }
        }
        return match;
    }
    function compact(array) {
        return filterList(array, isGiven);
    }
    function compactObject(object) {
        return pickBy(object, isGiven);
    }
    function uniq(array) {
        if (array.length < 2) {
            return array;
        }
        return Array.from(new Set(array));
    }
    function uniqBy(array, mapper) {
        if (array.length < 2) {
            return array;
        }
        mapper = iteratee(mapper);
        const seenElements = new Set();
        return filterList(array, function (elem, index) {
            const mapped = mapper(elem, index);
            if (seenElements.has(mapped)) {
                return false;
            }
            else {
                seenElements.add(mapped);
                return true;
            }
        });
    }
    function filterList(list, tester) {
        tester = iteratee(tester);
        const matches = [];
        each(list, function (element, index) {
            if (tester(element, index)) {
                return matches.push(element);
            }
        });
        return matches;
    }
    function reject(list, tester) {
        tester = negate(iteratee(tester));
        return filterList(list, tester);
    }
    function intersect(array1, array2) {
        return filterList(array1, element => contains(array2, element));
    }
    function scheduleTimer(millis, callback) {
        return setTimeout(callback, millis);
    }
    function queueTask(task) {
        return setTimeout(task);
    }
    function last(value) {
        return value[value.length - 1];
    }
    function contains(value, subValue) {
        let indexOf = value.indexOf || Array.prototype.indexOf;
        return indexOf.call(value, subValue) >= 0;
    }
    function containsAll(values, subValues) {
        return every(subValues, (subValue) => contains(values, subValue));
    }
    function objectContains(object, subObject) {
        const reducedValue = pick(object, Object.keys(subObject));
        return isEqual(subObject, reducedValue);
    }
    function pick(object, keys) {
        const filtered = {};
        for (let key of keys) {
            if (key in object) {
                filtered[key] = object[key];
            }
        }
        return filtered;
    }
    function pickBy(object, tester) {
        tester = iteratee(tester);
        const filtered = {};
        for (let key in object) {
            const value = object[key];
            if (tester(value, key, object)) {
                filtered[key] = object[key];
            }
        }
        return filtered;
    }
    function omit(object, keys) {
        return pickBy(object, (_value, key) => !contains(keys, key));
    }
    function unresolvablePromise() {
        return new Promise(noop);
    }
    function remove(array, element) {
        const index = array.indexOf(element);
        if (index >= 0) {
            array.splice(index, 1);
            return element;
        }
    }
    function evalOption(value, ...args) {
        return isFunction(value) ? value(...args) : value;
    }
    function evalAutoOption(value, autoMeans, ...args) {
        value = evalOption(value, ...args);
        if (value === 'auto') {
            value = evalOption(autoMeans, ...args);
        }
        return value;
    }
    const ESCAPE_HTML_ENTITY_MAP = {
        "&": "&amp;",
        "<": "&lt;",
        ">": "&gt;",
        '"': '&quot;',
        "'": '&#x27;'
    };
    function escapeHTML(string) {
        return string.replace(/[&<>"']/g, char => ESCAPE_HTML_ENTITY_MAP[char]);
    }
    function escapeRegExp(string) {
        return string.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
    }
    function pluckKey(object, key) {
        const value = object[key];
        delete object[key];
        return value;
    }
    function renameKey(object, oldKey, newKey) {
        if (oldKey in object) {
            object[newKey] = pluckKey(object, oldKey);
        }
    }
    function extractLastArg(args, tester) {
        if (tester(last(args))) {
            return args.pop();
        }
    }
    function extractCallback(args) {
        return extractLastArg(args, isFunction);
    }
    function extractOptions(args) {
        return extractLastArg(args, isOptions) || {};
    }
    function identity(arg) {
        return arg;
    }
    function sequence(functions) {
        functions = compact(functions);
        return (...args) => map(functions, fn => fn(...args));
    }
    function flatten(array) {
        const flattened = [];
        for (let object of array) {
            if (isList(object)) {
                flattened.push(...object);
            }
            else {
                flattened.push(object);
            }
        }
        return flattened;
    }
    function flatMap(array, block) {
        return flatten(map(array, block));
    }
    function always(promise, callback = identity) {
        return promise.then(callback, callback);
    }
    function newDeferred() {
        let resolveFn;
        let rejectFn;
        const nativePromise = new Promise(function (givenResolve, givenReject) {
            resolveFn = givenResolve;
            rejectFn = givenReject;
        });
        nativePromise.resolve = resolveFn;
        nativePromise.reject = rejectFn;
        return nativePromise;
    }
    function isBasicObjectProperty(k) {
        return Object.prototype.hasOwnProperty(k);
    }
    function isEqual(a, b) {
        if (a?.valueOf) {
            a = a.valueOf();
        }
        if (b?.valueOf) {
            b = b.valueOf();
        }
        if (typeof (a) !== typeof (b)) {
            return false;
        }
        else if (isList(a) && isList(b)) {
            return isEqualList(a, b);
        }
        else if (isObject(a) && a[isEqual.key]) {
            return a[isEqual.key](b);
        }
        else if (isOptions(a) && isOptions(b)) {
            const aKeys = Object.keys(a);
            const bKeys = Object.keys(b);
            if (isEqualList(aKeys, bKeys)) {
                return every(aKeys, aKey => isEqual(a[aKey], b[aKey]));
            }
            else {
                return false;
            }
        }
        else {
            return a === b;
        }
    }
    isEqual.key = 'up.util.isEqual';
    function isEqualList(a, b) {
        return (a.length === b.length) && every(a, (elem, index) => isEqual(elem, b[index]));
    }
    function getSimpleTokens(value, { json = false, separator = /[,\s]/ } = {}) {
        if (!isString(value)) {
            return wrapList(value);
        }
        else if (json && /^\[.*]$/.test(value)) {
            return parseRelaxedJSON(value);
        }
        else {
            return splitSimpleTokenString(value, separator);
        }
    }
    function splitSimpleTokenString(value, separator) {
        let parts = up.migrate.splitAtOr?.(value) || value.split(separator);
        return parts.map((s) => s.trim()).filter(identity);
    }
    function getComplexTokens(value) {
        if (!isString(value)) {
            return wrapList(value);
        }
        else {
            let { maskedTokens, restore } = complexTokenOutlines(value);
            return maskedTokens.map((token) => restore(token));
        }
    }
    function complexTokenOutlines(string) {
        let { masked, restore } = expressionOutline(string);
        let maskedTokens = splitSimpleTokenString(masked, ',');
        return { maskedTokens, restore };
    }
    function wrapValue(constructor, ...args) {
        return (args[0] instanceof constructor) ? args[0] : new constructor(...args);
    }
    let nextUid = 0;
    function uid() {
        return nextUid++;
    }
    function reverse(list) {
        return copy(list).reverse();
    }
    function withRenamedKeys(object, renameKeyFn) {
        const renamed = {};
        for (let key in object) {
            let transformed = renameKeyFn(key);
            if (isGiven(transformed)) {
                renamed[transformed] = object[key];
            }
        }
        return renamed;
    }
    function camelToKebabCase(str) {
        return str.replace(/[A-Z]/g, char => '-' + char.toLowerCase());
    }
    function lowerCaseFirst(str) {
        return str[0].toLowerCase() + str.slice(1);
    }
    function upperCaseFirst(str) {
        return str[0].toUpperCase() + str.slice(1);
    }
    function defineDelegates(object, props, targetProvider) {
        for (let prop of props) {
            Object.defineProperty(object, prop, {
                get() {
                    const target = targetProvider.call(this);
                    let value = target[prop];
                    if (isFunction(value)) {
                        value = value.bind(target);
                    }
                    return value;
                },
                set(newValue) {
                    const target = targetProvider.call(this);
                    target[prop] = newValue;
                }
            });
        }
    }
    function delegatePromise(object, targetProvider) {
        return defineDelegates(object, ['then', 'catch', 'finally'], targetProvider);
    }
    function stringifyArg(arg, placeholder = '%o') {
        let string;
        const maxLength = 200;
        if (placeholder === '%c') {
            return '';
        }
        if (placeholder === '%s' && isGiven(arg)) {
            arg = arg.toString();
        }
        if (isString(arg)) {
            string = arg.trim().replace(/[\n\r\t ]+/g, ' ');
            if (placeholder === '%o') {
                string = JSON.stringify(string);
            }
        }
        else if (isUndefined(arg)) {
            string = 'undefined';
        }
        else if (isNumber(arg) || isFunction(arg)) {
            string = arg.toString();
        }
        else if (isArray(arg)) {
            string = `[${map(arg, stringifyArg).join(', ')}]`;
        }
        else if (isJQuery(arg)) {
            string = `$(${map(arg, stringifyArg).join(', ')})`;
        }
        else if (isElement(arg)) {
            string = `<${arg.tagName.toLowerCase()}`;
            for (let attr of ['id', 'up-id', 'name', 'class']) {
                let value = arg.getAttribute(attr);
                if (value) {
                    string += ` ${attr}="${value}"`;
                }
            }
            string += ">";
        }
        else if (isRegExp(arg) || isError(arg)) {
            string = arg.toString();
        }
        else {
            try {
                string = JSON.stringify(arg);
            }
            catch (error) {
                if (error.name === 'TypeError') {
                    string = '(circular structure)';
                }
                else {
                    throw error;
                }
            }
        }
        if (string.length > maxLength) {
            string = `${string.substr(0, maxLength)}…${last(string)}`;
        }
        return string;
    }
    const SPRINTF_PLACEHOLDERS = /%[oOdisfc]/g;
    function sprintf(message, ...args) {
        return message.replace(SPRINTF_PLACEHOLDERS, (placeholder) => stringifyArg(args.shift(), placeholder));
    }
    function negate(fn) {
        return function (...args) {
            return !fn(...args);
        };
    }
    function useMemoizeCacheEntry(cacheEntry) {
        if (cacheEntry.error) {
            throw cacheEntry.error;
        }
        else {
            return cacheEntry.value;
        }
    }
    function buildMemoizeCacheEntry(oldImpl, self, args) {
        try {
            return { value: oldImpl.apply(self, args) };
        }
        catch (e) {
            return { error: e };
        }
    }
    function memoizeMethod(object, propLiteral) {
        for (let prop in propLiteral) {
            let originalDescriptor = Object.getOwnPropertyDescriptor(object, prop);
            let oldImpl = originalDescriptor.value;
            let cachingImpl = function (...args) {
                let cache = this[`__${prop}MemoizeCache`] ||= {};
                let cacheKey = JSON.stringify(args);
                cache[cacheKey] ||= buildMemoizeCacheEntry(oldImpl, this, args);
                return useMemoizeCacheEntry(cache[cacheKey]);
            };
            object[prop] = cachingImpl;
        }
    }
    function safeStringifyJSON(value) {
        let json = JSON.stringify(value);
        return escapeHighASCII(json);
    }
    function escapeHighASCII(string) {
        let unicodeEscape = (char) => "\\u" + char.charCodeAt(0).toString(16).padStart(4, '0');
        return string.replace(/[^\x00-\x7F]/g, unicodeEscape);
    }
    function variant(source, changes = {}) {
        let variant = Object.create(source);
        Object.assign(variant, changes);
        return variant;
    }
    function parseArgs(args, ...specs) {
        let results = [];
        while (specs.length) {
            let lastSpec = specs.pop();
            if (lastSpec === 'options') {
                results.unshift(extractOptions(args));
            }
            else if (lastSpec === 'callback') {
                results.unshift(extractCallback(args));
            }
            else if (lastSpec === 'val') {
                results.unshift(args.pop());
            }
            else if (isFunction(lastSpec)) {
                let value = lastSpec(last(args)) ? args.pop() : undefined;
                results.unshift(value);
            }
        }
        return results;
    }
    function scanFunctions(...values) {
        return values.flat().filter(isFunction);
    }
    function cleaner() {
        let fns = [];
        let track = function (values, transform) {
            values = scanFunctions(...values).map(transform);
            fns.push(...scanFunctions(...values));
        };
        let api = function (...values) {
            track(values, identity);
        };
        api.guard = function (...values) {
            track(values, up.error.guardFn);
        };
        api.clean = function (...args) {
            let { length } = fns;
            for (let i = length - 1; i >= 0; i--)
                fns[i](...args);
            fns = [];
        };
        return api;
    }
    function maskPattern(str, patterns, { keepDelimiters = false } = {}) {
        let maskCount = 0;
        let maskPattern = /§(\d+)/g;
        let matches = [];
        let replaceLayers = 0;
        let replace = (replacePattern) => {
            let didReplace = false;
            str = str.replaceAll(replacePattern, function (match) {
                didReplace = true;
                let glyph = '§' + (maskCount++);
                let mask;
                let masked;
                if (keepDelimiters) {
                    let startDelimiter = match[0];
                    let endDelimiter = match.slice(-1);
                    masked = match.slice(1, -1);
                    mask = startDelimiter + glyph + endDelimiter;
                }
                else {
                    masked = match;
                    mask = glyph;
                }
                matches.push(masked);
                return mask;
            });
            if (didReplace)
                replaceLayers++;
        };
        [maskPattern, ...patterns].forEach(replace);
        let restore = (s, transform = identity) => {
            for (let i = 0; i < replaceLayers; i++) {
                s = s.replace(maskPattern, (match, placeholderIndex) => transform(matches[placeholderIndex]));
            }
            return s;
        };
        return { masked: str, restore };
    }
    const QUOTED_STRING_PATTERN = /'(?:\\\\|\\'|[^'])*'|"(?:\\\\|\\"|[^"])*"/g;
    const NESTED_GROUP_PATTERN = /{(?:[^{}]|{[^{}]*})*}|\((?:[^\(\)]|\([^\(\)]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\]/g;
    function expressionOutline(str) {
        return maskPattern(str, [QUOTED_STRING_PATTERN, NESTED_GROUP_PATTERN], { keepDelimiters: true });
    }
    function ensureDoubleQuotes(str) {
        if (str[0] === '"')
            return str;
        str = str.slice(1, -1);
        let transformed = str.replace(/(\\\\)|(\\')|(\\")|(")/g, function (_match, escapedBackslash, escapedSingleQuote, _doubleQuote) {
            return escapedBackslash
                || (escapedSingleQuote && "'")
                || '\\"';
        });
        return '"' + transformed + '"';
    }
    function parseString(value) {
        return JSON.parse(ensureDoubleQuotes(value));
    }
    function parseRelaxedJSON(str) {
        let { masked, restore } = maskPattern(str, [QUOTED_STRING_PATTERN]);
        masked = masked.replace(/([a-z_$][\w$]*:)/gi, (unquotedProperty) => ('"' + unquotedProperty.slice(0, -1) + '":'));
        masked = masked.replace(/,\s*([}\]])/g, '$1');
        masked = restore(masked, ensureDoubleQuotes);
        return JSON.parse(masked);
    }
    function parseScalarJSONPairs(str) {
        let { maskedTokens, restore } = complexTokenOutlines(str);
        return maskedTokens.map((maskedToken) => {
            let [_match, string, json] = maskedToken.match(/([^{]+)({[^}]*})?/);
            return [
                restore(string.trim()),
                json && parseRelaxedJSON(restore(json))
            ];
        });
    }
    return {
        parseURL,
        normalizeURL,
        matchableURL,
        matchableURLPatternAtom,
        matchURLs,
        normalizeMethod,
        methodAllowsPayload,
        copy,
        merge,
        mergeDefined,
        options: newOptions,
        parseArgIntoOptions,
        each,
        map,
        flatMap,
        mapObject,
        findResult,
        some,
        every,
        find: findInList,
        filter: filterList,
        reject,
        intersect,
        compact,
        compactObject,
        uniq,
        uniqBy,
        last,
        isNull,
        isDefined,
        isUndefined,
        isGiven,
        isMissing,
        isPresent,
        isBlank,
        presence,
        isObject,
        isFunction,
        isString,
        isBoolean,
        isNumber,
        isElement,
        isTextNode,
        isJQuery,
        isElementLike,
        isPromise,
        isOptions,
        isArray,
        isFormData,
        isList,
        isRegExp,
        isAdjacentPosition,
        timer: scheduleTimer,
        contains,
        containsAll,
        objectContains,
        toArray,
        pick,
        pickBy,
        omit,
        unresolvablePromise,
        remove,
        memoize,
        pluckKey,
        renameKey,
        extractOptions,
        extractCallback,
        noop,
        asyncNoop,
        identity,
        escapeHTML,
        escapeRegExp,
        sequence,
        evalOption,
        evalAutoOption,
        flatten,
        newDeferred,
        always,
        isBasicObjectProperty,
        isCrossOrigin,
        task: queueTask,
        isEqual,
        getSimpleTokens,
        getComplexTokens,
        wrapList,
        wrapValue,
        uid,
        upperCaseFirst,
        lowerCaseFirst,
        delegate: defineDelegates,
        delegatePromise,
        reverse,
        camelToKebabCase,
        sprintf,
        withRenamedKeys,
        memoizeMethod,
        safeStringifyJSON,
        variant,
        cleaner,
        scanFunctions,
        args: parseArgs,
        parseRelaxedJSON,
        parseScalarJSONPairs,
        maskPattern,
        expressionOutline,
        parseString,
    };
})();


/***/ }),
/* 4 */
/***/ (() => {

up.error = (function () {
    function fail(...args) {
        throw new up.Error(args);
    }
    function isCritical(error) {
        return (typeof error !== 'object') || ((error.name !== 'AbortError') && !(error instanceof up.RenderResult) && !(error instanceof up.Response));
    }
    function muteUncriticalRejection(promise) {
        return promise.catch(throwCritical);
    }
    function muteUncriticalSync(block) {
        try {
            return block();
        }
        catch (e) {
            throwCritical(e);
        }
    }
    function throwCritical(value) {
        if (isCritical(value)) {
            throw value;
        }
    }
    function guard(fn, ...args) {
        try {
            return fn(...args);
        }
        catch (error) {
            reportError(error);
        }
    }
    function guardFn(fn) {
        return (...args) => guard(() => fn(...args));
    }
    return {
        fail,
        throwCritical,
        muteUncriticalRejection,
        muteUncriticalSync,
        guard,
        guardFn,
    };
})();
up.fail = up.error.fail;


/***/ }),
/* 5 */
/***/ (() => {

up.migrate = {
    config: {},
};


/***/ }),
/* 6 */
/***/ (() => {

up.browser = (function () {
    function submitForm(form) {
        form.submit();
    }
    function canPushState() {
        return up.protocol.initialRequestMethod() === 'GET';
    }
    function canJQuery() {
        return !!window.jQuery;
    }
    function popCookie(name) {
        let value = document.cookie.match(new RegExp(name + "=(\\w+)"))?.[1];
        if (value) {
            document.cookie = name + '=;Max-Age=0;Path=/';
            return value;
        }
    }
    function assertConfirmed(options) {
        const confirmed = !options.confirm || window.confirm(options.confirm);
        if (!confirmed) {
            throw new up.Aborted('User canceled action');
        }
        return true;
    }
    return {
        submitForm,
        canPushState,
        canJQuery,
        assertConfirmed,
        popCookie,
    };
})();


/***/ }),
/* 7 */
/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {

__webpack_require__(8);
up.element = (function () {
    const u = up.util;
    function first(...args) {
        let [root = document, selector] = u.args(args, 'val', 'val');
        return root.querySelector(selector);
    }
    function subtree(root, selector) {
        const results = [];
        if (elementLikeMatches(root, selector)) {
            results.push(root);
        }
        results.push(...root.querySelectorAll(selector));
        return results;
    }
    function subtreeFirst(root, selector) {
        return elementLikeMatches(root, selector) ? root : root.querySelector(selector);
    }
    function elementLikeMatches(elementLike, selector) {
        return u.isElement(elementLike) && elementLike.matches(selector);
    }
    function contains(root, selectorOrElement) {
        const element = getOne(selectorOrElement);
        return Node.prototype.contains.call(root, element);
    }
    function ancestor(element, selector) {
        return element.parentNode?.closest(selector);
    }
    function around(element, selector) {
        return getList(element.closest(selector), subtree(element, selector));
    }
    function getOne(...args) {
        const value = args.pop();
        if (u.isElement(value)) {
            return value;
        }
        else if (u.isString(value)) {
            return first(...args, value);
        }
        else if (u.isList(value)) {
            if (value.length > 1) {
                up.fail('up.element.get(): Cannot cast multiple elements (%o) to a single element', value);
            }
            return value[0];
        }
        else {
            return value;
        }
    }
    function getList(...args) {
        return u.flatMap(args, valueToList);
    }
    function valueToList(value) {
        if (u.isString(value)) {
            return document.querySelectorAll(value);
        }
        else {
            return u.wrapList(value);
        }
    }
    function hide(element) {
        setVisible(element, false);
    }
    function show(element) {
        setVisible(element, true);
    }
    function showTemp(element) {
        return setVisibleTemp(element, true);
    }
    function hideTemp(element) {
        return setVisibleTemp(element, false);
    }
    function setVisibleTemp(element, newVisible) {
        if (newVisible === isVisible(element))
            return u.noop;
        setVisible(element, newVisible);
        return () => setVisible(element, !newVisible);
    }
    function setVisible(element, newVisible) {
        if (newVisible) {
            element.removeAttribute('hidden');
            if (element.style.display === 'none') {
                element.style.display = '';
            }
        }
        else {
            element.setAttribute('hidden', '');
        }
    }
    function toggle(element, newVisible = !isVisible(element)) {
        setVisible(element, newVisible);
    }
    function setAttrPresence(element, attr, value, newPresent) {
        if (newPresent) {
            return element.setAttribute(attr, value);
        }
        else {
            return element.removeAttribute(attr);
        }
    }
    function setAttrs(element, attrs) {
        for (let key in attrs) {
            const value = attrs[key];
            if (u.isGiven(value)) {
                element.setAttribute(key, value);
            }
            else {
                element.removeAttribute(key);
            }
        }
    }
    function setAttrsTemp(element, attrs) {
        let keys = Object.keys(attrs);
        let oldAttrs = pickAttrs(element, keys);
        setAttrs(element, attrs);
        return () => setAttrs(element, oldAttrs);
    }
    function metaContent(name) {
        const selector = "meta" + attrSelector('name', name);
        return first(selector)?.getAttribute('content');
    }
    function insertBefore(existingNode, newNode) {
        existingNode.parentNode.insertBefore(newNode, existingNode);
    }
    function createFromSelector(selector, attrs = {}) {
        let { includePath } = parseSelector(selector);
        let rootElement;
        let depthElement;
        let previousElement;
        for (let includeSegment of includePath) {
            let { tagName } = includeSegment;
            if (!tagName || tagName === '*') {
                tagName = 'div';
            }
            depthElement = document.createElement(tagName);
            if (!rootElement) {
                rootElement = depthElement;
            }
            makeVariation(depthElement, includeSegment);
            previousElement?.appendChild(depthElement);
            previousElement = depthElement;
        }
        for (let key in attrs) {
            let value = attrs[key];
            if (key === 'class') {
                addClasses(rootElement, u.wrapList(value));
            }
            else if (key === 'style') {
                setInlineStyle(rootElement, value);
            }
            else if (key === 'text') {
                rootElement.textContent = value;
            }
            else if (key === 'content') {
                if (u.isString(value)) {
                    rootElement.innerHTML = value;
                }
                else {
                    rootElement.append(...u.wrapList(value));
                }
            }
            else {
                rootElement.setAttribute(key, value);
            }
        }
        return rootElement;
    }
    function makeVariation(element, { id, classNames, attributes }) {
        if (id) {
            element.id = id;
        }
        for (let [name, value] of Object.entries(attributes)) {
            element.setAttribute(name, value);
        }
        addClasses(element, classNames);
    }
    function parseSelector(rawSelector) {
        let excludeRaw;
        const { masked: selectorOutline, restore: restoreSelectorLiterals, } = u.expressionOutline(rawSelector);
        const includeWithoutAttrs = selectorOutline.replace(/:not\([^)]*\)/, function (match) {
            excludeRaw = restoreSelectorLiterals(match);
            return '';
        });
        let includeRaw = restoreSelectorLiterals(includeWithoutAttrs);
        const includeSegments = includeWithoutAttrs.split(/[ >]+/);
        let includePath = includeSegments.map(function (depthSelector) {
            let parsed = {
                tagName: null,
                classNames: [],
                id: null,
                attributes: {}
            };
            depthSelector = depthSelector.replace(/^[\w-*]+/, function (match) {
                parsed.tagName = match;
                return '';
            });
            depthSelector = depthSelector.replace(/#([\w-]+)/, function (_match, id) {
                parsed.id = id;
                return '';
            });
            depthSelector = depthSelector.replace(/\.([\w-]+)/g, function (_match, className) {
                parsed.classNames.push(className);
                return '';
            });
            depthSelector = depthSelector.replace(/\[[^\]]*]/g, function (attr) {
                attr = restoreSelectorLiterals(attr);
                let [_raw, name, _operator, quote, value] = attr.match(/\[([\w-]+)(?:([~|^$*]?=)(["'])?([^\3\]]*?)\3)?]/);
                quote ||= '"';
                parsed.attributes[name] = value ? u.parseString(quote + value + quote) : '';
                return '';
            });
            if (depthSelector) {
                up.fail('Cannot parse selector: ' + rawSelector);
            }
            return parsed;
        });
        return {
            includePath,
            includeRaw,
            excludeRaw,
        };
    }
    function affix(...args) {
        let [parent, position = 'beforeend', selector, attributes] = u.args(args, 'val', u.isAdjacentPosition, 'val', 'options');
        const element = createFromSelector(selector, attributes);
        parent.insertAdjacentElement(position, element);
        return element;
    }
    const SINGLETON_TAG_NAMES = ['HTML', 'BODY', 'HEAD', 'TITLE'];
    const isSingleton = up.mockable(element => element.matches(SINGLETON_TAG_NAMES.join()));
    function elementTagName(element) {
        return element.tagName.toLowerCase();
    }
    function attrSelector(attribute, value) {
        if (u.isGiven(value)) {
            value = value.replace(/"/g, '\\"');
            return `[${attribute}="${value}"]`;
        }
        else {
            return `[${attribute}]`;
        }
    }
    function idSelector(id) {
        if (id.match(/^[a-z][a-z0-9\-_]*$/i)) {
            return `#${id}`;
        }
        else {
            return attrSelector('id', id);
        }
    }
    function classSelector(klass) {
        klass = klass.replace(/[^\w-]/g, '\\$&');
        return `.${klass}`;
    }
    function createBrokenDocumentFromHTML(html) {
        return new DOMParser().parseFromString(html, 'text/html');
    }
    function fixParserDamage(scriptish) {
        let clone = createFromHTML(scriptish.outerHTML);
        scriptish.replaceWith(clone);
    }
    function createFromHTML(html) {
        return extractSingular(createNodesFromHTML(html));
    }
    function extractSingular(nodes) {
        if (nodes.length === 1 && u.isElementLike(nodes[0])) {
            return nodes[0];
        }
        else {
            up.fail('Expected a single element, but got %d elements', nodes.length);
        }
    }
    function createNodesFromHTML(html) {
        html = html.trim();
        const range = document.createRange();
        range.setStart(document.body, 0);
        const fragment = range.createContextualFragment(html);
        return fragment.childNodes;
    }
    function getRoot() {
        return document.documentElement;
    }
    function paint(element) {
        element.offsetHeight;
    }
    function concludeCSSTransition(element) {
        const undo = setStyleTemp(element, { transition: 'none' });
        paint(element);
        return undo;
    }
    function hasCSSTransition(styleHash) {
        const prop = styleHash['transition-property'];
        const duration = styleHash['transition-duration'];
        const noTransition = ((prop === 'none') || ((prop === 'all') && (duration === 0)));
        return !noTransition;
    }
    function fixedToAbsolute(element) {
        const elementRectAsFixed = element.getBoundingClientRect();
        element.style.position = 'absolute';
        const offsetParentRect = element.offsetParent.getBoundingClientRect();
        setInlineStyle(element, {
            left: (elementRectAsFixed.left - computedStyleNumber(element, 'margin-left') - offsetParentRect.left) + 'px',
            top: (elementRectAsFixed.top - computedStyleNumber(element, 'margin-top') - offsetParentRect.top) + 'px',
            right: '',
            bottom: ''
        });
    }
    function setMissingAttrs(element, attrs) {
        for (let key in attrs) {
            setMissingAttr(element, key, attrs[key]);
        }
    }
    function setMissingAttr(element, key, value) {
        if (u.isMissing(element.getAttribute(key))) {
            element.setAttribute(key, value);
        }
    }
    function unwrap(wrapper) {
        preservingFocus(function () {
            let childNodes = [...wrapper.childNodes];
            for (let child of childNodes)
                insertBefore(wrapper, child);
            wrapper.remove();
        });
    }
    function wrapNodes(nodeOrNodes) {
        const wrapper = document.createElement('up-wrapper');
        wrapper.append(...u.wrapList(nodeOrNodes));
        return wrapper;
    }
    function wrapIfRequired(nodes) {
        if (nodes.length === 1 && u.isElement(nodes[0])) {
            return nodes[0];
        }
        else {
            return wrapNodes(nodes);
        }
    }
    function wrapChildren(element) {
        const wrapper = wrapNodes(element.childNodes);
        element.append(wrapper);
        return wrapper;
    }
    function preservingFocus(fn) {
        const oldFocusElement = document.activeElement;
        try {
            return fn();
        }
        finally {
            if (oldFocusElement && oldFocusElement !== document.activeElement) {
                oldFocusElement.focus({ preventScroll: true });
            }
        }
    }
    function parseAttr(element, attribute, ...parsers) {
        if (!element.hasAttribute?.(attribute))
            return undefined;
        let rawValue = element.getAttribute(attribute);
        for (let parser of parsers) {
            let parserResult = parser(rawValue, attribute, element);
            if (u.isDefined(parserResult))
                return parserResult;
        }
    }
    function stringAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseString);
    }
    let tryParseString = u.identity;
    function booleanAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseBoolean);
    }
    function tryParseBoolean(value, attribute) {
        switch (value) {
            case 'false': {
                return false;
            }
            case 'true':
            case '':
            case attribute:
                {
                    return true;
                }
        }
    }
    function booleanOrStringAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseBoolean, tryParseString);
    }
    function booleanOrNumberAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseBoolean, tryParseNumber);
    }
    function numberAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseNumber);
    }
    function tryParseNumber(value) {
        value = value.replaceAll('_', '');
        if (value.match(/^-?[\d.]+$/)) {
            return parseFloat(value);
        }
    }
    function jsonAttr(element, attribute) {
        return parseAttr(element, attribute, tryParseJSON);
    }
    function tryParseJSON(value) {
        if (value?.trim()) {
            return u.parseRelaxedJSON(value);
        }
    }
    function callbackAttr(link, attr, callbackOptions) {
        return parseAttr(link, attr, (value) => tryParseCallback(value, link, callbackOptions));
    }
    function tryParseCallback(code, link, { exposedKeys = [], mainKey = 'event' } = {}) {
        const callback = up.NonceableCallback.fromString(code).toFunction(mainKey, ...exposedKeys);
        return function (event) {
            const exposedValues = Object.values(u.pick(event, exposedKeys));
            return callback.call(link, event, ...exposedValues);
        };
    }
    function closestAttr(element, attr, readAttrFn = stringAttr) {
        let match = element.closest('[' + attr + ']');
        if (match) {
            return readAttrFn(match, attr);
        }
    }
    function addClasses(element, classes) {
        for (let klass of classes)
            element.classList.add(klass);
    }
    function addClassTemp(element, klass) {
        return setClassStateTemp(element, klass, true);
    }
    function removeClassTemp(element, klass) {
        return setClassStateTemp(element, klass, false);
    }
    function setClassStateTemp(element, klass, targetState) {
        if (element.classList.contains(klass) === targetState)
            return u.noop;
        element.classList.toggle(klass, targetState);
        return () => element.classList.toggle(klass, !targetState);
    }
    function computedStyle(element, props) {
        const style = window.getComputedStyle(element);
        return extractFromStyleObject(style, props);
    }
    function computedStyleNumber(element, prop) {
        const rawValue = computedStyle(element, prop);
        if (u.isPresent(rawValue)) {
            return parseFloat(rawValue);
        }
    }
    function inlineStyle(element, props) {
        const { style } = element;
        return extractFromStyleObject(style, props);
    }
    function extractFromStyleObject(style, keyOrKeys) {
        if (up.migrate.loaded)
            keyOrKeys = up.migrate.fixStyleProps(keyOrKeys);
        if (u.isString(keyOrKeys)) {
            return style.getPropertyValue(keyOrKeys);
        }
        else {
            return u.mapObject(keyOrKeys, (key) => [key, style.getPropertyValue(key)]);
        }
    }
    function setInlineStyle(element, props, unit = '') {
        if (up.migrate.loaded)
            props = up.migrate.fixStyleProps(props, unit);
        if (u.isString(props)) {
            element.setAttribute('style', props);
        }
        else {
            const { style } = element;
            for (let key in props) {
                let value = props[key];
                style.setProperty(key, value + unit);
            }
        }
    }
    function setStyleTemp(element, newStyles) {
        const oldStyles = inlineStyle(element, Object.keys(newStyles));
        setInlineStyle(element, newStyles);
        return () => setInlineStyle(element, oldStyles);
    }
    function isVisible(element) {
        return !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);
    }
    function isUpPrefixed(string) {
        return /^up-/.test(string);
    }
    function pickAttrs(element, attrNames) {
        return u.mapObject(attrNames, (name) => [name, element.getAttribute(name)]);
    }
    function upAttrs(element) {
        let attrNames = element.getAttributeNames().filter(isUpPrefixed);
        return pickAttrs(element, attrNames);
    }
    function upClasses(element) {
        return u.filter(element.classList.values(), isUpPrefixed);
    }
    function cleanJQuery(element) {
        if (up.browser.canJQuery()) {
            jQuery(element).remove();
        }
    }
    function isEmpty(element) {
        return !element.children.length > 0 && !element.innerText.trim();
    }
    function crossOriginSelector(attr) {
        return `[${attr}*="//"]:not([${attr}*="//${location.host}/"])`;
    }
    function isIntersectingWindow(element, { margin = 0 } = {}) {
        const rect = up.Rect.fromElement(element);
        rect.grow(margin);
        return (rect.bottom > 0) && (rect.top < window.innerHeight) &&
            (rect.right > 0) && (rect.left < window.innerWidth);
    }
    function unionSelector(includes, excludes) {
        let selector = `:is(${includes.join()})`;
        if (u.isPresent(excludes))