{"mappings":"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","sources":["node_modules/htmx.org/dist/htmx.js"],"sourcesContent":["// UMD insanity\n// This code sets up support for (in order) AMD, ES6 modules, and globals.\n(function (root, factory) {\n    //@ts-ignore\n    if (typeof define === 'function' && define.amd) {\n        // AMD. Register as an anonymous module.\n        //@ts-ignore\n        define([], factory);\n    } else if (typeof module === 'object' && module.exports) {\n        // Node. Does not work with strict CommonJS, but\n        // only CommonJS-like environments that support module.exports,\n        // like Node.\n        module.exports = factory();\n    } else {\n        // Browser globals\n        root.htmx = root.htmx || factory();\n    }\n}(typeof self !== 'undefined' ? self : this, function () {\nreturn (function () {\n        'use strict';\n\n        // Public API\n        //** @type {import(\"./htmx\").HtmxApi} */\n        // TODO: list all methods in public API\n        var htmx = {\n            onLoad: onLoadHelper,\n            process: processNode,\n            on: addEventListenerImpl,\n            off: removeEventListenerImpl,\n            trigger : triggerEvent,\n            ajax : ajaxHelper,\n            find : find,\n            findAll : findAll,\n            closest : closest,\n            values : function(elt, type){\n                var inputValues = getInputValues(elt, type || \"post\");\n                return inputValues.values;\n            },\n            remove : removeElement,\n            addClass : addClassToElement,\n            removeClass : removeClassFromElement,\n            toggleClass : toggleClassOnElement,\n            takeClass : takeClassForElement,\n            defineExtension : defineExtension,\n            removeExtension : removeExtension,\n            logAll : logAll,\n            logger : null,\n            config : {\n                historyEnabled:true,\n                historyCacheSize:10,\n                refreshOnHistoryMiss:false,\n                defaultSwapStyle:'innerHTML',\n                defaultSwapDelay:0,\n                defaultSettleDelay:20,\n                includeIndicatorStyles:true,\n                indicatorClass:'htmx-indicator',\n                requestClass:'htmx-request',\n                addedClass:'htmx-added',\n                settlingClass:'htmx-settling',\n                swappingClass:'htmx-swapping',\n                allowEval:true,\n                inlineScriptNonce:'',\n                attributesToSettle:[\"class\", \"style\", \"width\", \"height\"],\n                withCredentials:false,\n                timeout:0,\n                wsReconnectDelay: 'full-jitter',\n                wsBinaryType: 'blob',\n                disableSelector: \"[hx-disable], [data-hx-disable]\",\n                useTemplateFragments: false,\n                scrollBehavior: 'smooth',\n                defaultFocusScroll: false,\n                getCacheBusterParam: false,\n                globalViewTransitions: false,\n            },\n            parseInterval:parseInterval,\n            _:internalEval,\n            createEventSource: function(url){\n                return new EventSource(url, {withCredentials:true})\n            },\n            createWebSocket: function(url){\n                var sock = new WebSocket(url, []);\n                sock.binaryType = htmx.config.wsBinaryType;\n                return sock;\n            },\n            version: \"1.9.2\"\n        };\n\n        /** @type {import(\"./htmx\").HtmxInternalApi} */\n        var internalAPI = {\n            addTriggerHandler: addTriggerHandler,\n            bodyContains: bodyContains,\n            canAccessLocalStorage: canAccessLocalStorage,\n            filterValues: filterValues,\n            hasAttribute: hasAttribute,\n            getAttributeValue: getAttributeValue,\n            getClosestMatch: getClosestMatch,\n            getExpressionVars: getExpressionVars,\n            getHeaders: getHeaders,\n            getInputValues: getInputValues,\n            getInternalData: getInternalData,\n            getSwapSpecification: getSwapSpecification,\n            getTriggerSpecs: getTriggerSpecs,\n            getTarget: getTarget,\n            makeFragment: makeFragment,\n            mergeObjects: mergeObjects,\n            makeSettleInfo: makeSettleInfo,\n            oobSwap: oobSwap,\n            selectAndSwap: selectAndSwap,\n            settleImmediately: settleImmediately,\n            shouldCancel: shouldCancel,\n            triggerEvent: triggerEvent,\n            triggerErrorEvent: triggerErrorEvent,\n            withExtensions: withExtensions,\n        }\n\n        var VERBS = ['get', 'post', 'put', 'delete', 'patch'];\n        var VERB_SELECTOR = VERBS.map(function(verb){\n            return \"[hx-\" + verb + \"], [data-hx-\" + verb + \"]\"\n        }).join(\", \");\n\n        //====================================================================\n        // Utilities\n        //====================================================================\n\n        function parseInterval(str) {\n            if (str == undefined)  {\n                return undefined\n            }\n            if (str.slice(-2) == \"ms\") {\n                return parseFloat(str.slice(0,-2)) || undefined\n            }\n            if (str.slice(-1) == \"s\") {\n                return (parseFloat(str.slice(0,-1)) * 1000) || undefined\n            }\n            if (str.slice(-1) == \"m\") {\n                return (parseFloat(str.slice(0,-1)) * 1000 * 60) || undefined\n            }\n            return parseFloat(str) || undefined\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {string} name\n         * @returns {(string | null)}\n         */\n        function getRawAttribute(elt, name) {\n            return elt.getAttribute && elt.getAttribute(name);\n        }\n\n        // resolve with both hx and data-hx prefixes\n        function hasAttribute(elt, qualifiedName) {\n            return elt.hasAttribute && (elt.hasAttribute(qualifiedName) ||\n                elt.hasAttribute(\"data-\" + qualifiedName));\n        }\n\n        /**\n         *\n         * @param {HTMLElement} elt\n         * @param {string} qualifiedName\n         * @returns {(string | null)}\n         */\n        function getAttributeValue(elt, qualifiedName) {\n            return getRawAttribute(elt, qualifiedName) || getRawAttribute(elt, \"data-\" + qualifiedName);\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @returns {HTMLElement | null}\n         */\n        function parentElt(elt) {\n            return elt.parentElement;\n        }\n\n        /**\n         * @returns {Document}\n         */\n        function getDocument() {\n            return document;\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {(e:HTMLElement) => boolean} condition\n         * @returns {HTMLElement | null}\n         */\n        function getClosestMatch(elt, condition) {\n            while (elt && !condition(elt)) {\n                elt = parentElt(elt);\n            }\n\n            return elt ? elt : null;\n        }\n\n        function getAttributeValueWithDisinheritance(initialElement, ancestor, attributeName){\n            var attributeValue = getAttributeValue(ancestor, attributeName);\n            var disinherit = getAttributeValue(ancestor, \"hx-disinherit\");\n            if (initialElement !== ancestor && disinherit && (disinherit === \"*\" || disinherit.split(\" \").indexOf(attributeName) >= 0)) {\n                return \"unset\";\n            } else {\n                return attributeValue\n            }\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {string} attributeName\n         * @returns {string | null}\n         */\n        function getClosestAttributeValue(elt, attributeName) {\n            var closestAttr = null;\n            getClosestMatch(elt, function (e) {\n                return closestAttr = getAttributeValueWithDisinheritance(elt, e, attributeName);\n            });\n            if (closestAttr !== \"unset\") {\n                return closestAttr;\n            }\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {string} selector\n         * @returns {boolean}\n         */\n        function matches(elt, selector) {\n            // @ts-ignore: non-standard properties for browser compatability\n            // noinspection JSUnresolvedVariable\n            var matchesFunction = elt.matches || elt.matchesSelector || elt.msMatchesSelector || elt.mozMatchesSelector || elt.webkitMatchesSelector || elt.oMatchesSelector;\n            return matchesFunction && matchesFunction.call(elt, selector);\n        }\n\n        /**\n         * @param {string} str\n         * @returns {string}\n         */\n        function getStartTag(str) {\n            var tagMatcher = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i\n            var match = tagMatcher.exec( str );\n            if (match) {\n                return match[1].toLowerCase();\n            } else {\n                return \"\";\n            }\n        }\n\n        /**\n         *\n         * @param {string} resp\n         * @param {number} depth\n         * @returns {Element}\n         */\n        function parseHTML(resp, depth) {\n            var parser = new DOMParser();\n            var responseDoc = parser.parseFromString(resp, \"text/html\");\n\n            /** @type {Element} */\n            var responseNode = responseDoc.body;\n            while (depth > 0) {\n                depth--;\n                // @ts-ignore\n                responseNode = responseNode.firstChild;\n            }\n            if (responseNode == null) {\n                // @ts-ignore\n                responseNode = getDocument().createDocumentFragment();\n            }\n            return responseNode;\n        }\n\n        function aFullPageResponse(resp) {\n            return resp.match(/<body/);\n        }\n\n        /**\n         *\n         * @param {string} resp\n         * @returns {Element}\n         */\n        function makeFragment(resp) {\n            var partialResponse = !aFullPageResponse(resp);\n            if (htmx.config.useTemplateFragments && partialResponse) {\n                var documentFragment = parseHTML(\"<body><template>\" + resp + \"</template></body>\", 0);\n                // @ts-ignore type mismatch between DocumentFragment and Element.\n                // TODO: Are these close enough for htmx to use interchangably?\n                return documentFragment.querySelector('template').content;\n            } else {\n                var startTag = getStartTag(resp);\n                switch (startTag) {\n                    case \"thead\":\n                    case \"tbody\":\n                    case \"tfoot\":\n                    case \"colgroup\":\n                    case \"caption\":\n                        return parseHTML(\"<table>\" + resp + \"</table>\", 1);\n                    case \"col\":\n                        return parseHTML(\"<table><colgroup>\" + resp + \"</colgroup></table>\", 2);\n                    case \"tr\":\n                        return parseHTML(\"<table><tbody>\" + resp + \"</tbody></table>\", 2);\n                    case \"td\":\n                    case \"th\":\n                        return parseHTML(\"<table><tbody><tr>\" + resp + \"</tr></tbody></table>\", 3);\n                    case \"script\":\n                        return parseHTML(\"<div>\" + resp + \"</div>\", 1);\n                    default:\n                        return parseHTML(resp, 0);\n                }\n            }\n        }\n\n        /**\n         * @param {Function} func\n         */\n        function maybeCall(func){\n            if(func) {\n                func();\n            }\n        }\n\n        /**\n         * @param {any} o\n         * @param {string} type\n         * @returns\n         */\n        function isType(o, type) {\n            return Object.prototype.toString.call(o) === \"[object \" + type + \"]\";\n        }\n\n        /**\n         * @param {*} o\n         * @returns {o is Function}\n         */\n        function isFunction(o) {\n            return isType(o, \"Function\");\n        }\n\n        /**\n         * @param {*} o\n         * @returns {o is Object}\n         */\n        function isRawObject(o) {\n            return isType(o, \"Object\");\n        }\n\n        /**\n         * getInternalData retrieves \"private\" data stored by htmx within an element\n         * @param {HTMLElement} elt\n         * @returns {*}\n         */\n        function getInternalData(elt) {\n            var dataProp = 'htmx-internal-data';\n            var data = elt[dataProp];\n            if (!data) {\n                data = elt[dataProp] = {};\n            }\n            return data;\n        }\n\n        /**\n         * toArray converts an ArrayLike object into a real array.\n         * @param {ArrayLike} arr\n         * @returns {any[]}\n         */\n        function toArray(arr) {\n            var returnArr = [];\n            if (arr) {\n                for (var i = 0; i < arr.length; i++) {\n                    returnArr.push(arr[i]);\n                }\n            }\n            return returnArr\n        }\n\n        function forEach(arr, func) {\n            if (arr) {\n                for (var i = 0; i < arr.length; i++) {\n                    func(arr[i]);\n                }\n            }\n        }\n\n        function isScrolledIntoView(el) {\n            var rect = el.getBoundingClientRect();\n            var elemTop = rect.top;\n            var elemBottom = rect.bottom;\n            return elemTop < window.innerHeight && elemBottom >= 0;\n        }\n\n        function bodyContains(elt) {\n            // IE Fix\n            if (elt.getRootNode && elt.getRootNode() instanceof ShadowRoot) {\n                return getDocument().body.contains(elt.getRootNode().host);\n            } else {\n                return getDocument().body.contains(elt);\n            }\n        }\n\n        function splitOnWhitespace(trigger) {\n            return trigger.trim().split(/\\s+/);\n        }\n\n        /**\n         * mergeObjects takes all of the keys from\n         * obj2 and duplicates them into obj1\n         * @param {Object} obj1\n         * @param {Object} obj2\n         * @returns {Object}\n         */\n        function mergeObjects(obj1, obj2) {\n            for (var key in obj2) {\n                if (obj2.hasOwnProperty(key)) {\n                    obj1[key] = obj2[key];\n                }\n            }\n            return obj1;\n        }\n\n        function parseJSON(jString) {\n            try {\n                return JSON.parse(jString);\n            } catch(error) {\n                logError(error);\n                return null;\n            }\n        }\n\n        function canAccessLocalStorage() {\n            var test = 'htmx:localStorageTest';\n            try {\n                localStorage.setItem(test, test);\n                localStorage.removeItem(test);\n                return true;\n            } catch(e) {\n                return false;\n            }\n        }\n\n        function normalizePath(path) {\n            try {\n                var url = new URL(path);\n                if (url) {\n                    path = url.pathname + url.search;\n                }\n                // remove trailing slash, unless index page\n                if (!path.match('^/$')) {\n                    path = path.replace(/\\/+$/, '');\n                }\n                return path;\n            } catch (e) {\n                // be kind to IE11, which doesn't support URL()\n                return path;\n            }\n        }\n\n        //==========================================================================================\n        // public API\n        //==========================================================================================\n\n        function internalEval(str){\n            return maybeEval(getDocument().body, function () {\n                return eval(str);\n            });\n        }\n\n        function onLoadHelper(callback) {\n            var value = htmx.on(\"htmx:load\", function(evt) {\n                callback(evt.detail.elt);\n            });\n            return value;\n        }\n\n        function logAll(){\n            htmx.logger = function(elt, event, data) {\n                if(console) {\n                    console.log(event, elt, data);\n                }\n            }\n        }\n\n        function find(eltOrSelector, selector) {\n            if (selector) {\n                return eltOrSelector.querySelector(selector);\n            } else {\n                return find(getDocument(), eltOrSelector);\n            }\n        }\n\n        function findAll(eltOrSelector, selector) {\n            if (selector) {\n                return eltOrSelector.querySelectorAll(selector);\n            } else {\n                return findAll(getDocument(), eltOrSelector);\n            }\n        }\n\n        function removeElement(elt, delay) {\n            elt = resolveTarget(elt);\n            if (delay) {\n                setTimeout(function(){\n                    removeElement(elt);\n                    elt = null;\n                }, delay);\n            } else {\n                elt.parentElement.removeChild(elt);\n            }\n        }\n\n        function addClassToElement(elt, clazz, delay) {\n            elt = resolveTarget(elt);\n            if (delay) {\n                setTimeout(function(){\n                    addClassToElement(elt, clazz);\n                    elt = null;\n                }, delay);\n            } else {\n                elt.classList && elt.classList.add(clazz);\n            }\n        }\n\n        function removeClassFromElement(elt, clazz, delay) {\n            elt = resolveTarget(elt);\n            if (delay) {\n                setTimeout(function(){\n                    removeClassFromElement(elt, clazz);\n                    elt = null;\n                }, delay);\n            } else {\n                if (elt.classList) {\n                    elt.classList.remove(clazz);\n                    // if there are no classes left, remove the class attribute\n                    if (elt.classList.length === 0) {\n                        elt.removeAttribute(\"class\");\n                    }\n                }\n            }\n        }\n\n        function toggleClassOnElement(elt, clazz) {\n            elt = resolveTarget(elt);\n            elt.classList.toggle(clazz);\n        }\n\n        function takeClassForElement(elt, clazz) {\n            elt = resolveTarget(elt);\n            forEach(elt.parentElement.children, function(child){\n                removeClassFromElement(child, clazz);\n            })\n            addClassToElement(elt, clazz);\n        }\n\n        function closest(elt, selector) {\n            elt = resolveTarget(elt);\n            if (elt.closest) {\n                return elt.closest(selector);\n            } else {\n                // TODO remove when IE goes away\n                do{\n                    if (elt == null || matches(elt, selector)){\n                        return elt;\n                    }\n                }\n                while (elt = elt && parentElt(elt));\n                return null;\n            }\n        }\n\n        function normalizeSelector(selector) {\n            var trimmedSelector = selector.trim();\n            if (trimmedSelector.startsWith(\"<\") && trimmedSelector.endsWith(\"/>\")) {\n                return trimmedSelector.substring(1, trimmedSelector.length - 2);\n            } else {\n                return trimmedSelector;\n            }\n        }\n\n        function querySelectorAllExt(elt, selector) {\n            if (selector.indexOf(\"closest \") === 0) {\n                return [closest(elt, normalizeSelector(selector.substr(8)))];\n            } else if (selector.indexOf(\"find \") === 0) {\n                return [find(elt, normalizeSelector(selector.substr(5)))];\n            } else if (selector.indexOf(\"next \") === 0) {\n                return [scanForwardQuery(elt, normalizeSelector(selector.substr(5)))];\n            } else if (selector.indexOf(\"previous \") === 0) {\n                return [scanBackwardsQuery(elt, normalizeSelector(selector.substr(9)))];\n            } else if (selector === 'document') {\n                return [document];\n            } else if (selector === 'window') {\n                return [window];\n            } else {\n                return getDocument().querySelectorAll(normalizeSelector(selector));\n            }\n        }\n\n        var scanForwardQuery = function(start, match) {\n            var results = getDocument().querySelectorAll(match);\n            for (var i = 0; i < results.length; i++) {\n                var elt = results[i];\n                if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_PRECEDING) {\n                    return elt;\n                }\n            }\n        }\n\n        var scanBackwardsQuery = function(start, match) {\n            var results = getDocument().querySelectorAll(match);\n            for (var i = results.length - 1; i >= 0; i--) {\n                var elt = results[i];\n                if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_FOLLOWING) {\n                    return elt;\n                }\n            }\n        }\n\n        function querySelectorExt(eltOrSelector, selector) {\n            if (selector) {\n                return querySelectorAllExt(eltOrSelector, selector)[0];\n            } else {\n                return querySelectorAllExt(getDocument().body, eltOrSelector)[0];\n            }\n        }\n\n        function resolveTarget(arg2) {\n            if (isType(arg2, 'String')) {\n                return find(arg2);\n            } else {\n                return arg2;\n            }\n        }\n\n        function processEventArgs(arg1, arg2, arg3) {\n            if (isFunction(arg2)) {\n                return {\n                    target: getDocument().body,\n                    event: arg1,\n                    listener: arg2\n                }\n            } else {\n                return {\n                    target: resolveTarget(arg1),\n                    event: arg2,\n                    listener: arg3\n                }\n            }\n\n        }\n\n        function addEventListenerImpl(arg1, arg2, arg3) {\n            ready(function(){\n                var eventArgs = processEventArgs(arg1, arg2, arg3);\n                eventArgs.target.addEventListener(eventArgs.event, eventArgs.listener);\n            })\n            var b = isFunction(arg2);\n            return b ? arg2 : arg3;\n        }\n\n        function removeEventListenerImpl(arg1, arg2, arg3) {\n            ready(function(){\n                var eventArgs = processEventArgs(arg1, arg2, arg3);\n                eventArgs.target.removeEventListener(eventArgs.event, eventArgs.listener);\n            })\n            return isFunction(arg2) ? arg2 : arg3;\n        }\n\n        //====================================================================\n        // Node processing\n        //====================================================================\n\n        var DUMMY_ELT = getDocument().createElement(\"output\"); // dummy element for bad selectors\n        function findAttributeTargets(elt, attrName) {\n            var attrTarget = getClosestAttributeValue(elt, attrName);\n            if (attrTarget) {\n                if (attrTarget === \"this\") {\n                    return [findThisElement(elt, attrName)];\n                } else {\n                    var result = querySelectorAllExt(elt, attrTarget);\n                    if (result.length === 0) {\n                        logError('The selector \"' + attrTarget + '\" on ' + attrName + \" returned no matches!\");\n                        return [DUMMY_ELT]\n                    } else {\n                        return result;\n                    }\n                }\n            }\n        }\n\n        function findThisElement(elt, attribute){\n            return getClosestMatch(elt, function (elt) {\n                return getAttributeValue(elt, attribute) != null;\n            })\n        }\n\n        function getTarget(elt) {\n            var targetStr = getClosestAttributeValue(elt, \"hx-target\");\n            if (targetStr) {\n                if (targetStr === \"this\") {\n                    return findThisElement(elt,'hx-target');\n                } else {\n                    return querySelectorExt(elt, targetStr)\n                }\n            } else {\n                var data = getInternalData(elt);\n                if (data.boosted) {\n                    return getDocument().body;\n                } else {\n                    return elt;\n                }\n            }\n        }\n\n        function shouldSettleAttribute(name) {\n            var attributesToSettle = htmx.config.attributesToSettle;\n            for (var i = 0; i < attributesToSettle.length; i++) {\n                if (name === attributesToSettle[i]) {\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        function cloneAttributes(mergeTo, mergeFrom) {\n            forEach(mergeTo.attributes, function (attr) {\n                if (!mergeFrom.hasAttribute(attr.name) && shouldSettleAttribute(attr.name)) {\n                    mergeTo.removeAttribute(attr.name)\n                }\n            });\n            forEach(mergeFrom.attributes, function (attr) {\n                if (shouldSettleAttribute(attr.name)) {\n                    mergeTo.setAttribute(attr.name, attr.value);\n                }\n            });\n        }\n\n        function isInlineSwap(swapStyle, target) {\n            var extensions = getExtensions(target);\n            for (var i = 0; i < extensions.length; i++) {\n                var extension = extensions[i];\n                try {\n                    if (extension.isInlineSwap(swapStyle)) {\n                        return true;\n                    }\n                } catch(e) {\n                    logError(e);\n                }\n            }\n            return swapStyle === \"outerHTML\";\n        }\n\n        /**\n         *\n         * @param {string} oobValue\n         * @param {HTMLElement} oobElement\n         * @param {*} settleInfo\n         * @returns\n         */\n        function oobSwap(oobValue, oobElement, settleInfo) {\n            var selector = \"#\" + oobElement.id;\n            var swapStyle = \"outerHTML\";\n            if (oobValue === \"true\") {\n                // do nothing\n            } else if (oobValue.indexOf(\":\") > 0) {\n                swapStyle = oobValue.substr(0, oobValue.indexOf(\":\"));\n                selector  = oobValue.substr(oobValue.indexOf(\":\") + 1, oobValue.length);\n            } else {\n                swapStyle = oobValue;\n            }\n\n            var targets = getDocument().querySelectorAll(selector);\n            if (targets) {\n                forEach(\n                    targets,\n                    function (target) {\n                        var fragment;\n                        var oobElementClone = oobElement.cloneNode(true);\n                        fragment = getDocument().createDocumentFragment();\n                        fragment.appendChild(oobElementClone);\n                        if (!isInlineSwap(swapStyle, target)) {\n                            fragment = oobElementClone; // if this is not an inline swap, we use the content of the node, not the node itself\n                        }\n\n                        var beforeSwapDetails = {shouldSwap: true, target: target, fragment:fragment };\n                        if (!triggerEvent(target, 'htmx:oobBeforeSwap', beforeSwapDetails)) return;\n\n                        target = beforeSwapDetails.target; // allow re-targeting\n                        if (beforeSwapDetails['shouldSwap']){\n                            swap(swapStyle, target, target, fragment, settleInfo);\n                        }\n                        forEach(settleInfo.elts, function (elt) {\n                            triggerEvent(elt, 'htmx:oobAfterSwap', beforeSwapDetails);\n                        });\n                    }\n                );\n                oobElement.parentNode.removeChild(oobElement);\n            } else {\n                oobElement.parentNode.removeChild(oobElement);\n                triggerErrorEvent(getDocument().body, \"htmx:oobErrorNoTarget\", {content: oobElement});\n            }\n            return oobValue;\n        }\n\n        function handleOutOfBandSwaps(elt, fragment, settleInfo) {\n            var oobSelects = getClosestAttributeValue(elt, \"hx-select-oob\");\n            if (oobSelects) {\n                var oobSelectValues = oobSelects.split(\",\");\n                for (let i = 0; i < oobSelectValues.length; i++) {\n                    var oobSelectValue = oobSelectValues[i].split(\":\", 2);\n                    var id = oobSelectValue[0].trim();\n                    if (id.indexOf(\"#\") === 0) {\n                        id = id.substring(1);\n                    }\n                    var oobValue = oobSelectValue[1] || \"true\";\n                    var oobElement = fragment.querySelector(\"#\" + id);\n                    if (oobElement) {\n                        oobSwap(oobValue, oobElement, settleInfo);\n                    }\n                }\n            }\n            forEach(findAll(fragment, '[hx-swap-oob], [data-hx-swap-oob]'), function (oobElement) {\n                var oobValue = getAttributeValue(oobElement, \"hx-swap-oob\");\n                if (oobValue != null) {\n                    oobSwap(oobValue, oobElement, settleInfo);\n                }\n            });\n        }\n\n        function handlePreservedElements(fragment) {\n            forEach(findAll(fragment, '[hx-preserve], [data-hx-preserve]'), function (preservedElt) {\n                var id = getAttributeValue(preservedElt, \"id\");\n                var oldElt = getDocument().getElementById(id);\n                if (oldElt != null) {\n                    preservedElt.parentNode.replaceChild(oldElt, preservedElt);\n                }\n            });\n        }\n\n        function handleAttributes(parentNode, fragment, settleInfo) {\n            forEach(fragment.querySelectorAll(\"[id]\"), function (newNode) {\n                if (newNode.id && newNode.id.length > 0) {\n                    var normalizedId = newNode.id.replace(\"'\", \"\\\\'\");\n                    var normalizedTag = newNode.tagName.replace(':', '\\\\:');\n                    var oldNode = parentNode.querySelector(normalizedTag + \"[id='\" + normalizedId + \"']\");\n                    if (oldNode && oldNode !== parentNode) {\n                        var newAttributes = newNode.cloneNode();\n                        cloneAttributes(newNode, oldNode);\n                        settleInfo.tasks.push(function () {\n                            cloneAttributes(newNode, newAttributes);\n                        });\n                    }\n                }\n            });\n        }\n\n        function makeAjaxLoadTask(child) {\n            return function () {\n                removeClassFromElement(child, htmx.config.addedClass);\n                processNode(child);\n                processScripts(child);\n                processFocus(child)\n                triggerEvent(child, 'htmx:load');\n            };\n        }\n\n        function processFocus(child) {\n            var autofocus = \"[autofocus]\";\n            var autoFocusedElt = matches(child, autofocus) ? child : child.querySelector(autofocus)\n            if (autoFocusedElt != null) {\n                autoFocusedElt.focus();\n            }\n        }\n\n        function insertNodesBefore(parentNode, insertBefore, fragment, settleInfo) {\n            handleAttributes(parentNode, fragment, settleInfo);\n            while(fragment.childNodes.length > 0){\n                var child = fragment.firstChild;\n                addClassToElement(child, htmx.config.addedClass);\n                parentNode.insertBefore(child, insertBefore);\n                if (child.nodeType !== Node.TEXT_NODE && child.nodeType !== Node.COMMENT_NODE) {\n                    settleInfo.tasks.push(makeAjaxLoadTask(child));\n                }\n            }\n        }\n\n        // based on https://gist.github.com/hyamamoto/fd435505d29ebfa3d9716fd2be8d42f0,\n        // derived from Java's string hashcode implementation\n        function stringHash(string, hash) {\n            var char = 0;\n            while (char < string.length){\n                hash = (hash << 5) - hash + string.charCodeAt(char++) | 0; // bitwise or ensures we have a 32-bit int\n            }\n            return hash;\n        }\n\n        function attributeHash(elt) {\n            var hash = 0;\n            // IE fix\n            if (elt.attributes) {\n                for (var i = 0; i < elt.attributes.length; i++) {\n                    var attribute = elt.attributes[i];\n                    if(attribute.value){ // only include attributes w/ actual values (empty is same as non-existent)\n                        hash = stringHash(attribute.name, hash);\n                        hash = stringHash(attribute.value, hash);\n                    }\n                }\n            }\n            return hash;\n        }\n\n        function deInitNode(element) {\n            var internalData = getInternalData(element);\n            if (internalData.timeout) {\n                clearTimeout(internalData.timeout);\n            }\n            if (internalData.webSocket) {\n                internalData.webSocket.close();\n            }\n            if (internalData.sseEventSource) {\n                internalData.sseEventSource.close();\n            }\n            if (internalData.listenerInfos) {\n                forEach(internalData.listenerInfos, function (info) {\n                    if (info.on) {\n                        info.on.removeEventListener(info.trigger, info.listener);\n                    }\n                });\n            }\n            if (internalData.onHandlers) {\n                for (let i = 0; i < internalData.onHandlers.length; i++) {\n                    const handlerInfo = internalData.onHandlers[i];\n                    element.removeEventListener(handlerInfo.name, handlerInfo.handler);\n                }\n            }\n        }\n\n        function cleanUpElement(element) {\n            triggerEvent(element, \"htmx:beforeCleanupElement\")\n            deInitNode(element);\n            if (element.children) { // IE\n                forEach(element.children, function(child) { cleanUpElement(child) });\n            }\n        }\n\n        function swapOuterHTML(target, fragment, settleInfo) {\n            if (target.tagName === \"BODY\") {\n                return swapInnerHTML(target, fragment, settleInfo);\n            } else {\n                // @type {HTMLElement}\n                var newElt\n                var eltBeforeNewContent = target.previousSibling;\n                insertNodesBefore(parentElt(target), target, fragment, settleInfo);\n                if (eltBeforeNewContent == null) {\n                    newElt = parentElt(target).firstChild;\n                } else {\n                    newElt = eltBeforeNewContent.nextSibling;\n                }\n                getInternalData(target).replacedWith = newElt; // tuck away so we can fire events on it later\n                settleInfo.elts = [] // clear existing elements\n                while(newElt && newElt !== target) {\n                    if (newElt.nodeType === Node.ELEMENT_NODE) {\n                        settleInfo.elts.push(newElt);\n                    }\n                    newElt = newElt.nextElementSibling;\n                }\n                cleanUpElement(target);\n                parentElt(target).removeChild(target);\n            }\n        }\n\n        function swapAfterBegin(target, fragment, settleInfo) {\n            return insertNodesBefore(target, target.firstChild, fragment, settleInfo);\n        }\n\n        function swapBeforeBegin(target, fragment, settleInfo) {\n            return insertNodesBefore(parentElt(target), target, fragment, settleInfo);\n        }\n\n        function swapBeforeEnd(target, fragment, settleInfo) {\n            return insertNodesBefore(target, null, fragment, settleInfo);\n        }\n\n        function swapAfterEnd(target, fragment, settleInfo) {\n            return insertNodesBefore(parentElt(target), target.nextSibling, fragment, settleInfo);\n        }\n        function swapDelete(target, fragment, settleInfo) {\n            cleanUpElement(target);\n            return parentElt(target).removeChild(target);\n        }\n\n        function swapInnerHTML(target, fragment, settleInfo) {\n            var firstChild = target.firstChild;\n            insertNodesBefore(target, firstChild, fragment, settleInfo);\n            if (firstChild) {\n                while (firstChild.nextSibling) {\n                    cleanUpElement(firstChild.nextSibling)\n                    target.removeChild(firstChild.nextSibling);\n                }\n                cleanUpElement(firstChild)\n                target.removeChild(firstChild);\n            }\n        }\n\n        function maybeSelectFromResponse(elt, fragment) {\n            var selector = getClosestAttributeValue(elt, \"hx-select\");\n            if (selector) {\n                var newFragment = getDocument().createDocumentFragment();\n                forEach(fragment.querySelectorAll(selector), function (node) {\n                    newFragment.appendChild(node);\n                });\n                fragment = newFragment;\n            }\n            return fragment;\n        }\n\n        function swap(swapStyle, elt, target, fragment, settleInfo) {\n            switch (swapStyle) {\n                case \"none\":\n                    return;\n                case \"outerHTML\":\n                    swapOuterHTML(target, fragment, settleInfo);\n                    return;\n                case \"afterbegin\":\n                    swapAfterBegin(target, fragment, settleInfo);\n                    return;\n                case \"beforebegin\":\n                    swapBeforeBegin(target, fragment, settleInfo);\n                    return;\n                case \"beforeend\":\n                    swapBeforeEnd(target, fragment, settleInfo);\n                    return;\n                case \"afterend\":\n                    swapAfterEnd(target, fragment, settleInfo);\n                    return;\n                case \"delete\":\n                    swapDelete(target, fragment, settleInfo);\n                    return;\n                default:\n                    var extensions = getExtensions(elt);\n                    for (var i = 0; i < extensions.length; i++) {\n                        var ext = extensions[i];\n                        try {\n                            var newElements = ext.handleSwap(swapStyle, target, fragment, settleInfo);\n                            if (newElements) {\n                                if (typeof newElements.length !== 'undefined') {\n                                    // if handleSwap returns an array (like) of elements, we handle them\n                                    for (var j = 0; j < newElements.length; j++) {\n                                        var child = newElements[j];\n                                        if (child.nodeType !== Node.TEXT_NODE && child.nodeType !== Node.COMMENT_NODE) {\n                                            settleInfo.tasks.push(makeAjaxLoadTask(child));\n                                        }\n                                    }\n                                }\n                                return;\n                            }\n                        } catch (e) {\n                            logError(e);\n                        }\n                    }\n                    if (swapStyle === \"innerHTML\") {\n                        swapInnerHTML(target, fragment, settleInfo);\n                    } else {\n                        swap(htmx.config.defaultSwapStyle, elt, target, fragment, settleInfo);\n                    }\n            }\n        }\n\n        function findTitle(content) {\n            if (content.indexOf('<title') > -1) {\n                var contentWithSvgsRemoved = content.replace(/<svg(\\s[^>]*>|>)([\\s\\S]*?)<\\/svg>/gim, '');\n                var result = contentWithSvgsRemoved.match(/<title(\\s[^>]*>|>)([\\s\\S]*?)<\\/title>/im);\n\n                if (result) {\n                    return result[2];\n                }\n            }\n        }\n\n        function selectAndSwap(swapStyle, target, elt, responseText, settleInfo) {\n            settleInfo.title = findTitle(responseText);\n            var fragment = makeFragment(responseText);\n            if (fragment) {\n                handleOutOfBandSwaps(elt, fragment, settleInfo);\n                fragment = maybeSelectFromResponse(elt, fragment);\n                handlePreservedElements(fragment);\n                return swap(swapStyle, elt, target, fragment, settleInfo);\n            }\n        }\n\n        function handleTrigger(xhr, header, elt) {\n            var triggerBody = xhr.getResponseHeader(header);\n            if (triggerBody.indexOf(\"{\") === 0) {\n                var triggers = parseJSON(triggerBody);\n                for (var eventName in triggers) {\n                    if (triggers.hasOwnProperty(eventName)) {\n                        var detail = triggers[eventName];\n                        if (!isRawObject(detail)) {\n                            detail = {\"value\": detail}\n                        }\n                        triggerEvent(elt, eventName, detail);\n                    }\n                }\n            } else {\n                triggerEvent(elt, triggerBody, []);\n            }\n        }\n\n        var WHITESPACE = /\\s/;\n        var WHITESPACE_OR_COMMA = /[\\s,]/;\n        var SYMBOL_START = /[_$a-zA-Z]/;\n        var SYMBOL_CONT = /[_$a-zA-Z0-9]/;\n        var STRINGISH_START = ['\"', \"'\", \"/\"];\n        var NOT_WHITESPACE = /[^\\s]/;\n        function tokenizeString(str) {\n            var tokens = [];\n            var position = 0;\n            while (position < str.length) {\n                if(SYMBOL_START.exec(str.charAt(position))) {\n                    var startPosition = position;\n                    while (SYMBOL_CONT.exec(str.charAt(position + 1))) {\n                        position++;\n                    }\n                    tokens.push(str.substr(startPosition, position - startPosition + 1));\n                } else if (STRINGISH_START.indexOf(str.charAt(position)) !== -1) {\n                    var startChar = str.charAt(position);\n                    var startPosition = position;\n                    position++;\n                    while (position < str.length && str.charAt(position) !== startChar ) {\n                        if (str.charAt(position) === \"\\\\\") {\n                            position++;\n                        }\n                        position++;\n                    }\n                    tokens.push(str.substr(startPosition, position - startPosition + 1));\n                } else {\n                    var symbol = str.charAt(position);\n                    tokens.push(symbol);\n                }\n                position++;\n            }\n            return tokens;\n        }\n\n        function isPossibleRelativeReference(token, last, paramName) {\n            return SYMBOL_START.exec(token.charAt(0)) &&\n                token !== \"true\" &&\n                token !== \"false\" &&\n                token !== \"this\" &&\n                token !== paramName &&\n                last !== \".\";\n        }\n\n        function maybeGenerateConditional(elt, tokens, paramName) {\n            if (tokens[0] === '[') {\n                tokens.shift();\n                var bracketCount = 1;\n                var conditionalSource = \" return (function(\" + paramName + \"){ return (\";\n                var last = null;\n                while (tokens.length > 0) {\n                    var token = tokens[0];\n                    if (token === \"]\") {\n                        bracketCount--;\n                        if (bracketCount === 0) {\n                            if (last === null) {\n                                conditionalSource = conditionalSource + \"true\";\n                            }\n                            tokens.shift();\n                            conditionalSource += \")})\";\n                            try {\n                                var conditionFunction = maybeEval(elt,function () {\n                                    return Function(conditionalSource)();\n                                    },\n                                    function(){return true})\n                                conditionFunction.source = conditionalSource;\n                                return conditionFunction;\n                            } catch (e) {\n                                triggerErrorEvent(getDocument().body, \"htmx:syntax:error\", {error:e, source:conditionalSource})\n                                return null;\n                            }\n                        }\n                    } else if (token === \"[\") {\n                        bracketCount++;\n                    }\n                    if (isPossibleRelativeReference(token, last, paramName)) {\n                            conditionalSource += \"((\" + paramName + \".\" + token + \") ? (\" + paramName + \".\" + token + \") : (window.\" + token + \"))\";\n                    } else {\n                        conditionalSource = conditionalSource + token;\n                    }\n                    last = tokens.shift();\n                }\n            }\n        }\n\n        function consumeUntil(tokens, match) {\n            var result = \"\";\n            while (tokens.length > 0 && !tokens[0].match(match)) {\n                result += tokens.shift();\n            }\n            return result;\n        }\n\n        var INPUT_SELECTOR = 'input, textarea, select';\n\n        /**\n         * @param {HTMLElement} elt\n         * @returns {import(\"./htmx\").HtmxTriggerSpecification[]}\n         */\n        function getTriggerSpecs(elt) {\n            var explicitTrigger = getAttributeValue(elt, 'hx-trigger');\n            var triggerSpecs = [];\n            if (explicitTrigger) {\n                var tokens = tokenizeString(explicitTrigger);\n                do {\n                    consumeUntil(tokens, NOT_WHITESPACE);\n                    var initialLength = tokens.length;\n                    var trigger = consumeUntil(tokens, /[,\\[\\s]/);\n                    if (trigger !== \"\") {\n                        if (trigger === \"every\") {\n                            var every = {trigger: 'every'};\n                            consumeUntil(tokens, NOT_WHITESPACE);\n                            every.pollInterval = parseInterval(consumeUntil(tokens, /[,\\[\\s]/));\n                            consumeUntil(tokens, NOT_WHITESPACE);\n                            var eventFilter = maybeGenerateConditional(elt, tokens, \"event\");\n                            if (eventFilter) {\n                                every.eventFilter = eventFilter;\n                            }\n                            triggerSpecs.push(every);\n                        } else if (trigger.indexOf(\"sse:\") === 0) {\n                            triggerSpecs.push({trigger: 'sse', sseEvent: trigger.substr(4)});\n                        } else {\n                            var triggerSpec = {trigger: trigger};\n                            var eventFilter = maybeGenerateConditional(elt, tokens, \"event\");\n                            if (eventFilter) {\n                                triggerSpec.eventFilter = eventFilter;\n                            }\n                            while (tokens.length > 0 && tokens[0] !== \",\") {\n                                consumeUntil(tokens, NOT_WHITESPACE)\n                                var token = tokens.shift();\n                                if (token === \"changed\") {\n                                    triggerSpec.changed = true;\n                                } else if (token === \"once\") {\n                                    triggerSpec.once = true;\n                                } else if (token === \"consume\") {\n                                    triggerSpec.consume = true;\n                                } else if (token === \"delay\" && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    triggerSpec.delay = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));\n                                } else if (token === \"from\" && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    var from_arg = consumeUntil(tokens, WHITESPACE_OR_COMMA);\n                                    if (from_arg === \"closest\" || from_arg === \"find\" || from_arg === \"next\" || from_arg === \"previous\") {\n                                        tokens.shift();\n                                        from_arg +=\n                                            \" \" +\n                                            consumeUntil(\n                                                tokens,\n                                                WHITESPACE_OR_COMMA\n                                            );\n                                    }\n                                    triggerSpec.from = from_arg;\n                                } else if (token === \"target\" && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    triggerSpec.target = consumeUntil(tokens, WHITESPACE_OR_COMMA);\n                                } else if (token === \"throttle\" && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    triggerSpec.throttle = parseInterval(consumeUntil(tokens, WHITESPACE_OR_COMMA));\n                                } else if (token === \"queue\" && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    triggerSpec.queue = consumeUntil(tokens, WHITESPACE_OR_COMMA);\n                                } else if ((token === \"root\" || token === \"threshold\") && tokens[0] === \":\") {\n                                    tokens.shift();\n                                    triggerSpec[token] = consumeUntil(tokens, WHITESPACE_OR_COMMA);\n                                } else {\n                                    triggerErrorEvent(elt, \"htmx:syntax:error\", {token:tokens.shift()});\n                                }\n                            }\n                            triggerSpecs.push(triggerSpec);\n                        }\n                    }\n                    if (tokens.length === initialLength) {\n                        triggerErrorEvent(elt, \"htmx:syntax:error\", {token:tokens.shift()});\n                    }\n                    consumeUntil(tokens, NOT_WHITESPACE);\n                } while (tokens[0] === \",\" && tokens.shift())\n            }\n\n            if (triggerSpecs.length > 0) {\n                return triggerSpecs;\n            } else if (matches(elt, 'form')) {\n                return [{trigger: 'submit'}];\n            } else if (matches(elt, 'input[type=\"button\"]')){\n                return [{trigger: 'click'}];\n            } else if (matches(elt, INPUT_SELECTOR)) {\n                return [{trigger: 'change'}];\n            } else {\n                return [{trigger: 'click'}];\n            }\n        }\n\n        function cancelPolling(elt) {\n            getInternalData(elt).cancelled = true;\n        }\n\n        function processPolling(elt, handler, spec) {\n            var nodeData = getInternalData(elt);\n            nodeData.timeout = setTimeout(function () {\n                if (bodyContains(elt) && nodeData.cancelled !== true) {\n                    if (!maybeFilterEvent(spec, makeEvent('hx:poll:trigger', {triggerSpec:spec, target:elt}))) {\n                        handler(elt);\n                    }\n                    processPolling(elt, handler, spec);\n                }\n            }, spec.pollInterval);\n        }\n\n        function isLocalLink(elt) {\n            return location.hostname === elt.hostname &&\n                getRawAttribute(elt,'href') &&\n                getRawAttribute(elt,'href').indexOf(\"#\") !== 0;\n        }\n\n        function boostElement(elt, nodeData, triggerSpecs) {\n            if ((elt.tagName === \"A\" && isLocalLink(elt) && (elt.target === \"\" || elt.target === \"_self\")) || elt.tagName === \"FORM\") {\n                nodeData.boosted = true;\n                var verb, path;\n                if (elt.tagName === \"A\") {\n                    verb = \"get\";\n                    path = elt.href; // DOM property gives the fully resolved href of a relative link\n                } else {\n                    var rawAttribute = getRawAttribute(elt, \"method\");\n                    verb = rawAttribute ? rawAttribute.toLowerCase() : \"get\";\n                    if (verb === \"get\") {\n                    }\n                    path = getRawAttribute(elt, 'action');\n                }\n                triggerSpecs.forEach(function(triggerSpec) {\n                    addEventListener(elt, function(elt, evt) {\n                        issueAjaxRequest(verb, path, elt, evt)\n                    }, nodeData, triggerSpec, true);\n                });\n            }\n        }\n\n        /**\n         *\n         * @param {Event} evt\n         * @param {HTMLElement} elt\n         * @returns\n         */\n        function shouldCancel(evt, elt) {\n            if (evt.type === \"submit\" || evt.type === \"click\") {\n                if (elt.tagName === \"FORM\") {\n                    return true;\n                }\n                if (matches(elt, 'input[type=\"submit\"], button') && closest(elt, 'form') !== null) {\n                    return true;\n                }\n                if (elt.tagName === \"A\" && elt.href &&\n                    (elt.getAttribute('href') === '#' || elt.getAttribute('href').indexOf(\"#\") !== 0)) {\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        function ignoreBoostedAnchorCtrlClick(elt, evt) {\n            return getInternalData(elt).boosted && elt.tagName === \"A\" && evt.type === \"click\" && (evt.ctrlKey || evt.metaKey);\n        }\n\n        function maybeFilterEvent(triggerSpec, evt) {\n            var eventFilter = triggerSpec.eventFilter;\n            if(eventFilter){\n                try {\n                    return eventFilter(evt) !== true;\n                } catch(e) {\n                    triggerErrorEvent(getDocument().body, \"htmx:eventFilter:error\", {error: e, source:eventFilter.source});\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        function addEventListener(elt, handler, nodeData, triggerSpec, explicitCancel) {\n            var elementData = getInternalData(elt);\n            var eltsToListenOn;\n            if (triggerSpec.from) {\n                eltsToListenOn = querySelectorAllExt(elt, triggerSpec.from);\n            } else {\n                eltsToListenOn = [elt];\n            }\n            // store the initial value of the element so we can tell if it changes\n            if (triggerSpec.changed) {\n                elementData.lastValue = elt.value;\n            }\n            forEach(eltsToListenOn, function (eltToListenOn) {\n                var eventListener = function (evt) {\n                    if (!bodyContains(elt)) {\n                        eltToListenOn.removeEventListener(triggerSpec.trigger, eventListener);\n                        return;\n                    }\n                    if (ignoreBoostedAnchorCtrlClick(elt, evt)) {\n                        return;\n                    }\n                    if (explicitCancel || shouldCancel(evt, elt)) {\n                        evt.preventDefault();\n                    }\n                    if (maybeFilterEvent(triggerSpec, evt)) {\n                        return;\n                    }\n                    var eventData = getInternalData(evt);\n                    eventData.triggerSpec = triggerSpec;\n                    if (eventData.handledFor == null) {\n                        eventData.handledFor = [];\n                    }\n                    if (eventData.handledFor.indexOf(elt) < 0) {\n                        eventData.handledFor.push(elt);\n                        if (triggerSpec.consume) {\n                            evt.stopPropagation();\n                        }\n                        if (triggerSpec.target && evt.target) {\n                            if (!matches(evt.target, triggerSpec.target)) {\n                                return;\n                            }\n                        }\n                        if (triggerSpec.once) {\n                            if (elementData.triggeredOnce) {\n                                return;\n                            } else {\n                                elementData.triggeredOnce = true;\n                            }\n                        }\n                        if (triggerSpec.changed) {\n                            if (elementData.lastValue === elt.value) {\n                                return;\n                            } else {\n                                elementData.lastValue = elt.value;\n                            }\n                        }\n                        if (elementData.delayed) {\n                            clearTimeout(elementData.delayed);\n                        }\n                        if (elementData.throttle) {\n                            return;\n                        }\n\n                        if (triggerSpec.throttle) {\n                            if (!elementData.throttle) {\n                                handler(elt, evt);\n                                elementData.throttle = setTimeout(function () {\n                                    elementData.throttle = null;\n                                }, triggerSpec.throttle);\n                            }\n                        } else if (triggerSpec.delay) {\n                            elementData.delayed = setTimeout(function() { handler(elt, evt) }, triggerSpec.delay);\n                        } else {\n                            triggerEvent(elt, 'htmx:trigger')\n                            handler(elt, evt);\n                        }\n                    }\n                };\n                if (nodeData.listenerInfos == null) {\n                    nodeData.listenerInfos = [];\n                }\n                nodeData.listenerInfos.push({\n                    trigger: triggerSpec.trigger,\n                    listener: eventListener,\n                    on: eltToListenOn\n                })\n                eltToListenOn.addEventListener(triggerSpec.trigger, eventListener);\n            });\n        }\n\n        var windowIsScrolling = false // used by initScrollHandler\n        var scrollHandler = null;\n        function initScrollHandler() {\n            if (!scrollHandler) {\n                scrollHandler = function() {\n                    windowIsScrolling = true\n                };\n                window.addEventListener(\"scroll\", scrollHandler)\n                setInterval(function() {\n                    if (windowIsScrolling) {\n                        windowIsScrolling = false;\n                        forEach(getDocument().querySelectorAll(\"[hx-trigger='revealed'],[data-hx-trigger='revealed']\"), function (elt) {\n                            maybeReveal(elt);\n                        })\n                    }\n                }, 200);\n            }\n        }\n\n        function maybeReveal(elt) {\n            if (!hasAttribute(elt,'data-hx-revealed') && isScrolledIntoView(elt)) {\n                elt.setAttribute('data-hx-revealed', 'true');\n                var nodeData = getInternalData(elt);\n                if (nodeData.initHash) {\n                    triggerEvent(elt, 'revealed');\n                } else {\n                    // if the node isn't initialized, wait for it before triggering the request\n                    elt.addEventListener(\"htmx:afterProcessNode\", function(evt) { triggerEvent(elt, 'revealed') }, {once: true});\n                }\n            }\n        }\n\n        //====================================================================\n        // Web Sockets\n        //====================================================================\n\n        function processWebSocketInfo(elt, nodeData, info) {\n            var values = splitOnWhitespace(info);\n            for (var i = 0; i < values.length; i++) {\n                var value = values[i].split(/:(.+)/);\n                if (value[0] === \"connect\") {\n                    ensureWebSocket(elt, value[1], 0);\n                }\n                if (value[0] === \"send\") {\n                    processWebSocketSend(elt);\n                }\n            }\n        }\n\n        function ensureWebSocket(elt, wssSource, retryCount) {\n            if (!bodyContains(elt)) {\n                return;  // stop ensuring websocket connection when socket bearing element ceases to exist\n            }\n\n            if (wssSource.indexOf(\"/\") == 0) {  // complete absolute paths only\n                var base_part = location.hostname + (location.port ? ':'+location.port: '');\n                if (location.protocol == 'https:') {\n                    wssSource = \"wss://\" + base_part + wssSource;\n                } else if (location.protocol == 'http:') {\n                    wssSource = \"ws://\" + base_part + wssSource;\n                }\n            }\n            var socket = htmx.createWebSocket(wssSource);\n            socket.onerror = function (e) {\n                triggerErrorEvent(elt, \"htmx:wsError\", {error:e, socket:socket});\n                maybeCloseWebSocketSource(elt);\n            };\n\n            socket.onclose = function (e) {\n                if ([1006, 1012, 1013].indexOf(e.code) >= 0) {  // Abnormal Closure/Service Restart/Try Again Later\n                    var delay = getWebSocketReconnectDelay(retryCount);\n                    setTimeout(function() {\n                        ensureWebSocket(elt, wssSource, retryCount+1);  // creates a websocket with a new timeout\n                    }, delay);\n                }\n            };\n            socket.onopen = function (e) {\n                retryCount = 0;\n            }\n\n            getInternalData(elt).webSocket = socket;\n            socket.addEventListener('message', function (event) {\n                if (maybeCloseWebSocketSource(elt)) {\n                    return;\n                }\n\n                var response = event.data;\n                withExtensions(elt, function(extension){\n                    response = extension.transformResponse(response, null, elt);\n                });\n\n                var settleInfo = makeSettleInfo(elt);\n                var fragment = makeFragment(response);\n                var children = toArray(fragment.children);\n                for (var i = 0; i < children.length; i++) {\n                    var child = children[i];\n                    oobSwap(getAttributeValue(child, \"hx-swap-oob\") || \"true\", child, settleInfo);\n                }\n\n                settleImmediately(settleInfo.tasks);\n            });\n        }\n\n        function maybeCloseWebSocketSource(elt) {\n            if (!bodyContains(elt)) {\n                getInternalData(elt).webSocket.close();\n                return true;\n            }\n        }\n\n        function processWebSocketSend(elt) {\n            var webSocketSourceElt = getClosestMatch(elt, function (parent) {\n                return getInternalData(parent).webSocket != null;\n            });\n            if (webSocketSourceElt) {\n                elt.addEventListener(getTriggerSpecs(elt)[0].trigger, function (evt) {\n                    var webSocket = getInternalData(webSocketSourceElt).webSocket;\n                    var headers = getHeaders(elt, webSocketSourceElt);\n                    var results = getInputValues(elt, 'post');\n                    var errors = results.errors;\n                    var rawParameters = results.values;\n                    var expressionVars = getExpressionVars(elt);\n                    var allParameters = mergeObjects(rawParameters, expressionVars);\n                    var filteredParameters = filterValues(allParameters, elt);\n                    filteredParameters['HEADERS'] = headers;\n                    if (errors && errors.length > 0) {\n                        triggerEvent(elt, 'htmx:validation:halted', errors);\n                        return;\n                    }\n                    webSocket.send(JSON.stringify(filteredParameters));\n                    if(shouldCancel(evt, elt)){\n                        evt.preventDefault();\n                    }\n                });\n            } else {\n                triggerErrorEvent(elt, \"htmx:noWebSocketSourceError\");\n            }\n        }\n\n        function getWebSocketReconnectDelay(retryCount) {\n            var delay = htmx.config.wsReconnectDelay;\n            if (typeof delay === 'function') {\n                // @ts-ignore\n                return delay(retryCount);\n            }\n            if (delay === 'full-jitter') {\n                var exp = Math.min(retryCount, 6);\n                var maxDelay = 1000 * Math.pow(2, exp);\n                return maxDelay * Math.random();\n            }\n            logError('htmx.config.wsReconnectDelay must either be a function or the string \"full-jitter\"');\n        }\n\n        //====================================================================\n        // Server Sent Events\n        //====================================================================\n\n        function processSSEInfo(elt, nodeData, info) {\n            var values = splitOnWhitespace(info);\n            for (var i = 0; i < values.length; i++) {\n                var value = values[i].split(/:(.+)/);\n                if (value[0] === \"connect\") {\n                    processSSESource(elt, value[1]);\n                }\n\n                if ((value[0] === \"swap\")) {\n                    processSSESwap(elt, value[1])\n                }\n            }\n        }\n\n        function processSSESource(elt, sseSrc) {\n            var source = htmx.createEventSource(sseSrc);\n            source.onerror = function (e) {\n                triggerErrorEvent(elt, \"htmx:sseError\", {error:e, source:source});\n                maybeCloseSSESource(elt);\n            };\n            getInternalData(elt).sseEventSource = source;\n        }\n\n        function processSSESwap(elt, sseEventName) {\n            var sseSourceElt = getClosestMatch(elt, hasEventSource);\n            if (sseSourceElt) {\n                var sseEventSource = getInternalData(sseSourceElt).sseEventSource;\n                var sseListener = function (event) {\n                    if (maybeCloseSSESource(sseSourceElt)) {\n                        sseEventSource.removeEventListener(sseEventName, sseListener);\n                        return;\n                    }\n\n                    ///////////////////////////\n                    // TODO: merge this code with AJAX and WebSockets code in the future.\n\n                    var response = event.data;\n                    withExtensions(elt, function(extension){\n                        response = extension.transformResponse(response, null, elt);\n                    });\n\n                    var swapSpec = getSwapSpecification(elt)\n                    var target = getTarget(elt)\n                    var settleInfo = makeSettleInfo(elt);\n\n                    selectAndSwap(swapSpec.swapStyle, elt, target, response, settleInfo)\n                    settleImmediately(settleInfo.tasks)\n                    triggerEvent(elt, \"htmx:sseMessage\", event)\n                };\n\n                getInternalData(elt).sseListener = sseListener;\n                sseEventSource.addEventListener(sseEventName, sseListener);\n            } else {\n                triggerErrorEvent(elt, \"htmx:noSSESourceError\");\n            }\n        }\n\n        function processSSETrigger(elt, handler, sseEventName) {\n            var sseSourceElt = getClosestMatch(elt, hasEventSource);\n            if (sseSourceElt) {\n                var sseEventSource = getInternalData(sseSourceElt).sseEventSource;\n                var sseListener = function () {\n                    if (!maybeCloseSSESource(sseSourceElt)) {\n                        if (bodyContains(elt)) {\n                            handler(elt);\n                        } else {\n                            sseEventSource.removeEventListener(sseEventName, sseListener);\n                        }\n                    }\n                };\n                getInternalData(elt).sseListener = sseListener;\n                sseEventSource.addEventListener(sseEventName, sseListener);\n            } else {\n                triggerErrorEvent(elt, \"htmx:noSSESourceError\");\n            }\n        }\n\n        function maybeCloseSSESource(elt) {\n            if (!bodyContains(elt)) {\n                getInternalData(elt).sseEventSource.close();\n                return true;\n            }\n        }\n\n        function hasEventSource(node) {\n            return getInternalData(node).sseEventSource != null;\n        }\n\n        //====================================================================\n\n        function loadImmediately(elt, handler, nodeData, delay) {\n            var load = function(){\n                if (!nodeData.loaded) {\n                    nodeData.loaded = true;\n                    handler(elt);\n                }\n            }\n            if (delay) {\n                setTimeout(load, delay);\n            } else {\n                load();\n            }\n        }\n\n        function processVerbs(elt, nodeData, triggerSpecs) {\n            var explicitAction = false;\n            forEach(VERBS, function (verb) {\n                if (hasAttribute(elt,'hx-' + verb)) {\n                    var path = getAttributeValue(elt, 'hx-' + verb);\n                    explicitAction = true;\n                    nodeData.path = path;\n                    nodeData.verb = verb;\n                    triggerSpecs.forEach(function(triggerSpec) {\n                        addTriggerHandler(elt, triggerSpec, nodeData, function (elt, evt) {\n                            issueAjaxRequest(verb, path, elt, evt)\n                        })\n                    });\n                }\n            });\n            return explicitAction;\n        }\n\n        function addTriggerHandler(elt, triggerSpec, nodeData, handler) {\n            if (triggerSpec.sseEvent) {\n                processSSETrigger(elt, handler, triggerSpec.sseEvent);\n            } else if (triggerSpec.trigger === \"revealed\") {\n                initScrollHandler();\n                addEventListener(elt, handler, nodeData, triggerSpec);\n                maybeReveal(elt);\n            } else if (triggerSpec.trigger === \"intersect\") {\n                var observerOptions = {};\n                if (triggerSpec.root) {\n                    observerOptions.root = querySelectorExt(elt, triggerSpec.root)\n                }\n                if (triggerSpec.threshold) {\n                    observerOptions.threshold = parseFloat(triggerSpec.threshold);\n                }\n                var observer = new IntersectionObserver(function (entries) {\n                    for (var i = 0; i < entries.length; i++) {\n                        var entry = entries[i];\n                        if (entry.isIntersecting) {\n                            triggerEvent(elt, \"intersect\");\n                            break;\n                        }\n                    }\n                }, observerOptions);\n                observer.observe(elt);\n                addEventListener(elt, handler, nodeData, triggerSpec);\n            } else if (triggerSpec.trigger === \"load\") {\n                if (!maybeFilterEvent(triggerSpec, makeEvent(\"load\", {elt:elt}))) {\n                                loadImmediately(elt, handler, nodeData, triggerSpec.delay);\n                            }\n            } else if (triggerSpec.pollInterval) {\n                nodeData.polling = true;\n                processPolling(elt, handler, triggerSpec);\n            } else {\n                addEventListener(elt, handler, nodeData, triggerSpec);\n            }\n        }\n\n        function evalScript(script) {\n            if (script.type === \"text/javascript\" || script.type === \"module\" || script.type === \"\") {\n                var newScript = getDocument().createElement(\"script\");\n                forEach(script.attributes, function (attr) {\n                    newScript.setAttribute(attr.name, attr.value);\n                });\n                newScript.textContent = script.textContent;\n                newScript.async = false;\n                if (htmx.config.inlineScriptNonce) {\n                    newScript.nonce = htmx.config.inlineScriptNonce;\n                }\n                var parent = script.parentElement;\n\n                try {\n                    parent.insertBefore(newScript, script);\n                } catch (e) {\n                    logError(e);\n                } finally {\n                    // remove old script element, but only if it is still in DOM\n                    if (script.parentElement) {\n                        script.parentElement.removeChild(script);\n                    }\n                }\n            }\n        }\n\n        function processScripts(elt) {\n            if (matches(elt, \"script\")) {\n                evalScript(elt);\n            }\n            forEach(findAll(elt, \"script\"), function (script) {\n                evalScript(script);\n            });\n        }\n\n        function hasChanceOfBeingBoosted() {\n            return document.querySelector(\"[hx-boost], [data-hx-boost]\");\n        }\n\n        function findElementsToProcess(elt) {\n            if (elt.querySelectorAll) {\n                var boostedElts = hasChanceOfBeingBoosted() ? \", a, form\" : \"\";\n                var results = elt.querySelectorAll(VERB_SELECTOR + boostedElts + \", [hx-sse], [data-hx-sse], [hx-ws],\" +\n                    \" [data-hx-ws], [hx-ext], [data-hx-ext], [hx-trigger], [data-hx-trigger], [hx-on], [data-hx-on]\");\n                return results;\n            } else {\n                return [];\n            }\n        }\n\n        function initButtonTracking(form){\n            var maybeSetLastButtonClicked = function(evt){\n                var elt = closest(evt.target, \"button, input[type='submit']\");\n                if (elt !== null) {\n                    var internalData = getInternalData(form);\n                    internalData.lastButtonClicked = elt;\n                }\n            };\n\n            // need to handle both click and focus in:\n            //   focusin - in case someone tabs in to a button and hits the space bar\n            //   click - on OSX buttons do not focus on click see https://bugs.webkit.org/show_bug.cgi?id=13724\n\n            form.addEventListener('click', maybeSetLastButtonClicked)\n            form.addEventListener('focusin', maybeSetLastButtonClicked)\n            form.addEventListener('focusout', function(evt){\n                var internalData = getInternalData(form);\n                internalData.lastButtonClicked = null;\n            })\n        }\n\n        function countCurlies(line) {\n            var tokens = tokenizeString(line);\n            var netCurlies = 0;\n            for (let i = 0; i < tokens.length; i++) {\n                const token = tokens[i];\n                if (token === \"{\") {\n                    netCurlies++;\n                } else if (token === \"}\") {\n                    netCurlies--;\n                }\n            }\n            return netCurlies;\n        }\n\n        function addHxOnEventHandler(elt, eventName, code) {\n            var nodeData = getInternalData(elt);\n            nodeData.onHandlers = [];\n            var func = new Function(\"event\", code + \"; return;\");\n            var listener = elt.addEventListener(eventName, function (e) {\n                return func.call(elt, e);\n            });\n            nodeData.onHandlers.push({event:eventName, listener:listener});\n            return {nodeData, code, func, listener};\n        }\n\n        function processHxOn(elt) {\n            var hxOnValue = getAttributeValue(elt, 'hx-on');\n            if (hxOnValue) {\n                var handlers = {}\n                var lines = hxOnValue.split(\"\\n\");\n                var currentEvent = null;\n                var curlyCount = 0;\n                while (lines.length > 0) {\n                    var line = lines.shift();\n                    var match = line.match(/^\\s*([a-zA-Z:\\-]+:)(.*)/);\n                    if (curlyCount === 0 && match) {\n                        line.split(\":\")\n                        currentEvent = match[1].slice(0, -1); // strip last colon\n                        handlers[currentEvent] = match[2];\n                    } else {\n                        handlers[currentEvent] += line;\n                    }\n                    curlyCount += countCurlies(line);\n                }\n\n                for (var eventName in handlers) {\n                    addHxOnEventHandler(elt, eventName, handlers[eventName]);\n                }\n            }\n        }\n\n        function initNode(elt) {\n            if (elt.closest && elt.closest(htmx.config.disableSelector)) {\n                return;\n            }\n            var nodeData = getInternalData(elt);\n            if (nodeData.initHash !== attributeHash(elt)) {\n\n                nodeData.initHash = attributeHash(elt);\n\n                // clean up any previously processed info\n                deInitNode(elt);\n\n                processHxOn(elt);\n\n                triggerEvent(elt, \"htmx:beforeProcessNode\")\n\n                if (elt.value) {\n                    nodeData.lastValue = elt.value;\n                }\n\n                var triggerSpecs = getTriggerSpecs(elt);\n                var hasExplicitHttpAction = processVerbs(elt, nodeData, triggerSpecs);\n\n                if (!hasExplicitHttpAction) {\n                    if (getClosestAttributeValue(elt, \"hx-boost\") === \"true\") {\n                        boostElement(elt, nodeData, triggerSpecs);\n                    } else if (hasAttribute(elt, 'hx-trigger')) {\n                        triggerSpecs.forEach(function (triggerSpec) {\n                            // For \"naked\" triggers, don't do anything at all\n                            addTriggerHandler(elt, triggerSpec, nodeData, function () {\n                            })\n                        })\n                    }\n                }\n\n                if (elt.tagName === \"FORM\") {\n                    initButtonTracking(elt);\n                }\n\n                var sseInfo = getAttributeValue(elt, 'hx-sse');\n                if (sseInfo) {\n                    processSSEInfo(elt, nodeData, sseInfo);\n                }\n\n                var wsInfo = getAttributeValue(elt, 'hx-ws');\n                if (wsInfo) {\n                    processWebSocketInfo(elt, nodeData, wsInfo);\n                }\n                triggerEvent(elt, \"htmx:afterProcessNode\");\n            }\n        }\n\n        function processNode(elt) {\n            elt = resolveTarget(elt);\n            initNode(elt);\n            forEach(findElementsToProcess(elt), function(child) { initNode(child) });\n        }\n\n        //====================================================================\n        // Event/Log Support\n        //====================================================================\n\n        function kebabEventName(str) {\n            return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n        }\n\n        function makeEvent(eventName, detail) {\n            var evt;\n            if (window.CustomEvent && typeof window.CustomEvent === 'function') {\n                evt = new CustomEvent(eventName, {bubbles: true, cancelable: true, detail: detail});\n            } else {\n                evt = getDocument().createEvent('CustomEvent');\n                evt.initCustomEvent(eventName, true, true, detail);\n            }\n            return evt;\n        }\n\n        function triggerErrorEvent(elt, eventName, detail) {\n            triggerEvent(elt, eventName, mergeObjects({error:eventName}, detail));\n        }\n\n        function ignoreEventForLogging(eventName) {\n            return eventName === \"htmx:afterProcessNode\"\n        }\n\n        /**\n         * `withExtensions` locates all active extensions for a provided element, then\n         * executes the provided function using each of the active extensions.  It should\n         * be called internally at every extendable execution point in htmx.\n         *\n         * @param {HTMLElement} elt\n         * @param {(extension:import(\"./htmx\").HtmxExtension) => void} toDo\n         * @returns void\n         */\n        function withExtensions(elt, toDo) {\n            forEach(getExtensions(elt), function(extension){\n                try {\n                    toDo(extension);\n                } catch (e) {\n                    logError(e);\n                }\n            });\n        }\n\n        function logError(msg) {\n            if(console.error) {\n                console.error(msg);\n            } else if (console.log) {\n                console.log(\"ERROR: \", msg);\n            }\n        }\n\n        function triggerEvent(elt, eventName, detail) {\n            elt = resolveTarget(elt);\n            if (detail == null) {\n                detail = {};\n            }\n            detail[\"elt\"] = elt;\n            var event = makeEvent(eventName, detail);\n            if (htmx.logger && !ignoreEventForLogging(eventName)) {\n                htmx.logger(elt, eventName, detail);\n            }\n            if (detail.error) {\n                logError(detail.error);\n                triggerEvent(elt, \"htmx:error\", {errorInfo:detail})\n            }\n            var eventResult = elt.dispatchEvent(event);\n            var kebabName = kebabEventName(eventName);\n            if (eventResult && kebabName !== eventName) {\n                var kebabedEvent = makeEvent(kebabName, event.detail);\n                eventResult = eventResult && elt.dispatchEvent(kebabedEvent)\n            }\n            withExtensions(elt, function (extension) {\n                eventResult = eventResult && (extension.onEvent(eventName, event) !== false)\n            });\n            return eventResult;\n        }\n\n        //====================================================================\n        // History Support\n        //====================================================================\n        var currentPathForHistory = location.pathname+location.search;\n\n        function getHistoryElement() {\n            var historyElt = getDocument().querySelector('[hx-history-elt],[data-hx-history-elt]');\n            return historyElt || getDocument().body;\n        }\n\n        function saveToHistoryCache(url, content, title, scroll) {\n            if (!canAccessLocalStorage()) {\n                return;\n            }\n\n            url = normalizePath(url);\n\n            var historyCache = parseJSON(localStorage.getItem(\"htmx-history-cache\")) || [];\n            for (var i = 0; i < historyCache.length; i++) {\n                if (historyCache[i].url === url) {\n                    historyCache.splice(i, 1);\n                    break;\n                }\n            }\n            var newHistoryItem = {url:url, content: content, title:title, scroll:scroll};\n            triggerEvent(getDocument().body, \"htmx:historyItemCreated\", {item:newHistoryItem, cache: historyCache})\n            historyCache.push(newHistoryItem)\n            while (historyCache.length > htmx.config.historyCacheSize) {\n                historyCache.shift();\n            }\n            while(historyCache.length > 0){\n                try {\n                    localStorage.setItem(\"htmx-history-cache\", JSON.stringify(historyCache));\n                    break;\n                } catch (e) {\n                    triggerErrorEvent(getDocument().body, \"htmx:historyCacheError\", {cause:e, cache: historyCache})\n                    historyCache.shift(); // shrink the cache and retry\n                }\n            }\n        }\n\n        function getCachedHistory(url) {\n            if (!canAccessLocalStorage()) {\n                return null;\n            }\n\n            url = normalizePath(url);\n\n            var historyCache = parseJSON(localStorage.getItem(\"htmx-history-cache\")) || [];\n            for (var i = 0; i < historyCache.length; i++) {\n                if (historyCache[i].url === url) {\n                    return historyCache[i];\n                }\n            }\n            return null;\n        }\n\n        function cleanInnerHtmlForHistory(elt) {\n            var className = htmx.config.requestClass;\n            var clone = elt.cloneNode(true);\n            forEach(findAll(clone, \".\" + className), function(child){\n                removeClassFromElement(child, className);\n            });\n            return clone.innerHTML;\n        }\n\n        function saveCurrentPageToHistory() {\n            var elt = getHistoryElement();\n            var path = currentPathForHistory || location.pathname+location.search;\n\n            // Allow history snapshot feature to be disabled where hx-history=\"false\"\n            // is present *anywhere* in the current document we're about to save,\n            // so we can prevent privileged data entering the cache.\n            // The page will still be reachable as a history entry, but htmx will fetch it\n            // live from the server onpopstate rather than look in the localStorage cache\n            var disableHistoryCache = getDocument().querySelector('[hx-history=\"false\" i],[data-hx-history=\"false\" i]');\n            if (!disableHistoryCache) {\n                triggerEvent(getDocument().body, \"htmx:beforeHistorySave\", {path: path, historyElt: elt});\n                saveToHistoryCache(path, cleanInnerHtmlForHistory(elt), getDocument().title, window.scrollY);\n            }\n\n            if (htmx.config.historyEnabled) history.replaceState({htmx: true}, getDocument().title, window.location.href);\n        }\n\n        function pushUrlIntoHistory(path) {\n            // remove the cache buster parameter, if any\n            if (htmx.config.getCacheBusterParam) {\n                path = path.replace(/org\\.htmx\\.cache-buster=[^&]*&?/, '')\n                if (path.endsWith('&') || path.endsWith(\"?\")) {\n                    path = path.slice(0, -1);\n                }\n            }\n            if(htmx.config.historyEnabled) {\n                history.pushState({htmx:true}, \"\", path);\n            }\n            currentPathForHistory = path;\n        }\n\n        function replaceUrlInHistory(path) {\n            if(htmx.config.historyEnabled)  history.replaceState({htmx:true}, \"\", path);\n            currentPathForHistory = path;\n        }\n\n        function settleImmediately(tasks) {\n            forEach(tasks, function (task) {\n                task.call();\n            });\n        }\n\n        function loadHistoryFromServer(path) {\n            var request = new XMLHttpRequest();\n            var details = {path: path, xhr:request};\n            triggerEvent(getDocument().body, \"htmx:historyCacheMiss\", details);\n            request.open('GET', path, true);\n            request.setRequestHeader(\"HX-History-Restore-Request\", \"true\");\n            request.onload = function () {\n                if (this.status >= 200 && this.status < 400) {\n                    triggerEvent(getDocument().body, \"htmx:historyCacheMissLoad\", details);\n                    var fragment = makeFragment(this.response);\n                    // @ts-ignore\n                    fragment = fragment.querySelector('[hx-history-elt],[data-hx-history-elt]') || fragment;\n                    var historyElement = getHistoryElement();\n                    var settleInfo = makeSettleInfo(historyElement);\n                    var title = findTitle(this.response);\n                    if (title) {\n                        var titleElt = find(\"title\");\n                        if (titleElt) {\n                            titleElt.innerHTML = title;\n                        } else {\n                            window.document.title = title;\n                        }\n                    }\n                    // @ts-ignore\n                    swapInnerHTML(historyElement, fragment, settleInfo)\n                    settleImmediately(settleInfo.tasks);\n                    currentPathForHistory = path;\n                    triggerEvent(getDocument().body, \"htmx:historyRestore\", {path: path, cacheMiss:true, serverResponse:this.response});\n                } else {\n                    triggerErrorEvent(getDocument().body, \"htmx:historyCacheMissLoadError\", details);\n                }\n            };\n            request.send();\n        }\n\n        function restoreHistory(path) {\n            saveCurrentPageToHistory();\n            path = path || location.pathname+location.search;\n            var cached = getCachedHistory(path);\n            if (cached) {\n                var fragment = makeFragment(cached.content);\n                var historyElement = getHistoryElement();\n                var settleInfo = makeSettleInfo(historyElement);\n                swapInnerHTML(historyElement, fragment, settleInfo)\n                settleImmediately(settleInfo.tasks);\n                document.title = cached.title;\n                window.scrollTo(0, cached.scroll);\n                currentPathForHistory = path;\n                triggerEvent(getDocument().body, \"htmx:historyRestore\", {path:path, item:cached});\n            } else {\n                if (htmx.config.refreshOnHistoryMiss) {\n\n                    // @ts-ignore: optional parameter in reload() function throws error\n                    window.location.reload(true);\n                } else {\n                    loadHistoryFromServer(path);\n                }\n            }\n        }\n\n        function addRequestIndicatorClasses(elt) {\n            var indicators = findAttributeTargets(elt, 'hx-indicator');\n            if (indicators == null) {\n                indicators = [elt];\n            }\n            forEach(indicators, function (ic) {\n                var internalData = getInternalData(ic);\n                internalData.requestCount = (internalData.requestCount || 0) + 1;\n                ic.classList[\"add\"].call(ic.classList, htmx.config.requestClass);\n            });\n            return indicators;\n        }\n\n        function removeRequestIndicatorClasses(indicators) {\n            forEach(indicators, function (ic) {\n                var internalData = getInternalData(ic);\n                internalData.requestCount = (internalData.requestCount || 0) - 1;\n                if (internalData.requestCount === 0) {\n                    ic.classList[\"remove\"].call(ic.classList, htmx.config.requestClass);\n                }\n            });\n        }\n\n        //====================================================================\n        // Input Value Processing\n        //====================================================================\n\n        function haveSeenNode(processed, elt) {\n            for (var i = 0; i < processed.length; i++) {\n                var node = processed[i];\n                if (node.isSameNode(elt)) {\n                    return true;\n                }\n            }\n            return false;\n        }\n\n        function shouldInclude(elt) {\n            if(elt.name === \"\" || elt.name == null || elt.disabled) {\n                return false;\n            }\n            // ignore \"submitter\" types (see jQuery src/serialize.js)\n            if (elt.type === \"button\" || elt.type === \"submit\" || elt.tagName === \"image\" || elt.tagName === \"reset\" || elt.tagName === \"file\" ) {\n                return false;\n            }\n            if (elt.type === \"checkbox\" || elt.type === \"radio\" ) {\n                return elt.checked;\n            }\n            return true;\n        }\n\n        function processInputValue(processed, values, errors, elt, validate) {\n            if (elt == null || haveSeenNode(processed, elt)) {\n                return;\n            } else {\n                processed.push(elt);\n            }\n            if (shouldInclude(elt)) {\n                var name = getRawAttribute(elt,\"name\");\n                var value = elt.value;\n                if (elt.multiple) {\n                    value = toArray(elt.querySelectorAll(\"option:checked\")).map(function (e) { return e.value });\n                }\n                // include file inputs\n                if (elt.files) {\n                    value = toArray(elt.files);\n                }\n                // This is a little ugly because both the current value of the named value in the form\n                // and the new value could be arrays, so we have to handle all four cases :/\n                if (name != null && value != null) {\n                    var current = values[name];\n                    if (current !== undefined) {\n                        if (Array.isArray(current)) {\n                            if (Array.isArray(value)) {\n                                values[name] = current.concat(value);\n                            } else {\n                                current.push(value);\n                            }\n                        } else {\n                            if (Array.isArray(value)) {\n                                values[name] = [current].concat(value);\n                            } else {\n                                values[name] = [current, value];\n                            }\n                        }\n                    } else {\n                        values[name] = value;\n                    }\n                }\n                if (validate) {\n                    validateElement(elt, errors);\n                }\n            }\n            if (matches(elt, 'form')) {\n                var inputs = elt.elements;\n                forEach(inputs, function(input) {\n                    processInputValue(processed, values, errors, input, validate);\n                });\n            }\n        }\n\n        function validateElement(element, errors) {\n            if (element.willValidate) {\n                triggerEvent(element, \"htmx:validation:validate\")\n                if (!element.checkValidity()) {\n                    errors.push({elt: element, message:element.validationMessage, validity:element.validity});\n                    triggerEvent(element, \"htmx:validation:failed\", {message:element.validationMessage, validity:element.validity})\n                }\n            }\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {string} verb\n         */\n        function getInputValues(elt, verb) {\n            var processed = [];\n            var values = {};\n            var formValues = {};\n            var errors = [];\n            var internalData = getInternalData(elt);\n\n            // only validate when form is directly submitted and novalidate or formnovalidate are not set\n            // or if the element has an explicit hx-validate=\"true\" on it\n            var validate = (matches(elt, 'form') && elt.noValidate !== true) || getAttributeValue(elt, \"hx-validate\") === \"true\";\n            if (internalData.lastButtonClicked) {\n                validate = validate && internalData.lastButtonClicked.formNoValidate !== true;\n            }\n\n            // for a non-GET include the closest form\n            if (verb !== 'get') {\n                processInputValue(processed, formValues, errors, closest(elt, 'form'), validate);\n            }\n\n            // include the element itself\n            processInputValue(processed, values, errors, elt, validate);\n\n            // if a button or submit was clicked last, include its value\n            if (internalData.lastButtonClicked) {\n                var name = getRawAttribute(internalData.lastButtonClicked,\"name\");\n                if (name) {\n                    values[name] = internalData.lastButtonClicked.value;\n                }\n            }\n\n            // include any explicit includes\n            var includes = findAttributeTargets(elt, \"hx-include\");\n            forEach(includes, function(node) {\n                processInputValue(processed, values, errors, node, validate);\n                // if a non-form is included, include any input values within it\n                if (!matches(node, 'form')) {\n                    forEach(node.querySelectorAll(INPUT_SELECTOR), function (descendant) {\n                        processInputValue(processed, values, errors, descendant, validate);\n                    })\n                }\n            });\n\n            // form values take precedence, overriding the regular values\n            values = mergeObjects(values, formValues);\n\n            return {errors:errors, values:values};\n        }\n\n        function appendParam(returnStr, name, realValue) {\n            if (returnStr !== \"\") {\n                returnStr += \"&\";\n            }\n            if (String(realValue) === \"[object Object]\") {\n                realValue = JSON.stringify(realValue);\n            }\n            var s = encodeURIComponent(realValue);\n            returnStr += encodeURIComponent(name) + \"=\" + s;\n            return returnStr;\n        }\n\n        function urlEncode(values) {\n            var returnStr = \"\";\n            for (var name in values) {\n                if (values.hasOwnProperty(name)) {\n                    var value = values[name];\n                    if (Array.isArray(value)) {\n                        forEach(value, function(v) {\n                            returnStr = appendParam(returnStr, name, v);\n                        });\n                    } else {\n                        returnStr = appendParam(returnStr, name, value);\n                    }\n                }\n            }\n            return returnStr;\n        }\n\n        function makeFormData(values) {\n            var formData = new FormData();\n            for (var name in values) {\n                if (values.hasOwnProperty(name)) {\n                    var value = values[name];\n                    if (Array.isArray(value)) {\n                        forEach(value, function(v) {\n                            formData.append(name, v);\n                        });\n                    } else {\n                        formData.append(name, value);\n                    }\n                }\n            }\n            return formData;\n        }\n\n        //====================================================================\n        // Ajax\n        //====================================================================\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {HTMLElement} target\n         * @param {string} prompt\n         * @returns {Object} // TODO: Define/Improve HtmxHeaderSpecification\n         */\n        function getHeaders(elt, target, prompt) {\n            var headers = {\n                \"HX-Request\" : \"true\",\n                \"HX-Trigger\" : getRawAttribute(elt, \"id\"),\n                \"HX-Trigger-Name\" : getRawAttribute(elt, \"name\"),\n                \"HX-Target\" : getAttributeValue(target, \"id\"),\n                \"HX-Current-URL\" : getDocument().location.href,\n            }\n            getValuesForElement(elt, \"hx-headers\", false, headers)\n            if (prompt !== undefined) {\n                headers[\"HX-Prompt\"] = prompt;\n            }\n            if (getInternalData(elt).boosted) {\n                headers[\"HX-Boosted\"] = \"true\";\n            }\n            return headers;\n        }\n\n        /**\n         * filterValues takes an object containing form input values\n         * and returns a new object that only contains keys that are\n         * specified by the closest \"hx-params\" attribute\n         * @param {Object} inputValues\n         * @param {HTMLElement} elt\n         * @returns {Object}\n         */\n        function filterValues(inputValues, elt) {\n            var paramsValue = getClosestAttributeValue(elt, \"hx-params\");\n            if (paramsValue) {\n                if (paramsValue === \"none\") {\n                    return {};\n                } else if (paramsValue === \"*\") {\n                    return inputValues;\n                } else if(paramsValue.indexOf(\"not \") === 0) {\n                    forEach(paramsValue.substr(4).split(\",\"), function (name) {\n                        name = name.trim();\n                        delete inputValues[name];\n                    });\n                    return inputValues;\n                } else {\n                    var newValues = {}\n                    forEach(paramsValue.split(\",\"), function (name) {\n                        name = name.trim();\n                        newValues[name] = inputValues[name];\n                    });\n                    return newValues;\n                }\n            } else {\n                return inputValues;\n            }\n        }\n\n        function isAnchorLink(elt) {\n          return getRawAttribute(elt, 'href') && getRawAttribute(elt, 'href').indexOf(\"#\") >=0\n        }\n\n        /**\n         *\n         * @param {HTMLElement} elt\n         * @param {string} swapInfoOverride\n         * @returns {import(\"./htmx\").HtmxSwapSpecification}\n         */\n        function getSwapSpecification(elt, swapInfoOverride) {\n            var swapInfo = swapInfoOverride ? swapInfoOverride : getClosestAttributeValue(elt, \"hx-swap\");\n            var swapSpec = {\n                \"swapStyle\" : getInternalData(elt).boosted ? 'innerHTML' : htmx.config.defaultSwapStyle,\n                \"swapDelay\" : htmx.config.defaultSwapDelay,\n                \"settleDelay\" : htmx.config.defaultSettleDelay\n            }\n            if (getInternalData(elt).boosted && !isAnchorLink(elt)) {\n              swapSpec[\"show\"] = \"top\"\n            }\n            if (swapInfo) {\n                var split = splitOnWhitespace(swapInfo);\n                if (split.length > 0) {\n                    swapSpec[\"swapStyle\"] = split[0];\n                    for (var i = 1; i < split.length; i++) {\n                        var modifier = split[i];\n                        if (modifier.indexOf(\"swap:\") === 0) {\n                            swapSpec[\"swapDelay\"] = parseInterval(modifier.substr(5));\n                        }\n                        if (modifier.indexOf(\"settle:\") === 0) {\n                            swapSpec[\"settleDelay\"] = parseInterval(modifier.substr(7));\n                        }\n                        if (modifier.indexOf(\"transition:\") === 0) {\n                            swapSpec[\"transition\"] = modifier.substr(11) === \"true\";\n                        }\n                        if (modifier.indexOf(\"scroll:\") === 0) {\n                            var scrollSpec = modifier.substr(7);\n                            var splitSpec = scrollSpec.split(\":\");\n                            var scrollVal = splitSpec.pop();\n                            var selectorVal = splitSpec.length > 0 ? splitSpec.join(\":\") : null;\n                            swapSpec[\"scroll\"] = scrollVal;\n                            swapSpec[\"scrollTarget\"] = selectorVal;\n                        }\n                        if (modifier.indexOf(\"show:\") === 0) {\n                            var showSpec = modifier.substr(5);\n                            var splitSpec = showSpec.split(\":\");\n                            var showVal = splitSpec.pop();\n                            var selectorVal = splitSpec.length > 0 ? splitSpec.join(\":\") : null;\n                            swapSpec[\"show\"] = showVal;\n                            swapSpec[\"showTarget\"] = selectorVal;\n                        }\n                        if (modifier.indexOf(\"focus-scroll:\") === 0) {\n                            var focusScrollVal = modifier.substr(\"focus-scroll:\".length);\n                            swapSpec[\"focusScroll\"] = focusScrollVal == \"true\";\n                        }\n                    }\n                }\n            }\n            return swapSpec;\n        }\n\n        function usesFormData(elt) {\n            return getClosestAttributeValue(elt, \"hx-encoding\") === \"multipart/form-data\" ||\n                (matches(elt, \"form\") && getRawAttribute(elt, 'enctype') === \"multipart/form-data\");\n        }\n\n        function encodeParamsForBody(xhr, elt, filteredParameters) {\n            var encodedParameters = null;\n            withExtensions(elt, function (extension) {\n                if (encodedParameters == null) {\n                    encodedParameters = extension.encodeParameters(xhr, filteredParameters, elt);\n                }\n            });\n            if (encodedParameters != null) {\n                return encodedParameters;\n            } else {\n                if (usesFormData(elt)) {\n                    return makeFormData(filteredParameters);\n                } else {\n                    return urlEncode(filteredParameters);\n                }\n            }\n        }\n\n        /**\n         *\n         * @param {Element} target\n         * @returns {import(\"./htmx\").HtmxSettleInfo}\n         */\n        function makeSettleInfo(target) {\n            return {tasks: [], elts: [target]};\n        }\n\n        function updateScrollState(content, swapSpec) {\n            var first = content[0];\n            var last = content[content.length - 1];\n            if (swapSpec.scroll) {\n                var target = null;\n                if (swapSpec.scrollTarget) {\n                    target = querySelectorExt(first, swapSpec.scrollTarget);\n                }\n                if (swapSpec.scroll === \"top\" && (first || target)) {\n                    target = target || first;\n                    target.scrollTop = 0;\n                }\n                if (swapSpec.scroll === \"bottom\" && (last || target)) {\n                    target = target || last;\n                    target.scrollTop = target.scrollHeight;\n                }\n            }\n            if (swapSpec.show) {\n                var target = null;\n                if (swapSpec.showTarget) {\n                    var targetStr = swapSpec.showTarget;\n                    if (swapSpec.showTarget === \"window\") {\n                        targetStr = \"body\";\n                    }\n                    target = querySelectorExt(first, targetStr);\n                }\n                if (swapSpec.show === \"top\" && (first || target)) {\n                    target = target || first;\n                    target.scrollIntoView({block:'start', behavior: htmx.config.scrollBehavior});\n                }\n                if (swapSpec.show === \"bottom\" && (last || target)) {\n                    target = target || last;\n                    target.scrollIntoView({block:'end', behavior: htmx.config.scrollBehavior});\n                }\n            }\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {string} attr\n         * @param {boolean=} evalAsDefault\n         * @param {Object=} values\n         * @returns {Object}\n         */\n        function getValuesForElement(elt, attr, evalAsDefault, values) {\n            if (values == null) {\n                values = {};\n            }\n            if (elt == null) {\n                return values;\n            }\n            var attributeValue = getAttributeValue(elt, attr);\n            if (attributeValue) {\n                var str = attributeValue.trim();\n                var evaluateValue = evalAsDefault;\n                if (str === \"unset\") {\n                    return null;\n                }\n                if (str.indexOf(\"javascript:\") === 0) {\n                    str = str.substr(11);\n                    evaluateValue = true;\n                } else if (str.indexOf(\"js:\") === 0) {\n                    str = str.substr(3);\n                    evaluateValue = true;\n                }\n                if (str.indexOf('{') !== 0) {\n                    str = \"{\" + str + \"}\";\n                }\n                var varsValues;\n                if (evaluateValue) {\n                    varsValues = maybeEval(elt,function () {return Function(\"return (\" + str + \")\")();}, {});\n                } else {\n                    varsValues = parseJSON(str);\n                }\n                for (var key in varsValues) {\n                    if (varsValues.hasOwnProperty(key)) {\n                        if (values[key] == null) {\n                            values[key] = varsValues[key];\n                        }\n                    }\n                }\n            }\n            return getValuesForElement(parentElt(elt), attr, evalAsDefault, values);\n        }\n\n        function maybeEval(elt, toEval, defaultVal) {\n            if (htmx.config.allowEval) {\n                return toEval();\n            } else {\n                triggerErrorEvent(elt, 'htmx:evalDisallowedError');\n                return defaultVal;\n            }\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {*} expressionVars\n         * @returns\n         */\n        function getHXVarsForElement(elt, expressionVars) {\n            return getValuesForElement(elt, \"hx-vars\", true, expressionVars);\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @param {*} expressionVars\n         * @returns\n         */\n        function getHXValsForElement(elt, expressionVars) {\n            return getValuesForElement(elt, \"hx-vals\", false, expressionVars);\n        }\n\n        /**\n         * @param {HTMLElement} elt\n         * @returns {Object}\n         */\n        function getExpressionVars(elt) {\n            return mergeObjects(getHXVarsForElement(elt), getHXValsForElement(elt));\n        }\n\n        function safelySetHeaderValue(xhr, header, headerValue) {\n            if (headerValue !== null) {\n                try {\n                    xhr.setRequestHeader(header, headerValue);\n                } catch (e) {\n                    // On an exception, try to set the header URI encoded instead\n                    xhr.setRequestHeader(header, encodeURIComponent(headerValue));\n                    xhr.setRequestHeader(header + \"-URI-AutoEncoded\", \"true\");\n                }\n            }\n        }\n\n        function getPathFromResponse(xhr) {\n            // NB: IE11 does not support this stuff\n            if (xhr.responseURL && typeof(URL) !== \"undefined\") {\n                try {\n                    var url = new URL(xhr.responseURL);\n                    return url.pathname + url.search;\n                } catch (e) {\n                    triggerErrorEvent(getDocument().body, \"htmx:badResponseUrl\", {url: xhr.responseURL});\n                }\n            }\n        }\n\n        function hasHeader(xhr, regexp) {\n            return xhr.getAllResponseHeaders().match(regexp);\n        }\n\n        function ajaxHelper(verb, path, context) {\n            verb = verb.toLowerCase();\n            if (context) {\n                if (context instanceof Element || isType(context, 'String')) {\n                    return issueAjaxRequest(verb, path, null, null, {\n                        targetOverride: resolveTarget(context),\n                        returnPromise: true\n                    });\n                } else {\n                    return issueAjaxRequest(verb, path, resolveTarget(context.source), context.event,\n                        {\n                            handler : context.handler,\n                            headers : context.headers,\n                            values : context.values,\n                            targetOverride: resolveTarget(context.target),\n                            swapOverride: context.swap,\n                            returnPromise: true\n                        });\n                }\n            } else {\n                return issueAjaxRequest(verb, path, null, null, {\n                        returnPromise: true\n                });\n            }\n        }\n\n        function hierarchyForElt(elt) {\n            var arr = [];\n            while (elt) {\n                arr.push(elt);\n                elt = elt.parentElement;\n            }\n            return arr;\n        }\n\n        function issueAjaxRequest(verb, path, elt, event, etc, confirmed) {\n            var resolve = null;\n            var reject = null;\n            etc = etc != null ? etc : {};\n            if(etc.returnPromise && typeof Promise !== \"undefined\"){\n                var promise = new Promise(function (_resolve, _reject) {\n                    resolve = _resolve;\n                    reject = _reject;\n                });\n            }\n            if(elt == null) {\n                elt = getDocument().body;\n            }\n            var responseHandler = etc.handler || handleAjaxResponse;\n\n            if (!bodyContains(elt)) {\n                return; // do not issue requests for elements removed from the DOM\n            }\n            var target = etc.targetOverride || getTarget(elt);\n            if (target == null || target == DUMMY_ELT) {\n                triggerErrorEvent(elt, 'htmx:targetError', {target: getAttributeValue(elt, \"hx-target\")});\n                return;\n            }\n\n            // allow event-based confirmation w/ a callback\n            if (!confirmed) {\n                var issueRequest = function() {\n                    return issueAjaxRequest(verb, path, elt, event, etc, true);\n                }\n                var confirmDetails = {target: target, elt: elt, path: path, verb: verb, triggeringEvent: event, etc: etc, issueRequest: issueRequest};\n                if (triggerEvent(elt, 'htmx:confirm', confirmDetails) === false) {\n                    return;\n                }\n            }\n\n            var syncElt = elt;\n            var eltData = getInternalData(elt);\n            var syncStrategy = getClosestAttributeValue(elt, \"hx-sync\");\n            var queueStrategy = null;\n            var abortable = false;\n            if (syncStrategy) {\n                var syncStrings = syncStrategy.split(\":\");\n                var selector = syncStrings[0].trim();\n                if (selector === \"this\") {\n                    syncElt = findThisElement(elt, 'hx-sync');\n                } else {\n                    syncElt = querySelectorExt(elt, selector);\n                }\n                // default to the drop strategy\n                syncStrategy = (syncStrings[1] || 'drop').trim();\n                eltData = getInternalData(syncElt);\n                if (syncStrategy === \"drop\" && eltData.xhr && eltData.abortable !== true) {\n                    return;\n                } else if (syncStrategy === \"abort\") {\n                    if (eltData.xhr) {\n                        return;\n                    } else {\n                        abortable = true;\n                    }\n                } else if (syncStrategy === \"replace\") {\n                    triggerEvent(syncElt, 'htmx:abort'); // abort the current request and continue\n                } else if (syncStrategy.indexOf(\"queue\") === 0) {\n                    var queueStrArray = syncStrategy.split(\" \");\n                    queueStrategy = (queueStrArray[1] || \"last\").trim();\n                }\n            }\n\n            if (eltData.xhr) {\n                if (eltData.abortable) {\n                    triggerEvent(syncElt, 'htmx:abort'); // abort the current request and continue\n                } else {\n                    if(queueStrategy == null){\n                        if (event) {\n                            var eventData = getInternalData(event);\n                            if (eventData && eventData.triggerSpec && eventData.triggerSpec.queue) {\n                                queueStrategy = eventData.triggerSpec.queue;\n                            }\n                        }\n                        if (queueStrategy == null) {\n                            queueStrategy = \"last\";\n                        }\n                    }\n                    if (eltData.queuedRequests == null) {\n                        eltData.queuedRequests = [];\n                    }\n                    if (queueStrategy === \"first\" && eltData.queuedRequests.length === 0) {\n                        eltData.queuedRequests.push(function () {\n                            issueAjaxRequest(verb, path, elt, event, etc)\n                        });\n                    } else if (queueStrategy === \"all\") {\n                        eltData.queuedRequests.push(function () {\n                            issueAjaxRequest(verb, path, elt, event, etc)\n                        });\n                    } else if (queueStrategy === \"last\") {\n                        eltData.queuedRequests = []; // dump existing queue\n                        eltData.queuedRequests.push(function () {\n                            issueAjaxRequest(verb, path, elt, event, etc)\n                        });\n                    }\n                    return;\n                }\n            }\n\n            var xhr = new XMLHttpRequest();\n            eltData.xhr = xhr;\n            eltData.abortable = abortable;\n            var endRequestLock = function(){\n                eltData.xhr = null;\n                eltData.abortable = false;\n                if (eltData.queuedRequests != null &&\n                    eltData.queuedRequests.length > 0) {\n                    var queuedRequest = eltData.queuedRequests.shift();\n                    queuedRequest();\n                }\n            }\n            var promptQuestion = getClosestAttributeValue(elt, \"hx-prompt\");\n            if (promptQuestion) {\n                var promptResponse = prompt(promptQuestion);\n                // prompt returns null if cancelled and empty string if accepted with no entry\n                if (promptResponse === null ||\n                    !triggerEvent(elt, 'htmx:prompt', {prompt: promptResponse, target:target})) {\n                    maybeCall(resolve);\n                    endRequestLock();\n                    return promise;\n                }\n            }\n\n            var confirmQuestion = getClosestAttributeValue(elt, \"hx-confirm\");\n            if (confirmQuestion) {\n                if(!confirm(confirmQuestion)) {\n                    maybeCall(resolve);\n                    endRequestLock()\n                    return promise;\n                }\n            }\n\n\n            var headers = getHeaders(elt, target, promptResponse);\n            if (etc.headers) {\n                headers = mergeObjects(headers, etc.headers);\n            }\n            var results = getInputValues(elt, verb);\n            var errors = results.errors;\n            var rawParameters = results.values;\n            if (etc.values) {\n                rawParameters = mergeObjects(rawParameters, etc.values);\n            }\n            var expressionVars = getExpressionVars(elt);\n            var allParameters = mergeObjects(rawParameters, expressionVars);\n            var filteredParameters = filterValues(allParameters, elt);\n\n            if (verb !== 'get' && !usesFormData(elt)) {\n                headers['Content-Type'] = 'application/x-www-form-urlencoded';\n            }\n\n            if (htmx.config.getCacheBusterParam && verb === 'get') {\n                filteredParameters['org.htmx.cache-buster'] = getRawAttribute(target, \"id\") || \"true\";\n            }\n\n            // behavior of anchors w/ empty href is to use the current URL\n            if (path == null || path === \"\") {\n                path = getDocument().location.href;\n            }\n\n\n            var requestAttrValues = getValuesForElement(elt, 'hx-request');\n\n            var eltIsBoosted = getInternalData(elt).boosted;\n            var requestConfig = {\n                boosted: eltIsBoosted,\n                parameters: filteredParameters,\n                unfilteredParameters: allParameters,\n                headers:headers,\n                target:target,\n                verb:verb,\n                errors:errors,\n                withCredentials: etc.credentials || requestAttrValues.credentials || htmx.config.withCredentials,\n                timeout:  etc.timeout || requestAttrValues.timeout || htmx.config.timeout,\n                path:path,\n                triggeringEvent:event\n            };\n\n            if(!triggerEvent(elt, 'htmx:configRequest', requestConfig)){\n                maybeCall(resolve);\n                endRequestLock();\n                return promise;\n            }\n\n            // copy out in case the object was overwritten\n            path = requestConfig.path;\n            verb = requestConfig.verb;\n            headers = requestConfig.headers;\n            filteredParameters = requestConfig.parameters;\n            errors = requestConfig.errors;\n\n            if(errors && errors.length > 0){\n                triggerEvent(elt, 'htmx:validation:halted', requestConfig)\n                maybeCall(resolve);\n                endRequestLock();\n                return promise;\n            }\n\n            var splitPath = path.split(\"#\");\n            var pathNoAnchor = splitPath[0];\n            var anchor = splitPath[1];\n            var finalPathForGet = null;\n            if (verb === 'get') {\n                finalPathForGet = pathNoAnchor;\n                var values = Object.keys(filteredParameters).length !== 0;\n                if (values) {\n                    if (finalPathForGet.indexOf(\"?\") < 0) {\n                        finalPathForGet += \"?\";\n                    } else {\n                        finalPathForGet += \"&\";\n                    }\n                    finalPathForGet += urlEncode(filteredParameters);\n                    if (anchor) {\n                        finalPathForGet += \"#\" + anchor;\n                    }\n                }\n                xhr.open('GET', finalPathForGet, true);\n            } else {\n                xhr.open(verb.toUpperCase(), path, true);\n            }\n\n            xhr.overrideMimeType(\"text/html\");\n            xhr.withCredentials = requestConfig.withCredentials;\n            xhr.timeout = requestConfig.timeout;\n\n            // request headers\n            if (requestAttrValues.noHeaders) {\n                // ignore all headers\n            } else {\n                for (var header in headers) {\n                    if (headers.hasOwnProperty(header)) {\n                        var headerValue = headers[header];\n                        safelySetHeaderValue(xhr, header, headerValue);\n                    }\n                }\n            }\n\n            var responseInfo = {\n                xhr: xhr, target: target, requestConfig: requestConfig, etc: etc, boosted: eltIsBoosted,\n                pathInfo: {\n                    requestPath: path,\n                    finalRequestPath: finalPathForGet || path,\n                    anchor: anchor\n                }\n            };\n\n            xhr.onload = function () {\n                try {\n                    var hierarchy = hierarchyForElt(elt);\n                    responseInfo.pathInfo.responsePath = getPathFromResponse(xhr);\n                    responseHandler(elt, responseInfo);\n                    removeRequestIndicatorClasses(indicators);\n                    triggerEvent(elt, 'htmx:afterRequest', responseInfo);\n                    triggerEvent(elt, 'htmx:afterOnLoad', responseInfo);\n                    // if the body no longer contains the element, trigger the event on the closest parent\n                    // remaining in the DOM\n                    if (!bodyContains(elt)) {\n                        var secondaryTriggerElt = null;\n                        while (hierarchy.length > 0 && secondaryTriggerElt == null) {\n                            var parentEltInHierarchy = hierarchy.shift();\n                            if (bodyContains(parentEltInHierarchy)) {\n                                secondaryTriggerElt = parentEltInHierarchy;\n                            }\n                        }\n                        if (secondaryTriggerElt) {\n                            triggerEvent(secondaryTriggerElt, 'htmx:afterRequest', responseInfo);\n                            triggerEvent(secondaryTriggerElt, 'htmx:afterOnLoad', responseInfo);\n                        }\n                    }\n                    maybeCall(resolve);\n                    endRequestLock();\n                } catch (e) {\n                    triggerErrorEvent(elt, 'htmx:onLoadError', mergeObjects({error:e}, responseInfo));\n                    throw e;\n                }\n            }\n            xhr.onerror = function () {\n                removeRequestIndicatorClasses(indicators);\n                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);\n                triggerErrorEvent(elt, 'htmx:sendError', responseInfo);\n                maybeCall(reject);\n                endRequestLock();\n            }\n            xhr.onabort = function() {\n                removeRequestIndicatorClasses(indicators);\n                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);\n                triggerErrorEvent(elt, 'htmx:sendAbort', responseInfo);\n                maybeCall(reject);\n                endRequestLock();\n            }\n            xhr.ontimeout = function() {\n                removeRequestIndicatorClasses(indicators);\n                triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo);\n                triggerErrorEvent(elt, 'htmx:timeout', responseInfo);\n                maybeCall(reject);\n                endRequestLock();\n            }\n            if(!triggerEvent(elt, 'htmx:beforeRequest', responseInfo)){\n                maybeCall(resolve);\n                endRequestLock()\n                return promise\n            }\n            var indicators = addRequestIndicatorClasses(elt);\n\n            forEach(['loadstart', 'loadend', 'progress', 'abort'], function(eventName) {\n                forEach([xhr, xhr.upload], function (target) {\n                    target.addEventListener(eventName, function(event){\n                        triggerEvent(elt, \"htmx:xhr:\" + eventName, {\n                            lengthComputable:event.lengthComputable,\n                            loaded:event.loaded,\n                            total:event.total\n                        });\n                    })\n                });\n            });\n            triggerEvent(elt, 'htmx:beforeSend', responseInfo);\n            xhr.send(verb === 'get' ? null : encodeParamsForBody(xhr, elt, filteredParameters));\n            return promise;\n        }\n\n        function determineHistoryUpdates(elt, responseInfo) {\n\n            var xhr = responseInfo.xhr;\n\n            //===========================================\n            // First consult response headers\n            //===========================================\n            var pathFromHeaders = null;\n            var typeFromHeaders = null;\n            if (hasHeader(xhr,/HX-Push:/i)) {\n                pathFromHeaders = xhr.getResponseHeader(\"HX-Push\");\n                typeFromHeaders = \"push\";\n            } else if (hasHeader(xhr,/HX-Push-Url:/i)) {\n                pathFromHeaders = xhr.getResponseHeader(\"HX-Push-Url\");\n                typeFromHeaders = \"push\";\n            } else if (hasHeader(xhr,/HX-Replace-Url:/i)) {\n                pathFromHeaders = xhr.getResponseHeader(\"HX-Replace-Url\");\n                typeFromHeaders = \"replace\";\n            }\n\n            // if there was a response header, that has priority\n            if (pathFromHeaders) {\n                if (pathFromHeaders === \"false\") {\n                    return {}\n                } else {\n                    return {\n                        type: typeFromHeaders,\n                        path : pathFromHeaders\n                    }\n                }\n            }\n\n            //===========================================\n            // Next resolve via DOM values\n            //===========================================\n            var requestPath =  responseInfo.pathInfo.finalRequestPath;\n            var responsePath =  responseInfo.pathInfo.responsePath;\n\n            var pushUrl = getClosestAttributeValue(elt, \"hx-push-url\");\n            var replaceUrl = getClosestAttributeValue(elt, \"hx-replace-url\");\n            var elementIsBoosted = getInternalData(elt).boosted;\n\n            var saveType = null;\n            var path = null;\n\n            if (pushUrl) {\n                saveType = \"push\";\n                path = pushUrl;\n            } else if (replaceUrl) {\n                saveType = \"replace\";\n                path = replaceUrl;\n            } else if (elementIsBoosted) {\n                saveType = \"push\";\n                path = responsePath || requestPath; // if there is no response path, go with the original request path\n            }\n\n            if (path) {\n                // false indicates no push, return empty object\n                if (path === \"false\") {\n                    return {};\n                }\n\n                // true indicates we want to follow wherever the server ended up sending us\n                if (path === \"true\") {\n                    path = responsePath || requestPath; // if there is no response path, go with the original request path\n                }\n\n                // restore any anchor associated with the request\n                if (responseInfo.pathInfo.anchor &&\n                    path.indexOf(\"#\") === -1) {\n                    path = path + \"#\" + responseInfo.pathInfo.anchor;\n                }\n\n                return {\n                    type:saveType,\n                    path: path\n                }\n            } else {\n                return {};\n            }\n        }\n\n        function handleAjaxResponse(elt, responseInfo) {\n            var xhr = responseInfo.xhr;\n            var target = responseInfo.target;\n            var etc = responseInfo.etc;\n\n            if (!triggerEvent(elt, 'htmx:beforeOnLoad', responseInfo)) return;\n\n            if (hasHeader(xhr, /HX-Trigger:/i)) {\n                handleTrigger(xhr, \"HX-Trigger\", elt);\n            }\n\n            if (hasHeader(xhr, /HX-Location:/i)) {\n                saveCurrentPageToHistory();\n                var redirectPath = xhr.getResponseHeader(\"HX-Location\");\n                var swapSpec;\n                if (redirectPath.indexOf(\"{\") === 0) {\n                    swapSpec = parseJSON(redirectPath);\n                    // what's the best way to throw an error if the user didn't include this\n                    redirectPath = swapSpec['path'];\n                    delete swapSpec['path'];\n                }\n                ajaxHelper('GET', redirectPath, swapSpec).then(function(){\n                    pushUrlIntoHistory(redirectPath);\n                });\n                return;\n            }\n\n            if (hasHeader(xhr, /HX-Redirect:/i)) {\n                location.href = xhr.getResponseHeader(\"HX-Redirect\");\n                return;\n            }\n\n            if (hasHeader(xhr,/HX-Refresh:/i)) {\n                if (\"true\" === xhr.getResponseHeader(\"HX-Refresh\")) {\n                    location.reload();\n                    return;\n                }\n            }\n\n            if (hasHeader(xhr,/HX-Retarget:/i)) {\n                responseInfo.target = getDocument().querySelector(xhr.getResponseHeader(\"HX-Retarget\"));\n            }\n\n            var historyUpdate = determineHistoryUpdates(elt, responseInfo);\n\n            // by default htmx only swaps on 200 return codes and does not swap\n            // on 204 'No Content'\n            // this can be ovverriden by responding to the htmx:beforeSwap event and\n            // overriding the detail.shouldSwap property\n            var shouldSwap = xhr.status >= 200 && xhr.status < 400 && xhr.status !== 204;\n            var serverResponse = xhr.response;\n            var isError = xhr.status >= 400;\n            var beforeSwapDetails = mergeObjects({shouldSwap: shouldSwap, serverResponse:serverResponse, isError:isError}, responseInfo);\n            if (!triggerEvent(target, 'htmx:beforeSwap', beforeSwapDetails)) return;\n\n            target = beforeSwapDetails.target; // allow re-targeting\n            serverResponse = beforeSwapDetails.serverResponse; // allow updating content\n            isError = beforeSwapDetails.isError; // allow updating error\n\n            responseInfo.target = target; // Make updated target available to response events\n            responseInfo.failed = isError; // Make failed property available to response events\n            responseInfo.successful = !isError; // Make successful property available to response events\n\n            if (beforeSwapDetails.shouldSwap) {\n                if (xhr.status === 286) {\n                    cancelPolling(elt);\n                }\n\n                withExtensions(elt, function (extension) {\n                    serverResponse = extension.transformResponse(serverResponse, xhr, elt);\n                });\n\n                // Save current page if there will be a history update\n                if (historyUpdate.type) {\n                    saveCurrentPageToHistory();\n                }\n\n                var swapOverride = etc.swapOverride;\n                if (hasHeader(xhr,/HX-Reswap:/i)) {\n                    swapOverride = xhr.getResponseHeader(\"HX-Reswap\");\n                }\n                var swapSpec = getSwapSpecification(elt, swapOverride);\n\n                target.classList.add(htmx.config.swappingClass);\n\n                // optional transition API promise callbacks\n                var settleResolve = null;\n                var settleReject = null;\n\n                var doSwap = function () {\n                    try {\n                        var activeElt = document.activeElement;\n                        var selectionInfo = {};\n                        try {\n                            selectionInfo = {\n                                elt: activeElt,\n                                // @ts-ignore\n                                start: activeElt ? activeElt.selectionStart : null,\n                                // @ts-ignore\n                                end: activeElt ? activeElt.selectionEnd : null\n                            };\n                        } catch (e) {\n                            // safari issue - see https://github.com/microsoft/playwright/issues/5894\n                        }\n\n                        var settleInfo = makeSettleInfo(target);\n                        selectAndSwap(swapSpec.swapStyle, target, elt, serverResponse, settleInfo);\n\n                        if (selectionInfo.elt &&\n                            !bodyContains(selectionInfo.elt) &&\n                            selectionInfo.elt.id) {\n                            var newActiveElt = document.getElementById(selectionInfo.elt.id);\n                            var focusOptions = { preventScroll: swapSpec.focusScroll !== undefined ? !swapSpec.focusScroll : !htmx.config.defaultFocusScroll };\n                            if (newActiveElt) {\n                                // @ts-ignore\n                                if (selectionInfo.start && newActiveElt.setSelectionRange) {\n                                    // @ts-ignore\n                                    try {\n                                        newActiveElt.setSelectionRange(selectionInfo.start, selectionInfo.end);\n                                    } catch (e) {\n                                        // the setSelectionRange method is present on fields that don't support it, so just let this fail\n                                    }\n                                }\n                                newActiveElt.focus(focusOptions);\n                            }\n                        }\n\n                        target.classList.remove(htmx.config.swappingClass);\n                        forEach(settleInfo.elts, function (elt) {\n                            if (elt.classList) {\n                                elt.classList.add(htmx.config.settlingClass);\n                            }\n                            triggerEvent(elt, 'htmx:afterSwap', responseInfo);\n                        });\n\n                        if (hasHeader(xhr, /HX-Trigger-After-Swap:/i)) {\n                            var finalElt = elt;\n                            if (!bodyContains(elt)) {\n                                finalElt = getDocument().body;\n                            }\n                            handleTrigger(xhr, \"HX-Trigger-After-Swap\", finalElt);\n                        }\n\n                        var doSettle = function () {\n                            forEach(settleInfo.tasks, function (task) {\n                                task.call();\n                            });\n                            forEach(settleInfo.elts, function (elt) {\n                                if (elt.classList) {\n                                    elt.classList.remove(htmx.config.settlingClass);\n                                }\n                                triggerEvent(elt, 'htmx:afterSettle', responseInfo);\n                            });\n\n                            // if we need to save history, do so\n                            if (historyUpdate.type) {\n                                if (historyUpdate.type === \"push\") {\n                                    pushUrlIntoHistory(historyUpdate.path);\n                                    triggerEvent(getDocument().body, 'htmx:pushedIntoHistory', {path: historyUpdate.path});\n                                } else {\n                                    replaceUrlInHistory(historyUpdate.path);\n                                    triggerEvent(getDocument().body, 'htmx:replacedInHistory', {path: historyUpdate.path});\n                                }\n                            }\n                            if (responseInfo.pathInfo.anchor) {\n                                var anchorTarget = find(\"#\" + responseInfo.pathInfo.anchor);\n                                if(anchorTarget) {\n                                    anchorTarget.scrollIntoView({block:'start', behavior: \"auto\"});\n                                }\n                            }\n\n                            if(settleInfo.title) {\n                                var titleElt = find(\"title\");\n                                if(titleElt) {\n                                    titleElt.innerHTML = settleInfo.title;\n                                } else {\n                                    window.document.title = settleInfo.title;\n                                }\n                            }\n\n                            updateScrollState(settleInfo.elts, swapSpec);\n\n                            if (hasHeader(xhr, /HX-Trigger-After-Settle:/i)) {\n                                var finalElt = elt;\n                                if (!bodyContains(elt)) {\n                                    finalElt = getDocument().body;\n                                }\n                                handleTrigger(xhr, \"HX-Trigger-After-Settle\", finalElt);\n                            }\n                            maybeCall(settleResolve);\n                        }\n\n                        if (swapSpec.settleDelay > 0) {\n                            setTimeout(doSettle, swapSpec.settleDelay)\n                        } else {\n                            doSettle();\n                        }\n                    } catch (e) {\n                        triggerErrorEvent(elt, 'htmx:swapError', responseInfo);\n                        maybeCall(settleReject);\n                        throw e;\n                    }\n                };\n\n                var shouldTransition = htmx.config.globalViewTransitions\n                if(swapSpec.hasOwnProperty('transition')){\n                    shouldTransition = swapSpec.transition;\n                }\n\n                if(shouldTransition &&\n                    triggerEvent(elt, 'htmx:beforeTransition', responseInfo) &&\n                    typeof Promise !== \"undefined\" && document.startViewTransition){\n                    var settlePromise = new Promise(function (_resolve, _reject) {\n                        settleResolve = _resolve;\n                        settleReject = _reject;\n                    });\n                    // wrap the original doSwap() in a call to startViewTransition()\n                    var innerDoSwap = doSwap;\n                    doSwap = function() {\n                        document.startViewTransition(function () {\n                            innerDoSwap();\n                            return settlePromise;\n                        });\n                    }\n                }\n\n\n                if (swapSpec.swapDelay > 0) {\n                    setTimeout(doSwap, swapSpec.swapDelay)\n                } else {\n                    doSwap();\n                }\n            }\n            if (isError) {\n                triggerErrorEvent(elt, 'htmx:responseError', mergeObjects({error: \"Response Status Error Code \" + xhr.status + \" from \" + responseInfo.pathInfo.requestPath}, responseInfo));\n            }\n        }\n\n        //====================================================================\n        // Extensions API\n        //====================================================================\n\n        /** @type {Object<string, import(\"./htmx\").HtmxExtension>} */\n        var extensions = {};\n\n        /**\n         * extensionBase defines the default functions for all extensions.\n         * @returns {import(\"./htmx\").HtmxExtension}\n         */\n        function extensionBase() {\n            return {\n                init: function(api) {return null;},\n                onEvent : function(name, evt) {return true;},\n                transformResponse : function(text, xhr, elt) {return text;},\n                isInlineSwap : function(swapStyle) {return false;},\n                handleSwap : function(swapStyle, target, fragment, settleInfo) {return false;},\n                encodeParameters : function(xhr, parameters, elt) {return null;}\n            }\n        }\n\n        /**\n         * defineExtension initializes the extension and adds it to the htmx registry\n         *\n         * @param {string} name\n         * @param {import(\"./htmx\").HtmxExtension} extension\n         */\n        function defineExtension(name, extension) {\n            if(extension.init) {\n                extension.init(internalAPI)\n            }\n            extensions[name] = mergeObjects(extensionBase(), extension);\n        }\n\n        /**\n         * removeExtension removes an extension from the htmx registry\n         *\n         * @param {string} name\n         */\n        function removeExtension(name) {\n            delete extensions[name];\n        }\n\n        /**\n         * getExtensions searches up the DOM tree to return all extensions that can be applied to a given element\n         *\n         * @param {HTMLElement} elt\n         * @param {import(\"./htmx\").HtmxExtension[]=} extensionsToReturn\n         * @param {import(\"./htmx\").HtmxExtension[]=} extensionsToIgnore\n         */\n         function getExtensions(elt, extensionsToReturn, extensionsToIgnore) {\n\n            if (elt == undefined) {\n                return extensionsToReturn;\n            }\n            if (extensionsToReturn == undefined) {\n                extensionsToReturn = [];\n            }\n            if (extensionsToIgnore == undefined) {\n                extensionsToIgnore = [];\n            }\n            var extensionsForElement = getAttributeValue(elt, \"hx-ext\");\n            if (extensionsForElement) {\n                forEach(extensionsForElement.split(\",\"), function(extensionName){\n                    extensionName = extensionName.replace(/ /g, '');\n                    if (extensionName.slice(0, 7) == \"ignore:\") {\n                        extensionsToIgnore.push(extensionName.slice(7));\n                        return;\n                    }\n                    if (extensionsToIgnore.indexOf(extensionName) < 0) {\n                        var extension = extensions[extensionName];\n                        if (extension && extensionsToReturn.indexOf(extension) < 0) {\n                            extensionsToReturn.push(extension);\n                        }\n                    }\n                });\n            }\n            return getExtensions(parentElt(elt), extensionsToReturn, extensionsToIgnore);\n        }\n\n        //====================================================================\n        // Initialization\n        //====================================================================\n\n        function ready(fn) {\n            if (getDocument().readyState !== 'loading') {\n                fn();\n            } else {\n                getDocument().addEventListener('DOMContentLoaded', fn);\n            }\n        }\n\n        function insertIndicatorStyles() {\n            if (htmx.config.includeIndicatorStyles !== false) {\n                getDocument().head.insertAdjacentHTML(\"beforeend\",\n                    \"<style>\\\n                      .\" + htmx.config.indicatorClass + \"{opacity:0;transition: opacity 200ms ease-in;}\\\n                      .\" + htmx.config.requestClass + \" .\" + htmx.config.indicatorClass + \"{opacity:1}\\\n                      .\" + htmx.config.requestClass + \".\" + htmx.config.indicatorClass + \"{opacity:1}\\\n                    </style>\");\n            }\n        }\n\n        function getMetaConfig() {\n            var element = getDocument().querySelector('meta[name=\"htmx-config\"]');\n            if (element) {\n                // @ts-ignore\n                return parseJSON(element.content);\n            } else {\n                return null;\n            }\n        }\n\n        function mergeMetaConfig() {\n            var metaConfig = getMetaConfig();\n            if (metaConfig) {\n                htmx.config = mergeObjects(htmx.config , metaConfig)\n            }\n        }\n\n        // initialize the document\n        ready(function () {\n            mergeMetaConfig();\n            insertIndicatorStyles();\n            var body = getDocument().body;\n            processNode(body);\n            var restoredElts = getDocument().querySelectorAll(\n                \"[hx-trigger='restored'],[data-hx-trigger='restored']\"\n            );\n            body.addEventListener(\"htmx:abort\", function (evt) {\n                var target = evt.target;\n                var internalData = getInternalData(target);\n                if (internalData && internalData.xhr) {\n                    internalData.xhr.abort();\n                }\n            });\n            var originalPopstate = window.onpopstate;\n            window.onpopstate = function (event) {\n                if (event.state && event.state.htmx) {\n                    restoreHistory();\n                    forEach(restoredElts, function(elt){\n                        triggerEvent(elt, 'htmx:restored', {\n                            'document': getDocument(),\n                            'triggerEvent': triggerEvent\n                        });\n                    });\n                } else {\n                    if (originalPopstate) {\n                        originalPopstate(event);\n                    }\n                }\n            };\n            setTimeout(function () {\n                triggerEvent(body, 'htmx:load', {}); // give ready handlers a chance to load up before firing this event\n                body = null; // kill reference for gc\n            }, 0);\n        })\n\n        return htmx;\n    }\n)()\n}));\n"],"names":["root","factory","define","amd","module","exports","htmx","self","this","onLoad","onLoadHelper","process","processNode","on","addEventListenerImpl","off","removeEventListenerImpl","trigger","triggerEvent","ajax","ajaxHelper","find","findAll","closest","values","elt","type","getInputValues","remove","removeElement","addClass","addClassToElement","removeClass","removeClassFromElement","toggleClass","toggleClassOnElement","takeClass","takeClassForElement","defineExtension","removeExtension","logAll","logger","config","historyEnabled","historyCacheSize","refreshOnHistoryMiss","defaultSwapStyle","defaultSwapDelay","defaultSettleDelay","includeIndicatorStyles","indicatorClass","requestClass","addedClass","settlingClass","swappingClass","allowEval","inlineScriptNonce","attributesToSettle","withCredentials","timeout","wsReconnectDelay","wsBinaryType","disableSelector","useTemplateFragments","scrollBehavior","defaultFocusScroll","getCacheBusterParam","globalViewTransitions","parseInterval","_","internalEval","createEventSource","url","EventSource","createWebSocket","sock","WebSocket","binaryType","version","internalAPI","addTriggerHandler","bodyContains","canAccessLocalStorage","filterValues","hasAttribute","getAttributeValue","getClosestMatch","getExpressionVars","getHeaders","getInternalData","getSwapSpecification","getTriggerSpecs","getTarget","makeFragment","mergeObjects","makeSettleInfo","oobSwap","selectAndSwap","settleImmediately","shouldCancel","triggerErrorEvent","withExtensions","VERBS","VERB_SELECTOR","map","verb","join","str","undefined","slice","parseFloat","getRawAttribute","name","getAttribute","qualifiedName","parentElt","parentElement","getDocument","document","condition","getAttributeValueWithDisinheritance","initialElement","ancestor","attributeName","attributeValue","disinherit","split","indexOf","getClosestAttributeValue","closestAttr","e","matches","selector","matchesFunction","matchesSelector","msMatchesSelector","mozMatchesSelector","webkitMatchesSelector","oMatchesSelector","call","getStartTag","match","exec","toLowerCase","parseHTML","resp","depth","responseNode","DOMParser","parseFromString","body","firstChild","createDocumentFragment","aFullPageResponse","partialResponse","querySelector","content","maybeCall","func","isType","o","Object","prototype","toString","isFunction","isRawObject","dataProp","data","toArray","arr","returnArr","i","length","push","forEach","isScrolledIntoView","el","rect","getBoundingClientRect","elemTop","top","elemBottom","bottom","window","innerHeight","getRootNode","ShadowRoot","contains","host","splitOnWhitespace","trim","obj1","obj2","key","hasOwnProperty","parseJSON","jString","JSON","parse","error","logError","test","localStorage","setItem","removeItem","normalizePath","path","URL","pathname","search","replace","maybeEval","eval","callback","evt","detail","event","console","log","eltOrSelector","querySelectorAll","delay","resolveTarget","setTimeout","removeChild","clazz","classList","add","removeAttribute","toggle","children","child","normalizeSelector","trimmedSelector","startsWith","endsWith","substring","querySelectorAllExt","substr","scanForwardQuery","scanBackwardsQuery","start","results","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_FOLLOWING","querySelectorExt","arg2","processEventArgs","arg1","arg3","target","listener","ready","eventArgs","addEventListener","removeEventListener","DUMMY_ELT","createElement","findAttributeTargets","attrName","attrTarget","findThisElement","result","attribute","targetStr","boosted","shouldSettleAttribute","cloneAttributes","mergeTo","mergeFrom","attributes","attr","setAttribute","value","isInlineSwap","swapStyle","extensions","getExtensions","extension","oobValue","oobElement","settleInfo","id","targets","fragment","oobElementClone","cloneNode","appendChild","beforeSwapDetails","shouldSwap","swap","elts","parentNode","handleOutOfBandSwaps","oobSelects","oobSelectValues","oobSelectValue","handlePreservedElements","preservedElt","oldElt","getElementById","replaceChild","handleAttributes","newNode","normalizedId","normalizedTag","tagName","oldNode","newAttributes","tasks","makeAjaxLoadTask","processScripts","processFocus","autofocus","autoFocusedElt","focus","insertNodesBefore","insertBefore","childNodes","nodeType","TEXT_NODE","COMMENT_NODE","stringHash","string","hash","char","charCodeAt","attributeHash","deInitNode","element","internalData","clearTimeout","webSocket","close","sseEventSource","listenerInfos","info","onHandlers","handlerInfo","handler","cleanUpElement","swapOuterHTML","swapInnerHTML","newElt","eltBeforeNewContent","previousSibling","nextSibling","replacedWith","ELEMENT_NODE","nextElementSibling","swapAfterBegin","swapBeforeBegin","swapBeforeEnd","swapAfterEnd","swapDelete","maybeSelectFromResponse","newFragment","node","ext","newElements","handleSwap","j","findTitle","responseText","title","handleTrigger","xhr","header","triggerBody","getResponseHeader","triggers","eventName","WHITESPACE","WHITESPACE_OR_COMMA","SYMBOL_START","SYMBOL_CONT","STRINGISH_START","NOT_WHITESPACE","tokenizeString","tokens","position","charAt","startPosition","startChar","symbol","isPossibleRelativeReference","token","last","paramName","maybeGenerateConditional","shift","bracketCount","conditionalSource","conditionFunction","Function","source","consumeUntil","INPUT_SELECTOR","explicitTrigger","triggerSpecs","initialLength","every","pollInterval","eventFilter","sseEvent","triggerSpec","changed","once","consume","from_arg","from","throttle","queue","cancelPolling","cancelled","processPolling","spec","nodeData","maybeFilterEvent","makeEvent","isLocalLink","location","hostname","boostElement","href","rawAttribute","issueAjaxRequest","ignoreBoostedAnchorCtrlClick","ctrlKey","metaKey","explicitCancel","eltsToListenOn","elementData","lastValue","eltToListenOn","eventListener","preventDefault","eventData","handledFor","stopPropagation","triggeredOnce","delayed","windowIsScrolling","scrollHandler","initScrollHandler","setInterval","maybeReveal","initHash","processWebSocketInfo","ensureWebSocket","processWebSocketSend","wssSource","retryCount","base_part","port","protocol","socket","onerror","maybeCloseWebSocketSource","onclose","code","getWebSocketReconnectDelay","onopen","response","transformResponse","webSocketSourceElt","parent","headers","errors","filteredParameters","send","stringify","exp","Math","min","pow","random","processSSEInfo","processSSESource","processSSESwap","sseSrc","maybeCloseSSESource","sseEventName","sseSourceElt","hasEventSource","sseListener","swapSpec","processSSETrigger","loadImmediately","load","loaded","processVerbs","explicitAction","observerOptions","threshold","IntersectionObserver","entries","isIntersecting","observe","polling","evalScript","script","newScript","textContent","async","nonce","hasChanceOfBeingBoosted","findElementsToProcess","boostedElts","initButtonTracking","form","maybeSetLastButtonClicked","lastButtonClicked","countCurlies","line","netCurlies","addHxOnEventHandler","processHxOn","hxOnValue","handlers","lines","currentEvent","curlyCount","initNode","sseInfo","wsInfo","kebabEventName","CustomEvent","bubbles","cancelable","createEvent","initCustomEvent","ignoreEventForLogging","toDo","msg","errorInfo","eventResult","dispatchEvent","kebabName","kebabedEvent","onEvent","currentPathForHistory","getHistoryElement","saveToHistoryCache","scroll","historyCache","getItem","splice","newHistoryItem","item","cache","cause","getCachedHistory","cleanInnerHtmlForHistory","className","clone","innerHTML","saveCurrentPageToHistory","historyElt","scrollY","history","replaceState","pushUrlIntoHistory","pushState","replaceUrlInHistory","task","loadHistoryFromServer","request","XMLHttpRequest","details","open","setRequestHeader","onload","status","historyElement","titleElt","cacheMiss","serverResponse","restoreHistory","cached","scrollTo","reload","addRequestIndicatorClasses","indicators","ic","requestCount","removeRequestIndicatorClasses","haveSeenNode","processed","isSameNode","shouldInclude","disabled","checked","processInputValue","validate","multiple","files","current","Array","isArray","concat","validateElement","elements","input","willValidate","checkValidity","message","validationMessage","validity","formValues","noValidate","formNoValidate","descendant","appendParam","returnStr","realValue","String","s","encodeURIComponent","urlEncode","v","makeFormData","formData","FormData","append","prompt1","getValuesForElement","inputValues","paramsValue","newValues","isAnchorLink","swapInfoOverride","swapInfo","swapDelay","settleDelay","modifier","scrollVal","splitSpec","pop","selectorVal","showVal","focusScrollVal","usesFormData","encodeParamsForBody","encodedParameters","encodeParameters","updateScrollState","first","scrollTarget","scrollTop","scrollHeight","show","showTarget","scrollIntoView","block","behavior","evalAsDefault","varsValues","evaluateValue","toEval","defaultVal","getHXVarsForElement","expressionVars","getHXValsForElement","safelySetHeaderValue","headerValue","getPathFromResponse","responseURL","hasHeader","regexp","getAllResponseHeaders","context","Element","targetOverride","returnPromise","swapOverride","hierarchyForElt","etc","confirmed","resolve","reject","Promise","promise","_resolve","_reject","responseHandler","handleAjaxResponse","triggeringEvent","issueRequest","syncElt","eltData","syncStrategy","queueStrategy","abortable","syncStrings","queuedRequests","endRequestLock","queuedRequest","promptQuestion","promptResponse","prompt","confirmQuestion","confirm","rawParameters","allParameters","requestAttrValues","eltIsBoosted","requestConfig","parameters","unfilteredParameters","credentials","splitPath","pathNoAnchor","anchor","finalPathForGet","keys","toUpperCase","overrideMimeType","noHeaders","responseInfo","pathInfo","requestPath","finalRequestPath","hierarchy","responsePath","secondaryTriggerElt","parentEltInHierarchy","onabort","ontimeout","upload","lengthComputable","total","determineHistoryUpdates","pathFromHeaders","typeFromHeaders","pushUrl","replaceUrl","elementIsBoosted","saveType","redirectPath","then","historyUpdate","isError","failed","successful","settleResolve","settleReject","doSwap","activeElt","activeElement","selectionInfo","selectionStart","end","selectionEnd","newActiveElt","focusOptions","preventScroll","focusScroll","setSelectionRange","finalElt","doSettle","anchorTarget","shouldTransition","transition","startViewTransition","settlePromise","innerDoSwap","extensionBase","init","api","text","extensionsToReturn","extensionsToIgnore","extensionsForElement","extensionName","fn","readyState","insertIndicatorStyles","head","insertAdjacentHTML","getMetaConfig","mergeMetaConfig","metaConfig","restoredElts","abort","originalPopstate","onpopstate","state"],"version":3,"file":"index.5c6b3741.js.map"}