{"version":3,"file":"reg.min.mjs","mappings":"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","sources":["webpack://@felicity/sustainable-med-cities/./node_modules/recaptcha-v3/dist/ReCaptcha.js","webpack://@felicity/sustainable-med-cities/./node_modules/recaptcha-v3/dist/ReCaptchaInstance.js","webpack://@felicity/sustainable-med-cities/./node_modules/recaptcha-v3/dist/ReCaptchaLoader.js","webpack://@felicity/sustainable-med-cities/webpack/bootstrap","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/constants.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/constants.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/string.ext.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/date.ext.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/object.ext.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/url.ext.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/primitives/src/data/Mapper.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/dom/extensions.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/dom/ComponentRegistryEntry.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/dom/ComponentRegistry.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/i18n/src/Dictionary.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/ui/Component.mjs","webpack://@felicity/sustainable-med-cities/./node_modules/@felicity/vision/src/ui/Form.mjs","webpack://@felicity/sustainable-med-cities/./wwwsrc/reg.mjs"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ReCaptchaInstance = exports.getInstance = exports.load = void 0;\nvar ReCaptchaLoader_1 = require(\"./ReCaptchaLoader\");\nObject.defineProperty(exports, \"load\", { enumerable: true, get: function () { return ReCaptchaLoader_1.load; } });\nObject.defineProperty(exports, \"getInstance\", { enumerable: true, get: function () { return ReCaptchaLoader_1.getInstance; } });\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\nObject.defineProperty(exports, \"ReCaptchaInstance\", { enumerable: true, get: function () { return ReCaptchaInstance_1.ReCaptchaInstance; } });\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ReCaptchaInstance = void 0;\nvar ReCaptchaInstance = (function () {\n    function ReCaptchaInstance(siteKey, recaptchaID, recaptcha) {\n        this.siteKey = siteKey;\n        this.recaptchaID = recaptchaID;\n        this.recaptcha = recaptcha;\n        this.styleContainer = null;\n    }\n    ReCaptchaInstance.prototype.execute = function (action) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        if (!this.recaptcha.enterprise) return [3, 2];\n                        return [4, this.recaptcha.enterprise.execute(this.recaptchaID, { action: action })];\n                    case 1:\n                        _a = _b.sent();\n                        return [3, 4];\n                    case 2: return [4, this.recaptcha.execute(this.recaptchaID, { action: action })];\n                    case 3:\n                        _a = _b.sent();\n                        _b.label = 4;\n                    case 4: return [2, _a];\n                }\n            });\n        });\n    };\n    ReCaptchaInstance.prototype.getSiteKey = function () {\n        return this.siteKey;\n    };\n    ReCaptchaInstance.prototype.hideBadge = function () {\n        if (this.styleContainer !== null) {\n            return;\n        }\n        this.styleContainer = document.createElement(\"style\");\n        this.styleContainer.innerHTML =\n            \".grecaptcha-badge{visibility:hidden !important;}\";\n        document.head.appendChild(this.styleContainer);\n    };\n    ReCaptchaInstance.prototype.showBadge = function () {\n        if (this.styleContainer === null) {\n            return;\n        }\n        document.head.removeChild(this.styleContainer);\n        this.styleContainer = null;\n    };\n    return ReCaptchaInstance;\n}());\nexports.ReCaptchaInstance = ReCaptchaInstance;\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getInstance = exports.load = void 0;\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\nvar ELoadingState;\n(function (ELoadingState) {\n    ELoadingState[ELoadingState[\"NOT_LOADED\"] = 0] = \"NOT_LOADED\";\n    ELoadingState[ELoadingState[\"LOADING\"] = 1] = \"LOADING\";\n    ELoadingState[ELoadingState[\"LOADED\"] = 2] = \"LOADED\";\n})(ELoadingState || (ELoadingState = {}));\nvar ReCaptchaLoader = (function () {\n    function ReCaptchaLoader() {\n    }\n    ReCaptchaLoader.load = function (siteKey, options) {\n        if (options === void 0) { options = {}; }\n        if (typeof document === \"undefined\") {\n            return Promise.reject(new Error(\"This is a library for the browser!\"));\n        }\n        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADED) {\n            if (ReCaptchaLoader.instance.getSiteKey() === siteKey) {\n                return Promise.resolve(ReCaptchaLoader.instance);\n            }\n            else {\n                return Promise.reject(new Error(\"reCAPTCHA already loaded with different site key!\"));\n            }\n        }\n        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADING) {\n            if (siteKey !== ReCaptchaLoader.instanceSiteKey) {\n                return Promise.reject(new Error(\"reCAPTCHA already loaded with different site key!\"));\n            }\n            return new Promise(function (resolve, reject) {\n                ReCaptchaLoader.successfulLoadingConsumers.push(function (instance) { return resolve(instance); });\n                ReCaptchaLoader.errorLoadingRunnable.push(function (reason) {\n                    return reject(reason);\n                });\n            });\n        }\n        ReCaptchaLoader.instanceSiteKey = siteKey;\n        ReCaptchaLoader.setLoadingState(ELoadingState.LOADING);\n        var loader = new ReCaptchaLoader();\n        return new Promise(function (resolve, reject) {\n            loader\n                .loadScript(siteKey, options.useRecaptchaNet || false, options.useEnterprise || false, options.renderParameters ? options.renderParameters : {}, options.customUrl)\n                .then(function () {\n                ReCaptchaLoader.setLoadingState(ELoadingState.LOADED);\n                var widgetID = loader.doExplicitRender(grecaptcha, siteKey, options.explicitRenderParameters\n                    ? options.explicitRenderParameters\n                    : {}, options.useEnterprise || false);\n                var instance = new ReCaptchaInstance_1.ReCaptchaInstance(siteKey, widgetID, grecaptcha);\n                ReCaptchaLoader.successfulLoadingConsumers.forEach(function (v) {\n                    return v(instance);\n                });\n                ReCaptchaLoader.successfulLoadingConsumers = [];\n                if (options.autoHideBadge) {\n                    instance.hideBadge();\n                }\n                ReCaptchaLoader.instance = instance;\n                resolve(instance);\n            })\n                .catch(function (error) {\n                ReCaptchaLoader.errorLoadingRunnable.forEach(function (v) { return v(error); });\n                ReCaptchaLoader.errorLoadingRunnable = [];\n                reject(error);\n            });\n        });\n    };\n    ReCaptchaLoader.getInstance = function () {\n        return ReCaptchaLoader.instance;\n    };\n    ReCaptchaLoader.setLoadingState = function (state) {\n        ReCaptchaLoader.loadingState = state;\n    };\n    ReCaptchaLoader.getLoadingState = function () {\n        if (ReCaptchaLoader.loadingState === null) {\n            return ELoadingState.NOT_LOADED;\n        }\n        else {\n            return ReCaptchaLoader.loadingState;\n        }\n    };\n    ReCaptchaLoader.prototype.loadScript = function (siteKey, useRecaptchaNet, useEnterprise, renderParameters, customUrl) {\n        var _this = this;\n        if (useRecaptchaNet === void 0) { useRecaptchaNet = false; }\n        if (useEnterprise === void 0) { useEnterprise = false; }\n        if (renderParameters === void 0) { renderParameters = {}; }\n        if (customUrl === void 0) { customUrl = \"\"; }\n        var scriptElement = document.createElement(\"script\");\n        scriptElement.setAttribute(\"recaptcha-v3-script\", \"\");\n        scriptElement.setAttribute(\"async\", \"\");\n        scriptElement.setAttribute(\"defer\", \"\");\n        var scriptBase = \"https://www.google.com/recaptcha/api.js\";\n        if (useRecaptchaNet) {\n            if (useEnterprise) {\n                scriptBase = \"https://recaptcha.net/recaptcha/enterprise.js\";\n            }\n            else {\n                scriptBase = \"https://recaptcha.net/recaptcha/api.js\";\n            }\n        }\n        else if (useEnterprise) {\n            scriptBase = \"https://www.google.com/recaptcha/enterprise.js\";\n        }\n        if (customUrl) {\n            scriptBase = customUrl;\n        }\n        if (renderParameters.render) {\n            renderParameters.render = undefined;\n        }\n        var parametersQuery = this.buildQueryString(renderParameters);\n        scriptElement.src = scriptBase + \"?render=explicit\" + parametersQuery;\n        return new Promise(function (resolve, reject) {\n            scriptElement.addEventListener(\"load\", _this.waitForScriptToLoad(function () {\n                resolve(scriptElement);\n            }, useEnterprise), false);\n            scriptElement.onerror = function (error) {\n                ReCaptchaLoader.setLoadingState(ELoadingState.NOT_LOADED);\n                reject(error);\n            };\n            document.head.appendChild(scriptElement);\n        });\n    };\n    ReCaptchaLoader.prototype.buildQueryString = function (parameters) {\n        var parameterKeys = Object.keys(parameters);\n        if (parameterKeys.length < 1) {\n            return \"\";\n        }\n        return (\"&\" +\n            Object.keys(parameters)\n                .filter(function (parameterKey) {\n                return !!parameters[parameterKey];\n            })\n                .map(function (parameterKey) {\n                return parameterKey + \"=\" + parameters[parameterKey];\n            })\n                .join(\"&\"));\n    };\n    ReCaptchaLoader.prototype.waitForScriptToLoad = function (callback, useEnterprise) {\n        var _this = this;\n        return function () {\n            if (window.grecaptcha === undefined) {\n                setTimeout(function () {\n                    _this.waitForScriptToLoad(callback, useEnterprise);\n                }, ReCaptchaLoader.SCRIPT_LOAD_DELAY);\n            }\n            else {\n                if (useEnterprise) {\n                    window.grecaptcha.enterprise.ready(function () {\n                        callback();\n                    });\n                }\n                else {\n                    window.grecaptcha.ready(function () {\n                        callback();\n                    });\n                }\n            }\n        };\n    };\n    ReCaptchaLoader.prototype.doExplicitRender = function (grecaptcha, siteKey, parameters, isEnterprise) {\n        var augmentedParameters = __assign({ sitekey: siteKey }, parameters);\n        if (parameters.container) {\n            if (isEnterprise) {\n                return grecaptcha.enterprise.render(parameters.container, augmentedParameters);\n            }\n            else {\n                return grecaptcha.render(parameters.container, augmentedParameters);\n            }\n        }\n        else {\n            if (isEnterprise) {\n                return grecaptcha.enterprise.render(augmentedParameters);\n            }\n            else {\n                return grecaptcha.render(augmentedParameters);\n            }\n        }\n    };\n    ReCaptchaLoader.loadingState = null;\n    ReCaptchaLoader.instance = null;\n    ReCaptchaLoader.instanceSiteKey = null;\n    ReCaptchaLoader.successfulLoadingConsumers = [];\n    ReCaptchaLoader.errorLoadingRunnable = [];\n    ReCaptchaLoader.SCRIPT_LOAD_DELAY = 25;\n    return ReCaptchaLoader;\n}());\nexports.load = ReCaptchaLoader.load;\nexports.getInstance = ReCaptchaLoader.getInstance;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","/**\n * Available component registration modes\n */\nexport const COMPONENT_REGISTRATION_MODE = {\n  /**\n   * Register components on DOMContentLoaded event.\n   */\n  DOM_READY: 'dom-ready',\n\n  /**\n   * Register components when added to the registry.\n   */\n  IMMEDIATE: 'immediate',\n\n  /**\n   * Register components manually by calling the ComponentRegistry.register() method.\n   */\n  MANUAL: 'manual'\n};\n\n/**\n * Temporary component states\n */\nexport const STATE = {\n  /**\n   * State indicating that an asynchronous background process is running\n   */\n  LOADING: 'loading'\n};\n\n/**\n * Component interactivity status\n */\nexport const STATUS = {\n  /**\n   * Component is visible on the UI and can be interacted with\n   */\n  ACTIVE: 'active',\n\n  /**\n   * Component is not available or not visible on the UI\n   */\n  INACTIVE: 'inactive'\n};\n\n/**\n * Common event types triggered by the DOM or custom components\n */\nexport const EVENT = {\n  /**\n   * The DOM_READY event fires when the initial HTML document has been completely loaded and parsed,\n   * without waiting for stylesheets, images, and subframes to finish loading.\n   */\n  DOM_READY: 'DOMContentLoaded',\n\n  /**\n   * The RESIZE event fires when the document view (window) has been resized.\n   */\n  DOM_RESIZE: 'resize',\n\n  /**\n   * The hashchange event is fired when the fragment identifier of the URL has changed\n   * (the part of the URL beginning with and following the # symbol).\n   */\n  HASHCHANGE: 'hashchange',\n\n  /**\n   * Invoked when a component gets activated. Usually when it gets displayed.\n   */\n  ACTIVATED: 'activated',\n\n  /**\n   * Invoked when a component gets deactivated. Usually when it gets hidden.\n   */\n  DEACTIVATED: 'deactivated',\n\n  /**\n   * Custom event that is invoked by a component and intended to be handled by the context.\n   */\n  ACTION: 'action',\n\n  /**\n   * Invoked when the user interacts with an input field of data changes in the view model.\n   */\n  CHANGE: 'change',\n\n  /**\n   * Invoked when the application has completed performing its initialisation.\n   */\n  READY: 'ready',\n\n  /**\n   * Invoked when general error occures\n   */\n  ERROR: 'error',\n\n  /**\n   * Events fired on {@link HTMLElement}\n   */\n  ELEMENT: {\n    /**\n     * The auxclick event is fired at an Element when a non-primary pointing device button\n     * (any mouse button other than the primary—usually leftmost—button)\n     * has been pressed and released both within the same element.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/auxclick_event\n     */\n    AUXCLICK: 'auxclick',\n\n    /**\n     * The blur event fires when an element has lost focus.\n     * The event does not bubble, but the related focusout event that follows does bubble.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/blur_event\n     */\n    BLUR: 'blur',\n\n    /**\n     * An element receives a click event when a pointing device button\n     * (such as a mouse's primary mouse button) is both pressed and released while\n     * the pointer is located inside the element.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/click_event\n     */\n    CLICK: 'click',\n\n    /**\n     * The copy event fires when the user initiates a copy action\n     * through the browser's user interface.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/copy_event\n     */\n    COPY: 'copy',\n\n    /**\n     * The cut event is fired when the user has initiated a \"cut\" action\n     * through the browser's user interface.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/cut_event\n     */\n    CUT: 'cut',\n\n    /**\n     * The contextmenu event fires when the user attempts to open a context menu.\n     * This event is typically triggered by clicking the right mouse button,\n     * or by pressing the context menu key.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/contextmenu_event\n     */\n    CONTEXTMENU: 'contextmenu',\n\n    /**\n     * The drag event is fired every few hundred milliseconds as an element or\n     * text selection is being dragged by the user.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/drag_event\n     */\n    DRAG: 'drag',\n\n    /**\n     * The dragend event is fired when a drag operation is being ended\n     * (by releasing a mouse button or hitting the escape key).\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dragend_event\n     */\n    DRAGEND: 'dragend',\n\n    /**\n     * The dragenter event is fired when a dragged element or text selection\n     * enters a valid drop target.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dragenter_event\n     */\n    DRAGENTER: 'dragenter',\n\n    /**\n     * The dragleave event is fired when a dragged element or text selection\n     * leaves a valid drop target.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dragleave_event\n     */\n    DRAGLEAVE: 'dragleave',\n\n    /**\n     * The dragover event is fired when an element or text selection is being dragged\n     * over a valid drop target (every few hundred milliseconds).\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dragover_event\n     */\n    DRAGOVER: 'dragover',\n\n    /**\n     * The dragstart event is fired when the user starts dragging an element or text selection.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dragstart_event\n     */\n    DRAGSTART: 'dragstart',\n\n    /**\n     * The drop event is fired when an element or text selection is dropped on a valid drop target.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/drop_event\n     */\n    DROP: 'drop',\n\n    /**\n     * The focus event fires when an element has received focus.\n     * The event does not bubble, but the related focusin event that follows does bubble.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/focus_event\n     */\n    FOCUS: 'focus',\n\n    /**\n     * The paste event is fired when the user has initiated a \"paste\" action\n     * through the browser's user interface.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/paste_event\n     */\n    PASTE: 'paste'\n  },\n\n  /**\n   * Events fired on {@link HTMLInputElement}\n   */\n  INPUT: {\n    /**\n     * The select event fires when some text has been selected.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/select_event\n     */\n    SELECT: 'select',\n\n    /**\n     * The input event fires when the value of an <input>, <select>, or <textarea>\n     * element has been changed.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/input_event\n     */\n    INPUT: 'input',\n\n    /**\n     * The change event is fired for <input>, <select>, and <textarea> elements\n     * when the user modifies the element's value. Unlike the input event, the change event\n     * is not necessarily fired for each alteration to an element's value.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event\n     */\n    CHANGE: 'change',\n\n    /**\n     * The invalid event fires when a submittable element has been checked for validity and\n     * doesn't satisfy its constraints.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLInputElement/invalid_event\n     */\n    INVALID: 'invalid'\n  },\n\n  /**\n   * Events fired on {@link HTMLFormElement}\n   */\n  FORM: {\n    /**\n     * The formdata event fires after the entry list representing the form's data is constructed.\n     */\n    FORM_DATA: 'formdata',\n\n    /**\n     * The reset event fires when a form is reset.\n     */\n    RESET: 'reset',\n\n    /**\n     * The submit event fires when a form is submitted.\n     */\n    SUBMIT: 'submit'\n  },\n\n  WINDOW: {\n    /**\n     * The afterprint event is fired after the associated document has started printing\n     * or the print preview has been closed.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/afterprint_event\n     */\n    AFTERPRINT: 'afterprint',\n\n    /**\n     * The beforeprint event is fired when the associated document is about to be printed\n     * or previewed for printing.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeprint_event\n     */\n    BEFOREPRINT: 'beforeprint',\n\n    /**\n     * The beforeunload event is fired when the window, the document and its resources are about to\n     * be unloaded. The document is still visible and the event is still cancelable at this point.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event\n     */\n    BEFOREUNLOAD: 'beforeunload',\n\n    /**\n     * The hashchange event is fired when the fragment identifier of the URL has changed\n     * (the part of the URL beginning with and following the # symbol).\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/hashchange_event\n     */\n    HASHCHANGE: 'hashchange',\n\n    /**\n     * The languagechange event is fired at the global scope object when\n     * the user's preferred language changes.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/languagechange_event\n     */\n    LANGUAGECHANGE: 'languagechange',\n\n    /**\n     * The load event is fired when the whole page has loaded, including all dependent resources\n     * such as stylesheets and images. This is in contrast to DOMContentLoaded, which is fired\n     * as soon as the page DOM has been loaded, without waiting for resources to finish loading.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event\n     */\n    LOAD: 'load',\n\n    /**\n     * The message event is fired on a Window object when the window receives a message,\n     * for example from a call to Window.postMessage() from another browsing context.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/message_event\n     */\n    MESSAGE: 'message',\n\n    /**\n     * The offline event of the Window interface is fired when the browser has lost access to\n     * the network and the value of Navigator.onLine switches to false.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/offline_event\n     */\n    OFFLINE: 'offline',\n\n    /**\n     * The online event of the Window interface is fired when the browser has gained access to\n     * the network and the value of Navigator.onLine switches to true.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/online_event\n     */\n    ONLINE: 'online',\n\n    /**\n     * The pagehide event is sent to a Window when the browser hides the current page in the process\n     * of presenting a different page from the session's history.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event\n     */\n    PAGEHIDE: 'pagehide',\n\n    /**\n     * The pageshow event is sent to a Window when the browser displays the window's document\n     * due to navigation.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/pageshow_event\n     */\n    PAGESHOW: 'pageshow',\n\n    /**\n     * The popstate event of the Window interface is fired when the active history entry changes\n     * while the user navigates the session history. It changes the current history entry\n     * to that of the last page the user visited or, if history.pushState() has been used to add\n     * a history entry to the history stack, that history entry is used instead.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/popstate_event\n     */\n    POPSTATE: 'popstate',\n\n    /**\n     * The rejectionhandled event is sent to the script's global scope (usually window\n     * but also Worker) whenever a JavaScript Promise is rejected\n     * but after the promise rejection has been handled.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/rejectionhandled_event\n     */\n    REJECTIONHANDLED: 'rejectionhandled',\n\n    /**\n     * The storage event of the Window interface fires when a storage area (localStorage)\n     * has been modified in the context of another document.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/storage_event\n     */\n    STORAGE: 'storage',\n\n    /**\n     * The unhandledrejection event is sent to the global scope of a script when a JavaScript\n     * Promise that has no rejection handler is rejected;\n     * typically, this is the window, but may also be a Worker.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/unhandledrejection_event\n     */\n    UNHANDLEDREJECTION: 'unhandledrejection'\n  }\n};\n\n/**\n * Frequently used CSS settings\n */\nexport const STYLE = {\n  /**\n   * Turns off the display of an element so that it has no effect on layout\n   * (the document is rendered as though the element did not exist).\n   * All descendant elements also have their display turned off.\n   */\n  DISPLAY_NONE: 'none'\n};\n","/**\n * JavaScript variable types\n */\nexport const TYPE = {\n  /**\n   * Primitive value automatically assigned to variables that have just been declared,\n   * or to formal arguments for which there are no actual arguments.\n   */\n  UNDEFINED: 'undefined',\n\n  /**\n   * Logical data type that can have only the values true or false.\n   */\n  BOOLEAN: 'boolean',\n\n  /**\n   * Data type in the double-precision 64-bit floating point format (IEEE 754)\n   *\n   * @see https://en.wikipedia.org/wiki/Double_precision_floating-point_format\n   */\n  NUMBER: 'number',\n\n  /**\n   * Data type that can represent integers in the arbitrary precision format\n   *\n   * @see https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic\n   */\n  BIGINT: 'bigint',\n\n  /**\n   * Sequence of characters used to represent text.\n   */\n  STRING: 'string',\n\n  /**\n   * Data type Symbol can be referred to as a \"Symbol value\".\n   * In a JavaScript runtime environment, a symbol value is created by invoking the function Symbol,\n   * which dynamically produces an anonymous, unique value.\n   * A symbol may be used as an object property.\n   */\n  SYMBOL: 'symbol',\n\n  /**\n   * Code snippet that can be called by other code or by itself,\n   * or a variable that refers to the function.\n   */\n  FUNCTION: 'function',\n\n  /**\n   * Data type for any objects that can not be categorised otherwise.\n   */\n  OBJECT: 'object'\n};\n\n/**\n * HTTP request methods\n */\nexport const HTTP = {\n  /**\n   * The GET method requests a representation of the specified resource.\n   * Requests using GET should only retrieve data.\n   */\n  GET: 'GET',\n\n  /**\n   * The HEAD method asks for a response identical to a GET request,\n   * but without the response body.\n   */\n  HEAD: 'HEAD',\n\n  /**\n   * The POST method submits an entity to the specified resource,\n   * often causing a change in state or side effects on the server.\n   */\n  POST: 'POST',\n\n  /**\n   * The PUT method replaces all current representations\n   * of the target resource with the request payload.\n   */\n  PUT: 'PUT',\n\n  /**\n   * The DELETE method deletes the specified resource.\n   */\n  DELETE: 'DELETE',\n\n  /**\n   * The CONNECT method establishes a tunnel to the server\n   * identified by the target resource.\n   */\n  CONNECT: 'CONNECT',\n\n  /**\n   * The OPTIONS method describes the communication options for the target resource.\n   */\n  OPTIONS: 'OPTIONS',\n\n  /**\n   * The TRACE method performs a message loop-back test along the path to the target resource.\n   */\n  TRACE: 'TRACE',\n\n  /**\n   * The PATCH method applies partial modifications to a resource.\n   */\n  PATCH: 'PATCH'\n};\n\n/**\n * An HTTP header is a field of an HTTP request or response\n * that passes additional context and metadata about the request or response.\n */\nexport const HTTP_HEADER = {\n\n  AUTHENTICATION: {\n    /**\n     * Defines the authentication method that should be used to access a resource.\n     */\n    WWW_AUTHENTICATE: 'WWW-Authenticate',\n\n    /**\n     * Contains the credentials to authenticate a user-agent with a server.\n     */\n    AUTHORIZATION: 'Authorization',\n\n    /**\n     * Defines the authentication method that should be used to access a\n     * resource behind a proxy server.\n     */\n    PROXY_AUTHENTICATE: 'Proxy-Authenticate',\n\n    /**\n     * Contains the credentials to authenticate a user agent with a proxy server.\n     */\n    PROXY_AUTHORIZATION: 'Proxy-Authorization',\n  },\n\n  CACHING: {\n    /**\n     * The time, in seconds, that the object has been in a proxy cache.\n     */\n    AGE: 'Age',\n\n    /**\n     * Directives for caching mechanisms in both requests and responses.\n     */\n    CACHE_CONTROL: 'Cache-Control',\n\n    /**\n     * Clears browsing data (e.g. cookies, storage, cache)\n     * associated with the requesting website.\n     */\n    CLEAR_SITE_DATA: 'Clear-Site-Data',\n\n    /**\n     * The date/time after which the response is considered stale.\n     */\n    EXPIRES: 'Expires',\n\n    /**\n     * Implementation-specific header that may have various effects anywhere\n     * along the request-response chain. Used for backwards compatibility with\n     * HTTP/1.0 caches where the Cache-Control header is not yet present.\n     */\n    PRAGMA: 'Pragma',\n  },\n\n  /**\n   * HTTP Client hints are a set of request headers that provide useful information\n   * about the client such as device type and network conditions, and allow servers\n   * to optimize what is served for those conditions.\n   * Servers proactively requests the client hint headers they are interested in\n   * from the client using Accept-CH. The client may then choose to include the\n   * requested headers in subsequent requests.\n   */\n  CLIENT_HINTS: {\n    /**\n     * Servers can advertise support for Client Hints using the Accept-CH header\n     * field or an equivalent HTML <meta> element with http-equiv attribute.\n     */\n    ACCEPT_CH: 'Accept-CH',\n\n    /**\n     * Servers can ask the client to remember the set of Client Hints that the\n     * server supports for a specified period of time, to enable delivery of\n     * Client Hints on subsequent requests to the server's origin.\n     */\n    ACCEPT_CH_LIFETIME: 'Accept-CH-Lifetime',\n\n    /**\n     * User agent's branding and version.\n     */\n    SEC_CH_UA: 'Sec-CH-UA',\n\n    /**\n     * User agent's underlying platform architecture.\n     */\n    SEC_CH_UA_ARCH: 'Sec-CH-UA-Arch',\n\n    /**\n     * User agent's underlying CPU architecture bitness (for example \"64\" bit).\n     */\n    SEC_CH_UA_BITNESS: 'Sec-CH-UA-Bitness',\n\n    /**\n     * Full version for each brand in the user agent's brand list.\n     */\n    SEC_CH_UA_FULL_VERSION_LIST: 'Sec-CH-UA-Full-Version-List',\n\n    /**\n     * User agent is running on a mobile device or, more generally, prefers a\n     * \"mobile\" user experience.\n     */\n    SEC_CH_UA_MOBILE: 'Sec-CH-UA-Mobile',\n\n    /**\n     * User agent's device model.\n     */\n    SEC_CH_UA_MODEL: 'Sec-CH-UA-Model',\n\n    /**\n     * User agent's underlying operation system/platform.\n     */\n    SEC_CH_UA_PLATFORM: 'Sec-CH-UA-Platform',\n\n    /**\n     * User agent's underlying operation system version.\n     */\n    SEC_CH_UA_PLATFORM_VERSION: 'Sec-CH-UA-Platform-Version',\n\n    /**\n     * Approximate bandwidth of the client's connection to the server, in Mbps.\n     * This is part of the Network Information API.\n     */\n    DOWNLINK: 'Downlink',\n\n    /**\n     * The effective connection type (\"network profile\") that best matches the\n     * connection's latency and bandwidth. This is part of the Network Information API.\n     */\n    ECT: 'ECT',\n\n    /**\n     * Application layer round trip time (RTT) in milliseconds, which includes\n     * the server processing time. This is part of the Network Information API.\n     */\n    RTT: 'RTT',\n\n    /**\n     * A boolean that indicates the user agent's preference for reduced data usage.\n     */\n    SAVE_DATA: 'Save-Data'\n  },\n\n  CONDITIONALS: {\n    /**\n     * The last modification date of the resource, used to compare several versions\n     * of the same resource. It is less accurate than ETag, but easier to calculate\n     * in some environments. Conditional requests using If-Modified-Since and\n     * If-Unmodified-Since use this value to change the behavior of the request.\n     */\n    LAST_MODIFIED: 'Last-Modified',\n\n    /**\n     * A unique string identifying the version of the resource. Conditional requests\n     * using If-Match and If-None-Match use this value to change the behavior of the request.\n     */\n    ETAG: 'ETag',\n\n    /**\n     * Makes the request conditional, and applies the method only if the stored\n     * resource matches one of the given ETags.\n     */\n    IF_MATCH: 'If-Match',\n\n    /**\n     * Makes the request conditional, and applies the method only if the stored\n     * resource doesn't match any of the given ETags. This is used to update caches\n     * (for safe requests), or to prevent uploading a new resource when one already exists.\n     */\n    IF_NONE_MATCH: 'If-None-Match',\n\n    /**\n     * Makes the request conditional, and expects the resource to be transmitted only\n     * if it has been modified after the given date. This is used to transmit data\n     * only when the cache is out of date.\n     */\n    IF_MODIFIED_SINCE: 'If-Modified-Since',\n\n    /**\n     * Makes the request conditional, and expects the resource to be transmitted only\n     * if it has not been modified after the given date. This ensures the coherence of\n     * a new fragment of a specific range with previous ones, or to implement an\n     * optimistic concurrency control system when modifying existing documents.\n     */\n    IF_UNMODIFIED_SINCE: 'If-Unmodified-Since',\n\n    /**\n     * Determines how to match request headers to decide whether a cached response\n     * can be used rather than requesting a fresh one from the origin server.\n     */\n    VARY: 'Vary'\n  },\n\n  CONNECTION_MANAGEMENT: {\n    /**\n     * Controls whether the network connection stays open after the current transaction finishes.\n     */\n    CONNECTION: 'Connection',\n\n    /**\n     * Controls how long a persistent connection should stay open.\n     */\n    KEEP_ALIVE: 'Keep-Alive'\n  },\n\n  CONTENT_NEGOTIATION: {\n    /**\n     * Informs the server about the types of data that can be sent back.\n     */\n    ACCEPT: 'Accept',\n\n    /**\n     * The encoding algorithm, usually a compression algorithm, that can be\n     * used on the resource sent back.\n     */\n    ACCEPT_ENCODING: 'Accept-Encoding',\n\n    /**\n     * Informs the server about the human language the server is expected\n     * to send back. This is a hint and is not necessarily under the full control\n     * of the user: the server should always pay attention not to override an\n     * explicit user choice (like selecting a language from a dropdown).\n     */\n    ACCEPT_LANGUAGE: 'Accept-Language'\n  },\n\n  CONTROLS: {\n    /**\n     * Indicates expectations that need to be fulfilled by the server to\n     * properly handle the request.\n     */\n    EXPECT: 'Expect',\n\n    /**\n     * When using TRACE, indicates the maximum number of hops the request\n     * can do before being reflected to the sender.\n     */\n    MAX_FORWARDS: 'Max-Forwards'\n  },\n\n  COOKIES: {\n    /**\n     * Contains stored HTTP cookies previously sent by the server with\n     * the Set-Cookie header.\n     */\n    COOKIE: 'Cookie',\n\n    /**\n     * Send cookies from the server to the user-agent.\n     */\n    SET_COOKIE: 'Set-Cookie'\n  },\n\n  CORS: {\n    /**\n     * Indicates whether the response can be shared.\n     */\n    ACCESS_CONTROL_ALLOW_ORIGIN: 'Access-Control-Allow-Origin',\n\n    /**\n     * Indicates whether the response to the request can be exposed when\n     * the credentials flag is true.\n     */\n    ACCESS_CONTROL_ALLOW_CREDENTIALS: 'Access-Control-Allow-Credentials',\n\n    /**\n     * Used in response to a preflight request to indicate which HTTP headers\n     * can be used when making the actual request.\n     */\n    ACCESS_CONTROL_ALLOW_HEADERS: 'Access-Control-Allow-Headers',\n\n    /**\n     * Specifies the methods allowed when accessing the resource in response\n     * to a preflight request.\n     */\n    ACCESS_CONTROL_ALLOW_METHODS: 'Access-Control-Allow-Methods',\n\n    /**\n     * Indicates which headers can be exposed as part of the response\n     * by listing their names.\n     */\n    ACCESS_CONTROL_EXPOSE_HEADERS: 'Access-Control-Expose-Headers',\n\n    /**\n     * Indicates how long the results of a preflight request can be cached.\n     */\n    ACCESS_CONTROL_MAX_AGE: 'Access-Control-Max-Age',\n\n    /**\n     * Used when issuing a preflight request to let the server know which HTTP headers\n     * will be used when the actual request is made.\n     */\n    ACCESS_CONTROL_REQUEST_HEADERS: 'Access-Control-Request-Headers',\n\n    /**\n     * Used when issuing a preflight request to let the server know which HTTP method\n     * will be used when the actual request is made.\n     */\n    ACCESS_CONTROL_REQUEST_METHOD: 'Access-Control-Request-Method',\n\n    /**\n     * Indicates where a fetch originates from.\n     */\n    ORIGIN: 'Origin',\n\n    /**\n     * Specifies origins that are allowed to see values of attributes retrieved via\n     * features of the Resource Timing API, which would otherwise be reported as\n     * zero due to cross-origin restrictions.\n     */\n    TIMING_ALLOW_ORIGIN: 'Timing-Allow-Origin'\n  },\n\n  DOWNLOADS: {\n    /**\n     * Indicates if the resource transmitted should be displayed inline\n     * (default behavior without the header), or if it should be handled like\n     * a download and the browser should present a \"Save As\" dialog.\n     */\n    CONTENT_DISPOSITION: 'Content-Disposition'\n  },\n\n  MESSAGE_BODY: {\n    /**\n     * The size of the resource, in decimal number of bytes.\n     */\n    CONTENT_LENGTH: 'Content-Length',\n\n    /**\n     * Indicates the media type of the resource.\n     */\n    CONTENT_TYPE: 'Content-Type',\n\n    /**\n     * Used to specify the compression algorithm.\n     */\n    CONTENT_ENCODING: 'Content-Encoding',\n\n    /**\n     * Describes the human language(s) intended for the audience, so that it\n     * allows a user to differentiate according to the users' own preferred language.\n     */\n    CONTENT_LANGUAGE: 'Content-Language',\n\n    /**\n     * Indicates an alternate location for the returned data.\n     */\n    CONTENT_LOCATION: 'Content-Location'\n  },\n\n  PROXIES: {\n    /**\n     * Contains information from the client-facing side of proxy servers that\n     * is altered or lost when a proxy is involved in the path of the request.\n     */\n    FORWARDED: 'Forwarded',\n\n    /**\n     * Identifies the originating IP addresses of a client connecting to a\n     * web server through an HTTP proxy or a load balancer.\n     */\n    X_FORWARDED_FOR: 'X-Forwarded-For',\n\n    /**\n     * Identifies the original host requested that a client used to connect to\n     * your proxy or load balancer.\n     */\n    X_FORWARDED_HOST: 'X-Forwarded-Host',\n\n    /**\n     * Identifies the protocol (HTTP or HTTPS) that a client used to connect to\n     * your proxy or load balancer.\n     */\n    X_FORWARDED_PROTO: 'X-Forwarded-Proto',\n\n    /**\n     * Added by proxies, both forward and reverse proxies, and can appear in\n     * the request headers and the response headers.\n     */\n    VIA: 'Via'\n  },\n\n  REDIRECTS: {\n    /**\n     * Indicates the URL to redirect a page to.\n     */\n    LOCATION: 'Location'\n  },\n\n  REQUEST_CONTEXT: {\n    /**\n     * Contains an Internet email address for a human user who controls the\n     * requesting user agent.\n     */\n    FROM: 'From',\n\n    /**\n     * Specifies the domain name of the server (for virtual hosting), and\n     * (optionally) the TCP port number on which the server is listening.\n     */\n    HOST: 'Host',\n\n    /**\n     * The address of the previous web page from which a link to the currently\n     * requested page was followed.\n     */\n    REFERER: 'Referer',\n\n    /**\n     * Governs which referrer information sent in the Referer header should be\n     * included with requests made.\n     */\n    REFERRER_POLICY: 'Referrer-Policy',\n\n    /**\n     * Contains a characteristic string that allows the network protocol peers\n     * to identify the application type, operating system, software vendor or\n     * software version of the requesting software user agent. See also the Firefox\n     * user agent string reference.\n     */\n    USER_AGENT: 'User-Agent'\n  },\n\n  RESPONSE_CONTEXT: {\n    /**\n     * Lists the set of HTTP request methods supported by a resource.\n     */\n    ALLOW: 'Allow',\n\n    /**\n     * Contains information about the software used by the origin server to\n     * handle the request.\n     */\n    SERVER: 'Server'\n  },\n\n  RANGE_REQUESTS: {\n    /**\n     * Indicates if the server supports range requests, and if so in which\n     * unit the range can be expressed.\n     */\n    ACCEPT_RANGES: 'Accept-Ranges',\n\n    /**\n     * Indicates the part of a document that the server should return.\n     */\n    RANGE: 'Range',\n\n    /**\n     * Creates a conditional range request that is only fulfilled if the given\n     * etag or date matches the remote resource. Used to prevent downloading two\n     * ranges from incompatible version of the resource.\n     */\n    IF_RANGE: 'If-Range',\n\n    /**\n     * Indicates where in a full body message a partial message belongs.\n     */\n    CONTENT_RANGE: 'Content-Range'\n  },\n\n  SECURITY: {\n    /**\n     * Allows a server to declare an embedder policy for a given document.\n     */\n    CROSS_ORIGIN_EMBEDDER_POLICY: 'Cross-Origin-Embedder-Policy',\n\n    /**\n     * Prevents other domains from opening/controlling a window.\n     */\n    CROSS_ORIGIN_OPENER_POLICY: 'Cross-Origin-Opener-Policy',\n\n    /**\n     * Prevents other domains from reading the response of the resources to\n     * which this header is applied.\n     */\n    CROSS_ORIGIN_RESOURCE_POLICY: 'Cross-Origin-Resource-Policy',\n\n    /**\n     * Controls resources the user agent is allowed to load for a given page.\n     */\n    CONTENT_SECURITY_POLICY: 'Content-Security-Policy',\n\n    /**\n     * Allows web developers to experiment with policies by monitoring, but not\n     * enforcing, their effects. These violation reports consist of JSON documents\n     * sent via an HTTP POST request to the specified URI.\n     */\n    CONTENT_SECURITY_POLICY_REPORT_ONLY: 'Content-Security-Policy-Report-Only',\n\n    /**\n     * Allows sites to opt in to reporting and/or enforcement of\n     * Certificate Transparency requirements, which prevents the use of misissued\n     * certificates for that site from going unnoticed. When a site enables the\n     * Expect-CT header, they are requesting that Chrome check that any certificate\n     * for that site appears in public CT logs.\n     */\n    EXPECT_CT: 'Expect-CT',\n\n    /**\n     * Provides a mechanism to allow and deny the use of browser features in its\n     * own frame, and in iframes that it embeds.\n     */\n    FEATURE_POLICY: 'Feature-Policy',\n\n    /**\n     * Provides a mechanism to allow web applications to isolate their origins.\n     */\n    ORIGIN_ISOLATION: 'Origin-Isolation',\n\n    /**\n     * Force communication using HTTPS instead of HTTP.\n     */\n    STRICT_TRANSPORT_SECURITY: 'Strict-Transport-Security',\n\n    /**\n     * Sends a signal to the server expressing the client's preference for an\n     * encrypted and authenticated response, and that it can successfully handle\n     * the upgrade-insecure-requests directive.\n     */\n    UPGRADE_INSECURE_REQUESTS: 'Upgrade-Insecure-Requests',\n\n    /**\n     * Disables MIME sniffing and forces browser to use the type given in Content-Type.\n     */\n    X_CONTENT_TYPE_OPTIONS: 'X-Content-Type-Options',\n\n    /**\n     * The X-Download-Options HTTP header indicates that the browser\n     * (Internet Explorer) should not display the option to \"Open\" a file that\n     * has been downloaded from an application, to prevent phishing attacks as\n     * the file otherwise would gain access to execute in the context of the application.\n     */\n    X_DOWNLOAD_OPTIONS: 'X-Download-Options',\n\n    /**\n     * Indicates whether a browser should be allowed to render a page in a\n     * <frame>, <iframe>, <embed> or <object>.\n     */\n    X_FRAME_OPTIONS: 'X-Frame-Options',\n\n    /**\n     * Specifies if a cross-domain policy file (crossdomain.xml) is allowed.\n     * The file may define a policy to grant clients, such as Adobe's Flash Player\n     * (now obsolete), Adobe Acrobat, Microsoft Silverlight (now obsolete),\n     * or Apache Flex, permission to handle data across domains that would\n     * otherwise be restricted due to the Same-Origin Policy.\n     */\n    X_PERMITTED_CROSS_DOMAIN_POLICIES: 'X-Permitted-Cross-Domain-Policies',\n\n    /**\n     * May be set by hosting environments or other frameworks and contains i\n     * nformation about them while not providing any usefulness to the\n     * application or its visitors. Unset this header to avoid exposing\n     * potential vulnerabilities.\n     */\n    X_POWERED_BY: 'X-Powered-By',\n\n    /**\n     * Enables cross-site scripting filtering.\n     */\n    X_XSS_PROTECTION: 'X-XSS-Protection',\n\n    /**\n     * It is a request header that indicates the relationship between a request\n     * initiator's origin and its target's origin. It is a Structured Header\n     * whose value is a token with possible values cross-site, same-origin,\n     * same-site, and none.\n     */\n    SEC_FETCH_SITE: 'Sec-Fetch-Site',\n\n    /**\n     * It is a request header that indicates the request's mode to a server.\n     * It is a Structured Header whose value is a token with possible values\n     * cors, navigate, no-cors, same-origin, and websocket.\n     */\n    SEC_FETCH_MODE: 'Sec-Fetch-Mode',\n\n    /**\n     * It is a request header that indicates whether or not a navigation request\n     * was triggered by user activation. It is a Structured Header whose value\n     * is a boolean so possible values are ?0 for false and ?1 for true.\n     */\n    SEC_FETCH_USER: 'Sec-Fetch-User',\n\n    /**\n     * It is a request header that indicates the request's destination to a server.\n     * It is a Structured Header whose value is a token with possible values audio,\n     * audioworklet, document, embed, empty, font, image, manifest, object,\n     * paintworklet, report, script, serviceworker, sharedworker, style, track,\n     * video, worker, and xslt.\n     */\n    SEC_FETCH_DEST: 'Sec-Fetch-Dest',\n\n    /**\n     * A request header sent in preemptive request to fetch() a resource during\n     * service worker boot. The value, which is set with\n     * NavigationPreloadManager.setHeaderValue(), can be used to inform a server\n     * that a different resource should be returned than in a normal fetch() operation.\n     */\n    SERVICE_WORKER_NAVIGATION_PRELOAD: 'Service-Worker-Navigation-Preload',\n  },\n\n  TRANSFER_CODING: {\n    /**\n     * Specifies the form of encoding used to safely transfer the resource to the user.\n     */\n    TRANSFER_ENCODING: 'Transfer-Encoding',\n\n    /**\n     * Specifies the transfer encodings the user agent is willing to accept.\n     */\n    TE: 'TE',\n\n    /**\n     * Allows the sender to include additional fields at the end of chunked message.\n     */\n    TRAILER: 'Trailer'\n  },\n\n  OTHER: {\n    /**\n     * A client can express the desired push policy for a request by sending an\n     * Accept-Push-Policy header field in the request.\n     */\n    ACCEPT_PUSH_POLICY: 'Accept-Push-Policy',\n\n    /**\n     * A client can send the Accept-Signature header field to indicate intention\n     * to take advantage of any available signatures and to indicate what kinds\n     * of signatures it supports.\n     */\n    ACCEPT_SIGNATURE: 'Accept-Signature',\n\n    /**\n     * Used to list alternate ways to reach this service.\n     */\n    ALT_SVC: 'Alt-Svc',\n\n    /**\n     * Contains the date and time at which the message was originated.\n     */\n    DATE: 'Date',\n\n    /**\n     * Indicates that the request has been conveyed in TLS early data.\n     */\n    EARLY_DATA: 'Early-Data',\n\n    /**\n     * The Link entity-header field provides a means for serializing one or more\n     * links in HTTP headers. It is semantically equivalent to the HTML <link> element.\n     */\n    LINK: 'Link',\n\n    /**\n     * A Push-Policy defines the server behavior regarding push when processing a request.\n     */\n    PUSH_POLICY: 'Push-Policy',\n\n    /**\n     * Indicates how long the user agent should wait before making a follow-up request.\n     */\n    RETRY_AFTER: 'Retry-After',\n\n    /**\n     * The Signature header field conveys a list of signatures for an exchange,\n     * each one accompanied by information about how to determine the authority\n     * of and refresh that signature.\n     */\n    SIGNATURE: 'Signature',\n\n    /**\n     * The Signed-Headers header field identifies an ordered list of response\n     * header fields to include in a signature.\n     */\n    SIGNED_HEADERS: 'Signed-Headers',\n\n    /**\n     * Communicates one or more metrics and descriptions for the given\n     * request-response cycle.\n     */\n    SERVER_TIMING: 'Server-Timing',\n\n    /**\n     * Used to remove the path restriction by including this header in the\n     * response of the Service Worker script.\n     */\n    SERVICE_WORKER_ALLOWED: 'Service-Worker-Allowed',\n\n    /**\n     * Links generated code to a source map.\n     */\n    SOURCEMAP: 'SourceMap',\n\n    /**\n     * The relevant RFC document for the Upgrade header field is RFC 9110,\n     * section 7.8. The standard establishes rules for upgrading or changing to\n     * a different protocol on the current client, server, transport protocol\n     * connection. For example, this header standard allows a client to change\n     * from HTTP 1.1 to WebSocket, assuming the server decides to acknowledge\n     * and implement the Upgrade header field. Neither party is required to\n     * accept the terms specified in the Upgrade header field. It can be used in\n     * both client and server headers. If the Upgrade header field is specified,\n     * then the sender MUST also send the Connection header field with the\n     * upgrade option specified.\n     */\n    UPGRADE: 'Upgrade',\n\n    /**\n     * Controls DNS prefetching, a feature by which browsers proactively perform\n     * domain name resolution on both links that the user may choose to follow\n     * as well as URLs for items referenced by the document, including images,\n     * CSS, JavaScript, and so forth.\n     */\n    X_DNS_PREFETCH_CONTROL: 'X-DNS-Prefetch-Control'\n  }\n};\n\n/**\n * Media Types\n * @see https://www.iana.org/assignments/media-types/media-types.xhtml\n */\nexport const MIME = {\n  /**\n   * AAC audio\n   */\n  AAC: 'audio/aac',\n\n  /**\n   * AbiWord document\n   */\n  ABW: 'application/x-abiword',\n\n  /**\n   * Archive document (multiple files embedded)\n   */\n  ARC: 'application/x-freearc',\n\n  /**\n   * AVIF image\n   */\n  AVIF: 'image/avif',\n\n  /**\n   * AVI: Audio Video Interleave\n   */\n  AVI: 'video/x-msvideo',\n\n  /**\n   * Amazon Kindle eBook format\n   */\n  AZW: 'application/vnd.amazon.ebook',\n\n  /**\n   * Any kind of binary data\n   */\n  BIN: 'application/octet-stream',\n\n  /**\n   * Windows OS/2 Bitmap Graphics\n   */\n  BMP: 'image/bmp',\n\n  /**\n   * BZip archive\n   */\n  BZ: 'application/x-bzip',\n\n  /**\n   * BZip2 archive\n   */\n  BZ2: 'application/x-bzip2',\n\n  /**\n   * CD audio\n   */\n  CDA: 'application/x-cdf',\n\n  /**\n   * C-Shell script\n   */\n  CSH: 'application/x-csh',\n\n  /**\n   * Cascading Style Sheets (CSS)\n   */\n  CSS: 'text/css',\n\n  /**\n   * Comma-separated values (CSV)\n   */\n  CSV: 'text/csv',\n\n  /**\n   * Microsoft Word\n   */\n  DOC: 'application/msword',\n\n  /**\n   * Microsoft Word (OpenXML)\n   */\n  DOCX: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',\n\n  /**\n   * MS Embedded OpenType fonts\n   */\n  EOT: 'application/vnd.ms-fontobject',\n\n  /**\n   * Electronic publication (EPUB)\n   */\n  EPUB: 'application/epub+zip',\n\n  /**\n   * GZip Compressed Archive\n   */\n  GZ: 'application/gzip',\n\n  /**\n   * Graphics Interchange Format (GIF)\n   */\n  GIF: 'image/gif',\n\n  /**\n   * HyperText Markup Language (HTML)\n   */\n  HTML: 'text/html',\n\n  /**\n   * Icon format\n   */\n  ICO: 'image/vnd.microsoft.icon',\n\n  /**\n   * iCalendar format\n   */\n  ICS: 'text/calendar',\n\n  /**\n   * Java Archive (JAR)\n   */\n  JAR: 'application/java-archive',\n\n  /**\n   * JPEG images\n   */\n  JPG: 'image/jpeg',\n\n  /**\n   * JavaScript\n   */\n  JS: 'text/javascript',\n\n  /**\n   * JSON format\n   */\n  JSON: 'application/json',\n\n  /**\n   * JSON-LD format\n   */\n  JSONLD: 'application/ld+json',\n\n  /**\n   * Machine-readable details of errors in a HTTP response\n   *\n   * @see https://www.rfc-editor.org/rfc/rfc7807\n   */\n  JSON_PROBLEM: 'application/problem+json',\n\n  /**\n   * Markdown markup language\n   */\n  MD: 'text/markdown',\n\n  /**\n   * Musical Instrument Digital Interface (MIDI)\n   */\n  MIDI: 'audio/midi audio/x-midi',\n\n  /**\n   * JavaScript module\n   */\n  MJS: 'text/javascript',\n\n  /**\n   * MP3 audio\n   */\n  MP3: 'audio/mpeg',\n\n  /**\n   * MP4 video\n   */\n  MP4: 'video/mp4',\n\n  /**\n   * MPEG Video\n   */\n  MPEG: 'video/mpeg',\n\n  /**\n   * Apple Installer Package\n   */\n  MPKG: 'application/vnd.apple.installer+xml',\n\n  /**\n   * OpenDocument presentation document\n   */\n  ODP: 'application/vnd.oasis.opendocument.presentation',\n\n  /**\n   * OpenDocument spreadsheet document\n   */\n  ODS: 'application/vnd.oasis.opendocument.spreadsheet',\n\n  /**\n   * OpenDocument text document\n   */\n  ODT: 'application/vnd.oasis.opendocument.text',\n\n  /**\n   * OGG audio\n   */\n  OGA: 'audio/ogg',\n\n  /**\n   * OGG video\n   */\n  OGV: 'video/ogg',\n\n  /**\n   * OGG\n   */\n  OGX: 'application/ogg',\n\n  /**\n   * Opus audio\n   */\n  OPUS: 'audio/opus',\n\n  /**\n   * OpenType font\n   */\n  OTF: 'font/otf',\n\n  /**\n   * Portable Network Graphics\n   */\n  PNG: 'image/png',\n\n  /**\n   * Adobe Portable Document Format (PDF)\n   */\n  PDF: 'application/pdf',\n\n  /**\n   * Hypertext Preprocessor (Personal Home Page)\n   */\n  PHP: 'application/x-httpd-php',\n\n  /**\n   * Microsoft PowerPoint\n   */\n  PPT: 'application/vnd.ms-powerpoint',\n\n  /**\n   * Microsoft PowerPoint (OpenXML)\n   */\n  PPTX: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',\n\n  /**\n   * RAR archive\n   */\n  RAR: 'application/vnd.rar',\n\n  /**\n   * Rich Text Format (RTF)\n   */\n  RTF: 'application/rtf',\n\n  /**\n   * Bourne shell script\n   */\n  SH: 'application/x-sh',\n\n  /**\n   * Scalable Vector Graphics (SVG)\n   */\n  SVG: 'image/svg+xml',\n\n  /**\n   * Tape Archive (TAR)\n   */\n  TAR: 'application/x-tar',\n\n  /**\n   * Tagged Image File Format (TIFF)\n   */\n  TIFF: 'image/tiff',\n\n  /**\n   * MPEG transport stream\n   */\n  TS: 'video/mp2t',\n\n  /**\n   * TrueType Font\n   */\n  TTF: 'font/ttf',\n\n  /**\n   * Text, (generally ASCII or ISO 8859-n)\n   */\n  TXT: 'text/plain',\n\n  /**\n   * Microsoft Visio\n   */\n  VSD: 'application/vnd.visio',\n\n  /**\n   * Waveform Audio Format\n   */\n  WAV: 'audio/wav',\n\n  /**\n   * WEBM audio\n   */\n  WEBA: 'audio/webm',\n\n  /**\n   * WEBM video\n   */\n  WEBM: 'video/webm',\n\n  /**\n   * WEBP image\n   */\n  WEBP: 'image/webp',\n\n  /**\n   * Web Open Font Format (WOFF)\n   */\n  WOFF: 'font/woff',\n\n  /**\n   * Web Open Font Format (WOFF)\n   */\n  WOFF2: 'font/woff2',\n\n  /**\n   * XHTML\n   */\n  XHTML: 'application/xhtml+xml',\n\n  /**\n   * Microsoft Excel\n   */\n  XLS: 'application/vnd.ms-excel',\n\n  /**\n   * Microsoft Excel (OpenXML)\n   */\n  XLSX: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n\n  /**\n   * XML\n   */\n  XML: 'application/xml',\n\n  /**\n   * XUL\n   */\n  XUL: 'application/vnd.mozilla.xul+xml',\n\n  /**\n   * ZIP archive\n   */\n  ZIP: 'application/zip',\n\n  /**\n   * 7-zip archive\n   */\n  Z7: 'application/x-7z-compressed'\n};\n\n/**\n * Available types of notations for serialising nested objects into URL query parameters\n * @see https://datatracker.ietf.org/doc/html/rfc3986#section-3\n */\nexport const URL_PARAM_NOTATION = {\n  /**\n   * Dot notation\n   */\n  DOT: '.',\n\n  /**\n   * Bracket notation\n   */\n  BRACKET: '[]',\n};\n","/**\n * Returns the string in canonical form.\n * Canonical form is a list of segments that can be used as input for letter case transformations\n *\n * @param {string} input String to be represented as canonical segments\n * @returns {string[]} Canonical form of the input string\n */\nfunction canonicalForm(input) {\n  const segments = input\n    // Handle non-alphanumeric or separator characters as whitespaces\n    .replace(/[^a-zA-Z0-9. _-]/g, ' ')\n    // Let's split string by separator characters\n    .split(/[. _-]/);\n\n  let canonical = [];\n\n  // Take case switches and numbers into account\n  segments.forEach((segment) => {\n    const dashed = segment.replace(/([A-Z]|\\d+)/g, '-$1').toLowerCase().trim();\n    canonical = canonical.concat(dashed.split('-'));\n  });\n\n  return canonical.filter((s) => !!s);\n}\n\n/**\n * Transforms the string to its canonical form, applies preparator to each segment\n * and returns the joined string\n *\n * @param {string} input String to be converted\n * @param {string} separator Character(s) used when joining canonical segments\n * @param {Function | null} prepare Function to be applied to each canonical segment\n * @returns {string} Input string represented in the requested case\n */\nfunction convertCase(input, separator, prepare = null) {\n  if (!input) {\n    return '';\n  }\n\n  const canonical = canonicalForm(input);\n\n  if (typeof (prepare) === 'function') {\n    for (let i = 0; i < canonical.length; i++) {\n      canonical[i] = prepare(canonical[i]);\n    }\n  }\n\n  return canonical.join(separator);\n}\n\nObject.assign(String.prototype, {\n  /**\n   * Returns the string in PascalCase\n   *\n   * @returns {string} The input string in PascalCase\n   */\n  toPascalCase: function pascalCase() {\n    return convertCase(this, '', (s) => s[0].toUpperCase() + s.substring(1));\n  },\n\n  /**\n   * Returns the string in camelCase\n   *\n   * @returns {string} The input string in camelCase\n   */\n  toCamelCase: function camelCase() {\n    const pc = this.toPascalCase();\n    return !pc ? '' : pc[0].toLowerCase() + pc.substring(1);\n  },\n\n  /**\n   * Returns the string in Title Case\n   *\n   * @returns {string} The input string in Title Case\n   */\n  toTitleCase: function titleCase() {\n    return convertCase(this, ' ', (s) => s[0].toUpperCase() + s.substring(1));\n  },\n\n  /**\n   * Returns the string in dot.case\n   *\n   * @returns {string} The input string in dot.case\n   */\n  toDotCase: function dotCase() {\n    return convertCase(this, '.');\n  },\n\n  /**\n   * Returns the string in snake_case\n   *\n   * @returns {string} The input string in snake_case\n   */\n  toSnakeCase: function snakeCase() {\n    return convertCase(this, '_');\n  },\n\n  /**\n   * Returns the string in SCREAMING_SNAKE_CASE\n   *\n   * @returns {string} The input string in SCREAMING_SNAKE_CASE\n   */\n  toScreamingSnakeCase: function snakeCase() {\n    return this.toSnakeCase().toUpperCase();\n  },\n\n  /**\n   * Returns the string in dash-case\n   *\n   * @returns {string} The input string in dash-case\n   */\n  toDashCase: function dashCase() {\n    return convertCase(this, '-');\n  }\n});\n","Object.assign(Date, {\n  /**\n   * Determines whether the value is a date\n   *\n   * @param {any} date Value to be checked\n   * @returns {boolean} True if the value is a date\n   */\n  isDate(date) {\n    return Object.prototype.toString.call(date) === '[object Date]'\n      && !Number.isNaN(date.valueOf());\n  }\n});\n","import { TYPE } from './constants.mjs';\nimport './date.ext.mjs';\n\nObject.assign(Object, {\n  /**\n   * Return true if the examined object is plain\n   *\n   * @param {any} obj Input to be examined\n   * @returns {boolean} True if the input is a plain object\n   */\n  isPlain(obj) {\n    // Detect obvious negatives\n    if (!obj || toString.call(obj) !== '[object Object]') {\n      return false;\n    }\n\n    const proto = Object.getPrototypeOf(obj);\n\n    // Objects with no prototype (e.g., `Object.create( null )`) are plain\n    if (!proto) {\n      return true;\n    }\n\n    // Objects with prototype are plain if they were constructed by a global Object function\n    const ctor = Object.hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n    return typeof ctor === TYPE.FUNCTION && ctor.toString() === Object.toString();\n  },\n\n  /**\n   * Merges the contents of two or more objects together into the first one.\n   *\n   * @param {...any} arg List of objects to be merged\n   * @returns {object} The merged object\n   */\n  merge(...arg) {\n    const trg = arg[0] || {};\n\n    for (let i = 1; i < arg.length; i++) {\n      const obj = arg[i];\n\n      if (!obj) {\n        continue;\n      }\n\n      Object.keys(obj).forEach((key) => {\n        if (typeof obj[key] === TYPE.OBJECT) {\n          if (Array.isArray(obj[key])) {\n            trg[key] = obj[key].slice(0);\n          } else if (obj[key] !== null) {\n            trg[key] = Object.isPlain(obj[key])\n              ? Object.merge(trg[key], obj[key])\n              : obj[key];\n          } else {\n            trg[key] = null;\n          }\n        } else {\n          trg[key] = obj[key];\n        }\n      });\n    }\n\n    return trg;\n  },\n\n  /**\n   * Returns the value represented by the name/value pair that should be serialized.\n   * Dates get serialised to ISO 8601 GMT string.\n   *\n   * @param {any} obj Value to be prepared for serialisation\n   * @returns {object} The prepared object for serialisation\n   */\n  toJSON(obj) {\n    if (!obj) {\n      return obj;\n    }\n\n    const json = typeof (obj.toJSON) === TYPE.FUNCTION\n      ? obj.toJSON()\n      : obj;\n\n    if (typeof (json) === TYPE.OBJECT) {\n      const members = Object.keys(json);\n\n      members.forEach((member) => {\n        if (Date.isDate(json[member])) {\n          json[member] = json[member].toISOString();\n        } else if (Array.isArray(json[member])) {\n          for (let i = 0; i < json[member].length; i++) {\n            json[member][i] = Object.toJSON(json[member][i]);\n          }\n        } else {\n          json[member] = Object.toJSON(json[member]);\n        }\n      });\n    }\n\n    return json;\n  },\n\n  /**\n   * Collects all own and inherited property descriptors of an object\n   *\n   * @param {object} obj Object to inspect\n   * @returns {object} All property descriptors\n   */\n  propertyDescriptorsOf(obj) {\n    const\n      objPrototype = Object.getPrototypeOf(obj),\n      descriptors = Object.getOwnPropertyDescriptors(obj);\n\n    if (!Object.getOwnPropertyDescriptor(objPrototype, 'hasOwnProperty')) {\n      const prototypeDescriptors = Object.propertyDescriptorsOf(objPrototype);\n      delete prototypeDescriptors.constructor;\n\n      Object.assign(descriptors, prototypeDescriptors);\n    }\n\n    return descriptors;\n  }\n});\n","import { TYPE, URL_PARAM_NOTATION } from './constants.mjs';\n\nObject.assign(URL, {\n  /**\n   * Determines whether the value is a URL\n   *\n   * @param {any} url Value to be checked\n   * @returns {boolean} True if the value is a URL\n   */\n  isURL(url) {\n    return !!url && typeof url === TYPE.OBJECT && url.constructor?.name === 'URL';\n  }\n});\n\nObject.assign(URL.prototype, {\n\n  /**\n   * Adds parameters to the URL recursively\n   *\n   * @param {any} values Parameters to be added\n   * @param {string} key Key of the parameter\n   * @param {string} notation Notation for nested parameters\n   * @returns {void}\n   * @throws {Error} In case of unsupported notation\n   * @example\n   * const url = new URL('https://example.com');\n   * url.addParams({ foo: 'bar', baz: { qux: 'quux' } });\n   * console.log(url.toString()); // https://example.com/?foo=bar&baz.qux=quux\n   * @example\n   * const url = new URL('https://example.com');\n   * url.addParams({ foo: 'bar', baz: { qux: 'quux' } }, null, URL_PARAM_NOTATION.BRACKET);\n   * console.log(url.toString()); // https://example.com/?foo=bar&baz%5Bqux%5D=quux\n   */\n  addParams(values, key = null, notation = '.') {\n    if (!values) {\n      return;\n    }\n\n    if (typeof values === TYPE.OBJECT) {\n      Object.entries(values).forEach(([k, v]) => {\n        let subKey;\n        switch (notation) {\n          case URL_PARAM_NOTATION.BRACKET:\n            subKey = key ? `${key}[${k}]` : k;\n            break;\n\n          case URL_PARAM_NOTATION.DOT:\n            subKey = key ? `${key}.${k}` : k;\n            break;\n\n          default:\n            throw new Error(`Unsupported notation: ${notation}`);\n        }\n        this.addParams(v, subKey, notation);\n      });\n    } else {\n      this.searchParams.append(key, values);\n    }\n  }\n});\n","import '../object.ext.mjs';\nimport '../date.ext.mjs';\nimport { TYPE } from '../constants.mjs';\n\n/**\n * Mapper class that maps properties from a source object to a target object\n */\nexport default class Mapper {\n  #source;\n\n  /**\n   * If true then properties where the source values is undefined will be ignored\n   *\n   * @type {boolean}\n   */\n  ignoreUndefined = true;\n\n  constructor(source) {\n    /* eslint new-cap: [\"error\", { \"newIsCap\": false }] */\n    this.#source = typeof (source) === TYPE.FUNCTION ? new source() : source;\n  }\n\n  /**\n   * Creates a new mapper configured with the source object\n   *\n   * @param {object} source Object storing data to be mapped to a target\n   * @returns {Mapper} A new mapper instance configured with the source object\n   */\n  static from(source) {\n    return new Mapper(source);\n  }\n\n  /**\n   * Performs the mapping onto a target object\n   *\n   * @param {object} target Object that receives data from the source\n   * @returns {object} The mapped result\n   */\n  to(target) {\n    return typeof (target) === TYPE.FUNCTION\n      ? this.#map(new target())\n      : this.#map(target);\n  }\n\n  /* eslint no-param-reassign: [\"error\", { \"props\": false }] */\n  /**\n   * Maps the source object to the target object\n   *\n   * @param {object} target Object of which properties are to be set\n   * @param {object} source Source object for recursive mapping\n   * @returns {object} The mapped object\n   */\n  #map(target, source) {\n    const\n      descriptors = Object.propertyDescriptorsOf(target),\n      sourceObj = source ?? this.#source;\n\n    Object.keys(descriptors)\n      .filter((property) => descriptors[property].writable === true\n        || descriptors[property].set !== undefined)\n      .forEach((property) => {\n        const\n          sourceProperty = Object.getOwnPropertyDescriptor(sourceObj, property),\n          sourceValue = sourceObj[property];\n\n        if (sourceProperty && (!this.ignoreUndefined || sourceValue !== undefined)) {\n          if (target[property] == null) {\n            target[property] = sourceValue;\n          } else if (Date.isDate(target[property])) {\n            target[property] = Date.isDate(sourceValue)\n              ? sourceValue\n              : new Date(sourceValue);\n          } else if (URL.isURL(target[property])) {\n            target[property] = URL.isURL(sourceValue)\n              ? sourceValue\n              : new URL(sourceValue);\n          } else if (Array.isArray(target[property])) {\n            if (sourceValue == null) {\n              target[property] = null;\n            } else if (typeof (sourceValue) === TYPE.STRING) {\n              target[property] = sourceValue.split(',');\n            } else if (Array.isArray(sourceValue)) {\n              // We try to map two arrays but class definition might only be\n              // available on the target\n\n              if (target[property].length) {\n                let ItemType;\n                switch (typeof (target[property][0])) {\n                  case TYPE.OBJECT:\n                    // We infer the item type from the first target item and use it for the mapping\n                    ItemType = target[property][0].constructor;\n                    target[property] = sourceValue.map((item) => this.#map(new ItemType(), item));\n                    break;\n\n                  default:\n                    // The target is a list of primitive type items\n                    target[property] = [].concat(sourceValue);\n                    break;\n                }\n              } else {\n                // We do not have class definition inferred\n                target[property] = [].concat(sourceValue);\n              }\n            } else {\n              throw new Error(`Invalid source value for property ${property}`);\n            }\n          } else if (typeof (target[property]) === TYPE.OBJECT) {\n            this.#map(target[property], sourceValue);\n          } else {\n            target[property] = sourceValue;\n          }\n        }\n      });\n\n    return target;\n  }\n}\n","import { TYPE } from '@felicity/primitives';\nimport { STATE, EVENT } from '../constants.mjs';\n\n/* istanbul ignore next */\n/**\n * The .ready() method offers a way to run JavaScript code as soon as the page's Document Object\n * Model (DOM) becomes safe to manipulate.\n *\n * @param {Function} callback Event handler\n */\nwindow.document.ready = (callback) => {\n  if (typeof (callback) === TYPE.FUNCTION) {\n    if (document.isReady()) {\n      callback();\n    } else {\n      document.addEventListener(EVENT.DOM_READY, () => {\n        callback();\n        document.removeEventListener(EVENT.DOM_READY, callback);\n      });\n    }\n  }\n};\n\n/**\n * Determines if the page's Document Object Model (DOM) is safe to manipulate.\n */\nwindow.document.isReady = () => document.readyState !== STATE.LOADING;\n","import { COMPONENT_REGISTRATION_MODE } from '../constants.mjs';\n\n/**\n * Component registration status.\n */\nexport const COMPONENT_REGISTRATION_STATUS = {\n  /**\n   * Component is registered but not defined as a custom element.\n   */\n  REGISTERED: 'registered',\n\n  /**\n   * Component is defined as a custom element.\n   */\n  DEFINED: 'defined'\n};\n\n/**\n * Represents a custom element registration.\n */\nexport default class ComponentRegistryEntry {\n  /**\n   * Tag name of the component.\n   *\n   * @type {string}\n   */\n  tagName;\n\n  /**\n   * Constructor of the component.\n   *\n   * @type {Component}\n   * @see {@link Component}\n   */\n  componentConstructor;\n\n  /**\n   * Component registration mode.\n   *\n   * @type {string}\n   * @default COMPONENT_REGISTRATION_MODE.DOM_READY\n   */\n  mode = COMPONENT_REGISTRATION_MODE.DOM_READY;\n\n  /**\n   * Component registration status.\n   *\n   * @type {string}\n   */\n  status = COMPONENT_REGISTRATION_STATUS.REGISTERED;\n\n  /**\n   * Represents a component registration.\n   *\n   * @param {string} tagName Tag name of the component.\n   * @param {Component} componentConstructor Constructor of the component.\n   * @param {string} mode Component registration mode.\n   */\n  constructor(tagName, componentConstructor, mode = COMPONENT_REGISTRATION_MODE.DOM_READY) {\n    this.tagName = tagName;\n    this.componentConstructor = componentConstructor;\n    this.mode = mode;\n  }\n\n  /**\n   * Sets the component's registration status.\n   */\n  setStatus(status) {\n    this.status = status;\n  }\n}\n","import * as domExtensions from './extensions.mjs';\nimport { COMPONENT_REGISTRATION_MODE } from '../constants.mjs';\nimport ComponentRegistryEntry, { COMPONENT_REGISTRATION_STATUS } from './ComponentRegistryEntry.mjs';\n\n/**\n * Registry for all components.\n */\nexport default class ComponentRegistry {\n  /**\n   * Map of all registered components using registration mode as first-level key\n   * and tag name as second-level key.\n   *\n   * @type {Map<string, Map<string, ComponentRegistryEntry>>}\n   */\n  static map = new Map();\n\n  /**\n   * Flag indicating whether the DOMContentLoaded event handler is registered.\n   *\n   * @type {boolean}\n   */\n  static domReadyEventHandlerRegistered = false;\n\n  /**\n   * Registers a component.\n   *\n   * @param {string} tagName Tag name of the component.\n   * @param {Component} constructor Constructor of the component.\n   * @param {string} mode Component registration mode.\n   */\n  static add(tagName, constructor, mode = COMPONENT_REGISTRATION_MODE.DOM_READY) {\n    // Add mode map if not exists\n    if (!this.map.has(mode)) {\n      this.map.set(mode, new Map());\n    }\n\n    // Retrieve mode map\n    const modeMap = this.map.get(mode);\n\n    // Add entry if not exists\n    if (!modeMap.has(tagName)) {\n      modeMap.set(tagName, new ComponentRegistryEntry(tagName, constructor, mode));\n    }\n\n    switch (mode) {\n      case COMPONENT_REGISTRATION_MODE.DOM_READY:\n        // Define component if DOM is already ready\n        if (window.document.isReady()) {\n          this.defineEntry(modeMap.get(tagName));\n\n          // Add event handler for DOMContentLoaded if not already added\n        } else if (!this.domReadyEventHandlerRegistered) {\n          window.document.ready(() => {\n            this.defineAll(mode);\n            this.domReadyEventHandlerRegistered = true;\n          });\n        }\n        break;\n\n      case COMPONENT_REGISTRATION_MODE.IMMEDIATE:\n        this.defineEntry(modeMap.get(tagName));\n        break;\n\n      default:\n        break;\n    }\n  }\n\n  /**\n   * Defines all registered components in the specified registration mode.\n   *\n   * @param {string} mode Component registration mode.\n   */\n  static defineAll(mode = COMPONENT_REGISTRATION_MODE.MANUAL) {\n    if (this.map.has(mode)) {\n      const modeMap = this.map.get(mode);\n      modeMap.forEach((entry) => this.defineEntry(entry));\n    }\n  }\n\n  /**\n   * Defines a registered component.\n   *\n   * @param {ComponentRegistryEntry} entry Component registry entry.\n   */\n  static defineEntry(entry) {\n    if (entry.status === COMPONENT_REGISTRATION_STATUS.REGISTERED) {\n      this.define(entry.tagName, entry.componentConstructor);\n      entry.setStatus(COMPONENT_REGISTRATION_STATUS.DEFINED);\n    }\n  }\n\n  /**\n   * Defines a component as a custom element.\n   *\n   * @param {string} tagName Tag name of the component.\n   * @param {Component} constructor Constructor of the component.\n   */\n  static define(tagName, constructor) {\n    if (!window.customElements.get(tagName)) {\n      window.customElements.define(tagName, constructor);\n    }\n  }\n}\n","import { TYPE, MIME } from '@felicity/primitives';\n\nconst\n  regexBcp47 = /^([A-Za-z]{2,4})([_-][A-Za-z]{4})?([_-]([A-Za-z]{2}|[0-9]{3}))?$/,\n  DEFAULT_MODULE = 'general',\n  DEFAULT_SCOPE = 'global';\n\n/**\n * Translation service\n */\nexport default class Dictionary {\n  #defaultCulture;\n\n  #currentCulture;\n\n  #phrases = {};\n\n  /**\n   * Current BCP-47 / RFC 4646 compatible language tag\n   *\n   * @returns {string} Language tag of the active culture\n   */\n  get culture() {\n    return this.#currentCulture ?? this.#defaultCulture;\n  }\n\n  /**\n   * Sets the current culture to the given one if suppoerted\n   */\n  set culture(languageTag) {\n    if (!Dictionary.#isValidLanguageTag(languageTag)) {\n      return;\n    }\n\n    if (this.isCultureSupported(languageTag)) {\n      this.#currentCulture = languageTag;\n    }\n  }\n\n  /**\n   * Current ISO 3166-1 alpha-2 language code\n   *\n   * @returns {string} Alpha-2 language code\n   */\n  get alpha2() {\n    return Dictionary.#toAlpha2(this.culture);\n  }\n\n  /**\n   * Initialises a new instance of a dictionary using the specified source\n   *\n   * @param {string|object|HTMLScriptElement} source Source of the translations\n   */\n  constructor(source = 'i18n-dictionary') {\n    const htmlNode = window?.document.documentElement;\n\n    if (htmlNode) {\n      const lang = htmlNode.getAttribute('lang');\n\n      if (lang) {\n        this.#defaultCulture = lang;\n        this.#phrases[this.#defaultCulture] = {};\n      }\n\n      let sourceNode;\n\n      if (typeof (source) === TYPE.STRING) {\n        sourceNode = document.body.querySelector(`script[type=\"${MIME.JSON}\"][name=\"${source}\"]`);\n      }\n\n      if (source instanceof HTMLScriptElement) {\n        sourceNode = source;\n      }\n\n      if (sourceNode) {\n        const json = JSON.parse(sourceNode.innerHTML);\n        this.load(json);\n      }\n    }\n\n    if (typeof (source) === TYPE.OBJECT) {\n      this.load(source);\n    }\n  }\n\n  /**\n   * Stores the given translations\n   *\n   * @param {object} source Translations\n   */\n  load(source) {\n    this.#phrases = Object.merge(this.#phrases, source);\n  }\n\n  /**\n   * Loads and stores translations from a remote resource\n   *\n   * @param {string} url URL of the remote resource\n   */\n  async loadUrl(url) {\n    const response = await fetch(url);\n    if (!response.ok) {\n      return;\n    }\n\n    const json = await response.json();\n    if (json) {\n      this.load(json);\n    }\n  }\n\n  /**\n   * Determines if the specified culture is supported.\n   *\n   * @param {string} languageTag BCP-47 / RFC 4646 language tag\n   * @returns {boolean} True if culture is supported\n   */\n  isCultureSupported(languageTag) {\n    if (!Dictionary.#isValidLanguageTag(languageTag)) {\n      return false;\n    }\n\n    if (this.#phrases[languageTag]) {\n      return true;\n    }\n\n    const alpha2 = Dictionary.#toAlpha2(languageTag);\n    return this.isLanguageSupported(alpha2);\n  }\n\n  /**\n   * Determines if there is any supported culture with the given language.\n   *\n   * @param {string} alpha2 ISO 3166-1 alpha-2 language code\n   * @returns {boolean} True if language is supported\n   */\n  isLanguageSupported(alpha2) {\n    return !!this.#cultureByAlpha2(alpha2);\n  }\n\n  /**\n   * Translates a phrase to the specified language\n   *\n   * @param {string} phrase Phrase to be translated\n   * @param {string} scope Context of translation\n   * @param {string} module Name of the module defining the phrase to be translated\n   * @param {string} languageTag BCP-47 / RFC 4646 language tag\n   * @returns {string} Translated phrase\n   */\n  phrase(phrase, scope = DEFAULT_SCOPE, module = DEFAULT_MODULE, languageTag = null) {\n    let culture = languageTag ?? this.culture;\n\n    if (!this.isCultureSupported(culture)) {\n      const alpha2 = Dictionary.#toAlpha2(culture);\n      culture = this.#cultureByAlpha2(alpha2);\n    }\n\n    if (culture) {\n      const objModule = this.#phrases[culture][module];\n      if (objModule) {\n        const objScope = objModule[scope];\n        if (objScope) {\n          const translation = objScope[phrase];\n          if (translation) {\n            return translation;\n          }\n        }\n      }\n    }\n\n    return `[${phrase}]`;\n  }\n\n  /**\n   * Converts a language tag to ISO 3166-1 alpha-2 language code\n   *\n   * @param {string} languageTag BCP-47 / RFC 4646 language tag\n   * @returns {string} Alpha-2 language code\n   */\n  static #toAlpha2(languageTag) {\n    const matches = regexBcp47.exec(languageTag);\n\n    return matches.length ? matches[1] : null;\n  }\n\n  /**\n   * Validates a language tag against the regular expression\n   *\n   * @param {string} languageTag BCP-47 / RFC 4646 language tag\n   * @returns {boolean} True if language tag's format is valid\n   */\n  static #isValidLanguageTag(languageTag) {\n    return regexBcp47.test(languageTag);\n  }\n\n  /**\n   * Searches for the first supported culture with the given language\n   *\n   * @param {string} alpha2 ISO 3166-1 alpha-2 language code\n   * @returns {string} The first supported culture\n   */\n  #cultureByAlpha2(alpha2) {\n    return Object.keys(this.#phrases)\n      .find((key) => Dictionary.#toAlpha2(key) === alpha2);\n  }\n}\n","import { Dictionary } from '@felicity/i18n';\nimport {\n  stringExtensions, Mapper, MIME, TYPE\n} from '@felicity/primitives';\nimport {\n  COMPONENT_REGISTRATION_MODE, EVENT, STATUS, STYLE\n} from '../constants.mjs';\nimport ComponentRegistry from '../dom/ComponentRegistry.mjs';\n\n/**\n * Base class for creating custom web components that provide unified translation, event handling,\n * and property management functionalities.\n *\n * The `Component` class extends the `HTMLElement` and offers features such as:\n * - Automatic property initialization from options or data-* attributes.\n * - Reactive property handling, triggering 'CHANGE' events on property updates.\n * - Event-driven architecture with built-in methods for event dispatching (`trigger`),\n *   listening (`on`, `one`), and removal (`off`).\n * - Support for internationalization with integrated translation capabilities.\n * - Option to activate the component automatically upon insertion into the DOM (`autoActivate`).\n * - Optional viewport resize awareness for dynamic UI adjustments (`resizeAware`).\n * - Built-in mechanism to apply default CSS classes to the component.\n *\n * @example\n * // Defining a custom component by extending Component\n * class MyComponent extends Component {\n *   constructor(options) {\n *     super(options);\n *     this.autoActivate = true;\n *   }\n * }\n *\n * // Registering the component\n * MyComponent.register('my-component');\n *\n * @extends {HTMLElement}\n */\nexport default class Component extends HTMLElement {\n  /** @type {string} */\n  #status = STATUS.INACTIVE;\n\n  /** @type {boolean} */\n  #prepared = false;\n\n  /** @type {object} */\n  #descriptors = {};\n\n  /** @type {object} */\n  #properties = {};\n\n  /** @type {object} */\n  #options = {};\n\n  /** @type {Dictionary} */\n  #dictionary;\n\n  /**\n   * DOM tag name prefix used when registering custom elements.\n   *\n   * @type {string}\n   */\n  static tagPrefix = 'flc';\n\n  /**\n   * Registers a custom component with the specified tag name.\n   *\n   * @param {?string} componentName Tag name to be registered for the component\n   * @param {boolean} usePrefix If true the default prefix will be prepended to the tag name\n   * @param {string} mode Component registration mode\n   */\n  static register(\n    componentName = null,\n    usePrefix = true,\n    mode = COMPONENT_REGISTRATION_MODE.DOM_READY\n  ) {\n    const\n      prefix = usePrefix ? `${this.tagPrefix}-` : '',\n      tagName = `${prefix}${componentName ?? this.name}`.toDashCase();\n\n    ComponentRegistry.add(tagName, this, mode);\n  }\n\n  /**\n   * Replaces the DOM element with a new component\n   *\n   * @param {HTMLElement} element DOM element to be replaced\n   * @param {boolean|string[]} attributes List of attributes to inherit from the original element.\n   * @returns {Component} The newly constructed component\n   */\n  static replace(element, attributes) {\n    const\n      options = this.domOptions(element),\n      component = new this(options);\n\n    let attributeNames = [];\n    if (attributes === true) {\n      attributeNames = attributeNames.concat(element.getAttributeNames());\n    }\n    if (attributes instanceof Array) {\n      attributeNames = attributeNames.concat(attributes);\n    }\n\n    attributeNames.forEach((attribute) => {\n      component.setAttribute(attribute, element.getAttribute(attribute));\n    });\n\n    element.parentNode.replaceChild(component, element);\n\n    return component;\n  }\n\n  /**\n   * Collects options set as data-* attributes\n   *\n   * @param {HTMLElement} element DOM element having the data attributes\n   * @returns {object} Options specified as data attributes\n   */\n  static domOptions(element) {\n    return Object.keys({ ...element.dataset })\n      .reduce((acc, cur) => {\n        const val = element.dataset[cur];\n\n        switch (val.toLocaleLowerCase()) {\n          case 'true':\n            acc[cur] = true;\n            break;\n\n          case 'false':\n            acc[cur] = false;\n            break;\n\n          default:\n            acc[cur] = val;\n            break;\n        }\n\n        return acc;\n      }, {});\n  }\n\n  /**\n   * If true the component automatically gets activated when attached to the DOM and gets visible.\n   *\n   * @type {boolean}\n   */\n  autoActivate = false;\n\n  /**\n   * If true the component registers a handler to the event of changing the viewport size.\n   *\n   * @type {boolean}\n   */\n  resizeAware = false;\n\n  /**\n   * If true the component will be applied with the css class of [prefix]-component.\n   *\n   * @type {boolean}\n   */\n  useDefaultCssClass = true;\n\n  /**\n   * BCP-47 / RFC 4646 compatible tag specifying the culture settings used within the component.\n   *\n   * @type {string}\n   */\n  culture;\n\n  /**\n   * Indicates if the component has already been initialised when it was first attached to the DOM.\n   *\n   * @type {boolean}\n   */\n  get prepared() {\n    return this.#prepared;\n  }\n\n  /**\n   * Component constructor\n   *\n   * @param {HTMLElement|object} options Component configuration object\n   * or the element that will be replaced with the component\n   */\n  constructor(options) {\n    super();\n\n    if (options instanceof HTMLElement) {\n      this.#options = Component.domOptions(options);\n    } else {\n      this.#options = options;\n    }\n  }\n\n  /**\n   * Invoked each time the custom element is appended into a document-connected\n   * element. This will happen each time the node is moved, and may happen\n   * before the element's contents have been fully parsed.\n   */\n  connectedCallback() {\n    if (!this.prepared) {\n      this._prepare();\n      this.#prepared = true;\n    }\n  }\n\n  /**\n   * Puts the component to active status\n   */\n  activate() {\n    this.#status = STATUS.ACTIVE;\n    this.trigger(EVENT.ACTIVATED);\n  }\n\n  /**\n   * Puts the component to inactive status\n   */\n  deactivate() {\n    this.#status = STATUS.INACTIVE;\n    this.trigger(EVENT.DEACTIVATED);\n  }\n\n  /**\n   * @returns {boolean} True if the component is currently active\n   */\n  isActive() {\n    return this.#status === STATUS.ACTIVE;\n  }\n\n  /**\n   * Returns the phrase translated if translation available.\n   *\n   * @param {string} phrase Phrase or key in the specified scope\n   * @param {string} scope Scope of translation\n   * @param {string} module Module of translation\n   * @returns {string} The translated phrase\n   */\n  phrase(phrase, scope, module) {\n    if (this.#dictionary) {\n      return this.#dictionary.phrase(phrase, scope, module);\n    }\n\n    if (typeof (window.i18n?.dictionary?.phrase) === TYPE.FUNCTION) {\n      return window.i18n.dictionary.phrase(phrase, scope, module);\n    }\n\n    return phrase;\n  }\n\n  /**\n   * Dispatches an Event at the specified EventTarget, (synchronously) invoking\n   * the affected EventListeners in the appropriate order.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/dispatchEvent\n   * @param {string} type Name of the event\n   * @param {any} data Optional event data\n   * @returns {boolean} false if event is cancelable and at least one of the event\n   * handlers which received event called Event.preventDefault().\n   * Otherwise it returns true.\n   */\n  trigger(type, data) {\n    return this.dispatchEvent(new CustomEvent(type, {\n      detail: data,\n      cancelable: true\n    }));\n  }\n\n  /**\n   * Sets up a function that will be called whenever the specified event is\n   * delivered to the target\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n   * @param {string} type A case-sensitive string representing the event type to\n   * listen for.\n   * @param {any} listener The event listener object that receives a\n   * notification or a function that will be called when an event of the\n   * specified type occurs.\n   * @param {object|boolean} options An options object specifies characteristics\n   * about the event listener.\n   */\n  on(type, listener, options) {\n    this.addEventListener(type, listener, options);\n  }\n\n  /**\n   * Sets up a function that will be called once when the specified event is\n   * delivered to the target\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n   * @param {string} type A case-sensitive string representing the event type to\n   * listen for.\n   * @param {any} listener The event listener object that receives a\n   * notification or a function that will be called when an event of the\n   * specified type occurs.\n   * @param {object|boolean} options An options object specifies characteristics\n   * about the event listener.\n   */\n  one(type, listener, options) {\n    this.addEventListener(type, listener, options);\n    this.addEventListener(type, (e) => {\n      this.off(type, listener, options);\n    });\n  }\n\n  /**\n   * Removes a previously registered event listener\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/removeEventListener\n   * @param {string} type A string which specifies the type of event for which\n   * to remove an event listener.\n   * @param {any} listener The function of the event handler to remove from the\n   * event target.\n   * @param {object|boolean} options An options object that specifies\n   * characteristics about the event listener.\n   */\n  off(type, listener, options) {\n    this.removeEventListener(type, listener, options);\n  }\n\n  /**\n   * Tries to set the value to a property without triggering change event.\n   *\n   * @param {string} property Model property name\n   * @param {any} value Property value\n   */\n  set(property, value) {\n    // If only one argument is passed either the value cannot be set or\n    // the argument contains a set of properties to set.\n    if (value === undefined) {\n      if (property && typeof (property) === TYPE.OBJECT) {\n        Object.keys(property)\n          .forEach((key) => this.set(key, property[key]));\n      }\n\n      return;\n    }\n\n    if (typeof (this[property]) === TYPE.FUNCTION) {\n      this[property](value);\n      return;\n    }\n\n    const descriptor = this.#descriptors[property];\n    if (descriptor === undefined || descriptor.writable === false) {\n      return;\n    }\n\n    this.#properties[property] = value;\n  }\n\n  /**\n   * Returns the property value if exists, undefined otherwise.\n   * If the property name refers to a function it returns the value returned by the member.\n   *\n   * @param {any} property Model property name\n   * @returns {any} Property value\n   */\n  get(property) {\n    if (typeof (this[property]) === TYPE.FUNCTION) {\n      return this[property]();\n    }\n\n    return this[property];\n  }\n\n  /**\n   * Prepares the component for usage by initializing its properties, applying default styles,\n   * and setting up event listeners and translations.\n   *\n   * This method is called when the component is first attached to the DOM, and performs the\n   * following tasks:\n   * - Initializes component properties using options and data attributes.\n   * - Applies a default CSS class if `useDefaultCssClass` is true.\n   * - Activates the component automatically if `autoActivate` is true and the component is visible.\n   * - Registers a resize event listener if `resizeAware` is true.\n   * - Sets the component's `culture` based on the document's language or browser settings.\n   * - Loads translation data from a script element if present.\n   *\n   * @protected\n   */\n  _prepare() {\n    this.#initProperties({ ...Component.domOptions(this), ...this.#options });\n\n    if (this.useDefaultCssClass) {\n      this.classList.add(`${this.constructor.tagPrefix}-component`);\n    }\n\n    if (this.autoActivate && window.getComputedStyle(this).display !== STYLE.DISPLAY_NONE) {\n      this.activate();\n    }\n\n    if (this.resizeAware && typeof (this.resize) === TYPE.FUNCTION) {\n      window.addEventListener(EVENT.DOM_RESIZE, (e) => {\n        this.resize(e);\n      });\n    }\n\n    if (!this.culture) {\n      this.culture = document.documentElement.getAttribute('lang') ?? navigator.language;\n    }\n\n    const dictionaryElement = this.querySelector(`script[type=\"${MIME.JSON}\"][name=\"dictionary\"]`);\n    if (dictionaryElement) {\n      const json = JSON.parse(dictionaryElement.innerHTML);\n      this.#dictionary = new Dictionary(json);\n    }\n  }\n\n  /**\n   * Initializes the properties of the component based on the provided options.\n   *\n   * This method maps the properties from the options object to the component,\n   * sets up reactive property handling by defining custom getters and setters,\n   * and triggers a 'CHANGE' event whenever a property is updated.\n   *\n   * @param {object} options - The initial options used to set the component properties.\n   * These options are typically derived from the DOM element's dataset or passed configuration.\n   * @private\n   * @example\n   * const options = { autoActivate: true, resizeAware: false };\n   * this.#initProperties(options);\n   */\n  #initProperties(options) {\n    Mapper.from(options).to(this);\n\n    const descriptors = Object.getOwnPropertyDescriptors(this);\n    Object.keys(descriptors)\n      .filter((property) => descriptors[property].writable === true)\n      .forEach((property) => {\n        this.#properties[property] = this[property];\n\n        Object.defineProperty(this, property, {\n          enumerable: true,\n          configurable: false,\n          get() {\n            return this.#properties[property];\n          },\n          set(value) {\n            const oldValue = this[property];\n\n            // Return early if the value would not change\n            if (value === oldValue) {\n              return;\n            }\n\n            this.#properties[property] = value;\n\n            this.trigger(EVENT.CHANGE, {\n              property,\n              value,\n              oldValue\n            });\n          }\n        });\n\n        this.#descriptors[property] = Object.getOwnPropertyDescriptor(this, property);\n      });\n  }\n}\n","import {\n  HTTP, HTTP_HEADER, MIME\n} from '@felicity/primitives';\nimport { load } from 'recaptcha-v3';\nimport { EVENT } from '../constants.mjs';\nimport Component from './Component.mjs';\n\nexport default class Form extends Component {\n  /**\n   * URI of the page to return after success\n   *\n   * @type {string}\n   * @public\n   */\n  returnTo;\n\n  /**\n   * Number of milliseconds to wait before redirecting the user\n   *\n   * @type {number}\n   * @public\n   */\n  timeout = 0;\n\n  /**\n   * Relative path of the API endpoint that generates cross-site request forgery tokens\n   *\n   * @type {string}\n   * @public\n   */\n  verificationTokenEndpoint = '/api/login/token';\n\n  /**\n   * Specifies how the current culture setting will be added to the request\n   *\n   * @type {string}\n   * @public\n   */\n  setCulture;\n\n  /**\n   * Indicates if the form needs to be cleared after a successful submission\n   *\n   * @type {boolean}\n   * @public\n   */\n  clearOnSuccess = false;\n\n  /**\n   * Returns the wrapped form\n   *\n   * @type {HTMLFormElement}\n   * @public\n   */\n  get form() {\n    return this.#form;\n  }\n\n  /**\n   * Host of the antiforgery token service endpoint\n   *\n   * @type {string}\n   * @public\n   */\n  get host() {\n    return this.#host;\n  }\n\n  /**\n   * The URL that processes the form submission.\n   *\n   * @type {string}\n   * @public\n   */\n  get action() {\n    return this.form?.action;\n  }\n\n  /**\n   * Validation message container\n   *\n   * @type {HTMLElement}\n   * @public\n   */\n  get messages() {\n    return this.#messages;\n  }\n\n  /**\n   * Indicates if the form is currently submitting data\n   *\n   * @type {boolean}\n   * @public\n   */\n  get isSubmitting() {\n    return this.#submitting === true;\n  }\n\n  /**\n   * Wrapped form element\n   *\n   * @type {HTMLFormElement}\n   * @private\n   */\n  #form;\n\n  /**\n   * @type {string}\n   * @private\n   */\n  #host = '';\n\n  /**\n   * @type {HTMLElement}\n   * @private\n   */\n  #messages;\n\n  /**\n   * @type {string}\n   * @private\n   */\n  #errorMessageTemplate;\n\n  /**\n   * @type {string}\n   * @private\n   */\n  #successMessageTemplate;\n\n  /**\n   * @type {string}\n   * @private\n   */\n  #submitting;\n\n  constructor() {\n    super();\n\n    this.#form = this.querySelector('form');\n  }\n\n  /**\n   * Invoked each time the custom element is appended into a document-connected\n   * element. This will happen each time the node is moved, and may happen\n   * before the element's contents have been fully parsed.\n   */\n  connectedCallback() {\n    super.connectedCallback();\n\n    const action = this.form.getAttribute('action');\n\n    if (action?.toLowerCase().startsWith('http')) {\n      try {\n        const url = new URL(action);\n        this.#host = url.origin;\n      } catch {\n        this.#host = '';\n      }\n    }\n\n    if (!this.setCulture) {\n      this.setCulture = this.form.dataset.setCulture;\n    }\n\n    this.#messages = this.querySelector('.validation-message-container');\n    this.#errorMessageTemplate = this.querySelector('template[name=\"validationErrorMessage\"]')?.innerHTML;\n    this.#successMessageTemplate = this.querySelector('template[name=\"validationSuccessMessage\"]')?.innerHTML;\n\n    this.form.addEventListener(EVENT.FORM.SUBMIT, (e) => {\n      e.preventDefault();\n\n      if (this.isSubmitting) {\n        return;\n      }\n\n      this.#submitting = true;\n      this.getVerificationToken()\n        .then((xsrf) => {\n          const { captcha } = this.form.dataset;\n          if (captcha) {\n            const { siteKey } = this.form.dataset;\n            if (!siteKey) {\n              throw Error('CAPTCHA site key is missing');\n            }\n\n            load(siteKey).then((recaptcha) => {\n              recaptcha.execute(this.form.dataset.captchaAction).then((token) => {\n                const data = { captchaToken: token, ...this.getData() };\n\n                this.submit(data, xsrf);\n              });\n            });\n          } else {\n            this.submit(this.getData(), xsrf);\n          }\n        });\n    });\n\n    this.form.classList.remove('d-none');\n  }\n\n  /**\n   * Returns the currently stored form data as an object\n   *\n   * @returns {object} Form data as key-value map\n   */\n  getData() {\n    return Object.fromEntries(new FormData(this.form));\n  }\n\n  /**\n   * Enables/disables all input elements on the form\n   *\n   * @param {boolean} enable If true the form get enabled\n   */\n  enable(enable) {\n    this.querySelectorAll('input, button')\n      .forEach((inp) => {\n        const control = inp;\n        control.disabled = !enable;\n      });\n  }\n\n  /**\n   * Displays a message on the $messages panel using the message template\n   *\n   * @param {string} message Message to be displayed\n   * @param {boolean} success Indicates if the message means success or failure\n   * @public\n   */\n  showMessage(message, success) {\n    const template = success ? this.#successMessageTemplate : this.#errorMessageTemplate,\n      node = document.createElement('div');\n    node.innerHTML = template ?? '<div class=\"message\"></div>';\n    node.querySelector('.message').innerHTML = message;\n\n    this.messages.innerHTML = '';\n    this.messages.appendChild(node.firstElementChild);\n  }\n\n  /**\n   * Returns a valid antiforgery token\n   *\n   * @returns {Promise} Promise that gets resolved with the token\n   * @public\n   */\n  getVerificationToken() {\n    return new Promise((resolve) => {\n      const token = this.querySelector('[name=\"RequestVerificationToken\"]')?.value;\n\n      if (token) {\n        resolve(token);\n      } else {\n        fetch(`${this.host}${this.verificationTokenEndpoint}`, {\n          method: HTTP.GET,\n          headers: {\n            Accept: MIME.JSON\n          },\n        })\n          .then((response) => response.json())\n          .then((json) => resolve(json.requestToken));\n      }\n    });\n  }\n\n  /* eslint no-plusplus: 0 */\n  /**\n   * Submits the data alongside with the antiforgery token in the header\n   *\n   * @param {object} data Form data to submit\n   * @param {string} xsrf Antiforgery token\n   * @returns {Promise} Promise that gets resolved after success\n   * @public\n   */\n  submit(data, xsrf) {\n    this.enable(false);\n\n    let { action } = this,\n      url,\n      languages,\n      q,\n      accept;\n    const headers = {\n      RequestVerificationToken: xsrf,\n      [HTTP_HEADER.MESSAGE_BODY.CONTENT_TYPE]: MIME.JSON\n    };\n\n    switch (this.setCulture) {\n      case 'header':\n        languages = navigator.languages\n          .slice(0, 10)\n          .filter((lang) => lang !== this.culture);\n\n        q = 1;\n        accept = [this.culture, ...languages]\n          .map((l) => `${l};q=0.${10 - q++}`)\n          .join(',');\n\n        headers[HTTP_HEADER.CONTENT_NEGOTIATION.ACCEPT_LANGUAGE] = accept;\n        break;\n\n      case 'body':\n        Object.assign(data, {\n          culture: this.culture\n        });\n        break;\n\n      case 'query-string':\n        if (!action.toLowerCase().startsWith('http')) {\n          action = `${window.location.origin}/{action};`;\n        }\n\n        url = new URL(action);\n        url.searchParams.append('culture', this.culture);\n\n        action = url.toString();\n        break;\n\n      default:\n        break;\n    }\n\n    return new Promise((resolve) => {\n      fetch(action, {\n        method: this.form.getAttribute('method')?.toUpperCase() ?? HTTP.POST,\n        cache: 'no-cache',\n        headers,\n        body: JSON.stringify(data)\n      })\n        .then((response) => {\n          if (!response.ok) {\n            return this.handleError(response);\n          }\n\n          return response.json();\n        })\n        .then((json) => {\n          if (json) {\n            this.handleResponse(json);\n\n            resolve(true);\n          } else {\n            resolve(false);\n          }\n        })\n        .catch((error) => {\n          this.showMessage(error, false);\n        })\n        .then(() => {\n          this.enable(true);\n          this.#submitting = false;\n        });\n    });\n  }\n\n  /**\n   * Handles response data and performs default logic\n   * @param {object} json JSON response\n   */\n  handleResponse(json) {\n    this.showMessage(json.message, true);\n\n    if (this.returnTo) {\n      setTimeout(() => {\n        window.location = this.returnTo;\n      }, this.timeout);\n    }\n\n    if (this.clearOnSuccess) {\n      this.form.reset();\n    }\n  }\n\n  /**\n   * General error handling logic\n   * @param {Response} response HTTP response containing details of the error\n   * @public\n   */\n  async handleError(response) {\n    const { reason, content } = await this.#getErrorReason(response);\n\n    if (this.trigger(EVENT.ERROR, { reason, content })) {\n      if (response.status < 500) {\n        this.showMessage(reason, false);\n      } else {\n        throw new Error(reason);\n      }\n    }\n  }\n\n  /**\n   * Tries to retrieve the best description of an error\n   * @param {Response} response HTTP response\n   * @returns {string} Reason for the error\n   * @private\n   */\n  async #getErrorReason(response) {\n    const header = response.headers.get(HTTP_HEADER.MESSAGE_BODY.CONTENT_TYPE),\n      contentType = this.#parseContentType(header);\n\n    /** @type {string} */\n    let reason,\n      content;\n\n    switch (contentType) {\n      case MIME.JSON_PROBLEM:\n        content = await response.json();\n        reason = content.detail || content.title;\n        break;\n\n      case MIME.JSON:\n        content = await response.json();\n        reason = content.message ?? response.statusText;\n        break;\n\n      default:\n        content = await response.text();\n        reason = content?.length ? content : response.statusText;\n        break;\n    }\n\n    return { reason, content };\n  }\n\n  /* eslint class-methods-use-this: 0 */\n  /**\n   * Trimms everything after a semicolon, e.g. 'charset=utf-8'\n   * @param {string} header Response header\n   * @returns {string} First segment of the header\n   * @private\n   */\n  #parseContentType(header) {\n    const semicolonIdx = header?.indexOf(';');\n    return semicolonIdx > -1\n      ? header.substring(0, semicolonIdx)\n      : header;\n  }\n}\n\nif (!window.customElements.get('flc-form')) {\n  window.customElements.define('flc-form', Form);\n}\n","import { domExtensions } from '@felicity/vision';\n\nconst enableOwnerFields = (enable) => {\n    const section = document.getElementById('register-as-owner'),\n      fields = section.querySelectorAll('[data-required-for-owners=\"true\"]');\n\n    section.classList[enable ? 'remove' : 'add']('d-none');\n    fields.forEach((field) => {\n      if (enable) {\n        field.setAttribute('required', true);\n      } else {\n        field.removeAttribute('required');\n      }\n    });\n  },\n\n  registrationTypeChanged = (event) => {\n    const container = event.target.closest('.radio-button-list'),\n      selected = container.querySelector('input:checked');\n\n    enableOwnerFields(selected?.value === 'Owner');\n  },\n\n  initOwnerFields = () => {\n    const selected = document.querySelector('input[name=\"Input.RegistrationType\"]:checked');\n    enableOwnerFields(selected?.value === 'Owner');\n  };\n\ndocument.ready(() => {\n  document.getElementsByName('Input.RegistrationType')\n    .forEach((radio) => {\n      radio.addEventListener('change', registrationTypeChanged);\n    });\n\n  initOwnerFields();\n});\n"],"names":["exports","ReCaptchaLoader_1","Object","defineProperty","enumerable","get","load","__awaiter","this","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","apply","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","Symbol","iterator","n","v","op","TypeError","call","pop","length","push","ReCaptchaInstance","siteKey","recaptchaID","recaptcha","styleContainer","prototype","execute","action","_a","_b","enterprise","getSiteKey","hideBadge","document","createElement","innerHTML","head","appendChild","showBadge","removeChild","__assign","assign","s","i","arguments","p","hasOwnProperty","getInstance","ELoadingState","ReCaptchaInstance_1","ReCaptchaLoader","options","Error","getLoadingState","LOADED","instance","LOADING","instanceSiteKey","successfulLoadingConsumers","errorLoadingRunnable","reason","setLoadingState","loader","loadScript","useRecaptchaNet","useEnterprise","renderParameters","customUrl","widgetID","doExplicitRender","grecaptcha","explicitRenderParameters","forEach","autoHideBadge","catch","error","state","loadingState","NOT_LOADED","_this","scriptElement","setAttribute","scriptBase","render","undefined","parametersQuery","buildQueryString","src","addEventListener","waitForScriptToLoad","onerror","parameters","keys","filter","parameterKey","map","join","callback","window","setTimeout","SCRIPT_LOAD_DELAY","ready","isEnterprise","augmentedParameters","sitekey","container","__webpack_module_cache__","COMPONENT_REGISTRATION_MODE","STATUS","EVENT","TYPE","HTTP_HEADER","MIME","convertCase","input","separator","prepare","canonical","segments","replace","split","segment","dashed","toLowerCase","trim","concat","canonicalForm","Date","isDate","date","toString","Number","isNaN","valueOf","isPlain","obj","proto","getPrototypeOf","ctor","constructor","merge","arg","trg","key","Array","isArray","slice","toJSON","json","member","toISOString","propertyDescriptorsOf","objPrototype","descriptors","getOwnPropertyDescriptors","getOwnPropertyDescriptor","prototypeDescriptors","String","toPascalCase","toUpperCase","substring","toCamelCase","pc","toTitleCase","toDotCase","toSnakeCase","toScreamingSnakeCase","toDashCase","URL","isURL","url","name","addParams","values","notation","entries","k","subKey","searchParams","append","Mapper","ignoreUndefined","source","from","to","target","sourceObj","property","writable","set","sourceProperty","sourceValue","ItemType","item","isReady","removeEventListener","readyState","COMPONENT_REGISTRATION_STATUS","ComponentRegistryEntry","tagName","componentConstructor","mode","status","setStatus","ComponentRegistry","static","Map","add","has","modeMap","defineEntry","domReadyEventHandlerRegistered","defineAll","entry","define","customElements","regexBcp47","Dictionary","culture","languageTag","isCultureSupported","alpha2","htmlNode","documentElement","lang","getAttribute","sourceNode","querySelector","HTMLScriptElement","JSON","parse","loadUrl","response","fetch","ok","isLanguageSupported","phrase","scope","module","objModule","objScope","translation","matches","exec","test","find","Component","HTMLElement","register","componentName","usePrefix","tagPrefix","element","attributes","component","domOptions","attributeNames","getAttributeNames","attribute","parentNode","replaceChild","dataset","reduce","acc","cur","val","toLocaleLowerCase","autoActivate","resizeAware","useDefaultCssClass","prepared","super","connectedCallback","_prepare","activate","trigger","deactivate","isActive","i18n","dictionary","type","data","dispatchEvent","CustomEvent","detail","cancelable","on","listener","one","off","descriptor","classList","getComputedStyle","display","resize","navigator","language","dictionaryElement","configurable","oldValue","__webpack_require__","moduleId","cachedModule","__webpack_modules__","returnTo","timeout","verificationTokenEndpoint","setCulture","clearOnSuccess","form","host","messages","isSubmitting","startsWith","origin","preventDefault","getVerificationToken","xsrf","captcha","captchaAction","token","captchaToken","getData","submit","remove","fromEntries","FormData","enable","querySelectorAll","inp","disabled","showMessage","message","success","template","node","firstElementChild","method","headers","Accept","requestToken","languages","q","accept","RequestVerificationToken","l","location","cache","stringify","handleError","handleResponse","reset","content","header","title","statusText","text","semicolonIdx","indexOf","enableOwnerFields","section","getElementById","fields","field","removeAttribute","registrationTypeChanged","event","selected","closest","getElementsByName","radio","initOwnerFields"],"sourceRoot":""}