{"version":3,"file":"htmx.js","mappings":"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","sources":["webpack://Ghost Gear/./node_modules/htmx.org/dist/htmx.esm.js","webpack://Ghost Gear/./node_modules/idiomorph/dist/idiomorph-ext.esm.js","webpack://Ghost Gear/webpack/bootstrap","webpack://Ghost Gear/webpack/runtime/define property getters","webpack://Ghost Gear/webpack/runtime/hasOwnProperty shorthand","webpack://Ghost Gear/webpack/runtime/make namespace object","webpack://Ghost Gear/./ghost_gear/js/htmx.js"],"sourcesContent":["var htmx = (function() {\n  'use strict'\n\n  // Public API\n  const htmx = {\n    // Tsc madness here, assigning the functions directly results in an invalid TypeScript output, but reassigning is fine\n    /* Event processing */\n    /** @type {typeof onLoadHelper} */\n    onLoad: null,\n    /** @type {typeof processNode} */\n    process: null,\n    /** @type {typeof addEventListenerImpl} */\n    on: null,\n    /** @type {typeof removeEventListenerImpl} */\n    off: null,\n    /** @type {typeof triggerEvent} */\n    trigger: null,\n    /** @type {typeof ajaxHelper} */\n    ajax: null,\n    /* DOM querying helpers */\n    /** @type {typeof find} */\n    find: null,\n    /** @type {typeof findAll} */\n    findAll: null,\n    /** @type {typeof closest} */\n    closest: null,\n    /**\n     * Returns the input values that would resolve for a given element via the htmx value resolution mechanism\n     *\n     * @see https://htmx.org/api/#values\n     *\n     * @param {Element} elt the element to resolve values on\n     * @param {HttpVerb} type the request type (e.g. **get** or **post**) non-GET's will include the enclosing form of the element. Defaults to **post**\n     * @returns {Object}\n     */\n    values: function(elt, type) {\n      const inputValues = getInputValues(elt, type || 'post')\n      return inputValues.values\n    },\n    /* DOM manipulation helpers */\n    /** @type {typeof removeElement} */\n    remove: null,\n    /** @type {typeof addClassToElement} */\n    addClass: null,\n    /** @type {typeof removeClassFromElement} */\n    removeClass: null,\n    /** @type {typeof toggleClassOnElement} */\n    toggleClass: null,\n    /** @type {typeof takeClassForElement} */\n    takeClass: null,\n    /** @type {typeof swap} */\n    swap: null,\n    /* Extension entrypoints */\n    /** @type {typeof defineExtension} */\n    defineExtension: null,\n    /** @type {typeof removeExtension} */\n    removeExtension: null,\n    /* Debugging */\n    /** @type {typeof logAll} */\n    logAll: null,\n    /** @type {typeof logNone} */\n    logNone: null,\n    /* Debugging */\n    /**\n     * The logger htmx uses to log with\n     *\n     * @see https://htmx.org/api/#logger\n     */\n    logger: null,\n    /**\n     * A property holding the configuration htmx uses at runtime.\n     *\n     * Note that using a [meta tag](https://htmx.org/docs/#config) is the preferred mechanism for setting these properties.\n     *\n     * @see https://htmx.org/api/#config\n     */\n    config: {\n      /**\n       * Whether to use history.\n       * @type boolean\n       * @default true\n       */\n      historyEnabled: true,\n      /**\n       * The number of pages to keep in **sessionStorage** for history support.\n       * @type number\n       * @default 10\n       */\n      historyCacheSize: 10,\n      /**\n       * @type boolean\n       * @default false\n       */\n      refreshOnHistoryMiss: false,\n      /**\n       * The default swap style to use if **[hx-swap](https://htmx.org/attributes/hx-swap)** is omitted.\n       * @type HtmxSwapStyle\n       * @default 'innerHTML'\n       */\n      defaultSwapStyle: 'innerHTML',\n      /**\n       * The default delay between receiving a response from the server and doing the swap.\n       * @type number\n       * @default 0\n       */\n      defaultSwapDelay: 0,\n      /**\n       * The default delay between completing the content swap and settling attributes.\n       * @type number\n       * @default 20\n       */\n      defaultSettleDelay: 20,\n      /**\n       * If true, htmx will inject a small amount of CSS into the page to make indicators invisible unless the **htmx-indicator** class is present.\n       * @type boolean\n       * @default true\n       */\n      includeIndicatorStyles: true,\n      /**\n       * The class to place on indicators when a request is in flight.\n       * @type string\n       * @default 'htmx-indicator'\n       */\n      indicatorClass: 'htmx-indicator',\n      /**\n       * The class to place on triggering elements when a request is in flight.\n       * @type string\n       * @default 'htmx-request'\n       */\n      requestClass: 'htmx-request',\n      /**\n       * The class to temporarily place on elements that htmx has added to the DOM.\n       * @type string\n       * @default 'htmx-added'\n       */\n      addedClass: 'htmx-added',\n      /**\n       * The class to place on target elements when htmx is in the settling phase.\n       * @type string\n       * @default 'htmx-settling'\n       */\n      settlingClass: 'htmx-settling',\n      /**\n       * The class to place on target elements when htmx is in the swapping phase.\n       * @type string\n       * @default 'htmx-swapping'\n       */\n      swappingClass: 'htmx-swapping',\n      /**\n       * Allows the use of eval-like functionality in htmx, to enable **hx-vars**, trigger conditions & script tag evaluation. Can be set to **false** for CSP compatibility.\n       * @type boolean\n       * @default true\n       */\n      allowEval: true,\n      /**\n       * If set to false, disables the interpretation of script tags.\n       * @type boolean\n       * @default true\n       */\n      allowScriptTags: true,\n      /**\n       * If set, the nonce will be added to inline scripts.\n       * @type string\n       * @default ''\n       */\n      inlineScriptNonce: '',\n      /**\n       * If set, the nonce will be added to inline styles.\n       * @type string\n       * @default ''\n       */\n      inlineStyleNonce: '',\n      /**\n       * The attributes to settle during the settling phase.\n       * @type string[]\n       * @default ['class', 'style', 'width', 'height']\n       */\n      attributesToSettle: ['class', 'style', 'width', 'height'],\n      /**\n       * Allow cross-site Access-Control requests using credentials such as cookies, authorization headers or TLS client certificates.\n       * @type boolean\n       * @default false\n       */\n      withCredentials: false,\n      /**\n       * @type number\n       * @default 0\n       */\n      timeout: 0,\n      /**\n       * The default implementation of **getWebSocketReconnectDelay** for reconnecting after unexpected connection loss by the event code **Abnormal Closure**, **Service Restart** or **Try Again Later**.\n       * @type {'full-jitter' | ((retryCount:number) => number)}\n       * @default \"full-jitter\"\n       */\n      wsReconnectDelay: 'full-jitter',\n      /**\n       * The type of binary data being received over the WebSocket connection\n       * @type BinaryType\n       * @default 'blob'\n       */\n      wsBinaryType: 'blob',\n      /**\n       * @type string\n       * @default '[hx-disable], [data-hx-disable]'\n       */\n      disableSelector: '[hx-disable], [data-hx-disable]',\n      /**\n       * @type {'auto' | 'instant' | 'smooth'}\n       * @default 'instant'\n       */\n      scrollBehavior: 'instant',\n      /**\n       * If the focused element should be scrolled into view.\n       * @type boolean\n       * @default false\n       */\n      defaultFocusScroll: false,\n      /**\n       * If set to true htmx will include a cache-busting parameter in GET requests to avoid caching partial responses by the browser\n       * @type boolean\n       * @default false\n       */\n      getCacheBusterParam: false,\n      /**\n       * If set to true, htmx will use the View Transition API when swapping in new content.\n       * @type boolean\n       * @default false\n       */\n      globalViewTransitions: false,\n      /**\n       * htmx will format requests with these methods by encoding their parameters in the URL, not the request body\n       * @type {(HttpVerb)[]}\n       * @default ['get', 'delete']\n       */\n      methodsThatUseUrlParams: ['get', 'delete'],\n      /**\n       * If set to true, disables htmx-based requests to non-origin hosts.\n       * @type boolean\n       * @default false\n       */\n      selfRequestsOnly: true,\n      /**\n       * If set to true htmx will not update the title of the document when a title tag is found in new content\n       * @type boolean\n       * @default false\n       */\n      ignoreTitle: false,\n      /**\n       * Whether the target of a boosted element is scrolled into the viewport.\n       * @type boolean\n       * @default true\n       */\n      scrollIntoViewOnBoost: true,\n      /**\n       * The cache to store evaluated trigger specifications into.\n       * You may define a simple object to use a never-clearing cache, or implement your own system using a [proxy object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy)\n       * @type {Object|null}\n       * @default null\n       */\n      triggerSpecsCache: null,\n      /** @type boolean */\n      disableInheritance: false,\n      /** @type HtmxResponseHandlingConfig[] */\n      responseHandling: [\n        { code: '204', swap: false },\n        { code: '[23]..', swap: true },\n        { code: '[45]..', swap: false, error: true }\n      ],\n      /**\n       * Whether to process OOB swaps on elements that are nested within the main response element.\n       * @type boolean\n       * @default true\n       */\n      allowNestedOobSwaps: true,\n      /**\n       * Whether to treat history cache miss full page reload requests as a \"HX-Request\" by returning this response header\n       * This should always be disabled when using HX-Request header to optionally return partial responses\n       * @type boolean\n       * @default true\n       */\n      historyRestoreAsHxRequest: true,\n      /**\n       * Whether to report input validation errors to the end user and update focus to the first input that fails validation.\n       * This should always be enabled as this matches default browser form submit behaviour\n       * @type boolean\n       * @default false\n       */\n      reportValidityOfForms: false\n    },\n    /** @type {typeof parseInterval} */\n    parseInterval: null,\n    /**\n     * proxy of window.location used for page reload functions\n     * @type location\n     */\n    location,\n    /** @type {typeof internalEval} */\n    _: null,\n    version: '2.0.10'\n  }\n  // Tsc madness part 2\n  htmx.onLoad = onLoadHelper\n  htmx.process = processNode\n  htmx.on = addEventListenerImpl\n  htmx.off = removeEventListenerImpl\n  htmx.trigger = triggerEvent\n  htmx.ajax = ajaxHelper\n  htmx.find = find\n  htmx.findAll = findAll\n  htmx.closest = closest\n  htmx.remove = removeElement\n  htmx.addClass = addClassToElement\n  htmx.removeClass = removeClassFromElement\n  htmx.toggleClass = toggleClassOnElement\n  htmx.takeClass = takeClassForElement\n  htmx.swap = swap\n  htmx.defineExtension = defineExtension\n  htmx.removeExtension = removeExtension\n  htmx.logAll = logAll\n  htmx.logNone = logNone\n  htmx.parseInterval = parseInterval\n  htmx._ = internalEval\n\n  const internalAPI = {\n    addTriggerHandler,\n    bodyContains,\n    canAccessLocalStorage,\n    findThisElement,\n    filterValues,\n    swap,\n    hasAttribute,\n    getAttributeValue,\n    getClosestAttributeValue,\n    getClosestMatch,\n    getExpressionVars,\n    getHeaders,\n    getInputValues,\n    getInternalData,\n    getSwapSpecification,\n    getTriggerSpecs,\n    getTarget,\n    makeFragment,\n    mergeObjects,\n    makeSettleInfo,\n    oobSwap,\n    querySelectorExt,\n    settleImmediately,\n    shouldCancel,\n    triggerEvent,\n    triggerErrorEvent,\n    withExtensions\n  }\n\n  const VERBS = ['get', 'post', 'put', 'delete', 'patch']\n  const VERB_SELECTOR = VERBS.map(function(verb) {\n    return '[hx-' + verb + '], [data-hx-' + verb + ']'\n  }).join(', ')\n\n  //= ===================================================================\n  // Utilities\n  //= ===================================================================\n\n  /**\n   * Parses an interval string consistent with the way htmx does. Useful for plugins that have timing-related attributes.\n   *\n   * Caution: Accepts an int followed by either **s** or **ms**. All other values use **parseFloat**\n   *\n   * @see https://htmx.org/api/#parseInterval\n   *\n   * @param {string} str timing string\n   * @returns {number|undefined}\n   */\n  function parseInterval(str) {\n    if (str == undefined) {\n      return undefined\n    }\n\n    let interval = NaN\n    if (str.slice(-2) == 'ms') {\n      interval = parseFloat(str.slice(0, -2))\n    } else if (str.slice(-1) == 's') {\n      interval = parseFloat(str.slice(0, -1)) * 1000\n    } else if (str.slice(-1) == 'm') {\n      interval = parseFloat(str.slice(0, -1)) * 1000 * 60\n    } else {\n      interval = parseFloat(str)\n    }\n    return isNaN(interval) ? undefined : interval\n  }\n\n  /**\n   * @param {Node} elt\n   * @param {string} name\n   * @returns {(string | null)}\n   */\n  function getRawAttribute(elt, name) {\n    return elt instanceof Element && elt.getAttribute(name)\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {string} qualifiedName\n   * @returns {boolean}\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 {Node} 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 {Node} elt\n   * @returns {Node | null}\n   */\n  function parentElt(elt) {\n    const parent = elt.parentElement\n    if (!parent && elt.parentNode instanceof ShadowRoot) return elt.parentNode\n    return parent\n  }\n\n  /**\n   * @returns {Document}\n   */\n  function getDocument() {\n    return document\n  }\n\n  /**\n   * @param {Node} elt\n   * @param {boolean} global\n   * @returns {Node|Document}\n   */\n  function getRootNode(elt, global) {\n    return elt.getRootNode ? elt.getRootNode({ composed: global }) : getDocument()\n  }\n\n  /**\n   * @param {Node} elt\n   * @param {(e:Node) => boolean} condition\n   * @returns {Node | null}\n   */\n  function getClosestMatch(elt, condition) {\n    while (elt && !condition(elt)) {\n      elt = parentElt(elt)\n    }\n\n    return elt || null\n  }\n\n  /**\n   * @param {Element} initialElement\n   * @param {Element} ancestor\n   * @param {string} attributeName\n   * @returns {string|null}\n   */\n  function getAttributeValueWithDisinheritance(initialElement, ancestor, attributeName) {\n    const attributeValue = getAttributeValue(ancestor, attributeName)\n    const disinherit = getAttributeValue(ancestor, 'hx-disinherit')\n    var inherit = getAttributeValue(ancestor, 'hx-inherit')\n    if (initialElement !== ancestor) {\n      if (htmx.config.disableInheritance) {\n        if (inherit && (inherit === '*' || inherit.split(' ').indexOf(attributeName) >= 0)) {\n          return attributeValue\n        } else {\n          return null\n        }\n      }\n      if (disinherit && (disinherit === '*' || disinherit.split(' ').indexOf(attributeName) >= 0)) {\n        return 'unset'\n      }\n    }\n    return attributeValue\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {string} attributeName\n   * @returns {string | null}\n   */\n  function getClosestAttributeValue(elt, attributeName) {\n    let closestAttr = null\n    getClosestMatch(elt, function(e) {\n      return !!(closestAttr = getAttributeValueWithDisinheritance(elt, asElement(e), attributeName))\n    })\n    if (closestAttr !== 'unset') {\n      return closestAttr\n    }\n  }\n\n  /**\n   * @param {Node} elt\n   * @param {string} selector\n   * @returns {boolean}\n   */\n  function matches(elt, selector) {\n    return elt instanceof Element && elt.matches(selector)\n  }\n\n  /**\n   * @param {string} str\n   * @returns {string}\n   */\n  function getStartTag(str) {\n    const tagMatcher = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i\n    const match = tagMatcher.exec(str)\n    if (match) {\n      return match[1].toLowerCase()\n    } else {\n      return ''\n    }\n  }\n\n  /**\n   * @param {string} resp\n   * @returns {Document}\n   */\n  function parseHTML(resp) {\n    if ('parseHTMLUnsafe' in Document) {\n      return Document.parseHTMLUnsafe(resp)\n    }\n    const parser = new DOMParser()\n    return parser.parseFromString(resp, 'text/html')\n  }\n\n  /**\n   * @param {DocumentFragment} fragment\n   * @param {Node} elt\n   */\n  function takeChildrenFor(fragment, elt) {\n    while (elt.childNodes.length > 0) {\n      fragment.append(elt.childNodes[0])\n    }\n  }\n\n  /**\n   * @param {HTMLScriptElement} script\n   * @returns {HTMLScriptElement}\n   */\n  function duplicateScript(script) {\n    const 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    return newScript\n  }\n\n  /**\n   * @param {HTMLScriptElement} script\n   * @returns {boolean}\n   */\n  function isJavaScriptScriptNode(script) {\n    return script.matches('script') && (script.type === 'text/javascript' || script.type === 'module' || script.type === '')\n  }\n\n  /**\n   * we have to make new copies of script tags that we are going to insert because\n   * SOME browsers (not saying who, but it involves an element and an animal) don't\n   * execute scripts created in <template> tags when they are inserted into the DOM\n   * and all the others do lmao\n   * @param {DocumentFragment} fragment\n   */\n  function normalizeScriptTags(fragment) {\n    Array.from(fragment.querySelectorAll('script')).forEach(/** @param {HTMLScriptElement} script */ (script) => {\n      if (isJavaScriptScriptNode(script)) {\n        const newScript = duplicateScript(script)\n        const parent = script.parentNode\n        try {\n          parent.insertBefore(newScript, script)\n        } catch (e) {\n          logError(e)\n        } finally {\n          script.remove()\n        }\n      }\n    })\n  }\n\n  /**\n   * @typedef {DocumentFragment & {title?: string}} DocumentFragmentWithTitle\n   * @description  a document fragment representing the response HTML, including\n   * a `title` property for any title information found\n   */\n\n  /**\n   * @param {string} response HTML\n   * @returns {DocumentFragmentWithTitle}\n   */\n  function makeFragment(response) {\n    // strip head tag to determine shape of response we are dealing with\n    const responseWithNoHead = response.replace(/<head(\\s[^>]*)?>[\\s\\S]*?<\\/head>/i, '')\n    const startTag = getStartTag(responseWithNoHead)\n    /** @type DocumentFragmentWithTitle */\n    let fragment\n    if (startTag === 'html') {\n      // if it is a full document, parse it and return the body\n      fragment = /** @type DocumentFragmentWithTitle */ (new DocumentFragment())\n      const doc = parseHTML(response)\n      takeChildrenFor(fragment, doc.body)\n      fragment.title = doc.title\n    } else if (startTag === 'body') {\n      // parse body w/o wrapping in template\n      fragment = /** @type DocumentFragmentWithTitle */ (new DocumentFragment())\n      const doc = parseHTML(responseWithNoHead)\n      takeChildrenFor(fragment, doc.body)\n      fragment.title = doc.title\n    } else {\n      // otherwise we have non-body partial HTML content, so wrap it in a template to maximize parsing flexibility\n      const doc = parseHTML('<body><template class=\"internal-htmx-wrapper\">' + responseWithNoHead + '</template></body>')\n      fragment = /** @type DocumentFragmentWithTitle */ (doc.querySelector('template').content)\n      // extract title into fragment for later processing\n      fragment.title = doc.title\n\n      // for legacy reasons we support a title tag at the root level of non-body responses, so we need to handle it\n      var titleElement = fragment.querySelector('title')\n      if (titleElement && titleElement.parentNode === fragment) {\n        titleElement.remove()\n        fragment.title = titleElement.innerText\n      }\n    }\n    if (fragment) {\n      if (htmx.config.allowScriptTags) {\n        normalizeScriptTags(fragment)\n      } else {\n        // remove all script tags if scripts are disabled\n        fragment.querySelectorAll('script').forEach((script) => script.remove())\n      }\n    }\n    return fragment\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 typeof 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   * @typedef {Object} OnHandler\n   * @property {(keyof HTMLElementEventMap)|string} event\n   * @property {EventListener} listener\n   */\n\n  /**\n   * @typedef {Object} ListenerInfo\n   * @property {string} trigger\n   * @property {EventListener} listener\n   * @property {EventTarget} on\n   */\n\n  /**\n   * @typedef {Object} HtmxNodeInternalData\n   * Element data\n   * @property {number} [initHash]\n   * @property {boolean} [boosted]\n   * @property {OnHandler[]} [onHandlers]\n   * @property {number} [timeout]\n   * @property {ListenerInfo[]} [listenerInfos]\n   * @property {boolean} [cancelled]\n   * @property {boolean} [triggeredOnce]\n   * @property {number} [delayed]\n   * @property {number|null} [throttle]\n   * @property {WeakMap<HtmxTriggerSpecification,WeakMap<EventTarget,string>>} [lastValue]\n   * @property {boolean} [loaded]\n   * @property {string} [path]\n   * @property {string} [verb]\n   * @property {boolean} [polling]\n   * @property {HTMLButtonElement|HTMLInputElement|null} [lastButtonClicked]\n   * @property {number} [requestCount]\n   * @property {XMLHttpRequest} [xhr]\n   * @property {(() => void)[]} [queuedRequests]\n   * @property {boolean} [abortable]\n   * @property {boolean} [firstInitCompleted]\n   *\n   * Event data\n   * @property {HtmxTriggerSpecification} [triggerSpec]\n   * @property {EventTarget[]} [handledFor]\n   */\n\n  /**\n   * getInternalData retrieves \"private\" data stored by htmx within an element\n   * @param {EventTarget|Event} elt\n   * @returns {HtmxNodeInternalData}\n   */\n  function getInternalData(elt) {\n    const dataProp = 'htmx-internal-data'\n    let 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   * @template T\n   * @param {ArrayLike<T>} arr\n   * @returns {T[]}\n   */\n  function toArray(arr) {\n    const returnArr = []\n    if (arr) {\n      for (let i = 0; i < arr.length; i++) {\n        returnArr.push(arr[i])\n      }\n    }\n    return returnArr\n  }\n\n  /**\n   * @template T\n   * @param {T[]|NamedNodeMap|HTMLCollection|HTMLFormControlsCollection|ArrayLike<T>} arr\n   * @param {(T) => void} func\n   */\n  function forEach(arr, func) {\n    if (arr) {\n      for (let i = 0; i < arr.length; i++) {\n        func(arr[i])\n      }\n    }\n  }\n\n  /**\n   * @param {Element} el\n   * @returns {boolean}\n   */\n  function isScrolledIntoView(el) {\n    const rect = el.getBoundingClientRect()\n    const elemTop = rect.top\n    const elemBottom = rect.bottom\n    return elemTop < window.innerHeight && elemBottom >= 0\n  }\n\n  /**\n   * Checks whether the element is in the document (includes shadow roots).\n   * This function this is a slight misnomer; it will return true even for elements in the head.\n   *\n   * @param {Node} elt\n   * @returns {boolean}\n   */\n  function bodyContains(elt) {\n    return elt.getRootNode({ composed: true }) === document\n  }\n\n  /**\n   * @param {string} trigger\n   * @returns {string[]}\n   */\n  function splitOnWhitespace(trigger) {\n    return trigger.trim().split(/\\s+/)\n  }\n\n  /**\n   * mergeObjects takes all the keys from\n   * obj2 and duplicates them into obj1\n   * @template T1\n   * @template T2\n   * @param {T1} obj1\n   * @param {T2} obj2\n   * @returns {T1 & T2}\n   */\n  function mergeObjects(obj1, obj2) {\n    for (const key in obj2) {\n      if (obj2.hasOwnProperty(key)) {\n        // @ts-ignore tsc doesn't seem to properly handle types merging\n        obj1[key] = obj2[key]\n      }\n    }\n    // @ts-ignore tsc doesn't seem to properly handle types merging\n    return obj1\n  }\n\n  /**\n   * @param {string} jString\n   * @returns {any|null}\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  /**\n   * @returns {boolean}\n   */\n  function canAccessLocalStorage() {\n    const test = 'htmx:sessionStorageTest'\n    try {\n      sessionStorage.setItem(test, test)\n      sessionStorage.removeItem(test)\n      return true\n    } catch (e) {\n      return false\n    }\n  }\n\n  /**\n   * @param {string} path\n   * @returns {string}\n   */\n  function normalizePath(path) {\n    try {\n      const url = new URL(path, window.location.href)\n      path = url.pathname + url.search\n    } catch (e) {\n      // fallback for malformed URLs\n    }\n    // remove trailing slash, unless index page\n    if (path != '/') {\n      path = path.replace(/\\/+$/, '')\n    }\n    return path\n  }\n\n  //= =========================================================================================\n  // public API\n  //= =========================================================================================\n\n  /**\n   * @param {string} str\n   * @returns {any}\n   */\n  function internalEval(str) {\n    return maybeEval(getDocument().body, function() {\n      return eval(str)\n    })\n  }\n\n  /**\n   * Adds a callback for the **htmx:load** event. This can be used to process new content, for example initializing the content with a javascript library\n   *\n   * @see https://htmx.org/api/#onLoad\n   *\n   * @param {(elt: Node) => void} callback the callback to call on newly loaded content\n   * @returns {EventListener}\n   */\n  function onLoadHelper(callback) {\n    const value = htmx.on('htmx:load', /** @param {CustomEvent} evt */ function(evt) {\n      callback(evt.detail.elt)\n    })\n    return value\n  }\n\n  /**\n   * Log all htmx events, useful for debugging.\n   *\n   * @see https://htmx.org/api/#logAll\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 logNone() {\n    htmx.logger = null\n  }\n\n  /**\n   * Finds an element matching the selector\n   *\n   * @see https://htmx.org/api/#find\n   *\n   * @param {ParentNode|string} eltOrSelector  the root element to find the matching element in, inclusive | the selector to match\n   * @param {string} [selector] the selector to match\n   * @returns {Element|null}\n   */\n  function find(eltOrSelector, selector) {\n    if (typeof eltOrSelector !== 'string') {\n      return eltOrSelector.querySelector(selector)\n    } else {\n      return find(getDocument(), eltOrSelector)\n    }\n  }\n\n  /**\n   * Finds all elements matching the selector\n   *\n   * @see https://htmx.org/api/#findAll\n   *\n   * @param {ParentNode|string} eltOrSelector the root element to find the matching elements in, inclusive | the selector to match\n   * @param {string} [selector] the selector to match\n   * @returns {NodeListOf<Element>}\n   */\n  function findAll(eltOrSelector, selector) {\n    if (typeof eltOrSelector !== 'string') {\n      return eltOrSelector.querySelectorAll(selector)\n    } else {\n      return findAll(getDocument(), eltOrSelector)\n    }\n  }\n\n  /**\n   * @returns Window\n   */\n  function getWindow() {\n    return window\n  }\n\n  /**\n   * Removes an element from the DOM\n   *\n   * @see https://htmx.org/api/#remove\n   *\n   * @param {Node} elt\n   * @param {number} [delay]\n   */\n  function removeElement(elt, delay) {\n    elt = resolveTarget(elt)\n    if (delay) {\n      getWindow().setTimeout(function() {\n        removeElement(elt)\n        elt = null\n      }, delay)\n    } else {\n      parentElt(elt).removeChild(elt)\n    }\n  }\n\n  /**\n   * @param {any} elt\n   * @return {Element|null}\n   */\n  function asElement(elt) {\n    return elt instanceof Element ? elt : null\n  }\n\n  /**\n   * @param {any} elt\n   * @return {HTMLElement|null}\n   */\n  function asHtmlElement(elt) {\n    return elt instanceof HTMLElement ? elt : null\n  }\n\n  /**\n   * @param {any} value\n   * @return {string|null}\n   */\n  function asString(value) {\n    return typeof value === 'string' ? value : null\n  }\n\n  /**\n   * @param {EventTarget} elt\n   * @return {ParentNode|null}\n   */\n  function asParentNode(elt) {\n    return elt instanceof Element || elt instanceof Document || elt instanceof DocumentFragment ? elt : null\n  }\n\n  /**\n   * This method adds a class to the given element.\n   *\n   * @see https://htmx.org/api/#addClass\n   *\n   * @param {Element|string} elt the element to add the class to\n   * @param {string} clazz the class to add\n   * @param {number} [delay] the delay (in milliseconds) before class is added\n   */\n  function addClassToElement(elt, clazz, delay) {\n    elt = asElement(resolveTarget(elt))\n    if (!elt) {\n      return\n    }\n    if (delay) {\n      getWindow().setTimeout(function() {\n        addClassToElement(elt, clazz)\n        elt = null\n      }, delay)\n    } else {\n      elt.classList && elt.classList.add(clazz)\n    }\n  }\n\n  /**\n   * Removes a class from the given element\n   *\n   * @see https://htmx.org/api/#removeClass\n   *\n   * @param {Node|string} node element to remove the class from\n   * @param {string} clazz the class to remove\n   * @param {number} [delay] the delay (in milliseconds before class is removed)\n   */\n  function removeClassFromElement(node, clazz, delay) {\n    let elt = asElement(resolveTarget(node))\n    if (!elt) {\n      return\n    }\n    if (delay) {\n      getWindow().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  /**\n   * Toggles the given class on an element\n   *\n   * @see https://htmx.org/api/#toggleClass\n   *\n   * @param {Element|string} elt the element to toggle the class on\n   * @param {string} clazz the class to toggle\n   */\n  function toggleClassOnElement(elt, clazz) {\n    elt = resolveTarget(elt)\n    elt.classList.toggle(clazz)\n  }\n\n  /**\n   * Takes the given class from its siblings, so that among its siblings, only the given element will have the class.\n   *\n   * @see https://htmx.org/api/#takeClass\n   *\n   * @param {Node|string} elt the element that will take the class\n   * @param {string} clazz the class to take\n   */\n  function takeClassForElement(elt, clazz) {\n    elt = resolveTarget(elt)\n    forEach(elt.parentElement.children, function(child) {\n      removeClassFromElement(child, clazz)\n    })\n    addClassToElement(asElement(elt), clazz)\n  }\n\n  /**\n   * Finds the closest matching element in the given elements parentage, inclusive of the element\n   *\n   * @see https://htmx.org/api/#closest\n   *\n   * @param {Element|string} elt the element to find the selector from\n   * @param {string} selector the selector to find\n   * @returns {Element|null}\n   */\n  function closest(elt, selector) {\n    elt = asElement(resolveTarget(elt))\n    if (elt) {\n      return elt.closest(selector)\n    }\n    return null\n  }\n\n  /**\n   * @param {string} str\n   * @param {string} prefix\n   * @returns {boolean}\n   */\n  function startsWith(str, prefix) {\n    return str.substring(0, prefix.length) === prefix\n  }\n\n  /**\n   * @param {string} str\n   * @param {string} suffix\n   * @returns {boolean}\n   */\n  function endsWith(str, suffix) {\n    return str.substring(str.length - suffix.length) === suffix\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  function normalizeSelector(selector) {\n    const trimmedSelector = selector.trim()\n    if (startsWith(trimmedSelector, '<') && endsWith(trimmedSelector, '/>')) {\n      return trimmedSelector.substring(1, trimmedSelector.length - 2)\n    } else {\n      return trimmedSelector\n    }\n  }\n\n  /**\n   * @param {Node|Element|Document|string} elt\n   * @param {string} selector\n   * @param {boolean=} global\n   * @returns {(Node|Window)[]}\n   */\n  function querySelectorAllExt(elt, selector, global) {\n    if (selector.indexOf('global ') === 0) {\n      return querySelectorAllExt(elt, selector.slice(7), true)\n    }\n\n    elt = resolveTarget(elt)\n\n    const parts = []\n    {\n      let chevronsCount = 0\n      let offset = 0\n      for (let i = 0; i < selector.length; i++) {\n        const char = selector[i]\n        if (char === ',' && chevronsCount === 0) {\n          parts.push(selector.substring(offset, i))\n          offset = i + 1\n          continue\n        }\n        if (char === '<') {\n          chevronsCount++\n        } else if (char === '/' && i < selector.length - 1 && selector[i + 1] === '>') {\n          chevronsCount--\n        }\n      }\n      if (offset < selector.length) {\n        parts.push(selector.substring(offset))\n      }\n    }\n\n    const result = []\n    const unprocessedParts = []\n    while (parts.length > 0) {\n      const selector = normalizeSelector(parts.shift())\n      let item\n      if (selector.indexOf('closest ') === 0) {\n        item = closest(asElement(elt), normalizeSelector(selector.slice(8)))\n      } else if (selector.indexOf('find ') === 0) {\n        item = find(asParentNode(elt), normalizeSelector(selector.slice(5)))\n      } else if (selector === 'next' || selector === 'nextElementSibling') {\n        item = asElement(elt).nextElementSibling\n      } else if (selector.indexOf('next ') === 0) {\n        item = scanForwardQuery(elt, normalizeSelector(selector.slice(5)), !!global)\n      } else if (selector === 'previous' || selector === 'previousElementSibling') {\n        item = asElement(elt).previousElementSibling\n      } else if (selector.indexOf('previous ') === 0) {\n        item = scanBackwardsQuery(elt, normalizeSelector(selector.slice(9)), !!global)\n      } else if (selector === 'document') {\n        item = document\n      } else if (selector === 'window') {\n        item = window\n      } else if (selector === 'body') {\n        item = document.body\n      } else if (selector === 'root') {\n        item = getRootNode(elt, !!global)\n      } else if (selector === 'host') {\n        item = (/** @type ShadowRoot */(elt.getRootNode())).host\n      } else {\n        unprocessedParts.push(selector)\n      }\n\n      if (item) {\n        result.push(item)\n      }\n    }\n\n    if (unprocessedParts.length > 0) {\n      const standardSelector = unprocessedParts.join(',')\n      const rootNode = asParentNode(getRootNode(elt, !!global))\n      result.push(...toArray(rootNode.querySelectorAll(standardSelector)))\n    }\n\n    return result\n  }\n\n  /**\n   * @param {Node} start\n   * @param {string} match\n   * @param {boolean} global\n   * @returns {Element}\n   */\n  var scanForwardQuery = function(start, match, global) {\n    const results = asParentNode(getRootNode(start, global)).querySelectorAll(match)\n    for (let i = 0; i < results.length; i++) {\n      const elt = results[i]\n      if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_PRECEDING) {\n        return elt\n      }\n    }\n  }\n\n  /**\n   * @param {Node} start\n   * @param {string} match\n   * @param {boolean} global\n   * @returns {Element}\n   */\n  var scanBackwardsQuery = function(start, match, global) {\n    const results = asParentNode(getRootNode(start, global)).querySelectorAll(match)\n    for (let i = results.length - 1; i >= 0; i--) {\n      const elt = results[i]\n      if (elt.compareDocumentPosition(start) === Node.DOCUMENT_POSITION_FOLLOWING) {\n        return elt\n      }\n    }\n  }\n\n  /**\n   * @param {Node|string} eltOrSelector\n   * @param {string=} selector\n   * @returns {Node|Window}\n   */\n  function querySelectorExt(eltOrSelector, selector) {\n    if (typeof eltOrSelector !== 'string') {\n      return querySelectorAllExt(eltOrSelector, selector)[0]\n    } else {\n      return querySelectorAllExt(getDocument().body, eltOrSelector)[0]\n    }\n  }\n\n  /**\n   * @template {EventTarget} T\n   * @param {T|string} eltOrSelector\n   * @param {T} [context]\n   * @returns {Element|T|null}\n   */\n  function resolveTarget(eltOrSelector, context) {\n    if (typeof eltOrSelector === 'string') {\n      return find(asParentNode(context) || document, eltOrSelector)\n    } else {\n      return eltOrSelector\n    }\n  }\n\n  /**\n   * @typedef {keyof HTMLElementEventMap|string} AnyEventName\n   */\n\n  /**\n   * @typedef {Object} EventArgs\n   * @property {EventTarget} target\n   * @property {AnyEventName} event\n   * @property {EventListener} listener\n   * @property {Object|boolean} options\n   */\n\n  /**\n   * @param {EventTarget|AnyEventName} arg1\n   * @param {AnyEventName|EventListener} arg2\n   * @param {EventListener|Object|boolean} [arg3]\n   * @param {Object|boolean} [arg4]\n   * @returns {EventArgs}\n   */\n  function processEventArgs(arg1, arg2, arg3, arg4) {\n    if (isFunction(arg2)) {\n      return {\n        target: getDocument().body,\n        event: asString(arg1),\n        listener: arg2,\n        options: arg3\n      }\n    } else {\n      return {\n        target: resolveTarget(arg1),\n        event: asString(arg2),\n        listener: arg3,\n        options: arg4\n      }\n    }\n  }\n\n  /**\n   * Adds an event listener to an element\n   *\n   * @see https://htmx.org/api/#on\n   *\n   * @param {EventTarget|string} arg1 the element to add the listener to | the event name to add the listener for\n   * @param {string|EventListener} arg2 the event name to add the listener for | the listener to add\n   * @param {EventListener|Object|boolean} [arg3] the listener to add | options to add\n   * @param {Object|boolean} [arg4] options to add\n   * @returns {EventListener}\n   */\n  function addEventListenerImpl(arg1, arg2, arg3, arg4) {\n    ready(function() {\n      const eventArgs = processEventArgs(arg1, arg2, arg3, arg4)\n      eventArgs.target.addEventListener(eventArgs.event, eventArgs.listener, eventArgs.options)\n    })\n    const b = isFunction(arg2)\n    return b ? arg2 : arg3\n  }\n\n  /**\n   * Removes an event listener from an element\n   *\n   * @see https://htmx.org/api/#off\n   *\n   * @param {EventTarget|string} arg1 the element to remove the listener from | the event name to remove the listener from\n   * @param {string|EventListener} arg2 the event name to remove the listener from | the listener to remove\n   * @param {EventListener} [arg3] the listener to remove\n   * @returns {EventListener}\n   */\n  function removeEventListenerImpl(arg1, arg2, arg3) {\n    ready(function() {\n      const 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  const DUMMY_ELT = getDocument().createElement('output') // dummy element for bad selectors\n  /**\n   * @param {Element} elt\n   * @param {string} attrName\n   * @returns {(Node|Window)[]}\n   */\n  function findAttributeTargets(elt, attrName) {\n    const attrTarget = getClosestAttributeValue(elt, attrName)\n    if (attrTarget) {\n      if (attrTarget === 'this') {\n        return [findThisElement(elt, attrName)]\n      } else {\n        const result = querySelectorAllExt(elt, attrTarget)\n        // find `inherit` whole word in value, make sure it's surrounded by commas or is at the start/end of string\n        const shouldInherit = /(^|,)(\\s*)inherit(\\s*)($|,)/.test(attrTarget)\n        if (shouldInherit) {\n          const eltToInheritFrom = asElement(getClosestMatch(elt, function(parent) {\n            return parent !== elt && hasAttribute(asElement(parent), attrName)\n          }))\n          if (eltToInheritFrom) {\n            result.push(...findAttributeTargets(eltToInheritFrom, attrName))\n          }\n        }\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  /**\n   * @param {Element} elt\n   * @param {string} attribute\n   * @returns {Element|null}\n   */\n  function findThisElement(elt, attribute) {\n    return asElement(getClosestMatch(elt, function(elt) {\n      return getAttributeValue(asElement(elt), attribute) != null\n    }))\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {Node|Window|null}\n   */\n  function getTarget(elt) {\n    const 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      const data = getInternalData(elt)\n      if (data.boosted) {\n        return getDocument().body\n      } else {\n        return elt\n      }\n    }\n  }\n\n  /**\n   * @param {string} name\n   * @returns {boolean}\n   */\n  function shouldSettleAttribute(name) {\n    return htmx.config.attributesToSettle.includes(name)\n  }\n\n  /**\n   * @param {Element} mergeTo\n   * @param {Element} mergeFrom\n   */\n  function cloneAttributes(mergeTo, mergeFrom) {\n    forEach(Array.from(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  /**\n   * @param {HtmxSwapStyle} swapStyle\n   * @param {Element} target\n   * @returns {boolean}\n   */\n  function isInlineSwap(swapStyle, target) {\n    const extensions = getExtensions(target)\n    for (let i = 0; i < extensions.length; i++) {\n      const 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   * @param {string} oobValue\n   * @param {Element} oobElement\n   * @param {HtmxSettleInfo} settleInfo\n   * @param {Node|Document} [rootNode]\n   * @returns\n   */\n  function oobSwap(oobValue, oobElement, settleInfo, rootNode) {\n    rootNode = rootNode || getDocument()\n    let selector = '#' + CSS.escape(getRawAttribute(oobElement, 'id'))\n    /** @type HtmxSwapStyle */\n    let swapStyle = 'outerHTML'\n    if (oobValue === 'true') {\n      // do nothing\n    } else if (oobValue.indexOf(':') > 0) {\n      swapStyle = oobValue.substring(0, oobValue.indexOf(':'))\n      selector = oobValue.substring(oobValue.indexOf(':') + 1)\n    } else {\n      swapStyle = oobValue\n    }\n    oobElement.removeAttribute('hx-swap-oob')\n    oobElement.removeAttribute('data-hx-swap-oob')\n\n    const targets = querySelectorAllExt(rootNode, selector, false)\n    if (targets.length) {\n      forEach(\n        targets,\n        function(target) {\n          let fragment\n          const oobElementClone = oobElement.cloneNode(true)\n          fragment = getDocument().createDocumentFragment()\n          fragment.appendChild(oobElementClone)\n          if (!isInlineSwap(swapStyle, target)) {\n            fragment = asParentNode(oobElementClone) // if this is not an inline swap, we use the content of the node, not the node itself\n          }\n\n          const beforeSwapDetails = { shouldSwap: true, target, fragment }\n          if (!triggerEvent(target, 'htmx:oobBeforeSwap', beforeSwapDetails)) return\n\n          target = beforeSwapDetails.target // allow re-targeting\n          if (beforeSwapDetails.shouldSwap) {\n            handlePreservedElements(fragment)\n            swapWithStyle(swapStyle, target, target, fragment, settleInfo)\n            restorePreservedElements()\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, target: selector })\n    }\n    return oobValue\n  }\n\n  function restorePreservedElements() {\n    const pantry = find('#--htmx-preserve-pantry--')\n    if (pantry) {\n      for (const preservedElt of [...pantry.children]) {\n        const existingElement = find('#' + preservedElt.id)\n        // @ts-ignore - use proposed moveBefore feature\n        existingElement.parentNode.moveBefore(preservedElt, existingElement)\n        existingElement.remove()\n      }\n      pantry.remove()\n    }\n  }\n\n  /**\n   * @param {DocumentFragment|ParentNode} fragment\n   */\n  function handlePreservedElements(fragment) {\n    forEach(findAll(fragment, '[hx-preserve], [data-hx-preserve]'), function(preservedElt) {\n      const id = getAttributeValue(preservedElt, 'id')\n      const existingElement = getDocument().getElementById(id)\n      if (existingElement != null) {\n        if (preservedElt.moveBefore) { // if the moveBefore API exists, use it\n          // get or create a storage spot for stuff\n          let pantry = find('#--htmx-preserve-pantry--')\n          if (pantry == null) {\n            getDocument().body.insertAdjacentHTML('afterend', \"<div id='--htmx-preserve-pantry--'></div>\")\n            pantry = find('#--htmx-preserve-pantry--')\n          }\n          // @ts-ignore - use proposed moveBefore feature\n          pantry.moveBefore(existingElement, null)\n        } else {\n          preservedElt.parentNode.replaceChild(existingElement, preservedElt)\n        }\n      }\n    })\n  }\n\n  /**\n   * @param {Node} parentNode\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function handleAttributes(parentNode, fragment, settleInfo) {\n    forEach(fragment.querySelectorAll('[id]'), function(newNode) {\n      const id = getRawAttribute(newNode, 'id')\n      if (id && id.length > 0) {\n        const parentElt = asParentNode(parentNode)\n        const oldNode = parentElt && parentElt.querySelector(CSS.escape(newNode.tagName) + '#' + CSS.escape(id))\n        if (oldNode && oldNode !== parentElt) {\n          const newAttributes = newNode.cloneNode()\n          cloneAttributes(newNode, oldNode)\n          settleInfo.tasks.push(function() {\n            cloneAttributes(newNode, newAttributes)\n          })\n        }\n      }\n    })\n  }\n\n  /**\n   * @param {Node} child\n   * @returns {HtmxSettleTask}\n   */\n  function makeAjaxLoadTask(child) {\n    return function() {\n      removeClassFromElement(child, htmx.config.addedClass)\n      processNode(asElement(child))\n      processFocus(asParentNode(child))\n      triggerEvent(child, 'htmx:load')\n    }\n  }\n\n  /**\n   * @param {ParentNode} child\n   */\n  function processFocus(child) {\n    const autofocus = '[autofocus]'\n    const autoFocusedElt = asHtmlElement(matches(child, autofocus) ? child : child.querySelector(autofocus))\n    if (autoFocusedElt != null) {\n      autoFocusedElt.focus()\n    }\n  }\n\n  /**\n   * @param {Node} parentNode\n   * @param {Node} insertBefore\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function insertNodesBefore(parentNode, insertBefore, fragment, settleInfo) {\n    handleAttributes(parentNode, fragment, settleInfo)\n    while (fragment.childNodes.length > 0) {\n      const child = fragment.firstChild\n      addClassToElement(asElement(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  /**\n   * based on https://gist.github.com/hyamamoto/fd435505d29ebfa3d9716fd2be8d42f0,\n   * derived from Java's string hashcode implementation\n   * @param {string} string\n   * @param {number} hash\n   * @returns {number}\n   */\n  function stringHash(string, hash) {\n    let 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  /**\n   * @param {Element} elt\n   * @returns {number}\n   */\n  function attributeHash(elt) {\n    let hash = 0\n    for (let i = 0; i < elt.attributes.length; i++) {\n      const 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    return hash\n  }\n\n  /**\n   * @param {EventTarget} elt\n   */\n  function deInitOnHandlers(elt) {\n    const internalData = getInternalData(elt)\n    if (internalData.onHandlers) {\n      for (let i = 0; i < internalData.onHandlers.length; i++) {\n        const handlerInfo = internalData.onHandlers[i]\n        removeEventListenerImpl(elt, handlerInfo.event, handlerInfo.listener)\n      }\n      delete internalData.onHandlers\n    }\n  }\n\n  /**\n   * @param {Node} element\n   */\n  function deInitNode(element) {\n    const internalData = getInternalData(element)\n    if (internalData.timeout) {\n      clearTimeout(internalData.timeout)\n    }\n    if (internalData.listenerInfos) {\n      forEach(internalData.listenerInfos, function(info) {\n        if (info.on) {\n          removeEventListenerImpl(info.on, info.trigger, info.listener)\n        }\n      })\n    }\n    deInitOnHandlers(element)\n    forEach(Object.keys(internalData), function(key) { if (key !== 'firstInitCompleted') delete internalData[key] })\n  }\n\n  /**\n   * @param {Node} element\n   */\n  function cleanUpElement(element) {\n    triggerEvent(element, 'htmx:beforeCleanupElement')\n    deInitNode(element)\n    // @ts-ignore\n    forEach(element.children, function(child) { cleanUpElement(child) })\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapOuterHTML(target, fragment, settleInfo) {\n    if (target.tagName === 'BODY') { // special case the body to innerHTML because DocumentFragments can't contain a body elt unfortunately\n      return swapInnerHTML(target, fragment, settleInfo)\n    }\n    /** @type {Node} */\n    let newElt\n    const eltBeforeNewContent = target.previousSibling\n    const parentNode = parentElt(target)\n    if (!parentNode) { // when parent node disappears, we can't do anything\n      return\n    }\n    insertNodesBefore(parentNode, target, fragment, settleInfo)\n    if (eltBeforeNewContent == null) {\n      newElt = parentNode.firstChild\n    } else {\n      newElt = eltBeforeNewContent.nextSibling\n    }\n    settleInfo.elts = settleInfo.elts.filter(function(e) { return e !== target })\n    // scan through all newly added content and add all elements to the settle info so we trigger\n    // events properly on them\n    while (newElt && newElt !== target) {\n      if (newElt instanceof Element) {\n        settleInfo.elts.push(newElt)\n      }\n      newElt = newElt.nextSibling\n    }\n    cleanUpElement(target)\n    target.remove()\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapAfterBegin(target, fragment, settleInfo) {\n    return insertNodesBefore(target, target.firstChild, fragment, settleInfo)\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapBeforeBegin(target, fragment, settleInfo) {\n    return insertNodesBefore(parentElt(target), target, fragment, settleInfo)\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapBeforeEnd(target, fragment, settleInfo) {\n    return insertNodesBefore(target, null, fragment, settleInfo)\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapAfterEnd(target, fragment, settleInfo) {\n    return insertNodesBefore(parentElt(target), target.nextSibling, fragment, settleInfo)\n  }\n\n  /**\n   * @param {Element} target\n   */\n  function swapDelete(target) {\n    cleanUpElement(target)\n    const parent = parentElt(target)\n    if (parent) {\n      return parent.removeChild(target)\n    }\n  }\n\n  /**\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapInnerHTML(target, fragment, settleInfo) {\n    const 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  /**\n   * @param {HtmxSwapStyle} swapStyle\n   * @param {Element} elt\n   * @param {Element} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapWithStyle(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)\n        return\n      default:\n        var extensions = getExtensions(elt)\n        for (let i = 0; i < extensions.length; i++) {\n          const ext = extensions[i]\n          try {\n            const newElements = ext.handleSwap(swapStyle, target, fragment, settleInfo)\n            if (newElements) {\n              if (Array.isArray(newElements)) {\n                // if handleSwap returns an array (like) of elements, we handle them\n                for (let j = 0; j < newElements.length; j++) {\n                  const 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          swapWithStyle(htmx.config.defaultSwapStyle, elt, target, fragment, settleInfo)\n        }\n    }\n  }\n\n  /**\n   * @param {DocumentFragment} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   * @param {Node|Document} [rootNode]\n   */\n  function findAndSwapOobElements(fragment, settleInfo, rootNode) {\n    var oobElts = findAll(fragment, '[hx-swap-oob], [data-hx-swap-oob]')\n    forEach(oobElts, function(oobElement) {\n      if (htmx.config.allowNestedOobSwaps || oobElement.parentElement === null) {\n        const oobValue = getAttributeValue(oobElement, 'hx-swap-oob')\n        if (oobValue != null) {\n          oobSwap(oobValue, oobElement, settleInfo, rootNode)\n        }\n      } else {\n        oobElement.removeAttribute('hx-swap-oob')\n        oobElement.removeAttribute('data-hx-swap-oob')\n      }\n    })\n    return oobElts.length > 0\n  }\n\n  /**\n   * Implements complete swapping pipeline, including: delay, view transitions, focus and selection preservation,\n   * title updates, scroll, OOB swapping, normal swapping and settling\n   * @param {string|Element} target\n   * @param {string} content\n   * @param {HtmxSwapSpecification} swapSpec\n   * @param {SwapOptions} [swapOptions]\n   */\n  function swap(target, content, swapSpec, swapOptions) {\n    if (!swapOptions) {\n      swapOptions = {}\n    }\n    // optional transition API promise callbacks\n    let settleResolve = null\n    let settleReject = null\n\n    let doSwap = function() {\n      maybeCall(swapOptions.beforeSwapCallback)\n\n      target = resolveTarget(target)\n      const rootNode = swapOptions.contextElement ? getRootNode(swapOptions.contextElement, false) : getDocument()\n\n      // preserve focus and selection\n      const activeElt = document.activeElement\n      let selectionInfo = {}\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      const settleInfo = makeSettleInfo(target)\n\n      // For text content swaps, don't parse the response as HTML, just insert it\n      if (swapSpec.swapStyle === 'textContent') {\n        target.textContent = content\n      // Otherwise, make the fragment and process it\n      } else {\n        let fragment = makeFragment(content)\n\n        settleInfo.title = swapOptions.title || fragment.title\n        if (swapOptions.historyRequest) {\n          // @ts-ignore fragment can be a parentNode Element\n          fragment = fragment.querySelector('[hx-history-elt],[data-hx-history-elt]') || fragment\n        }\n\n        // select-oob swaps\n        if (swapOptions.selectOOB) {\n          const oobSelectValues = swapOptions.selectOOB.split(',')\n          for (let i = 0; i < oobSelectValues.length; i++) {\n            const oobSelectValue = oobSelectValues[i].split(':', 2)\n            let id = oobSelectValue[0].trim()\n            if (id.indexOf('#') === 0) {\n              id = id.substring(1)\n            }\n            const oobValue = oobSelectValue[1] || 'true'\n            const oobElement = fragment.querySelector('#' + id)\n            if (oobElement) {\n              oobSwap(oobValue, oobElement, settleInfo, rootNode)\n            }\n          }\n        }\n        // oob swaps\n        findAndSwapOobElements(fragment, settleInfo, rootNode)\n        forEach(findAll(fragment, 'template'), /** @param {HTMLTemplateElement} template */function(template) {\n          if (template.content && findAndSwapOobElements(template.content, settleInfo, rootNode)) {\n            // Avoid polluting the DOM with empty templates that were only used to encapsulate oob swap\n            template.remove()\n          }\n        })\n\n        // normal swap\n        if (swapOptions.select) {\n          const newFragment = getDocument().createDocumentFragment()\n          forEach(fragment.querySelectorAll(swapOptions.select), function(node) {\n            newFragment.appendChild(node)\n          })\n          fragment = newFragment\n        }\n        handlePreservedElements(fragment)\n        swapWithStyle(swapSpec.swapStyle, swapOptions.contextElement, target, fragment, settleInfo)\n        restorePreservedElements()\n      }\n\n      // apply saved focus and selection information to swapped content\n      if (selectionInfo.elt &&\n        !bodyContains(selectionInfo.elt) &&\n        getRawAttribute(selectionInfo.elt, 'id')) {\n        const newActiveElt = document.getElementById(getRawAttribute(selectionInfo.elt, 'id'))\n        const focusOptions = { preventScroll: swapSpec.focusScroll !== undefined ? !swapSpec.focusScroll : !htmx.config.defaultFocusScroll }\n        if (newActiveElt) {\n          // @ts-ignore\n          if (selectionInfo.start && newActiveElt.setSelectionRange) {\n            try {\n              // @ts-ignore\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      removeClassFromElement(target, htmx.config.swappingClass)\n      forEach(settleInfo.elts, function(elt) {\n        if (elt.classList) {\n          addClassToElement(elt, htmx.config.settlingClass)\n        }\n        triggerEvent(elt, 'htmx:afterSwap', swapOptions.eventInfo)\n      })\n      maybeCall(swapOptions.afterSwapCallback)\n\n      // merge in new title after swap but before settle\n      if (!swapSpec.ignoreTitle) {\n        handleTitle(settleInfo.title)\n      }\n\n      // settle\n      const doSettle = function() {\n        forEach(settleInfo.tasks, function(task) {\n          task.call()\n        })\n        forEach(settleInfo.elts, function(elt) {\n          if (elt.classList) {\n            removeClassFromElement(elt, htmx.config.settlingClass)\n          }\n          triggerEvent(elt, 'htmx:afterSettle', swapOptions.eventInfo)\n        })\n\n        if (swapOptions.anchor) {\n          const anchorTarget = asElement(resolveTarget('#' + swapOptions.anchor))\n          if (anchorTarget) {\n            anchorTarget.scrollIntoView({ block: 'start', behavior: 'auto' })\n          }\n        }\n\n        updateScrollState(settleInfo.elts, swapSpec)\n        maybeCall(swapOptions.afterSettleCallback)\n        maybeCall(settleResolve)\n      }\n\n      if (swapSpec.settleDelay > 0) {\n        getWindow().setTimeout(doSettle, swapSpec.settleDelay)\n      } else {\n        doSettle()\n      }\n    }\n    let shouldTransition = htmx.config.globalViewTransitions\n    if (swapSpec.hasOwnProperty('transition')) {\n      shouldTransition = swapSpec.transition\n    }\n\n    const elt = swapOptions.contextElement || getDocument()\n\n    if (shouldTransition &&\n            triggerEvent(elt, 'htmx:beforeTransition', swapOptions.eventInfo) &&\n            typeof Promise !== 'undefined' &&\n            // @ts-ignore experimental feature atm\n            document.startViewTransition) {\n      const settlePromise = new Promise(function(_resolve, _reject) {\n        settleResolve = _resolve\n        settleReject = _reject\n      })\n      // wrap the original doSwap() in a call to startViewTransition()\n      const innerDoSwap = doSwap\n      doSwap = function() {\n        // @ts-ignore experimental feature atm\n        document.startViewTransition(function() {\n          innerDoSwap()\n          return settlePromise\n        })\n      }\n    }\n\n    try {\n      if (swapSpec?.swapDelay && swapSpec.swapDelay > 0) {\n        getWindow().setTimeout(doSwap, swapSpec.swapDelay)\n      } else {\n        doSwap()\n      }\n    } catch (e) {\n      triggerErrorEvent(elt, 'htmx:swapError', swapOptions.eventInfo)\n      maybeCall(settleReject)\n      throw e\n    }\n  }\n\n  /**\n   * @param {XMLHttpRequest} xhr\n   * @param {string} header\n   * @param {EventTarget} elt\n   */\n  function handleTriggerHeader(xhr, header, elt) {\n    const triggerBody = xhr.getResponseHeader(header)\n    if (triggerBody.indexOf('{') === 0) {\n      const triggers = parseJSON(triggerBody)\n      for (const eventName in triggers) {\n        if (triggers.hasOwnProperty(eventName)) {\n          let detail = triggers[eventName]\n          if (isRawObject(detail)) {\n            // @ts-ignore\n            elt = detail.target !== undefined ? detail.target : elt\n          } else {\n            detail = { value: detail }\n          }\n          triggerEvent(elt, eventName, detail)\n        }\n      }\n    } else {\n      const eventNames = triggerBody.split(',')\n      for (let i = 0; i < eventNames.length; i++) {\n        triggerEvent(elt, eventNames[i].trim(), [])\n      }\n    }\n  }\n\n  const WHITESPACE = /\\s/\n  const WHITESPACE_OR_COMMA = /[\\s,]/\n  const SYMBOL_START = /[_$a-zA-Z]/\n  const SYMBOL_CONT = /[_$a-zA-Z0-9]/\n  const STRINGISH_START = ['\"', \"'\", '/']\n  const NOT_WHITESPACE = /[^\\s]/\n  const COMBINED_SELECTOR_START = /[{(]/\n  const COMBINED_SELECTOR_END = /[})]/\n\n  /**\n   * @param {string} str\n   * @returns {string[]}\n   */\n  function tokenizeString(str) {\n    /** @type string[] */\n    const tokens = []\n    let 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.substring(startPosition, position + 1))\n      } else if (STRINGISH_START.indexOf(str.charAt(position)) !== -1) {\n        const 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.substring(startPosition, position + 1))\n      } else {\n        const symbol = str.charAt(position)\n        tokens.push(symbol)\n      }\n      position++\n    }\n    return tokens\n  }\n\n  /**\n   * @param {string} token\n   * @param {string|null} last\n   * @param {string} paramName\n   * @returns {boolean}\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  /**\n   * @param {EventTarget|string} elt\n   * @param {string[]} tokens\n   * @param {string} paramName\n   * @returns {ConditionalFunction|null}\n   */\n  function maybeGenerateConditional(elt, tokens, paramName) {\n    if (tokens[0] === '[') {\n      tokens.shift()\n      let bracketCount = 1\n      let conditionalSource = ' return (function(' + paramName + '){ return ('\n      let last = null\n      while (tokens.length > 0) {\n        const token = tokens[0]\n        // @ts-ignore For some reason tsc doesn't understand the shift call, and thinks we're comparing the same value here, i.e. '[' vs ']'\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              const 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  /**\n   * @param {string[]} tokens\n   * @param {RegExp} match\n   * @returns {string}\n   */\n  function consumeUntil(tokens, match) {\n    let result = ''\n    while (tokens.length > 0 && !match.test(tokens[0])) {\n      result += tokens.shift()\n    }\n    return result\n  }\n\n  /**\n   * @param {string[]} tokens\n   * @returns {string}\n   */\n  function consumeCSSSelector(tokens) {\n    let result\n    if (tokens.length > 0 && COMBINED_SELECTOR_START.test(tokens[0])) {\n      tokens.shift()\n      result = consumeUntil(tokens, COMBINED_SELECTOR_END).trim()\n      tokens.shift()\n    } else {\n      result = consumeUntil(tokens, WHITESPACE_OR_COMMA)\n    }\n    return result\n  }\n\n  const INPUT_SELECTOR = 'input, textarea, select'\n\n  /**\n   * @param {Element} elt\n   * @param {string} explicitTrigger\n   * @param {Object} cache for trigger specs\n   * @returns {HtmxTriggerSpecification[]}\n   */\n  function parseAndCacheTrigger(elt, explicitTrigger, cache) {\n    /** @type HtmxTriggerSpecification[] */\n    const triggerSpecs = []\n    const tokens = tokenizeString(explicitTrigger)\n    do {\n      consumeUntil(tokens, NOT_WHITESPACE)\n      const initialLength = tokens.length\n      const trigger = consumeUntil(tokens, /[,\\[\\s]/)\n      if (trigger !== '') {\n        if (trigger === 'every') {\n          /** @type HtmxTriggerSpecification */\n          const 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 {\n          /** @type HtmxTriggerSpecification */\n          const triggerSpec = { trigger }\n          var eventFilter = maybeGenerateConditional(elt, tokens, 'event')\n          if (eventFilter) {\n            triggerSpec.eventFilter = eventFilter\n          }\n          consumeUntil(tokens, NOT_WHITESPACE)\n          while (tokens.length > 0 && tokens[0] !== ',') {\n            const 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              if (COMBINED_SELECTOR_START.test(tokens[0])) {\n                var from_arg = consumeCSSSelector(tokens)\n              } else {\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                  const selector = consumeCSSSelector(tokens)\n                  // `next` and `previous` allow a selector-less syntax\n                  if (selector.length > 0) {\n                    from_arg += ' ' + selector\n                  }\n                }\n              }\n              triggerSpec.from = from_arg\n            } else if (token === 'target' && tokens[0] === ':') {\n              tokens.shift()\n              triggerSpec.target = consumeCSSSelector(tokens)\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' && tokens[0] === ':') {\n              tokens.shift()\n              triggerSpec[token] = consumeCSSSelector(tokens)\n            } else if (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            consumeUntil(tokens, NOT_WHITESPACE)\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    if (cache) {\n      cache[explicitTrigger] = triggerSpecs\n    }\n    return triggerSpecs\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {HtmxTriggerSpecification[]}\n   */\n  function getTriggerSpecs(elt) {\n    const explicitTrigger = getAttributeValue(elt, 'hx-trigger')\n    let triggerSpecs = []\n    if (explicitTrigger) {\n      const cache = htmx.config.triggerSpecsCache\n      triggerSpecs = (cache && cache[explicitTrigger]) || parseAndCacheTrigger(elt, explicitTrigger, cache)\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\"], input[type=\"submit\"]')) {\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  /**\n   * @param {Element} elt\n   */\n  function cancelPolling(elt) {\n    getInternalData(elt).cancelled = true\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {TriggerHandler} handler\n   * @param {HtmxTriggerSpecification} spec\n   */\n  function processPolling(elt, handler, spec) {\n    const nodeData = getInternalData(elt)\n    nodeData.timeout = getWindow().setTimeout(function() {\n      if (bodyContains(elt) && nodeData.cancelled !== true) {\n        if (!maybeFilterEvent(spec, elt, makeEvent('hx:poll:trigger', {\n          triggerSpec: spec,\n          target: elt\n        }))) {\n          handler(elt)\n        }\n        processPolling(elt, handler, spec)\n      }\n    }, spec.pollInterval)\n  }\n\n  /**\n   * @param {HTMLAnchorElement} elt\n   * @returns {boolean}\n   */\n  function isLocalLink(elt) {\n    return location.hostname === elt.hostname &&\n      getRawAttribute(elt, 'href') &&\n      getRawAttribute(elt, 'href').indexOf('#') !== 0\n  }\n\n  /**\n   * @param {Element} elt\n   */\n  function eltIsDisabled(elt) {\n    return closest(elt, htmx.config.disableSelector)\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxNodeInternalData} nodeData\n   * @param {HtmxTriggerSpecification[]} triggerSpecs\n   */\n  function boostElement(elt, nodeData, triggerSpecs) {\n    if ((elt instanceof HTMLAnchorElement && isLocalLink(elt) && (elt.target === '' || elt.target === '_self')) || (elt.tagName === 'FORM' && String(getRawAttribute(elt, 'method')).toLowerCase() !== 'dialog')) {\n      nodeData.boosted = true\n      let verb, path\n      if (elt.tagName === 'A') {\n        verb = (/** @type HttpVerb */('get'))\n        path = getRawAttribute(elt, 'href')\n      } else {\n        const rawAttribute = getRawAttribute(elt, 'method')\n        verb = (/** @type HttpVerb */(rawAttribute ? rawAttribute.toLowerCase() : 'get'))\n        path = getRawAttribute(elt, 'action')\n        if (path == null || path === '') {\n          // if there is no action attribute on the form set path to current href before the\n          // following logic to properly clear parameters on a GET (not on a POST!)\n          path = location.href\n        }\n        if (verb === 'get' && path.includes('?')) {\n          path = path.replace(/\\?[^#]+/, '')\n        }\n      }\n      triggerSpecs.forEach(function(triggerSpec) {\n        addEventListener(elt, function(node, evt) {\n          const elt = asElement(node)\n          if (eltIsDisabled(elt)) {\n            cleanUpElement(elt)\n            return\n          }\n          issueAjaxRequest(verb, path, elt, evt)\n        }, nodeData, triggerSpec, true)\n      })\n    }\n  }\n\n  /**\n   * @param {Event} evt\n   * @param {Element} elt\n   * @returns {boolean}\n   */\n  function shouldCancel(evt, elt) {\n    if (evt.type === 'submit' && elt.tagName === 'FORM') {\n      return true\n    } else if (evt.type === 'click') {\n      // find button wrapping the trigger element\n      const btn = /** @type {HTMLButtonElement|HTMLInputElement|null} */ (elt.closest('input[type=\"submit\"], button'))\n      // Do not cancel on buttons that 1) don't have a related form or 2) have a type attribute of 'reset'/'button'.\n      if (btn && btn.form && btn.type === 'submit') {\n        return true\n      }\n\n      // find link wrapping the trigger element\n      const link = elt.closest('a')\n      // Allow links with href=\"#fragment\" (anchors with content after #) to perform normal fragment navigation.\n      // Cancel default action for links with href=\"#\" (bare hash) to prevent scrolling to top and unwanted URL changes.\n      const samePageAnchor = /^#.+/\n      if (link && link.href && !samePageAnchor.test(link.getAttribute('href'))) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * @param {Node} elt\n   * @param {Event|MouseEvent|KeyboardEvent|TouchEvent} evt\n   * @returns {boolean}\n   */\n  function ignoreBoostedAnchorCtrlClick(elt, evt) {\n    return getInternalData(elt).boosted && elt instanceof HTMLAnchorElement && evt.type === 'click' &&\n      // @ts-ignore this will resolve to undefined for events that don't define those properties, which is fine\n      (evt.ctrlKey || evt.metaKey)\n  }\n\n  /**\n   * @param {HtmxTriggerSpecification} triggerSpec\n   * @param {Node} elt\n   * @param {Event} evt\n   * @returns {boolean}\n   */\n  function maybeFilterEvent(triggerSpec, elt, evt) {\n    const eventFilter = triggerSpec.eventFilter\n    if (eventFilter) {\n      try {\n        return eventFilter.call(elt, evt) !== true\n      } catch (e) {\n        const source = eventFilter.source\n        triggerErrorEvent(getDocument().body, 'htmx:eventFilter:error', { error: e, source })\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {TriggerHandler} handler\n   * @param {HtmxNodeInternalData} nodeData\n   * @param {HtmxTriggerSpecification} triggerSpec\n   * @param {boolean} [explicitCancel]\n   */\n  function addEventListener(elt, handler, nodeData, triggerSpec, explicitCancel) {\n    const elementData = getInternalData(elt)\n    /** @type {(Node|Window)[]} */\n    let eltsToListenOn\n    if (triggerSpec.from) {\n      eltsToListenOn = querySelectorAllExt(elt, triggerSpec.from)\n    } else {\n      eltsToListenOn = [elt]\n    }\n    // store the initial values of the elements, so we can tell if they change\n    if (triggerSpec.changed) {\n      if (!('lastValue' in elementData)) {\n        elementData.lastValue = new WeakMap()\n      }\n      eltsToListenOn.forEach(function(eltToListenOn) {\n        if (!elementData.lastValue.has(triggerSpec)) {\n          elementData.lastValue.set(triggerSpec, new WeakMap())\n        }\n        // @ts-ignore value will be undefined for non-input elements, which is fine\n        elementData.lastValue.get(triggerSpec).set(eltToListenOn, eltToListenOn.value)\n      })\n    }\n    forEach(eltsToListenOn, function(eltToListenOn) {\n      /** @type EventListener */\n      const 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, eltToListenOn)) {\n          evt.preventDefault()\n        }\n        if (maybeFilterEvent(triggerSpec, elt, evt)) {\n          return\n        }\n        const 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(asElement(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            const node = evt.target\n            // @ts-ignore value will be undefined for non-input elements, which is fine\n            const value = node.value\n            const lastValue = elementData.lastValue.get(triggerSpec)\n            if (lastValue.has(node) && lastValue.get(node) === value) {\n              return\n            }\n            lastValue.set(node, value)\n          }\n          if (elementData.delayed) {\n            clearTimeout(elementData.delayed)\n          }\n          if (elementData.throttle) {\n            return\n          }\n\n          if (triggerSpec.throttle > 0) {\n            if (!elementData.throttle) {\n              triggerEvent(elt, 'htmx:trigger')\n              handler(elt, evt)\n              elementData.throttle = getWindow().setTimeout(function() {\n                elementData.throttle = null\n              }, triggerSpec.throttle)\n            }\n          } else if (triggerSpec.delay > 0) {\n            elementData.delayed = getWindow().setTimeout(function() {\n              triggerEvent(elt, 'htmx:trigger')\n              handler(elt, evt)\n            }, 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  let windowIsScrolling = false // used by initScrollHandler\n  let scrollHandler = null\n  function initScrollHandler() {\n    if (!scrollHandler) {\n      scrollHandler = function() {\n        windowIsScrolling = true\n      }\n      window.addEventListener('scroll', scrollHandler)\n      window.addEventListener('resize', 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  /**\n   * @param {Element} elt\n   */\n  function maybeReveal(elt) {\n    if (!hasAttribute(elt, 'data-hx-revealed') && isScrolledIntoView(elt)) {\n      elt.setAttribute('data-hx-revealed', 'true')\n      const 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() { triggerEvent(elt, 'revealed') }, { once: true })\n      }\n    }\n  }\n\n  //= ===================================================================\n\n  /**\n   * @param {Element} elt\n   * @param {TriggerHandler} handler\n   * @param {HtmxNodeInternalData} nodeData\n   * @param {number} delay\n   */\n  function loadImmediately(elt, handler, nodeData, delay) {\n    const load = function() {\n      if (!nodeData.loaded) {\n        nodeData.loaded = true\n        triggerEvent(elt, 'htmx:trigger')\n        handler(elt)\n      }\n    }\n    if (delay > 0) {\n      getWindow().setTimeout(load, delay)\n    } else {\n      load()\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxNodeInternalData} nodeData\n   * @param {HtmxTriggerSpecification[]} triggerSpecs\n   * @returns {boolean}\n   */\n  function processVerbs(elt, nodeData, triggerSpecs) {\n    let explicitAction = false\n    forEach(VERBS, function(verb) {\n      if (hasAttribute(elt, 'hx-' + verb)) {\n        const 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(node, evt) {\n            const elt = asElement(node)\n            if (eltIsDisabled(elt)) {\n              cleanUpElement(elt)\n              return\n            }\n            issueAjaxRequest(verb, path, elt, evt)\n          })\n        })\n      }\n    })\n    return explicitAction\n  }\n\n  /**\n   * @callback TriggerHandler\n   * @param {Element} elt\n   * @param {Event} [evt]\n   */\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxTriggerSpecification} triggerSpec\n   * @param {HtmxNodeInternalData} nodeData\n   * @param {TriggerHandler} handler\n   */\n  function addTriggerHandler(elt, triggerSpec, nodeData, handler) {\n    if (triggerSpec.trigger === 'revealed') {\n      initScrollHandler()\n      addEventListener(elt, handler, nodeData, triggerSpec)\n      maybeReveal(asElement(elt))\n    } else if (triggerSpec.trigger === 'intersect') {\n      const 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      const observer = new IntersectionObserver(function(entries) {\n        for (let i = 0; i < entries.length; i++) {\n          const entry = entries[i]\n          if (entry.isIntersecting) {\n            triggerEvent(elt, 'intersect')\n            break\n          }\n        }\n      }, observerOptions)\n      observer.observe(asElement(elt))\n      addEventListener(asElement(elt), handler, nodeData, triggerSpec)\n    } else if (!nodeData.firstInitCompleted && triggerSpec.trigger === 'load') {\n      if (!maybeFilterEvent(triggerSpec, elt, makeEvent('load', { elt }))) {\n        loadImmediately(asElement(elt), handler, nodeData, triggerSpec.delay)\n      }\n    } else if (triggerSpec.pollInterval > 0) {\n      nodeData.polling = true\n      processPolling(asElement(elt), handler, triggerSpec)\n    } else {\n      addEventListener(elt, handler, nodeData, triggerSpec)\n    }\n  }\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function shouldProcessHxOn(node) {\n    const elt = asElement(node)\n    if (!elt) {\n      return false\n    }\n    const attributes = elt.attributes\n    for (let j = 0; j < attributes.length; j++) {\n      const attrName = attributes[j].name\n      if (startsWith(attrName, 'hx-on:') || startsWith(attrName, 'data-hx-on:') ||\n        startsWith(attrName, 'hx-on-') || startsWith(attrName, 'data-hx-on-')) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * @param {Node} elt\n   * @returns {Element[]}\n   */\n  const HX_ON_QUERY = new XPathEvaluator()\n    .createExpression('.//*[@*[ starts-with(name(), \"hx-on:\") or starts-with(name(), \"data-hx-on:\") or' +\n      ' starts-with(name(), \"hx-on-\") or starts-with(name(), \"data-hx-on-\") ]]')\n\n  function processHXOnRoot(elt, elements) {\n    if (shouldProcessHxOn(elt)) {\n      elements.push(asElement(elt))\n    }\n    const iter = HX_ON_QUERY.evaluate(elt)\n    let node = null\n    while (node = iter.iterateNext()) elements.push(asElement(node))\n  }\n\n  function findHxOnWildcardElements(elt) {\n    /** @type {Element[]} */\n    const elements = []\n    if (elt instanceof DocumentFragment) {\n      for (const child of elt.childNodes) {\n        processHXOnRoot(child, elements)\n      }\n    } else {\n      processHXOnRoot(elt, elements)\n    }\n    return elements\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {NodeListOf<Element>|[]}\n   */\n  function findElementsToProcess(elt) {\n    if (elt.querySelectorAll) {\n      const boostedSelector = ', [hx-boost] a, [data-hx-boost] a, a[hx-boost], a[data-hx-boost]'\n\n      const extensionSelectors = []\n      for (const e in extensions) {\n        const extension = extensions[e]\n        if (extension.getSelectors) {\n          var selectors = extension.getSelectors()\n          if (selectors) {\n            extensionSelectors.push(selectors)\n          }\n        }\n      }\n\n      const results = elt.querySelectorAll(VERB_SELECTOR + boostedSelector + \", form, [type='submit'],\" +\n        ' [hx-ext], [data-hx-ext], [hx-trigger], [data-hx-trigger]' + extensionSelectors.flat().map(s => ', ' + s).join(''))\n\n      return results\n    } else {\n      return []\n    }\n  }\n\n  /**\n   * Handle submit buttons/inputs that have the form attribute set\n   * see https://developer.mozilla.org/docs/Web/HTML/Element/button\n   * @param {Event} evt\n   */\n  function maybeSetLastButtonClicked(evt) {\n    const elt = getTargetButton(evt.target)\n    const internalData = getRelatedFormData(evt)\n    if (internalData) {\n      internalData.lastButtonClicked = elt\n    }\n  }\n\n  /**\n   * @param {Event} evt\n   */\n  function maybeUnsetLastButtonClicked(evt) {\n    const internalData = getRelatedFormData(evt)\n    if (internalData) {\n      internalData.lastButtonClicked = null\n    }\n  }\n\n  /**\n   * @param {EventTarget} target\n   * @returns {HTMLButtonElement|HTMLInputElement|null}\n   */\n  function getTargetButton(target) {\n    return /** @type {HTMLButtonElement|HTMLInputElement|null} */ (closest(asElement(target), \"button, input[type='submit']\"))\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {HTMLFormElement|null}\n   */\n  function getRelatedForm(elt) {\n    // @ts-ignore Get the related form if available, else find the closest parent form\n    return elt.form || closest(elt, 'form')\n  }\n\n  /**\n   * @param {Event} evt\n   * @returns {HtmxNodeInternalData|undefined}\n   */\n  function getRelatedFormData(evt) {\n    const elt = getTargetButton(evt.target)\n    if (!elt) {\n      return\n    }\n    const form = getRelatedForm(elt)\n    if (!form) {\n      return\n    }\n    return getInternalData(form)\n  }\n\n  /**\n   * @param {EventTarget} elt\n   */\n  function initButtonTracking(elt) {\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    elt.addEventListener('click', maybeSetLastButtonClicked)\n    elt.addEventListener('focusin', maybeSetLastButtonClicked)\n    elt.addEventListener('focusout', maybeUnsetLastButtonClicked)\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {string} eventName\n   * @param {string} code\n   */\n  function addHxOnEventHandler(elt, eventName, code) {\n    const nodeData = getInternalData(elt)\n    if (!Array.isArray(nodeData.onHandlers)) {\n      nodeData.onHandlers = []\n    }\n    let func\n    /** @type EventListener */\n    const listener = function(e) {\n      maybeEval(elt, function() {\n        if (eltIsDisabled(elt)) {\n          return\n        }\n        if (!func) {\n          func = new Function('event', code)\n        }\n        func.call(elt, e)\n      })\n    }\n    elt.addEventListener(eventName, listener)\n    nodeData.onHandlers.push({ event: eventName, listener })\n  }\n\n  /**\n   * @param {Element} elt\n   */\n  function processHxOnWildcard(elt) {\n    // wipe any previous on handlers so that this function takes precedence\n    deInitOnHandlers(elt)\n\n    for (let i = 0; i < elt.attributes.length; i++) {\n      const name = elt.attributes[i].name\n      const value = elt.attributes[i].value\n      if (startsWith(name, 'hx-on') || startsWith(name, 'data-hx-on')) {\n        const afterOnPosition = name.indexOf('-on') + 3\n        const nextChar = name.slice(afterOnPosition, afterOnPosition + 1)\n        if (nextChar === '-' || nextChar === ':') {\n          let eventName = name.slice(afterOnPosition + 1)\n          // if the eventName starts with a colon or dash, prepend \"htmx\" for shorthand support\n          if (startsWith(eventName, ':')) {\n            eventName = 'htmx' + eventName\n          } else if (startsWith(eventName, '-')) {\n            eventName = 'htmx:' + eventName.slice(1)\n          } else if (startsWith(eventName, 'htmx-')) {\n            eventName = 'htmx:' + eventName.slice(5)\n          }\n\n          addHxOnEventHandler(elt, eventName, value)\n        }\n      }\n    }\n  }\n\n  /**\n   * @param {Element|HTMLInputElement} elt\n   */\n  function initNode(elt) {\n    triggerEvent(elt, 'htmx:beforeProcessNode')\n\n    const nodeData = getInternalData(elt)\n    const triggerSpecs = getTriggerSpecs(elt)\n    const 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    // Handle submit buttons/inputs that have the form attribute set\n    // see https://developer.mozilla.org/docs/Web/HTML/Element/button\n    if (elt.tagName === 'FORM' || (getRawAttribute(elt, 'type') === 'submit' && hasAttribute(elt, 'form'))) {\n      initButtonTracking(elt)\n    }\n\n    nodeData.firstInitCompleted = true\n    triggerEvent(elt, 'htmx:afterProcessNode')\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {boolean}\n   */\n  function maybeDeInitAndHash(elt) {\n    // Ensure only valid Elements and not shadow DOM roots are inited\n    if (!(elt instanceof Element)) {\n      return false\n    }\n\n    const nodeData = getInternalData(elt)\n    const hash = attributeHash(elt)\n    if (nodeData.initHash !== hash) {\n      deInitNode(elt)\n      nodeData.initHash = hash\n      return true\n    }\n    return false\n  }\n\n  /**\n   * Processes new content, enabling htmx behavior. This can be useful if you have content that is added to the DOM outside of the normal htmx request cycle but still want htmx attributes to work.\n   *\n   * @see https://htmx.org/api/#process\n   *\n   * @param {Element|string} elt element to process\n   */\n  function processNode(elt) {\n    elt = resolveTarget(elt)\n    if (eltIsDisabled(elt)) {\n      cleanUpElement(elt)\n      return\n    }\n\n    const elementsToInit = []\n    if (maybeDeInitAndHash(elt)) {\n      elementsToInit.push(elt)\n    }\n    forEach(findElementsToProcess(elt), function(child) {\n      if (eltIsDisabled(child)) {\n        cleanUpElement(child)\n        return\n      }\n      if (maybeDeInitAndHash(child)) {\n        elementsToInit.push(child)\n      }\n    })\n\n    forEach(findHxOnWildcardElements(elt), processHxOnWildcard)\n    forEach(elementsToInit, initNode)\n  }\n\n  //= ===================================================================\n  // Event/Log Support\n  //= ===================================================================\n\n  /**\n   * @param {string} str\n   * @returns {string}\n   */\n  function kebabEventName(str) {\n    return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()\n  }\n\n  /**\n   * @param {string} eventName\n   * @param {any} detail\n   * @returns {CustomEvent}\n   */\n  function makeEvent(eventName, detail) {\n    // TODO: `composed: true` here is a hack to make global event handlers work with events in shadow DOM\n    // This breaks expected encapsulation but needs to be here until decided otherwise by core devs\n    return new CustomEvent(eventName, { bubbles: true, cancelable: true, composed: true, detail })\n  }\n\n  /**\n   * @param {EventTarget|string} elt\n   * @param {string} eventName\n   * @param {any=} detail\n   */\n  function triggerErrorEvent(elt, eventName, detail) {\n    triggerEvent(elt, eventName, mergeObjects({ error: eventName }, detail))\n  }\n\n  /**\n   * @param {string} eventName\n   * @returns {boolean}\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. You can filter\n   * the element's extensions by giving it a list of extensions to ignore. It should\n   * be called internally at every extendable execution point in htmx.\n   *\n   * @param {Element} elt\n   * @param {(extension:HtmxExtension) => void} toDo\n   * @param {string[]=} extensionsToIgnore\n   * @returns void\n   */\n  function withExtensions(elt, toDo, extensionsToIgnore) {\n    forEach(getExtensions(elt, [], extensionsToIgnore), function(extension) {\n      try {\n        toDo(extension)\n      } catch (e) {\n        logError(e)\n      }\n    })\n  }\n\n  function logError(msg) {\n    console.error(msg)\n  }\n\n  /**\n   * Triggers a given event on an element\n   *\n   * @see https://htmx.org/api/#trigger\n   *\n   * @param {EventTarget|string} elt the element to trigger the event on\n   * @param {string} eventName the name of the event to trigger\n   * @param {any=} detail details for the event\n   * @returns {boolean}\n   */\n  function triggerEvent(elt, eventName, detail) {\n    elt = resolveTarget(elt)\n    if (detail == null) {\n      detail = {}\n    }\n    detail.elt = elt\n    const 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 + (detail.target ? ', ' + detail.target : ''))\n      triggerEvent(elt, 'htmx:error', { errorInfo: detail })\n    }\n    let eventResult = elt.dispatchEvent(event)\n    const kebabName = kebabEventName(eventName)\n    if (eventResult && kebabName !== eventName) {\n      const kebabedEvent = makeEvent(kebabName, event.detail)\n      eventResult = eventResult && elt.dispatchEvent(kebabedEvent)\n    }\n    withExtensions(asElement(elt), function(extension) {\n      eventResult = eventResult && (extension.onEvent(eventName, event) !== false && !event.defaultPrevented)\n    })\n    return eventResult\n  }\n\n  //= ===================================================================\n  // History Support\n  //= ===================================================================\n  let currentPathForHistory\n\n  /**\n   * @param {string} path\n   */\n  function setCurrentPathForHistory(path) {\n    currentPathForHistory = path\n    if (canAccessLocalStorage()) {\n      sessionStorage.setItem('htmx-current-path-for-history', path)\n    }\n  }\n\n  setCurrentPathForHistory(location.pathname + location.search)\n\n  /**\n   * @returns {Element}\n   */\n  function getHistoryElement() {\n    const historyElt = getDocument().querySelector('[hx-history-elt],[data-hx-history-elt]')\n    return historyElt || getDocument().body\n  }\n\n  /**\n   * @param {string} url\n   * @param {Element} rootElt\n   */\n  function saveToHistoryCache(url, rootElt) {\n    if (!canAccessLocalStorage()) {\n      return\n    }\n\n    // get state to save\n    const innerHTML = cleanInnerHtmlForHistory(rootElt)\n    const title = getDocument().title\n    const scroll = window.scrollY\n\n    if (htmx.config.historyCacheSize <= 0) {\n      // make sure that an eventually already existing cache is purged\n      sessionStorage.removeItem('htmx-history-cache')\n      return\n    }\n\n    url = normalizePath(url)\n\n    const historyCache = parseJSON(sessionStorage.getItem('htmx-history-cache')) || []\n    for (let i = 0; i < historyCache.length; i++) {\n      if (historyCache[i].url === url) {\n        historyCache.splice(i, 1)\n        break\n      }\n    }\n\n    /** @type HtmxHistoryItem */\n    const newHistoryItem = { url, content: innerHTML, title, scroll }\n\n    triggerEvent(getDocument().body, 'htmx:historyItemCreated', { item: newHistoryItem, cache: historyCache })\n\n    historyCache.push(newHistoryItem)\n    while (historyCache.length > htmx.config.historyCacheSize) {\n      historyCache.shift()\n    }\n\n    // keep trying to save the cache until it succeeds or is empty\n    while (historyCache.length > 0) {\n      try {\n        sessionStorage.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  /**\n   * @typedef {Object} HtmxHistoryItem\n   * @property {string} url\n   * @property {string} content\n   * @property {string} title\n   * @property {number} scroll\n   */\n\n  /**\n   * @param {string} url\n   * @returns {HtmxHistoryItem|null}\n   */\n  function getCachedHistory(url) {\n    if (!canAccessLocalStorage()) {\n      return null\n    }\n\n    url = normalizePath(url)\n\n    const historyCache = parseJSON(sessionStorage.getItem('htmx-history-cache')) || []\n    for (let i = 0; i < historyCache.length; i++) {\n      if (historyCache[i].url === url) {\n        return historyCache[i]\n      }\n    }\n    return null\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {string}\n   */\n  function cleanInnerHtmlForHistory(elt) {\n    const className = htmx.config.requestClass\n    const clone = /** @type Element */ (elt.cloneNode(true))\n    forEach(findAll(clone, '.' + className), function(child) {\n      removeClassFromElement(child, className)\n    })\n    // remove the disabled attribute for any element disabled due to an htmx request\n    forEach(findAll(clone, '[data-disabled-by-htmx]'), function(child) {\n      child.removeAttribute('disabled')\n    })\n    return clone.innerHTML\n  }\n\n  function saveCurrentPageToHistory() {\n    const elt = getHistoryElement()\n    let path = currentPathForHistory\n    if (canAccessLocalStorage()) {\n      path = sessionStorage.getItem('htmx-current-path-for-history')\n    }\n    path = path || 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 sessionStorage cache\n    const disableHistoryCache = getDocument().querySelector('[hx-history=\"false\" i],[data-hx-history=\"false\" i]')\n    if (!disableHistoryCache) {\n      triggerEvent(getDocument().body, 'htmx:beforeHistorySave', { path, historyElt: elt })\n      saveToHistoryCache(path, elt)\n    }\n\n    if (htmx.config.historyEnabled) history.replaceState({ htmx: true }, getDocument().title, location.href)\n  }\n\n  /**\n   * @param {string} path\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 (endsWith(path, '&') || endsWith(path, '?')) {\n        path = path.slice(0, -1)\n      }\n    }\n    if (htmx.config.historyEnabled) {\n      history.pushState({ htmx: true }, '', path)\n    }\n    setCurrentPathForHistory(path)\n  }\n\n  /**\n   * @param {string} path\n   */\n  function replaceUrlInHistory(path) {\n    if (htmx.config.historyEnabled) history.replaceState({ htmx: true }, '', path)\n    setCurrentPathForHistory(path)\n  }\n\n  /**\n   * @param {HtmxSettleTask[]} tasks\n   */\n  function settleImmediately(tasks) {\n    forEach(tasks, function(task) {\n      task.call(undefined)\n    })\n  }\n\n  /**\n   * @param {string} path\n   */\n  function loadHistoryFromServer(path) {\n    const request = new XMLHttpRequest()\n    const swapSpec = { swapStyle: 'innerHTML', swapDelay: 0, settleDelay: 0 }\n    const details = { path, xhr: request, historyElt: getHistoryElement(), swapSpec }\n    request.open('GET', path, true)\n    if (htmx.config.historyRestoreAsHxRequest) {\n      request.setRequestHeader('HX-Request', 'true')\n    }\n    request.setRequestHeader('HX-History-Restore-Request', 'true')\n    request.setRequestHeader('HX-Current-URL', location.href)\n    request.onload = function() {\n      if (this.status >= 200 && this.status < 400) {\n        details.response = this.response\n        triggerEvent(getDocument().body, 'htmx:historyCacheMissLoad', details)\n        swap(details.historyElt, details.response, swapSpec, {\n          contextElement: details.historyElt,\n          historyRequest: true\n        })\n        setCurrentPathForHistory(details.path)\n        triggerEvent(getDocument().body, 'htmx:historyRestore', { path, cacheMiss: true, serverResponse: details.response })\n      } else {\n        triggerErrorEvent(getDocument().body, 'htmx:historyCacheMissLoadError', details)\n      }\n    }\n    if (triggerEvent(getDocument().body, 'htmx:historyCacheMiss', details)) {\n      request.send() // only send request if event not prevented\n    }\n  }\n\n  /**\n   * @param {string} [path]\n   */\n  function restoreHistory(path) {\n    saveCurrentPageToHistory()\n    path = path || location.pathname + location.search\n    const cached = getCachedHistory(path)\n    if (cached) {\n      const swapSpec = { swapStyle: 'innerHTML', swapDelay: 0, settleDelay: 0, scroll: cached.scroll }\n      const details = { path, item: cached, historyElt: getHistoryElement(), swapSpec }\n      if (triggerEvent(getDocument().body, 'htmx:historyCacheHit', details)) {\n        swap(details.historyElt, cached.content, swapSpec, {\n          contextElement: details.historyElt,\n          title: cached.title\n        })\n        setCurrentPathForHistory(details.path)\n        triggerEvent(getDocument().body, 'htmx:historyRestore', details)\n      }\n    } else {\n      if (htmx.config.refreshOnHistoryMiss) {\n        // @ts-ignore: optional parameter in reload() function throws error\n        // noinspection JSUnresolvedReference\n        htmx.location.reload(true)\n      } else {\n        loadHistoryFromServer(path)\n      }\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {Element[]}\n   */\n  function addRequestIndicatorClasses(elt) {\n    let indicators = /** @type Element[] */ (findAttributeTargets(elt, 'hx-indicator'))\n    if (indicators == null) {\n      indicators = [elt]\n    }\n    forEach(indicators, function(ic) {\n      const internalData = getInternalData(ic)\n      internalData.requestCount = (internalData.requestCount || 0) + 1\n      addClassToElement(ic, htmx.config.requestClass)\n    })\n    return indicators\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {Element[]}\n   */\n  function disableElements(elt) {\n    let disabledElts = /** @type Element[] */ (findAttributeTargets(elt, 'hx-disabled-elt'))\n    if (disabledElts == null) {\n      disabledElts = []\n    }\n    forEach(disabledElts, function(disabledElement) {\n      const internalData = getInternalData(disabledElement)\n      internalData.requestCount = (internalData.requestCount || 0) + 1\n      if (!disabledElement.hasAttribute('disabled')) {\n        disabledElement.setAttribute('disabled', '')\n        disabledElement.setAttribute('data-disabled-by-htmx', '')\n      }\n    })\n    return disabledElts\n  }\n\n  /**\n   * @param {Element[]} indicators\n   * @param {Element[]} disabled\n   */\n  function removeRequestIndicators(indicators, disabled) {\n    forEach(indicators.concat(disabled), function(ele) {\n      const internalData = getInternalData(ele)\n      internalData.requestCount = (internalData.requestCount || 1) - 1\n    })\n    forEach(indicators, function(ic) {\n      const internalData = getInternalData(ic)\n      if (internalData.requestCount === 0) {\n        removeClassFromElement(ic, htmx.config.requestClass)\n      }\n    })\n    forEach(disabled, function(disabledElement) {\n      const internalData = getInternalData(disabledElement)\n      if (internalData.requestCount === 0 && disabledElement.hasAttribute('data-disabled-by-htmx')) {\n        disabledElement.removeAttribute('disabled')\n        disabledElement.removeAttribute('data-disabled-by-htmx')\n      }\n    })\n  }\n\n  //= ===================================================================\n  // Input Value Processing\n  //= ===================================================================\n\n  /**\n   * @param {Element[]} processed\n   * @param {Element} elt\n   * @returns {boolean}\n   */\n  function haveSeenNode(processed, elt) {\n    for (let i = 0; i < processed.length; i++) {\n      const node = processed[i]\n      if (node.isSameNode(elt)) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * @param {Element} element\n   * @return {boolean}\n   */\n  function shouldInclude(element) {\n    // Cast to trick tsc, undefined values will work fine here\n    const elt = /** @type {HTMLInputElement} */ (element)\n    if (elt.name === '' || elt.name == null || elt.disabled || closest(elt, 'fieldset[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  /**\n   * @param {string} name\n   * @param {string|Array|FormDataEntryValue} value\n   * @param {FormData} formData */\n  function addValueToFormData(name, value, formData) {\n    if (name != null && value != null) {\n      if (Array.isArray(value)) {\n        value.forEach(function(v) { formData.append(name, v) })\n      } else {\n        formData.append(name, value)\n      }\n    }\n  }\n\n  /**\n   * @param {string} name\n   * @param {string|Array} value\n   * @param {FormData} formData */\n  function removeValueFromFormData(name, value, formData) {\n    if (name != null && value != null) {\n      let values = formData.getAll(name)\n      if (Array.isArray(value)) {\n        values = values.filter(v => value.indexOf(v) < 0)\n      } else {\n        values = values.filter(v => v !== value)\n      }\n      formData.delete(name)\n      forEach(values, v => formData.append(name, v))\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @returns {string|Array}\n   */\n  function getValueFromInput(elt) {\n    if (elt instanceof HTMLSelectElement && elt.multiple) {\n      return toArray(elt.querySelectorAll('option:checked')).map(function(e) { return (/** @type HTMLOptionElement */(e)).value })\n    }\n    // include file inputs\n    if (elt instanceof HTMLInputElement && elt.files) {\n      return toArray(elt.files)\n    }\n    // @ts-ignore value will be undefined for non-input elements, which is fine\n    return elt.value\n  }\n\n  /**\n   * @param {Element[]} processed\n   * @param {FormData} formData\n   * @param {HtmxElementValidationError[]} errors\n   * @param {Element|HTMLInputElement|HTMLSelectElement|HTMLFormElement} elt\n   * @param {boolean} validate\n   */\n  function processInputValue(processed, formData, errors, elt, validate) {\n    if (elt == null || haveSeenNode(processed, elt)) {\n      return\n    } else {\n      processed.push(elt)\n    }\n    if (shouldInclude(elt)) {\n      const name = getRawAttribute(elt, 'name')\n      addValueToFormData(name, getValueFromInput(elt), formData)\n      if (validate) {\n        validateElement(elt, errors)\n      }\n    }\n    if (elt instanceof HTMLFormElement) {\n      forEach(elt.elements, function(input) {\n        if (processed.indexOf(input) >= 0) {\n          // The input has already been processed and added to the values, but the FormData that will be\n          //  constructed right after on the form, will include it once again. So remove that input's value\n          //  now to avoid duplicates\n          removeValueFromFormData(input.name, getValueFromInput(input), formData)\n        } else {\n          processed.push(input)\n        }\n        if (validate) {\n          validateElement(input, errors)\n        }\n      })\n      new FormData(elt).forEach(function(value, name) {\n        if (value instanceof File && value.name === '') {\n          return // ignore no-name files\n        }\n        addValueToFormData(name, value, formData)\n      })\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxElementValidationError[]} errors\n   */\n  function validateElement(elt, errors) {\n    const element = /** @type {HTMLElement & ElementInternals} */ (elt)\n    if (element.willValidate) {\n      triggerEvent(element, 'htmx:validation:validate')\n      if (!element.checkValidity()) {\n        if (\n          triggerEvent(element, 'htmx:validation:failed', {\n            message: element.validationMessage,\n            validity: element.validity\n          }) &&\n          !errors.length &&\n          htmx.config.reportValidityOfForms\n        ) {\n          element.reportValidity()\n        }\n        errors.push({ elt: element, message: element.validationMessage, validity: element.validity })\n      }\n    }\n  }\n\n  /**\n   * Override values in the one FormData with those from another.\n   * @param {FormData} receiver the formdata that will be mutated\n   * @param {FormData} donor the formdata that will provide the overriding values\n   * @returns {FormData} the {@linkcode receiver}\n   */\n  function overrideFormData(receiver, donor) {\n    for (const key of donor.keys()) {\n      receiver.delete(key)\n    }\n    donor.forEach(function(value, key) {\n      receiver.append(key, value)\n    })\n    return receiver\n  }\n\n  /**\n * @param {Element|HTMLFormElement} elt\n * @param {HttpVerb} verb\n * @returns {{errors: HtmxElementValidationError[], formData: FormData, values: Object}}\n */\n  function getInputValues(elt, verb) {\n    /** @type Element[] */\n    const processed = []\n    const formData = new FormData()\n    const priorityFormData = new FormData()\n    /** @type HtmxElementValidationError[] */\n    const errors = []\n    const internalData = getInternalData(elt)\n    if (internalData.lastButtonClicked && !bodyContains(internalData.lastButtonClicked)) {\n      internalData.lastButtonClicked = null\n    }\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    let validate = (elt instanceof HTMLFormElement && 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 related form, which may or may not be a parent element of elt\n    if (verb !== 'get') {\n      processInputValue(processed, priorityFormData, errors, getRelatedForm(elt), validate)\n    }\n\n    // include the element itself\n    processInputValue(processed, formData, errors, elt, validate)\n\n    // if a button or submit was clicked last, include its value\n    if (internalData.lastButtonClicked || elt.tagName === 'BUTTON' ||\n    (elt.tagName === 'INPUT' && getRawAttribute(elt, 'type') === 'submit')) {\n      const button = internalData.lastButtonClicked || (/** @type HTMLInputElement|HTMLButtonElement */(elt))\n      const name = getRawAttribute(button, 'name')\n      addValueToFormData(name, button.value, priorityFormData)\n    }\n\n    // include any explicit includes\n    const includes = findAttributeTargets(elt, 'hx-include')\n    forEach(includes, function(node) {\n      processInputValue(processed, formData, errors, asElement(node), validate)\n      // if a non-form is included, include any input values within it\n      if (!matches(node, 'form')) {\n        forEach(asParentNode(node).querySelectorAll(INPUT_SELECTOR), function(descendant) {\n          processInputValue(processed, formData, errors, descendant, validate)\n        })\n      }\n    })\n\n    // values from a <form> take precedence, overriding the regular values\n    overrideFormData(formData, priorityFormData)\n\n    return { errors, formData, values: formDataProxy(formData) }\n  }\n\n  /**\n   * @param {string} returnStr\n   * @param {string} name\n   * @param {any} realValue\n   * @returns {string}\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    const s = encodeURIComponent(realValue)\n    returnStr += encodeURIComponent(name) + '=' + s\n    return returnStr\n  }\n\n  /**\n   * @param {FormData|Object} values\n   * @returns string\n   */\n  function urlEncode(values) {\n    values = formDataFromObject(values)\n    let returnStr = ''\n    values.forEach(function(value, key) {\n      returnStr = appendParam(returnStr, key, value)\n    })\n    return returnStr\n  }\n\n  //= ===================================================================\n  // Ajax\n  //= ===================================================================\n\n  /**\n * @param {Element} elt\n * @param {Element} target\n * @param {string} prompt\n * @returns {HtmxHeaderSpecification}\n */\n  function getHeaders(elt, target, prompt) {\n    /** @type HtmxHeaderSpecification */\n    const 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': 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 {FormData} inputValues\n * @param {Element} elt\n * @returns {FormData}\n */\n  function filterValues(inputValues, elt) {\n    const paramsValue = getClosestAttributeValue(elt, 'hx-params')\n    if (paramsValue) {\n      if (paramsValue === 'none') {\n        return new FormData()\n      } else if (paramsValue === '*') {\n        return inputValues\n      } else if (paramsValue.indexOf('not ') === 0) {\n        forEach(paramsValue.slice(4).split(','), function(name) {\n          name = name.trim()\n          inputValues.delete(name)\n        })\n        return inputValues\n      } else {\n        const newValues = new FormData()\n        forEach(paramsValue.split(','), function(name) {\n          name = name.trim()\n          if (inputValues.has(name)) {\n            inputValues.getAll(name).forEach(function(value) { newValues.append(name, value) })\n          }\n        })\n        return newValues\n      }\n    } else {\n      return inputValues\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @return {boolean}\n   */\n  function isAnchorLink(elt) {\n    return !!getRawAttribute(elt, 'href') && getRawAttribute(elt, 'href').indexOf('#') >= 0\n  }\n\n  /**\n * @param {Element} elt\n * @param {HtmxSwapStyle} [swapInfoOverride]\n * @returns {HtmxSwapSpecification}\n */\n  function getSwapSpecification(elt, swapInfoOverride) {\n    const swapInfo = swapInfoOverride || getClosestAttributeValue(elt, 'hx-swap')\n    /** @type HtmxSwapSpecification */\n    const swapSpec = {\n      swapStyle: getInternalData(elt).boosted ? 'innerHTML' : htmx.config.defaultSwapStyle,\n      swapDelay: htmx.config.defaultSwapDelay,\n      settleDelay: htmx.config.defaultSettleDelay\n    }\n    if (htmx.config.scrollIntoViewOnBoost && getInternalData(elt).boosted && !isAnchorLink(elt)) {\n      swapSpec.show = 'top'\n    }\n    if (swapInfo) {\n      const split = splitOnWhitespace(swapInfo)\n      if (split.length > 0) {\n        for (let i = 0; i < split.length; i++) {\n          const value = split[i]\n          if (value.indexOf('swap:') === 0) {\n            swapSpec.swapDelay = parseInterval(value.slice(5))\n          } else if (value.indexOf('settle:') === 0) {\n            swapSpec.settleDelay = parseInterval(value.slice(7))\n          } else if (value.indexOf('transition:') === 0) {\n            swapSpec.transition = value.slice(11) === 'true'\n          } else if (value.indexOf('ignoreTitle:') === 0) {\n            swapSpec.ignoreTitle = value.slice(12) === 'true'\n          } else if (value.indexOf('scroll:') === 0) {\n            const scrollSpec = value.slice(7)\n            var splitSpec = scrollSpec.split(':')\n            const scrollVal = splitSpec.pop()\n            var selectorVal = splitSpec.length > 0 ? splitSpec.join(':') : null\n            // @ts-ignore\n            swapSpec.scroll = scrollVal\n            swapSpec.scrollTarget = selectorVal\n          } else if (value.indexOf('show:') === 0) {\n            const showSpec = value.slice(5)\n            var splitSpec = showSpec.split(':')\n            const showVal = splitSpec.pop()\n            var selectorVal = splitSpec.length > 0 ? splitSpec.join(':') : null\n            swapSpec.show = showVal\n            swapSpec.showTarget = selectorVal\n          } else if (value.indexOf('focus-scroll:') === 0) {\n            const focusScrollVal = value.slice('focus-scroll:'.length)\n            swapSpec.focusScroll = focusScrollVal == 'true'\n          } else if (i == 0) {\n            swapSpec.swapStyle = value\n          } else {\n            logError('Unknown modifier in hx-swap: ' + value)\n          }\n        }\n      }\n    }\n    return swapSpec\n  }\n\n  /**\n   * @param {Element} elt\n   * @return {boolean}\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  /**\n   * @param {XMLHttpRequest} xhr\n   * @param {Element} elt\n   * @param {FormData} filteredParameters\n   * @returns {*|string|null}\n   */\n  function encodeParamsForBody(xhr, elt, filteredParameters) {\n    let 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        // Force conversion to an actual FormData object in case filteredParameters is a formDataProxy\n        // See https://github.com/bigskysoftware/htmx/issues/2317\n        return overrideFormData(new FormData(), formDataFromObject(filteredParameters))\n      } else {\n        return urlEncode(filteredParameters)\n      }\n    }\n  }\n\n  /**\n *\n * @param {Element} target\n * @returns {HtmxSettleInfo}\n */\n  function makeSettleInfo(target) {\n    return { tasks: [], elts: [target] }\n  }\n\n  /**\n   * @param {Element[]} content\n   * @param {HtmxSwapSpecification} swapSpec\n   */\n  function updateScrollState(content, swapSpec) {\n    const first = content[0]\n    const last = content[content.length - 1]\n    if (swapSpec.scroll) {\n      var target = null\n      if (swapSpec.scrollTarget) {\n        target = asElement(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      if (typeof swapSpec.scroll === 'number') {\n        getWindow().setTimeout(function() {\n          window.scrollTo(0, /** @type number */ (swapSpec.scroll))\n        }, 0) // next 'tick', so browser has time to render layout\n      }\n    }\n    if (swapSpec.show) {\n      var target = null\n      if (swapSpec.showTarget) {\n        let targetStr = swapSpec.showTarget\n        if (swapSpec.showTarget === 'window') {\n          targetStr = 'body'\n        }\n        target = asElement(querySelectorExt(first, targetStr))\n      }\n      if (swapSpec.show === 'top' && (first || target)) {\n        target = target || first\n        // @ts-ignore For some reason tsc doesn't recognize \"instant\" as a valid option for now\n        target.scrollIntoView({ block: 'start', behavior: htmx.config.scrollBehavior })\n      }\n      if (swapSpec.show === 'bottom' && (last || target)) {\n        target = target || last\n        // @ts-ignore For some reason tsc doesn't recognize \"instant\" as a valid option for now\n        target.scrollIntoView({ block: 'end', behavior: htmx.config.scrollBehavior })\n      }\n    }\n  }\n\n  /**\n * @param {Element} elt\n * @param {string} attr\n * @param {boolean=} evalAsDefault\n * @param {Object=} values\n * @param {Event=} event\n * @returns {Object}\n */\n  function getValuesForElement(elt, attr, evalAsDefault, values, event) {\n    if (values == null) {\n      values = {}\n    }\n    if (elt == null) {\n      return values\n    }\n    const attributeValue = getAttributeValue(elt, attr)\n    if (attributeValue) {\n      let str = attributeValue.trim()\n      let evaluateValue = evalAsDefault\n      if (str === 'unset') {\n        return null\n      }\n      if (str.indexOf('javascript:') === 0) {\n        str = str.slice(11)\n        evaluateValue = true\n      } else if (str.indexOf('js:') === 0) {\n        str = str.slice(3)\n        evaluateValue = true\n      }\n      if (str.indexOf('{') !== 0) {\n        str = '{' + str + '}'\n      }\n      let varsValues\n      if (evaluateValue) {\n        varsValues = maybeEval(elt, function() {\n          if (event) {\n            return Function('event', 'return (' + str + ')').call(elt, event)\n          } else { // allow window.event to be accessible\n            return Function('return (' + str + ')').call(elt)\n          }\n        }, {})\n      } else {\n        varsValues = parseJSON(str)\n      }\n      for (const 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(asElement(parentElt(elt)), attr, evalAsDefault, values, event)\n  }\n\n  /**\n   * @param {EventTarget|string} elt\n   * @param {() => any} toEval\n   * @param {any=} defaultVal\n   * @returns {any}\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 {Element} elt\n * @param {Event=} event\n * @param {*?=} expressionVars\n * @returns\n */\n  function getHXVarsForElement(elt, event, expressionVars) {\n    return getValuesForElement(elt, 'hx-vars', true, expressionVars, event)\n  }\n\n  /**\n * @param {Element} elt\n * @param {Event=} event\n * @param {*?=} expressionVars\n * @returns\n */\n  function getHXValsForElement(elt, event, expressionVars) {\n    return getValuesForElement(elt, 'hx-vals', false, expressionVars, event)\n  }\n\n  /**\n * @param {Element} elt\n * @param {Event=} event\n * @returns {FormData}\n */\n  function getExpressionVars(elt, event) {\n    return mergeObjects(getHXVarsForElement(elt, event), getHXValsForElement(elt, event))\n  }\n\n  /**\n   * @param {XMLHttpRequest} xhr\n   * @param {string} header\n   * @param {string|null} headerValue\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  /**\n   * @param {XMLHttpRequest} xhr\n   * @return {string}\n   */\n  function getPathFromResponse(xhr) {\n    if (xhr.responseURL) {\n      try {\n        const 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  /**\n   * @param {XMLHttpRequest} xhr\n   * @param {RegExp} regexp\n   * @return {boolean}\n   */\n  function hasHeader(xhr, regexp) {\n    return regexp.test(xhr.getAllResponseHeaders())\n  }\n\n  /**\n   * Issues an htmx-style AJAX request\n   *\n   * @see https://htmx.org/api/#ajax\n   *\n   * @param {HttpVerb} verb\n   * @param {string} path the URL path to make the AJAX\n   * @param {Element|string|HtmxAjaxHelperContext} context the element to target (defaults to the **body**) | a selector for the target | a context object that contains any of the following\n   * @return {Promise<void>} Promise that resolves immediately if no request is sent, or when the request is complete\n   */\n  function ajaxHelper(verb, path, context) {\n    verb = (/** @type HttpVerb */(verb.toLowerCase()))\n    if (context) {\n      if (context instanceof Element || typeof context === 'string') {\n        return issueAjaxRequest(verb, path, null, null, {\n          targetOverride: resolveTarget(context) || DUMMY_ELT,\n          returnPromise: true\n        })\n      } else {\n        let resolvedTarget = resolveTarget(context.target)\n        // If target is supplied but can't resolve OR source is supplied but both target and source can't be resolved\n        // then use DUMMY_ELT to abort the request with htmx:targetError to avoid it replacing body by mistake\n        if ((context.target && !resolvedTarget) || (context.source && !resolvedTarget && !resolveTarget(context.source))) {\n          resolvedTarget = DUMMY_ELT\n        }\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: resolvedTarget,\n            swapOverride: context.swap,\n            select: context.select,\n            returnPromise: true,\n            push: context.push,\n            replace: context.replace,\n            selectOOB: context.selectOOB\n          })\n      }\n    } else {\n      return issueAjaxRequest(verb, path, null, null, {\n        returnPromise: true\n      })\n    }\n  }\n\n  /**\n   * @param {Element} elt\n   * @return {Element[]}\n   */\n  function hierarchyForElt(elt) {\n    const arr = []\n    while (elt) {\n      arr.push(elt)\n      elt = elt.parentElement\n    }\n    return arr\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {string} path\n   * @param {HtmxRequestConfig} requestConfig\n   * @return {boolean}\n   */\n  function verifyPath(elt, path, requestConfig) {\n    const url = new URL(path, location.protocol !== 'about:' ? location.href : window.origin)\n    const origin = location.protocol !== 'about:' ? location.origin : window.origin\n    const sameHost = origin === url.origin\n\n    if (htmx.config.selfRequestsOnly) {\n      if (!sameHost) {\n        return false\n      }\n    }\n    return triggerEvent(elt, 'htmx:validateUrl', mergeObjects({ url, sameHost }, requestConfig))\n  }\n\n  /**\n   * @param {Object|FormData} obj\n   * @return {FormData}\n   */\n  function formDataFromObject(obj) {\n    if (obj instanceof FormData) return obj\n    const formData = new FormData()\n    for (const key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        if (obj[key] && typeof obj[key].forEach === 'function') {\n          obj[key].forEach(function(v) { formData.append(key, v) })\n        } else if (typeof obj[key] === 'object' && !(obj[key] instanceof Blob)) {\n          formData.append(key, JSON.stringify(obj[key]))\n        } else {\n          formData.append(key, obj[key])\n        }\n      }\n    }\n    return formData\n  }\n\n  /**\n   * @param {FormData} formData\n   * @param {string} name\n   * @param {Array} array\n   * @returns {Array}\n   */\n  function formDataArrayProxy(formData, name, array) {\n    // mutating the array should mutate the underlying form data\n    return new Proxy(array, {\n      get: function(target, key) {\n        if (typeof key === 'number') return target[key]\n        if (key === 'length') return target.length\n        if (key === 'push') {\n          return function(value) {\n            target.push(value)\n            formData.append(name, value)\n          }\n        }\n        if (typeof target[key] === 'function') {\n          return function() {\n            target[key].apply(target, arguments)\n            formData.delete(name)\n            target.forEach(function(v) { formData.append(name, v) })\n          }\n        }\n\n        if (target[key] && target[key].length === 1) {\n          return target[key][0]\n        } else {\n          return target[key]\n        }\n      },\n      set: function(target, index, value) {\n        target[index] = value\n        formData.delete(name)\n        target.forEach(function(v) { formData.append(name, v) })\n        return true\n      }\n    })\n  }\n\n  /**\n   * @param {FormData} formData\n   * @returns {Object}\n   */\n  function formDataProxy(formData) {\n    return new Proxy(formData, {\n      get: function(target, name) {\n        if (typeof name === 'symbol') {\n          // Forward symbol calls to the FormData itself directly\n          const result = Reflect.get(target, name)\n          // Wrap in function with apply to correctly bind the FormData context, as a direct call would result in an illegal invocation error\n          if (typeof result === 'function') {\n            return function() {\n              return result.apply(formData, arguments)\n            }\n          } else {\n            return result\n          }\n        }\n        if (name === 'toJSON') {\n          // Support JSON.stringify call on proxy\n          return () => Object.fromEntries(formData)\n        }\n        if (name in target) {\n          // Wrap in function with apply to correctly bind the FormData context, as a direct call would result in an illegal invocation error\n          if (typeof target[name] === 'function') {\n            return function() {\n              return formData[name].apply(formData, arguments)\n            }\n          }\n        }\n        const array = formData.getAll(name)\n        // Those 2 undefined & single value returns are for retro-compatibility as we weren't using FormData before\n        if (array.length === 0) {\n          return undefined\n        } else if (array.length === 1) {\n          return array[0]\n        } else {\n          return formDataArrayProxy(target, name, array)\n        }\n      },\n      set: function(target, name, value) {\n        if (typeof name !== 'string') {\n          return false\n        }\n        target.delete(name)\n        if (value && typeof value.forEach === 'function') {\n          value.forEach(function(v) { target.append(name, v) })\n        } else if (typeof value === 'object' && !(value instanceof Blob)) {\n          target.append(name, JSON.stringify(value))\n        } else {\n          target.append(name, value)\n        }\n        return true\n      },\n      deleteProperty: function(target, name) {\n        if (typeof name === 'string') {\n          target.delete(name)\n        }\n        return true\n      },\n      // Support Object.assign call from proxy\n      ownKeys: function(target) {\n        return Reflect.ownKeys(Object.fromEntries(target))\n      },\n      getOwnPropertyDescriptor: function(target, prop) {\n        return Reflect.getOwnPropertyDescriptor(Object.fromEntries(target), prop)\n      }\n    })\n  }\n\n  /**\n   * @param {HttpVerb} verb\n   * @param {string} path\n   * @param {Element} elt\n   * @param {Event} event\n   * @param {HtmxAjaxEtc} [etc]\n   * @param {boolean} [confirmed]\n   * @return {Promise<void>}\n   */\n  function issueAjaxRequest(verb, path, elt, event, etc, confirmed) {\n    let resolve = null\n    let 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    const responseHandler = etc.handler || handleAjaxResponse\n    const select = etc.select || null\n\n    if (!bodyContains(elt)) {\n    // do not issue requests for elements removed from the DOM\n      maybeCall(resolve)\n      return promise\n    }\n    const target = etc.targetOverride || asElement(getTarget(elt))\n    if (target == null || target == DUMMY_ELT) {\n      triggerErrorEvent(elt, 'htmx:targetError', { target: getClosestAttributeValue(elt, 'hx-target') })\n      maybeCall(reject)\n      return promise\n    }\n\n    let eltData = getInternalData(elt)\n    const submitter = eltData.lastButtonClicked\n\n    if (submitter) {\n      const buttonPath = getRawAttribute(submitter, 'formaction')\n      if (buttonPath != null) {\n        path = buttonPath\n      }\n\n      const buttonVerb = getRawAttribute(submitter, 'formmethod')\n      if (buttonVerb != null) {\n        if (VERBS.includes(buttonVerb.toLowerCase())) {\n          verb = (/** @type HttpVerb */(buttonVerb))\n        } else {\n          maybeCall(resolve)\n          return promise\n        }\n      }\n    }\n\n    const confirmQuestion = getClosestAttributeValue(elt, 'hx-confirm')\n    // allow event-based confirmation w/ a callback\n    if (confirmed === undefined) {\n      const issueRequest = function(skipConfirmation) {\n        return issueAjaxRequest(verb, path, elt, event, etc, !!skipConfirmation)\n      }\n      const confirmDetails = { target, elt, path, verb, triggeringEvent: event, etc, issueRequest, question: confirmQuestion }\n      if (triggerEvent(elt, 'htmx:confirm', confirmDetails) === false) {\n        maybeCall(resolve)\n        return promise\n      }\n    }\n\n    let syncElt = elt\n    let syncStrategy = getClosestAttributeValue(elt, 'hx-sync')\n    let queueStrategy = null\n    let abortable = false\n    if (syncStrategy) {\n      const syncStrings = syncStrategy.split(':')\n      const selector = syncStrings[0].trim()\n      if (selector === 'this') {\n        syncElt = findThisElement(elt, 'hx-sync')\n      } else {\n        syncElt = asElement(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        maybeCall(resolve)\n        return promise\n      } else if (syncStrategy === 'abort') {\n        if (eltData.xhr) {\n          maybeCall(resolve)\n          return promise\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        const 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            const 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        maybeCall(resolve)\n        return promise\n      }\n    }\n\n    const xhr = new XMLHttpRequest()\n    eltData.xhr = xhr\n    eltData.abortable = abortable\n    const endRequestLock = function() {\n      eltData.xhr = null\n      eltData.abortable = false\n      if (eltData.queuedRequests != null &&\n      eltData.queuedRequests.length > 0) {\n        const queuedRequest = eltData.queuedRequests.shift()\n        queuedRequest()\n      }\n    }\n    const 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 })) {\n        maybeCall(resolve)\n        endRequestLock()\n        return promise\n      }\n    }\n\n    if (confirmQuestion && !confirmed) {\n      if (!confirm(confirmQuestion)) {\n        maybeCall(resolve)\n        endRequestLock()\n        return promise\n      }\n    }\n\n    let headers = getHeaders(elt, target, promptResponse)\n\n    if (verb !== 'get' && !usesFormData(elt)) {\n      headers['Content-Type'] = 'application/x-www-form-urlencoded'\n    }\n\n    if (etc.headers) {\n      headers = mergeObjects(headers, etc.headers)\n    }\n    const results = getInputValues(elt, verb)\n    let errors = results.errors\n    const rawFormData = results.formData\n    if (etc.values) {\n      overrideFormData(rawFormData, formDataFromObject(etc.values))\n    }\n    const expressionVars = formDataFromObject(getExpressionVars(elt, event))\n    const allFormData = overrideFormData(rawFormData, expressionVars)\n    let filteredFormData = filterValues(allFormData, elt)\n\n    if (htmx.config.getCacheBusterParam && verb === 'get') {\n      filteredFormData.set('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 = location.href\n    }\n\n    /**\n     * @type {Object}\n     * @property {boolean} [credentials]\n     * @property {number} [timeout]\n     * @property {boolean} [noHeaders]\n     */\n    const requestAttrValues = getValuesForElement(elt, 'hx-request')\n\n    const eltIsBoosted = getInternalData(elt).boosted\n\n    let useUrlParams = htmx.config.methodsThatUseUrlParams.indexOf(verb) >= 0\n\n    /** @type HtmxRequestConfig */\n    const requestConfig = {\n      boosted: eltIsBoosted,\n      useUrlParams,\n      formData: filteredFormData,\n      parameters: formDataProxy(filteredFormData),\n      unfilteredFormData: allFormData,\n      unfilteredParameters: formDataProxy(allFormData),\n      headers,\n      elt,\n      target,\n      verb,\n      errors,\n      withCredentials: etc.credentials || requestAttrValues.credentials || htmx.config.withCredentials,\n      timeout: etc.timeout || requestAttrValues.timeout || htmx.config.timeout,\n      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    filteredFormData = formDataFromObject(requestConfig.parameters)\n    errors = requestConfig.errors\n    useUrlParams = requestConfig.useUrlParams\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    const splitPath = path.split('#')\n    const pathNoAnchor = splitPath[0]\n    const anchor = splitPath[1]\n\n    let finalPath = path\n    if (useUrlParams) {\n      finalPath = pathNoAnchor\n      const hasValues = !filteredFormData.keys().next().done\n      if (hasValues) {\n        if (finalPath.indexOf('?') < 0) {\n          finalPath += '?'\n        } else {\n          finalPath += '&'\n        }\n        finalPath += urlEncode(filteredFormData)\n        if (anchor) {\n          finalPath += '#' + anchor\n        }\n      }\n    }\n\n    if (!verifyPath(elt, finalPath, requestConfig)) {\n      triggerErrorEvent(elt, 'htmx:invalidPath', requestConfig)\n      maybeCall(reject)\n      endRequestLock()\n      return promise\n    }\n\n    xhr.open(verb.toUpperCase(), finalPath, true)\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 (const header in headers) {\n        if (headers.hasOwnProperty(header)) {\n          const headerValue = headers[header]\n          safelySetHeaderValue(xhr, header, headerValue)\n        }\n      }\n    }\n\n    /** @type {HtmxResponseInfo} */\n    const responseInfo = {\n      xhr,\n      target,\n      requestConfig,\n      etc,\n      boosted: eltIsBoosted,\n      select,\n      pathInfo: {\n        requestPath: path,\n        finalRequestPath: finalPath,\n        responsePath: null,\n        anchor\n      }\n    }\n\n    xhr.onload = function() {\n      try {\n        const hierarchy = hierarchyForElt(elt)\n        responseInfo.pathInfo.responsePath = getPathFromResponse(xhr)\n        responseHandler(elt, responseInfo)\n        if (responseInfo.keepIndicators !== true) {\n          removeRequestIndicators(indicators, disableElts)\n        }\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          let secondaryTriggerElt = null\n          while (hierarchy.length > 0 && secondaryTriggerElt == null) {\n            const 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      } catch (e) {\n        triggerErrorEvent(elt, 'htmx:onLoadError', mergeObjects({ error: e }, responseInfo))\n        throw e\n      } finally {\n        endRequestLock()\n      }\n    }\n    xhr.onerror = function() {\n      removeRequestIndicators(indicators, disableElts)\n      triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo)\n      triggerErrorEvent(elt, 'htmx:sendError', responseInfo)\n      maybeCall(reject)\n      endRequestLock()\n    }\n    xhr.onabort = function() {\n      removeRequestIndicators(indicators, disableElts)\n      triggerErrorEvent(elt, 'htmx:afterRequest', responseInfo)\n      triggerErrorEvent(elt, 'htmx:sendAbort', responseInfo)\n      maybeCall(reject)\n      endRequestLock()\n    }\n    xhr.ontimeout = function() {\n      removeRequestIndicators(indicators, disableElts)\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    var disableElts = disableElements(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    const params = useUrlParams ? null : encodeParamsForBody(xhr, elt, filteredFormData)\n    xhr.send(params)\n    return promise\n  }\n\n  /**\n   * @typedef {Object} HtmxHistoryUpdate\n   * @property {string|null} [type]\n   * @property {string|null} [path]\n   */\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxResponseInfo} responseInfo\n   * @return {HtmxHistoryUpdate}\n   */\n  function determineHistoryUpdates(elt, responseInfo) {\n    const xhr = responseInfo.xhr\n\n    //= ==========================================\n    // First consult response headers\n    //= ==========================================\n    let pathFromHeaders = null\n    let 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    const requestPath = responseInfo.pathInfo.finalRequestPath\n    const responsePath = responseInfo.pathInfo.responsePath\n\n    let pushUrl = responseInfo.etc.push || getClosestAttributeValue(elt, 'hx-push-url')\n    let replaceUrl = responseInfo.etc.replace || getClosestAttributeValue(elt, 'hx-replace-url')\n    if (pushUrl === 'false') pushUrl = null\n    if (replaceUrl === 'false') replaceUrl = null\n    const elementIsBoosted = getInternalData(elt).boosted\n\n    let saveType = null\n    let 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      // 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 && path.indexOf('#') === -1) {\n        path = path + '#' + responseInfo.pathInfo.anchor\n      }\n\n      return {\n        type: saveType,\n        path\n      }\n    } else {\n      return {}\n    }\n  }\n\n  /**\n   * @param {HtmxResponseHandlingConfig} responseHandlingConfig\n   * @param {number} status\n   * @return {boolean}\n   */\n  function codeMatches(responseHandlingConfig, status) {\n    var regExp = new RegExp(responseHandlingConfig.code)\n    return regExp.test(status.toString(10))\n  }\n\n  /**\n   * @param {XMLHttpRequest} xhr\n   * @return {HtmxResponseHandlingConfig}\n   */\n  function resolveResponseHandling(xhr) {\n    for (var i = 0; i < htmx.config.responseHandling.length; i++) {\n      /** @type HtmxResponseHandlingConfig */\n      var responseHandlingElement = htmx.config.responseHandling[i]\n      if (codeMatches(responseHandlingElement, xhr.status)) {\n        return responseHandlingElement\n      }\n    }\n    // no matches, return no swap\n    return {\n      swap: false\n    }\n  }\n\n  /**\n   * @param {string} title\n   */\n  function handleTitle(title) {\n    if (title) {\n      const titleElt = find('title')\n      if (titleElt) {\n        titleElt.textContent = title\n      } else {\n        window.document.title = title\n      }\n    }\n  }\n\n  /**\n   * Resove the Retarget selector and throw if not found\n   * @param {Element} elt\n   * @param {String} target\n   * @returns {Element}\n   */\n  function resolveRetarget(elt, target) {\n    if (target === 'this') {\n      return elt\n    }\n    const resolvedTarget = asElement(querySelectorExt(elt, target))\n    if (resolvedTarget == null) {\n      triggerErrorEvent(elt, 'htmx:targetError', { target })\n      throw new Error(`Invalid re-target ${target}`)\n    }\n    return resolvedTarget\n  }\n\n  /**\n   * @param {Element} elt\n   * @param {HtmxResponseInfo} responseInfo\n   */\n  function handleAjaxResponse(elt, responseInfo) {\n    const xhr = responseInfo.xhr\n    let target = responseInfo.target\n    const etc = responseInfo.etc\n    const responseInfoSelect = responseInfo.select\n\n    if (!triggerEvent(elt, 'htmx:beforeOnLoad', responseInfo)) return\n\n    if (hasHeader(xhr, /HX-Trigger:/i)) {\n      handleTriggerHeader(xhr, 'HX-Trigger', elt)\n    }\n\n    if (hasHeader(xhr, /HX-Location:/i)) {\n      let redirectPath = xhr.getResponseHeader('HX-Location')\n      /** @type {HtmxAjaxHelperContext&{path?:string}} */\n      var redirectSwapSpec = {}\n      if (redirectPath.indexOf('{') === 0) {\n        redirectSwapSpec = parseJSON(redirectPath)\n        // what's the best way to throw an error if the user didn't include this\n        redirectPath = redirectSwapSpec.path\n        delete redirectSwapSpec.path\n      }\n      redirectSwapSpec.push = redirectSwapSpec.push ?? 'true'\n      ajaxHelper('get', redirectPath, redirectSwapSpec)\n      return\n    }\n\n    const shouldRefresh = hasHeader(xhr, /HX-Refresh:/i) && xhr.getResponseHeader('HX-Refresh') === 'true'\n\n    if (hasHeader(xhr, /HX-Redirect:/i)) {\n      responseInfo.keepIndicators = true\n      htmx.location.href = xhr.getResponseHeader('HX-Redirect')\n      shouldRefresh && htmx.location.reload()\n      return\n    }\n\n    if (shouldRefresh) {\n      responseInfo.keepIndicators = true\n      htmx.location.reload()\n      return\n    }\n\n    const historyUpdate = determineHistoryUpdates(elt, responseInfo)\n\n    const responseHandling = resolveResponseHandling(xhr)\n    const shouldSwap = responseHandling.swap\n    let isError = !!responseHandling.error\n    let ignoreTitle = htmx.config.ignoreTitle || responseHandling.ignoreTitle\n    let selectOverride = responseHandling.select\n    if (responseHandling.target) {\n      responseInfo.target = resolveRetarget(elt, responseHandling.target)\n    }\n    var swapOverride = etc.swapOverride\n    if (swapOverride == null && responseHandling.swapOverride) {\n      swapOverride = responseHandling.swapOverride\n    }\n\n    // response headers override response handling config\n    if (hasHeader(xhr, /HX-Retarget:/i)) {\n      responseInfo.target = resolveRetarget(elt, xhr.getResponseHeader('HX-Retarget'))\n    }\n\n    if (hasHeader(xhr, /HX-Reswap:/i)) {\n      swapOverride = xhr.getResponseHeader('HX-Reswap')\n    }\n\n    var serverResponse = xhr.response\n    /** @type HtmxBeforeSwapDetails */\n    var beforeSwapDetails = mergeObjects({\n      shouldSwap,\n      serverResponse,\n      isError,\n      ignoreTitle,\n      selectOverride,\n      swapOverride\n    }, responseInfo)\n\n    if (responseHandling.event && !triggerEvent(target, responseHandling.event, beforeSwapDetails)) return\n\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    ignoreTitle = beforeSwapDetails.ignoreTitle // allow updating ignoring title\n    selectOverride = beforeSwapDetails.selectOverride // allow updating select override\n    swapOverride = beforeSwapDetails.swapOverride // allow updating swap override\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 swapSpec = getSwapSpecification(elt, swapOverride)\n\n      if (!swapSpec.hasOwnProperty('ignoreTitle')) {\n        swapSpec.ignoreTitle = ignoreTitle\n      }\n\n      addClassToElement(target, htmx.config.swappingClass)\n\n      if (responseInfoSelect) {\n        selectOverride = responseInfoSelect\n      }\n\n      if (hasHeader(xhr, /HX-Reselect:/i)) {\n        selectOverride = xhr.getResponseHeader('HX-Reselect')\n      }\n\n      const selectOOB = etc.selectOOB || getClosestAttributeValue(elt, 'hx-select-oob')\n      const select = getClosestAttributeValue(elt, 'hx-select')\n\n      swap(target, serverResponse, swapSpec, {\n        select: selectOverride === 'unset' ? null : selectOverride || select,\n        selectOOB,\n        eventInfo: responseInfo,\n        anchor: responseInfo.pathInfo.anchor,\n        contextElement: elt,\n        afterSwapCallback: function() {\n          if (hasHeader(xhr, /HX-Trigger-After-Swap:/i)) {\n            let finalElt = elt\n            if (!bodyContains(elt)) {\n              finalElt = getDocument().body\n            }\n            handleTriggerHeader(xhr, 'HX-Trigger-After-Swap', finalElt)\n          }\n        },\n        afterSettleCallback: function() {\n          if (hasHeader(xhr, /HX-Trigger-After-Settle:/i)) {\n            let finalElt = elt\n            if (!bodyContains(elt)) {\n              finalElt = getDocument().body\n            }\n            handleTriggerHeader(xhr, 'HX-Trigger-After-Settle', finalElt)\n          }\n        },\n        beforeSwapCallback: function() {\n          // if we need to save history, do so, before swapping so that relative resources have the correct base URL\n          if (historyUpdate.type) {\n            triggerEvent(getDocument().body, 'htmx:beforeHistoryUpdate', mergeObjects({ history: historyUpdate }, responseInfo))\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        }\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, HtmxExtension>} */\n  const extensions = {}\n\n  /**\n   * extensionBase defines the default functions for all extensions.\n   * @returns {HtmxExtension}\n   */\n  function extensionBase() {\n    return {\n      init: function(api) { return null },\n      getSelectors: function() { 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   * @see https://htmx.org/api/#defineExtension\n   *\n   * @param {string} name the extension name\n   * @param {Partial<HtmxExtension>} extension the extension definition\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   * @see https://htmx.org/api/#removeExtension\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 {Element} elt\n   * @param {HtmxExtension[]=} extensionsToReturn\n   * @param {string[]=} extensionsToIgnore\n   * @returns {HtmxExtension[]}\n   */\n  function getExtensions(elt, extensionsToReturn, extensionsToIgnore) {\n    if (extensionsToReturn == undefined) {\n      extensionsToReturn = []\n    }\n    if (elt == undefined) {\n      return extensionsToReturn\n    }\n    if (extensionsToIgnore == undefined) {\n      extensionsToIgnore = []\n    }\n    const 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          const extension = extensions[extensionName]\n          if (extension && extensionsToReturn.indexOf(extension) < 0) {\n            extensionsToReturn.push(extension)\n          }\n        }\n      })\n    }\n    return getExtensions(asElement(parentElt(elt)), extensionsToReturn, extensionsToIgnore)\n  }\n\n  //= ===================================================================\n  // Initialization\n  //= ===================================================================\n  var isReady = false\n  getDocument().addEventListener('DOMContentLoaded', function() {\n    isReady = true\n  })\n\n  /**\n   * Execute a function now if DOMContentLoaded has fired, otherwise listen for it.\n   *\n   * This function uses isReady because there is no reliable way to ask the browser whether\n   * the DOMContentLoaded event has already been fired; there's a gap between DOMContentLoaded\n   * firing and readystate=complete.\n   */\n  function ready(fn) {\n    // Checking readyState here is a failsafe in case the htmx script tag entered the DOM by\n    // some means other than the initial page load.\n    if (isReady || getDocument().readyState === 'complete') {\n      fn()\n    } else {\n      getDocument().addEventListener('DOMContentLoaded', fn)\n    }\n  }\n\n  function insertIndicatorStyles() {\n    if (htmx.config.includeIndicatorStyles !== false) {\n      const nonceAttribute = htmx.config.inlineStyleNonce ? ` nonce=\"${htmx.config.inlineStyleNonce}\"` : ''\n      const indicator = htmx.config.indicatorClass\n      const request = htmx.config.requestClass\n      getDocument().head.insertAdjacentHTML('beforeend',\n        `<style${nonceAttribute}>` +\n        `.${indicator}{opacity:0;visibility: hidden} ` +\n        `.${request} .${indicator}, .${request}.${indicator}{opacity:1;visibility: visible;transition: opacity 200ms ease-in}` +\n        '</style>'\n      )\n    }\n  }\n\n  function getMetaConfig() {\n    /** @type HTMLMetaElement */\n    const element = getDocument().querySelector('meta[name=\"htmx-config\"]')\n    if (element) {\n      return parseJSON(element.content)\n    } else {\n      return null\n    }\n  }\n\n  function mergeMetaConfig() {\n    const 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    let body = getDocument().body\n    processNode(body)\n    const restoredElts = getDocument().querySelectorAll(\n      \"[hx-trigger='restored'],[data-hx-trigger='restored']\"\n    )\n    body.addEventListener('htmx:abort', function(evt) {\n      const target = (/** @type {CustomEvent} */(evt)).detail.elt || evt.target\n      const internalData = getInternalData(target)\n      if (internalData && internalData.xhr) {\n        internalData.xhr.abort()\n      }\n    })\n    /** @type {(ev: PopStateEvent) => any} */\n    const originalPopstate = window.onpopstate ? window.onpopstate.bind(window) : null\n    /** @type {(ev: PopStateEvent) => any} */\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\n          })\n        })\n      } else {\n        if (originalPopstate) {\n          originalPopstate(event)\n        }\n      }\n    }\n    getWindow().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/** @typedef {'get'|'head'|'post'|'put'|'delete'|'connect'|'options'|'trace'|'patch'} HttpVerb */\n\n/**\n * @typedef {Object} SwapOptions\n * @property {string} [select]\n * @property {string} [selectOOB]\n * @property {*} [eventInfo]\n * @property {string} [anchor]\n * @property {Element} [contextElement]\n * @property {swapCallback} [afterSwapCallback]\n * @property {swapCallback} [afterSettleCallback]\n * @property {swapCallback} [beforeSwapCallback]\n * @property {string} [title]\n * @property {boolean} [historyRequest]\n */\n\n/**\n * @callback swapCallback\n */\n\n/**\n * @typedef {'innerHTML' | 'outerHTML' | 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend' | 'delete' | 'none' | string} HtmxSwapStyle\n */\n\n/**\n * @typedef HtmxSwapSpecification\n * @property {HtmxSwapStyle} swapStyle\n * @property {number} swapDelay\n * @property {number} settleDelay\n * @property {boolean} [transition]\n * @property {boolean} [ignoreTitle]\n * @property {string} [head]\n * @property {'top' | 'bottom' | number } [scroll]\n * @property {string} [scrollTarget]\n * @property {string} [show]\n * @property {string} [showTarget]\n * @property {boolean} [focusScroll]\n */\n\n/**\n * @typedef {((this:Node, evt:Event) => boolean) & {source: string}} ConditionalFunction\n */\n\n/**\n * @typedef {Object} HtmxTriggerSpecification\n * @property {string} trigger\n * @property {number} [pollInterval]\n * @property {ConditionalFunction} [eventFilter]\n * @property {boolean} [changed]\n * @property {boolean} [once]\n * @property {boolean} [consume]\n * @property {number} [delay]\n * @property {string} [from]\n * @property {string} [target]\n * @property {number} [throttle]\n * @property {string} [queue]\n * @property {string} [root]\n * @property {string} [threshold]\n */\n\n/**\n * @typedef {{elt: Element, message: string, validity: ValidityState}} HtmxElementValidationError\n */\n\n/**\n * @typedef {Record<string, string>} HtmxHeaderSpecification\n * @property {'true'} HX-Request\n * @property {string|null} HX-Trigger\n * @property {string|null} HX-Trigger-Name\n * @property {string|null} HX-Target\n * @property {string} HX-Current-URL\n * @property {string} [HX-Prompt]\n * @property {'true'} [HX-Boosted]\n * @property {string} [Content-Type]\n * @property {'true'} [HX-History-Restore-Request]\n */\n\n/**\n * @typedef HtmxAjaxHelperContext\n * @property {Element|string} [source]\n * @property {Event} [event]\n * @property {HtmxAjaxHandler} [handler]\n * @property {Element|string} [target]\n * @property {HtmxSwapStyle} [swap]\n * @property {Object|FormData} [values]\n * @property {Record<string,string>} [headers]\n * @property {string} [select]\n * @property {string} [push]\n * @property {string} [replace]\n * @property {string} [selectOOB]\n */\n\n/**\n * @typedef {Object} HtmxRequestConfig\n * @property {boolean} boosted\n * @property {boolean} useUrlParams\n * @property {FormData} formData\n * @property {Object} parameters formData proxy\n * @property {FormData} unfilteredFormData\n * @property {Object} unfilteredParameters unfilteredFormData proxy\n * @property {HtmxHeaderSpecification} headers\n * @property {Element} elt\n * @property {Element} target\n * @property {HttpVerb} verb\n * @property {HtmxElementValidationError[]} errors\n * @property {boolean} withCredentials\n * @property {number} timeout\n * @property {string} path\n * @property {Event} triggeringEvent\n */\n\n/**\n * @typedef {Object} HtmxResponseInfo\n * @property {XMLHttpRequest} xhr\n * @property {Element} target\n * @property {HtmxRequestConfig} requestConfig\n * @property {HtmxAjaxEtc} etc\n * @property {boolean} boosted\n * @property {string} select\n * @property {{requestPath: string, finalRequestPath: string, responsePath: string|null, anchor: string}} pathInfo\n * @property {boolean} [failed]\n * @property {boolean} [successful]\n * @property {boolean} [keepIndicators]\n */\n\n/**\n * @typedef {Object} HtmxAjaxEtc\n * @property {boolean} [returnPromise]\n * @property {HtmxAjaxHandler} [handler]\n * @property {string} [select]\n * @property {Element} [targetOverride]\n * @property {HtmxSwapStyle} [swapOverride]\n * @property {Record<string,string>} [headers]\n * @property {Object|FormData} [values]\n * @property {boolean} [credentials]\n * @property {number} [timeout]\n * @property {string} [push]\n * @property {string} [replace]\n * @property {string} [selectOOB]\n */\n\n/**\n * @typedef {Object} HtmxResponseHandlingConfig\n * @property {string} [code]\n * @property {boolean} swap\n * @property {boolean} [error]\n * @property {boolean} [ignoreTitle]\n * @property {string} [select]\n * @property {string} [target]\n * @property {string} [swapOverride]\n * @property {string} [event]\n */\n\n/**\n * @typedef {HtmxResponseInfo & {shouldSwap: boolean, serverResponse: any, isError: boolean, ignoreTitle: boolean, selectOverride:string, swapOverride:string}} HtmxBeforeSwapDetails\n */\n\n/**\n * @callback HtmxAjaxHandler\n * @param {Element} elt\n * @param {HtmxResponseInfo} responseInfo\n */\n\n/**\n * @typedef {(() => void)} HtmxSettleTask\n */\n\n/**\n * @typedef {Object} HtmxSettleInfo\n * @property {HtmxSettleTask[]} tasks\n * @property {Element[]} elts\n * @property {string} [title]\n */\n\n/**\n * @see https://github.com/bigskysoftware/htmx-extensions/blob/main/README.md\n * @typedef {Object} HtmxExtension\n * @property {(api: any) => void} init\n * @property {(name: string, event: CustomEvent) => boolean} onEvent\n * @property {(text: string, xhr: XMLHttpRequest, elt: Element) => string} transformResponse\n * @property {(swapStyle: HtmxSwapStyle) => boolean} isInlineSwap\n * @property {(swapStyle: HtmxSwapStyle, target: Node, fragment: Node, settleInfo: HtmxSettleInfo) => boolean|Node[]} handleSwap\n * @property {(xhr: XMLHttpRequest, parameters: FormData, elt: Node) => *|string|null} encodeParameters\n * @property {() => string[]|null} getSelectors\n */\nexport default htmx\n","import htmx from \"htmx.org\";\n\n/**\n * @typedef {object} ConfigHead\n *\n * @property {'merge' | 'append' | 'morph' | 'none'} [style]\n * @property {boolean} [block]\n * @property {boolean} [ignore]\n * @property {function(Element): boolean} [shouldPreserve]\n * @property {function(Element): boolean} [shouldReAppend]\n * @property {function(Element): boolean} [shouldRemove]\n * @property {function(Element, {added: Node[], kept: Element[], removed: Element[]}): void} [afterHeadMorphed]\n */\n\n/**\n * @typedef {object} ConfigCallbacks\n *\n * @property {function(Node): boolean} [beforeNodeAdded]\n * @property {function(Node): void} [afterNodeAdded]\n * @property {function(Element, Node): boolean} [beforeNodeMorphed]\n * @property {function(Element, Node): void} [afterNodeMorphed]\n * @property {function(Element): boolean} [beforeNodeRemoved]\n * @property {function(Element): void} [afterNodeRemoved]\n * @property {function(string, Element, \"update\" | \"remove\"): boolean} [beforeAttributeUpdated]\n */\n\n/**\n * @typedef {object} Config\n *\n * @property {'outerHTML' | 'innerHTML'} [morphStyle]\n * @property {boolean} [ignoreActive]\n * @property {boolean} [ignoreActiveValue]\n * @property {boolean} [restoreFocus]\n * @property {ConfigCallbacks} [callbacks]\n * @property {ConfigHead} [head]\n */\n\n/**\n * @typedef {function} NoOp\n *\n * @returns {void}\n */\n\n/**\n * @typedef {object} ConfigHeadInternal\n *\n * @property {'merge' | 'append' | 'morph' | 'none'} style\n * @property {boolean} [block]\n * @property {boolean} [ignore]\n * @property {(function(Element): boolean) | NoOp} shouldPreserve\n * @property {(function(Element): boolean) | NoOp} shouldReAppend\n * @property {(function(Element): boolean) | NoOp} shouldRemove\n * @property {(function(Element, {added: Node[], kept: Element[], removed: Element[]}): void) | NoOp} afterHeadMorphed\n */\n\n/**\n * @typedef {object} ConfigCallbacksInternal\n *\n * @property {(function(Node): boolean) | NoOp} beforeNodeAdded\n * @property {(function(Node): void) | NoOp} afterNodeAdded\n * @property {(function(Node, Node): boolean) | NoOp} beforeNodeMorphed\n * @property {(function(Node, Node): void) | NoOp} afterNodeMorphed\n * @property {(function(Node): boolean) | NoOp} beforeNodeRemoved\n * @property {(function(Node): void) | NoOp} afterNodeRemoved\n * @property {(function(string, Element, \"update\" | \"remove\"): boolean) | NoOp} beforeAttributeUpdated\n */\n\n/**\n * @typedef {object} ConfigInternal\n *\n * @property {'outerHTML' | 'innerHTML'} morphStyle\n * @property {boolean} [ignoreActive]\n * @property {boolean} [ignoreActiveValue]\n * @property {boolean} [restoreFocus]\n * @property {ConfigCallbacksInternal} callbacks\n * @property {ConfigHeadInternal} head\n */\n\n/**\n * @typedef {Object} IdSets\n * @property {Set<string>} persistentIds\n * @property {Map<Node, Set<string>>} idMap\n */\n\n/**\n * @typedef {Function} Morph\n *\n * @param {Element | Document} oldNode\n * @param {Element | Node | HTMLCollection | Node[] | string | null} newContent\n * @param {Config} [config]\n * @returns {undefined | Node[]}\n */\n\n// base IIFE to define idiomorph\n/**\n *\n * @type {{defaults: ConfigInternal, morph: Morph}}\n */\nvar Idiomorph = (function () {\n  \"use strict\";\n\n  /**\n   * @typedef {object} MorphContext\n   *\n   * @property {Element} target\n   * @property {Element} newContent\n   * @property {ConfigInternal} config\n   * @property {ConfigInternal['morphStyle']} morphStyle\n   * @property {ConfigInternal['ignoreActive']} ignoreActive\n   * @property {ConfigInternal['ignoreActiveValue']} ignoreActiveValue\n   * @property {ConfigInternal['restoreFocus']} restoreFocus\n   * @property {Map<Node, Set<string>>} idMap\n   * @property {Set<string>} persistentIds\n   * @property {ConfigInternal['callbacks']} callbacks\n   * @property {ConfigInternal['head']} head\n   * @property {HTMLDivElement} pantry\n   * @property {Element[]} activeElementAndParents\n   */\n\n  //=============================================================================\n  // AND NOW IT BEGINS...\n  //=============================================================================\n\n  const noOp = () => {};\n  /**\n   * Default configuration values, updatable by users now\n   * @type {ConfigInternal}\n   */\n  const defaults = {\n    morphStyle: \"outerHTML\",\n    callbacks: {\n      beforeNodeAdded: noOp,\n      afterNodeAdded: noOp,\n      beforeNodeMorphed: noOp,\n      afterNodeMorphed: noOp,\n      beforeNodeRemoved: noOp,\n      afterNodeRemoved: noOp,\n      beforeAttributeUpdated: noOp,\n    },\n    head: {\n      style: \"merge\",\n      shouldPreserve: (elt) => elt.getAttribute(\"im-preserve\") === \"true\",\n      shouldReAppend: (elt) => elt.getAttribute(\"im-re-append\") === \"true\",\n      shouldRemove: noOp,\n      afterHeadMorphed: noOp,\n    },\n    restoreFocus: true,\n  };\n\n  /**\n   * Core idiomorph function for morphing one DOM tree to another\n   *\n   * @param {Element | Document} oldNode\n   * @param {Element | Node | HTMLCollection | Node[] | string | null} newContent\n   * @param {Config} [config]\n   * @returns {Promise<Node[]> | Node[]}\n   */\n  function morph(oldNode, newContent, config = {}) {\n    oldNode = normalizeElement(oldNode);\n    const newNode = normalizeParent(newContent);\n    const ctx = createMorphContext(oldNode, newNode, config);\n\n    const morphedNodes = saveAndRestoreFocus(ctx, () => {\n      return withHeadBlocking(\n        ctx,\n        oldNode,\n        newNode,\n        /** @param {MorphContext} ctx */ (ctx) => {\n          if (ctx.morphStyle === \"innerHTML\") {\n            morphChildren(ctx, oldNode, newNode);\n            return Array.from(oldNode.childNodes);\n          } else {\n            return morphOuterHTML(ctx, oldNode, newNode);\n          }\n        },\n      );\n    });\n\n    ctx.pantry.remove();\n    return morphedNodes;\n  }\n\n  /**\n   * Morph just the outerHTML of the oldNode to the newContent\n   * We have to be careful because the oldNode could have siblings which need to be untouched\n   * @param {MorphContext} ctx\n   * @param {Element} oldNode\n   * @param {Element} newNode\n   * @returns {Node[]}\n   */\n  function morphOuterHTML(ctx, oldNode, newNode) {\n    const oldParent = normalizeParent(oldNode);\n    morphChildren(\n      ctx,\n      oldParent,\n      newNode,\n      // these two optional params are the secret sauce\n      oldNode, // start point for iteration\n      oldNode.nextSibling, // end point for iteration\n    );\n    // this is safe even with siblings, because normalizeParent returns a SlicedParentNode if needed.\n    return Array.from(oldParent.childNodes);\n  }\n\n  /**\n   * @param {MorphContext} ctx\n   * @param {Function} fn\n   * @returns {Promise<Node[]> | Node[]}\n   */\n  function saveAndRestoreFocus(ctx, fn) {\n    if (!ctx.config.restoreFocus) return fn();\n    let activeElement =\n      /** @type {HTMLInputElement|HTMLTextAreaElement|null} */ (\n        document.activeElement\n      );\n\n    // don't bother if the active element is not an input or textarea\n    if (\n      !(\n        activeElement instanceof HTMLInputElement ||\n        activeElement instanceof HTMLTextAreaElement\n      )\n    ) {\n      return fn();\n    }\n\n    const { id: activeElementId, selectionStart, selectionEnd } = activeElement;\n\n    const results = fn();\n\n    if (\n      activeElementId &&\n      activeElementId !== document.activeElement?.getAttribute(\"id\")\n    ) {\n      activeElement = ctx.target.querySelector(`[id=\"${activeElementId}\"]`);\n      activeElement?.focus();\n    }\n    if (activeElement && !activeElement.selectionEnd && selectionEnd) {\n      activeElement.setSelectionRange(selectionStart, selectionEnd);\n    }\n\n    return results;\n  }\n\n  const morphChildren = (function () {\n    /**\n     * This is the core algorithm for matching up children.  The idea is to use id sets to try to match up\n     * nodes as faithfully as possible.  We greedily match, which allows us to keep the algorithm fast, but\n     * by using id sets, we are able to better match up with content deeper in the DOM.\n     *\n     * Basic algorithm:\n     * - for each node in the new content:\n     *   - search self and siblings for an id set match, falling back to a soft match\n     *   - if match found\n     *     - remove any nodes up to the match:\n     *       - pantry persistent nodes\n     *       - delete the rest\n     *     - morph the match\n     *   - elsif no match found, and node is persistent\n     *     - find its match by querying the old root (future) and pantry (past)\n     *     - move it and its children here\n     *     - morph it\n     *   - else\n     *     - create a new node from scratch as a last result\n     *\n     * @param {MorphContext} ctx the merge context\n     * @param {Element} oldParent the old content that we are merging the new content into\n     * @param {Element} newParent the parent element of the new content\n     * @param {Node|null} [insertionPoint] the point in the DOM we start morphing at (defaults to first child)\n     * @param {Node|null} [endPoint] the point in the DOM we stop morphing at (defaults to after last child)\n     */\n    function morphChildren(\n      ctx,\n      oldParent,\n      newParent,\n      insertionPoint = null,\n      endPoint = null,\n    ) {\n      // normalize\n      if (\n        oldParent instanceof HTMLTemplateElement &&\n        newParent instanceof HTMLTemplateElement\n      ) {\n        // @ts-ignore we can pretend the DocumentFragment is an Element\n        oldParent = oldParent.content;\n        // @ts-ignore ditto\n        newParent = newParent.content;\n      }\n      insertionPoint ||= oldParent.firstChild;\n\n      // run through all the new content\n      for (const newChild of newParent.childNodes) {\n        // once we reach the end of the old parent content skip to the end and insert the rest\n        if (insertionPoint && insertionPoint != endPoint) {\n          const bestMatch = findBestMatch(\n            ctx,\n            newChild,\n            insertionPoint,\n            endPoint,\n          );\n          if (bestMatch) {\n            // if the node to morph is not at the insertion point then remove/move up to it\n            if (bestMatch !== insertionPoint) {\n              removeNodesBetween(ctx, insertionPoint, bestMatch);\n            }\n            morphNode(bestMatch, newChild, ctx);\n            insertionPoint = bestMatch.nextSibling;\n            continue;\n          }\n        }\n\n        // if the matching node is elsewhere in the original content\n        if (newChild instanceof Element) {\n          // we can pretend the id is non-null because the next `.has` line will reject it if not\n          const newChildId = /** @type {String} */ (\n            newChild.getAttribute(\"id\")\n          );\n          if (ctx.persistentIds.has(newChildId)) {\n            // move it and all its children here and morph\n            const movedChild = moveBeforeById(\n              oldParent,\n              newChildId,\n              insertionPoint,\n              ctx,\n            );\n            morphNode(movedChild, newChild, ctx);\n            insertionPoint = movedChild.nextSibling;\n            continue;\n          }\n        }\n\n        // last resort: insert the new node from scratch\n        const insertedNode = createNode(\n          oldParent,\n          newChild,\n          insertionPoint,\n          ctx,\n        );\n        // could be null if beforeNodeAdded prevented insertion\n        if (insertedNode) {\n          insertionPoint = insertedNode.nextSibling;\n        }\n      }\n\n      // remove any remaining old nodes that didn't match up with new content\n      while (insertionPoint && insertionPoint != endPoint) {\n        const tempNode = insertionPoint;\n        insertionPoint = insertionPoint.nextSibling;\n        removeNode(ctx, tempNode);\n      }\n    }\n\n    /**\n     * This performs the action of inserting a new node while handling situations where the node contains\n     * elements with persistent ids and possible state info we can still preserve by moving in and then morphing\n     *\n     * @param {Element} oldParent\n     * @param {Node} newChild\n     * @param {Node|null} insertionPoint\n     * @param {MorphContext} ctx\n     * @returns {Node|null}\n     */\n    function createNode(oldParent, newChild, insertionPoint, ctx) {\n      if (ctx.callbacks.beforeNodeAdded(newChild) === false) return null;\n      if (ctx.idMap.has(newChild)) {\n        // node has children with ids with possible state so create a dummy elt of same type and apply full morph algorithm\n        const newEmptyChild = document.createElement(\n          /** @type {Element} */ (newChild).tagName,\n        );\n        oldParent.insertBefore(newEmptyChild, insertionPoint);\n        morphNode(newEmptyChild, newChild, ctx);\n        ctx.callbacks.afterNodeAdded(newEmptyChild);\n        return newEmptyChild;\n      } else {\n        // optimisation: no id state to preserve so we can just insert a clone of the newChild and its descendants\n        const newClonedChild = document.importNode(newChild, true); // importNode to not mutate newParent\n        oldParent.insertBefore(newClonedChild, insertionPoint);\n        ctx.callbacks.afterNodeAdded(newClonedChild);\n        return newClonedChild;\n      }\n    }\n\n    //=============================================================================\n    // Matching Functions\n    //=============================================================================\n    const findBestMatch = (function () {\n      /**\n       * Scans forward from the startPoint to the endPoint looking for a match\n       * for the node. It looks for an id set match first, then a soft match.\n       * We abort softmatching if we find two future soft matches, to reduce churn.\n       * @param {Node} node\n       * @param {MorphContext} ctx\n       * @param {Node | null} startPoint\n       * @param {Node | null} endPoint\n       * @returns {Node | null}\n       */\n      function findBestMatch(ctx, node, startPoint, endPoint) {\n        let softMatch = null;\n        let nextSibling = node.nextSibling;\n        let siblingSoftMatchCount = 0;\n\n        let cursor = startPoint;\n        while (cursor && cursor != endPoint) {\n          // soft matching is a prerequisite for id set matching\n          if (isSoftMatch(cursor, node)) {\n            if (isIdSetMatch(ctx, cursor, node)) {\n              return cursor; // found an id set match, we're done!\n            }\n\n            // we haven't yet saved a soft match fallback\n            if (softMatch === null) {\n              // the current soft match will hard match something else in the future, leave it\n              if (!ctx.idMap.has(cursor)) {\n                // save this as the fallback if we get through the loop without finding a hard match\n                softMatch = cursor;\n              }\n            }\n          }\n          if (\n            softMatch === null &&\n            nextSibling &&\n            isSoftMatch(cursor, nextSibling)\n          ) {\n            // The next new node has a soft match with this node, so\n            // increment the count of future soft matches\n            siblingSoftMatchCount++;\n            nextSibling = nextSibling.nextSibling;\n\n            // If there are two future soft matches, block soft matching for this node to allow\n            // future siblings to soft match. This is to reduce churn in the DOM when an element\n            // is prepended.\n            if (siblingSoftMatchCount >= 2) {\n              softMatch = undefined;\n            }\n          }\n\n          // if the current node contains active element, stop looking for better future matches,\n          // because if one is found, this node will be moved to the pantry, reparenting it and thus losing focus\n          // @ts-ignore pretend cursor is Element rather than Node, we're just testing for array inclusion\n          if (ctx.activeElementAndParents.includes(cursor)) break;\n\n          cursor = cursor.nextSibling;\n        }\n\n        return softMatch || null;\n      }\n\n      /**\n       *\n       * @param {MorphContext} ctx\n       * @param {Node} oldNode\n       * @param {Node} newNode\n       * @returns {boolean}\n       */\n      function isIdSetMatch(ctx, oldNode, newNode) {\n        let oldSet = ctx.idMap.get(oldNode);\n        let newSet = ctx.idMap.get(newNode);\n\n        if (!newSet || !oldSet) return false;\n\n        for (const id of oldSet) {\n          // a potential match is an id in the new and old nodes that\n          // has not already been merged into the DOM\n          // But the newNode content we call this on has not been\n          // merged yet and we don't allow duplicate IDs so it is simple\n          if (newSet.has(id)) {\n            return true;\n          }\n        }\n        return false;\n      }\n\n      /**\n       *\n       * @param {Node} oldNode\n       * @param {Node} newNode\n       * @returns {boolean}\n       */\n      function isSoftMatch(oldNode, newNode) {\n        // ok to cast: if one is not element, `id` and `tagName` will be undefined and we'll just compare that.\n        const oldElt = /** @type {Element} */ (oldNode);\n        const newElt = /** @type {Element} */ (newNode);\n\n        return (\n          oldElt.nodeType === newElt.nodeType &&\n          oldElt.tagName === newElt.tagName &&\n          // If oldElt has an `id` with possible state and it doesn't match newElt.id then avoid morphing.\n          // We'll still match an anonymous node with an IDed newElt, though, because if it got this far,\n          // its not persistent, and new nodes can't have any hidden state.\n          // We can't use .id because of form input shadowing, and we can't count on .getAttribute's presence because it could be a document-fragment\n          (!oldElt.getAttribute?.(\"id\") ||\n            oldElt.getAttribute?.(\"id\") === newElt.getAttribute?.(\"id\"))\n        );\n      }\n\n      return findBestMatch;\n    })();\n\n    //=============================================================================\n    // DOM Manipulation Functions\n    //=============================================================================\n\n    /**\n     * Gets rid of an unwanted DOM node; strategy depends on nature of its reuse:\n     * - Persistent nodes will be moved to the pantry for later reuse\n     * - Other nodes will have their hooks called, and then are removed\n     * @param {MorphContext} ctx\n     * @param {Node} node\n     */\n    function removeNode(ctx, node) {\n      // are we going to id set match this later?\n      if (ctx.idMap.has(node)) {\n        // skip callbacks and move to pantry\n        moveBefore(ctx.pantry, node, null);\n      } else {\n        // remove for realsies\n        if (ctx.callbacks.beforeNodeRemoved(node) === false) return;\n        node.parentNode?.removeChild(node);\n        ctx.callbacks.afterNodeRemoved(node);\n      }\n    }\n\n    /**\n     * Remove nodes between the start and end nodes\n     * @param {MorphContext} ctx\n     * @param {Node} startInclusive\n     * @param {Node} endExclusive\n     * @returns {Node|null}\n     */\n    function removeNodesBetween(ctx, startInclusive, endExclusive) {\n      /** @type {Node | null} */\n      let cursor = startInclusive;\n      // remove nodes until the endExclusive node\n      while (cursor && cursor !== endExclusive) {\n        let tempNode = /** @type {Node} */ (cursor);\n        cursor = cursor.nextSibling;\n        removeNode(ctx, tempNode);\n      }\n      return cursor;\n    }\n\n    /**\n     * Search for an element by id within the document and pantry, and move it using moveBefore.\n     *\n     * @param {Element} parentNode - The parent node to which the element will be moved.\n     * @param {string} id - The ID of the element to be moved.\n     * @param {Node | null} after - The reference node to insert the element before.\n     *                              If `null`, the element is appended as the last child.\n     * @param {MorphContext} ctx\n     * @returns {Element} The found element\n     */\n    function moveBeforeById(parentNode, id, after, ctx) {\n      const target =\n        /** @type {Element} - will always be found */\n        (\n          // ctx.target.id unsafe because of form input shadowing\n          // ctx.target could be a document fragment which doesn't have `getAttribute`\n          (ctx.target.getAttribute?.(\"id\") === id && ctx.target) ||\n            ctx.target.querySelector(`[id=\"${id}\"]`) ||\n            ctx.pantry.querySelector(`[id=\"${id}\"]`)\n        );\n      removeElementFromAncestorsIdMaps(target, ctx);\n      moveBefore(parentNode, target, after);\n      return target;\n    }\n\n    /**\n     * Removes an element from its ancestors' id maps. This is needed when an element is moved from the\n     * \"future\" via `moveBeforeId`. Otherwise, its erstwhile ancestors could be mistakenly moved to the\n     * pantry rather than being deleted, preventing their removal hooks from being called.\n     *\n     * @param {Element} element - element to remove from its ancestors' id maps\n     * @param {MorphContext} ctx\n     */\n    function removeElementFromAncestorsIdMaps(element, ctx) {\n      // we know id is non-null String, because this function is only called on elements with ids\n      const id = /** @type {String} */ (element.getAttribute(\"id\"));\n      /** @ts-ignore - safe to loop in this way **/\n      while ((element = element.parentNode)) {\n        let idSet = ctx.idMap.get(element);\n        if (idSet) {\n          idSet.delete(id);\n          if (!idSet.size) {\n            ctx.idMap.delete(element);\n          }\n        }\n      }\n    }\n\n    /**\n     * Moves an element before another element within the same parent.\n     * Uses the proposed `moveBefore` API if available (and working), otherwise falls back to `insertBefore`.\n     * This is essentialy a forward-compat wrapper.\n     *\n     * @param {Element} parentNode - The parent node containing the after element.\n     * @param {Node} element - The element to be moved.\n     * @param {Node | null} after - The reference node to insert `element` before.\n     *                              If `null`, `element` is appended as the last child.\n     */\n    function moveBefore(parentNode, element, after) {\n      // @ts-ignore - use proposed moveBefore feature\n      if (parentNode.moveBefore) {\n        try {\n          // @ts-ignore - use proposed moveBefore feature\n          parentNode.moveBefore(element, after);\n        } catch (e) {\n          // fall back to insertBefore as some browsers may fail on moveBefore when trying to move Dom disconnected nodes to pantry\n          parentNode.insertBefore(element, after);\n        }\n      } else {\n        parentNode.insertBefore(element, after);\n      }\n    }\n\n    return morphChildren;\n  })();\n\n  //=============================================================================\n  // Single Node Morphing Code\n  //=============================================================================\n  const morphNode = (function () {\n    /**\n     * @param {Node} oldNode root node to merge content into\n     * @param {Node} newContent new content to merge\n     * @param {MorphContext} ctx the merge context\n     * @returns {Node | null} the element that ended up in the DOM\n     */\n    function morphNode(oldNode, newContent, ctx) {\n      if (ctx.ignoreActive && oldNode === document.activeElement) {\n        // don't morph focused element\n        return null;\n      }\n\n      if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false) {\n        return oldNode;\n      }\n\n      if (oldNode instanceof HTMLHeadElement && ctx.head.ignore) {\n        // ignore the head element\n      } else if (\n        oldNode instanceof HTMLHeadElement &&\n        ctx.head.style !== \"morph\"\n      ) {\n        // ok to cast: if newContent wasn't also a <head>, it would've got caught in the `!isSoftMatch` branch above\n        handleHeadElement(\n          oldNode,\n          /** @type {HTMLHeadElement} */ (newContent),\n          ctx,\n        );\n      } else {\n        morphAttributes(oldNode, newContent, ctx);\n        if (!ignoreValueOfActiveElement(oldNode, ctx)) {\n          // @ts-ignore newContent can be a node here because .firstChild will be null\n          morphChildren(ctx, oldNode, newContent);\n        }\n      }\n      ctx.callbacks.afterNodeMorphed(oldNode, newContent);\n      return oldNode;\n    }\n\n    /**\n     * syncs the oldNode to the newNode, copying over all attributes and\n     * inner element state from the newNode to the oldNode\n     *\n     * @param {Node} oldNode the node to copy attributes & state to\n     * @param {Node} newNode the node to copy attributes & state from\n     * @param {MorphContext} ctx the merge context\n     */\n    function morphAttributes(oldNode, newNode, ctx) {\n      let type = newNode.nodeType;\n\n      // if is an element type, sync the attributes from the\n      // new node into the new node\n      if (type === 1 /* element type */) {\n        const oldElt = /** @type {Element} */ (oldNode);\n        const newElt = /** @type {Element} */ (newNode);\n\n        const oldAttributes = oldElt.attributes;\n        const newAttributes = newElt.attributes;\n        for (const newAttribute of newAttributes) {\n          if (ignoreAttribute(newAttribute.name, oldElt, \"update\", ctx)) {\n            continue;\n          }\n          if (oldElt.getAttribute(newAttribute.name) !== newAttribute.value) {\n            oldElt.setAttribute(newAttribute.name, newAttribute.value);\n          }\n        }\n        // iterate backwards to avoid skipping over items when a delete occurs\n        for (let i = oldAttributes.length - 1; 0 <= i; i--) {\n          const oldAttribute = oldAttributes[i];\n\n          // toAttributes is a live NamedNodeMap, so iteration+mutation is unsafe\n          // e.g. custom element attribute callbacks can remove other attributes\n          if (!oldAttribute) continue;\n\n          if (!newElt.hasAttribute(oldAttribute.name)) {\n            if (ignoreAttribute(oldAttribute.name, oldElt, \"remove\", ctx)) {\n              continue;\n            }\n            oldElt.removeAttribute(oldAttribute.name);\n          }\n        }\n\n        if (!ignoreValueOfActiveElement(oldElt, ctx)) {\n          syncInputValue(oldElt, newElt, ctx);\n        }\n      }\n\n      // sync text nodes\n      if (type === 8 /* comment */ || type === 3 /* text */) {\n        if (oldNode.nodeValue !== newNode.nodeValue) {\n          oldNode.nodeValue = newNode.nodeValue;\n        }\n      }\n    }\n\n    /**\n     * NB: many bothans died to bring us information:\n     *\n     *  https://github.com/patrick-steele-idem/morphdom/blob/master/src/specialElHandlers.js\n     *  https://github.com/choojs/nanomorph/blob/master/lib/morph.jsL113\n     *\n     * @param {Element} oldElement the element to sync the input value to\n     * @param {Element} newElement the element to sync the input value from\n     * @param {MorphContext} ctx the merge context\n     */\n    function syncInputValue(oldElement, newElement, ctx) {\n      if (\n        oldElement instanceof HTMLInputElement &&\n        newElement instanceof HTMLInputElement &&\n        newElement.type !== \"file\"\n      ) {\n        let newValue = newElement.value;\n        let oldValue = oldElement.value;\n\n        // sync boolean attributes\n        syncBooleanAttribute(oldElement, newElement, \"checked\", ctx);\n        syncBooleanAttribute(oldElement, newElement, \"disabled\", ctx);\n\n        if (!newElement.hasAttribute(\"value\")) {\n          if (!ignoreAttribute(\"value\", oldElement, \"remove\", ctx)) {\n            oldElement.value = \"\";\n            oldElement.removeAttribute(\"value\");\n          }\n        } else if (oldValue !== newValue) {\n          if (!ignoreAttribute(\"value\", oldElement, \"update\", ctx)) {\n            oldElement.setAttribute(\"value\", newValue);\n            oldElement.value = newValue;\n          }\n        }\n        // TODO: QUESTION(1cg): this used to only check `newElement` unlike the other branches -- why?\n        // did I break something?\n      } else if (\n        oldElement instanceof HTMLOptionElement &&\n        newElement instanceof HTMLOptionElement\n      ) {\n        syncBooleanAttribute(oldElement, newElement, \"selected\", ctx);\n      } else if (\n        oldElement instanceof HTMLTextAreaElement &&\n        newElement instanceof HTMLTextAreaElement\n      ) {\n        let newValue = newElement.value;\n        let oldValue = oldElement.value;\n        if (ignoreAttribute(\"value\", oldElement, \"update\", ctx)) {\n          return;\n        }\n        if (newValue !== oldValue) {\n          oldElement.value = newValue;\n        }\n        if (\n          oldElement.firstChild &&\n          oldElement.firstChild.nodeValue !== newValue\n        ) {\n          oldElement.firstChild.nodeValue = newValue;\n        }\n      }\n    }\n\n    /**\n     * @param {Element} oldElement element to write the value to\n     * @param {Element} newElement element to read the value from\n     * @param {string} attributeName the attribute name\n     * @param {MorphContext} ctx the merge context\n     */\n    function syncBooleanAttribute(oldElement, newElement, attributeName, ctx) {\n      // @ts-ignore this function is only used on boolean attrs that are reflected as dom properties\n      const newLiveValue = newElement[attributeName],\n        // @ts-ignore ditto\n        oldLiveValue = oldElement[attributeName];\n      if (newLiveValue !== oldLiveValue) {\n        const ignoreUpdate = ignoreAttribute(\n          attributeName,\n          oldElement,\n          \"update\",\n          ctx,\n        );\n        if (!ignoreUpdate) {\n          // update attribute's associated DOM property\n          // @ts-ignore this function is only used on boolean attrs that are reflected as dom properties\n          oldElement[attributeName] = newElement[attributeName];\n        }\n        if (newLiveValue) {\n          if (!ignoreUpdate) {\n            // https://developer.mozilla.org/en-US/docs/Glossary/Boolean/HTML\n            // this is the correct way to set a boolean attribute to \"true\"\n            oldElement.setAttribute(attributeName, \"\");\n          }\n        } else {\n          if (!ignoreAttribute(attributeName, oldElement, \"remove\", ctx)) {\n            oldElement.removeAttribute(attributeName);\n          }\n        }\n      }\n    }\n\n    /**\n     * @param {string} attr the attribute to be mutated\n     * @param {Element} element the element that is going to be updated\n     * @param {\"update\" | \"remove\"} updateType\n     * @param {MorphContext} ctx the merge context\n     * @returns {boolean} true if the attribute should be ignored, false otherwise\n     */\n    function ignoreAttribute(attr, element, updateType, ctx) {\n      if (\n        attr === \"value\" &&\n        ctx.ignoreActiveValue &&\n        element === document.activeElement\n      ) {\n        return true;\n      }\n      return (\n        ctx.callbacks.beforeAttributeUpdated(attr, element, updateType) ===\n        false\n      );\n    }\n\n    /**\n     * @param {Node} possibleActiveElement\n     * @param {MorphContext} ctx\n     * @returns {boolean}\n     */\n    function ignoreValueOfActiveElement(possibleActiveElement, ctx) {\n      return (\n        !!ctx.ignoreActiveValue &&\n        possibleActiveElement === document.activeElement &&\n        possibleActiveElement !== document.body\n      );\n    }\n\n    return morphNode;\n  })();\n\n  //=============================================================================\n  // Head Management Functions\n  //=============================================================================\n  /**\n   * @param {MorphContext} ctx\n   * @param {Element} oldNode\n   * @param {Element} newNode\n   * @param {function} callback\n   * @returns {Node[] | Promise<Node[]>}\n   */\n  function withHeadBlocking(ctx, oldNode, newNode, callback) {\n    if (ctx.head.block) {\n      const oldHead = oldNode.querySelector(\"head\");\n      const newHead = newNode.querySelector(\"head\");\n      if (oldHead && newHead) {\n        const promises = handleHeadElement(oldHead, newHead, ctx);\n        // when head promises resolve, proceed ignoring the head tag\n        return Promise.all(promises).then(() => {\n          const newCtx = Object.assign(ctx, {\n            head: {\n              block: false,\n              ignore: true,\n            },\n          });\n          return callback(newCtx);\n        });\n      }\n    }\n    // just proceed if we not head blocking\n    return callback(ctx);\n  }\n\n  /**\n   *  The HEAD tag can be handled specially, either w/ a 'merge' or 'append' style\n   *\n   * @param {Element} oldHead\n   * @param {Element} newHead\n   * @param {MorphContext} ctx\n   * @returns {Promise<void>[]}\n   */\n  function handleHeadElement(oldHead, newHead, ctx) {\n    let added = [];\n    let removed = [];\n    let preserved = [];\n    let nodesToAppend = [];\n\n    // put all new head elements into a Map, by their outerHTML\n    let srcToNewHeadNodes = new Map();\n    for (const newHeadChild of newHead.children) {\n      srcToNewHeadNodes.set(newHeadChild.outerHTML, newHeadChild);\n    }\n\n    // for each elt in the current head\n    for (const currentHeadElt of oldHead.children) {\n      // If the current head element is in the map\n      let inNewContent = srcToNewHeadNodes.has(currentHeadElt.outerHTML);\n      let isReAppended = ctx.head.shouldReAppend(currentHeadElt);\n      let isPreserved = ctx.head.shouldPreserve(currentHeadElt);\n      if (inNewContent || isPreserved) {\n        if (isReAppended) {\n          // remove the current version and let the new version replace it and re-execute\n          removed.push(currentHeadElt);\n        } else {\n          // this element already exists and should not be re-appended, so remove it from\n          // the new content map, preserving it in the DOM\n          srcToNewHeadNodes.delete(currentHeadElt.outerHTML);\n          preserved.push(currentHeadElt);\n        }\n      } else {\n        if (ctx.head.style === \"append\") {\n          // we are appending and this existing element is not new content\n          // so if and only if it is marked for re-append do we do anything\n          if (isReAppended) {\n            removed.push(currentHeadElt);\n            nodesToAppend.push(currentHeadElt);\n          }\n        } else {\n          // if this is a merge, we remove this content since it is not in the new head\n          if (ctx.head.shouldRemove(currentHeadElt) !== false) {\n            removed.push(currentHeadElt);\n          }\n        }\n      }\n    }\n\n    // Push the remaining new head elements in the Map into the\n    // nodes to append to the head tag\n    nodesToAppend.push(...srcToNewHeadNodes.values());\n\n    let promises = [];\n    for (const newNode of nodesToAppend) {\n      // TODO: This could theoretically be null, based on type\n      let newElt = /** @type {ChildNode} */ (\n        document.createRange().createContextualFragment(newNode.outerHTML)\n          .firstChild\n      );\n      if (ctx.callbacks.beforeNodeAdded(newElt) !== false) {\n        if (\n          (\"href\" in newElt && newElt.href) ||\n          (\"src\" in newElt && newElt.src)\n        ) {\n          /** @type {(result?: any) => void} */ let resolve;\n          let promise = new Promise(function (_resolve) {\n            resolve = _resolve;\n          });\n          newElt.addEventListener(\"load\", function () {\n            resolve();\n          });\n          promises.push(promise);\n        }\n        oldHead.appendChild(newElt);\n        ctx.callbacks.afterNodeAdded(newElt);\n        added.push(newElt);\n      }\n    }\n\n    // remove all removed elements, after we have appended the new elements to avoid\n    // additional network requests for things like style sheets\n    for (const removedElement of removed) {\n      if (ctx.callbacks.beforeNodeRemoved(removedElement) !== false) {\n        oldHead.removeChild(removedElement);\n        ctx.callbacks.afterNodeRemoved(removedElement);\n      }\n    }\n\n    ctx.head.afterHeadMorphed(oldHead, {\n      added: added,\n      kept: preserved,\n      removed: removed,\n    });\n    return promises;\n  }\n\n  //=============================================================================\n  // Create Morph Context Functions\n  //=============================================================================\n  const createMorphContext = (function () {\n    /**\n     *\n     * @param {Element} oldNode\n     * @param {Element} newContent\n     * @param {Config} config\n     * @returns {MorphContext}\n     */\n    function createMorphContext(oldNode, newContent, config) {\n      const { persistentIds, idMap } = createIdMaps(oldNode, newContent);\n\n      const mergedConfig = mergeDefaults(config);\n      const morphStyle = mergedConfig.morphStyle || \"outerHTML\";\n      if (![\"innerHTML\", \"outerHTML\"].includes(morphStyle)) {\n        throw `Do not understand how to morph style ${morphStyle}`;\n      }\n\n      return {\n        target: oldNode,\n        newContent: newContent,\n        config: mergedConfig,\n        morphStyle: morphStyle,\n        ignoreActive: mergedConfig.ignoreActive,\n        ignoreActiveValue: mergedConfig.ignoreActiveValue,\n        restoreFocus: mergedConfig.restoreFocus,\n        idMap: idMap,\n        persistentIds: persistentIds,\n        pantry: createPantry(),\n        activeElementAndParents: createActiveElementAndParents(oldNode),\n        callbacks: mergedConfig.callbacks,\n        head: mergedConfig.head,\n      };\n    }\n\n    /**\n     * Deep merges the config object and the Idiomorph.defaults object to\n     * produce a final configuration object\n     * @param {Config} config\n     * @returns {ConfigInternal}\n     */\n    function mergeDefaults(config) {\n      let finalConfig = Object.assign({}, defaults);\n\n      // copy top level stuff into final config\n      Object.assign(finalConfig, config);\n\n      // copy callbacks into final config (do this to deep merge the callbacks)\n      finalConfig.callbacks = Object.assign(\n        {},\n        defaults.callbacks,\n        config.callbacks,\n      );\n\n      // copy head config into final config  (do this to deep merge the head)\n      finalConfig.head = Object.assign({}, defaults.head, config.head);\n\n      return finalConfig;\n    }\n\n    /**\n     * @returns {HTMLDivElement}\n     */\n    function createPantry() {\n      const pantry = document.createElement(\"div\");\n      pantry.hidden = true;\n      document.body.insertAdjacentElement(\"afterend\", pantry);\n      return pantry;\n    }\n\n    /**\n     * @param {Element} oldNode\n     * @returns {Element[]}\n     */\n    function createActiveElementAndParents(oldNode) {\n      /** @type {Element[]} */\n      let activeElementAndParents = [];\n      let elt = document.activeElement;\n      if (elt?.tagName !== \"BODY\" && oldNode.contains(elt)) {\n        while (elt) {\n          activeElementAndParents.push(elt);\n          if (elt === oldNode) break;\n          elt = elt.parentElement;\n        }\n      }\n      return activeElementAndParents;\n    }\n\n    /**\n     * Returns all elements with an ID contained within the root element and its descendants\n     *\n     * @param {Element} root\n     * @returns {Element[]}\n     */\n    function findIdElements(root) {\n      let elements = Array.from(root.querySelectorAll(\"[id]\"));\n      // root could be a document fragment which doesn't have `getAttribute`\n      if (root.getAttribute?.(\"id\")) {\n        elements.push(root);\n      }\n      return elements;\n    }\n\n    /**\n     * A bottom-up algorithm that populates a map of Element -> IdSet.\n     * The idSet for a given element is the set of all IDs contained within its subtree.\n     * As an optimzation, we filter these IDs through the given list of persistent IDs,\n     * because we don't need to bother considering IDed elements that won't be in the new content.\n     *\n     * @param {Map<Node, Set<string>>} idMap\n     * @param {Set<string>} persistentIds\n     * @param {Element} root\n     * @param {Element[]} elements\n     */\n    function populateIdMapWithTree(idMap, persistentIds, root, elements) {\n      for (const elt of elements) {\n        // we can pretend id is non-null String, because the .has line will reject it immediately if not\n        const id = /** @type {String} */ (elt.getAttribute(\"id\"));\n        if (persistentIds.has(id)) {\n          /** @type {Element|null} */\n          let current = elt;\n          // walk up the parent hierarchy of that element, adding the id\n          // of element to the parent's id set\n          while (current) {\n            let idSet = idMap.get(current);\n            // if the id set doesn't exist, create it and insert it in the map\n            if (idSet == null) {\n              idSet = new Set();\n              idMap.set(current, idSet);\n            }\n            idSet.add(id);\n\n            if (current === root) break;\n            current = current.parentElement;\n          }\n        }\n      }\n    }\n\n    /**\n     * This function computes a map of nodes to all ids contained within that node (inclusive of the\n     * node).  This map can be used to ask if two nodes have intersecting sets of ids, which allows\n     * for a looser definition of \"matching\" than tradition id matching, and allows child nodes\n     * to contribute to a parent nodes matching.\n     *\n     * @param {Element} oldContent  the old content that will be morphed\n     * @param {Element} newContent  the new content to morph to\n     * @returns {IdSets}\n     */\n    function createIdMaps(oldContent, newContent) {\n      const oldIdElements = findIdElements(oldContent);\n      const newIdElements = findIdElements(newContent);\n\n      const persistentIds = createPersistentIds(oldIdElements, newIdElements);\n\n      /** @type {Map<Node, Set<string>>} */\n      let idMap = new Map();\n      populateIdMapWithTree(idMap, persistentIds, oldContent, oldIdElements);\n\n      /** @ts-ignore - if newContent is a duck-typed parent, pass its single child node as the root to halt upwards iteration */\n      const newRoot = newContent.__idiomorphRoot || newContent;\n      populateIdMapWithTree(idMap, persistentIds, newRoot, newIdElements);\n\n      return { persistentIds, idMap };\n    }\n\n    /**\n     * This function computes the set of ids that persist between the two contents excluding duplicates\n     *\n     * @param {Element[]} oldIdElements\n     * @param {Element[]} newIdElements\n     * @returns {Set<string>}\n     */\n    function createPersistentIds(oldIdElements, newIdElements) {\n      let duplicateIds = new Set();\n\n      /** @type {Map<string, string>} */\n      let oldIdTagNameMap = new Map();\n      for (const { id, tagName } of oldIdElements) {\n        if (oldIdTagNameMap.has(id)) {\n          duplicateIds.add(id);\n        } else {\n          oldIdTagNameMap.set(id, tagName);\n        }\n      }\n\n      let persistentIds = new Set();\n      for (const { id, tagName } of newIdElements) {\n        if (persistentIds.has(id)) {\n          duplicateIds.add(id);\n        } else if (oldIdTagNameMap.get(id) === tagName) {\n          persistentIds.add(id);\n        }\n        // skip if tag types mismatch because its not possible to morph one tag into another\n      }\n\n      for (const id of duplicateIds) {\n        persistentIds.delete(id);\n      }\n      return persistentIds;\n    }\n\n    return createMorphContext;\n  })();\n\n  //=============================================================================\n  // HTML Normalization Functions\n  //=============================================================================\n  const { normalizeElement, normalizeParent } = (function () {\n    /** @type {WeakSet<Node>} */\n    const generatedByIdiomorph = new WeakSet();\n\n    /**\n     *\n     * @param {Element | Document} content\n     * @returns {Element}\n     */\n    function normalizeElement(content) {\n      if (content instanceof Document) {\n        return content.documentElement;\n      } else {\n        return content;\n      }\n    }\n\n    /**\n     *\n     * @param {null | string | Node | HTMLCollection | Node[] | Document & {generatedByIdiomorph:boolean}} newContent\n     * @returns {Element}\n     */\n    function normalizeParent(newContent) {\n      if (newContent == null) {\n        return document.createElement(\"div\"); // dummy parent element\n      } else if (typeof newContent === \"string\") {\n        return normalizeParent(parseContent(newContent));\n      } else if (\n        generatedByIdiomorph.has(/** @type {Element} */ (newContent))\n      ) {\n        // the template tag created by idiomorph parsing can serve as a dummy parent\n        return /** @type {Element} */ (newContent);\n      } else if (newContent instanceof Node) {\n        if (newContent.parentNode) {\n          // we can't use the parent directly because newContent may have siblings\n          // that we don't want in the morph, and reparenting might be expensive (TODO is it?),\n          // so instead we create a fake parent node that only sees a slice of its children.\n          /** @type {Element} */\n          return /** @type {any} */ (new SlicedParentNode(newContent));\n        } else {\n          // a single node is added as a child to a dummy parent\n          const dummyParent = document.createElement(\"div\");\n          dummyParent.append(newContent);\n          return dummyParent;\n        }\n      } else {\n        // all nodes in the array or HTMLElement collection are consolidated under\n        // a single dummy parent element\n        const dummyParent = document.createElement(\"div\");\n        for (const elt of [...newContent]) {\n          dummyParent.append(elt);\n        }\n        return dummyParent;\n      }\n    }\n\n    /**\n     * A fake duck-typed parent element to wrap a single node, without actually reparenting it.\n     * This is useful because the node may have siblings that we don't want in the morph, and it may also be moved\n     * or replaced with one or more elements during the morph. This class effectively allows us a window into\n     * a slice of a node's children.\n     * \"If it walks like a duck, and quacks like a duck, then it must be a duck!\" -- James Whitcomb Riley (1849–1916)\n     */\n    class SlicedParentNode {\n      /** @param {Node} node */\n      constructor(node) {\n        this.originalNode = node;\n        this.realParentNode = /** @type {Element} */ (node.parentNode);\n        this.previousSibling = node.previousSibling;\n        this.nextSibling = node.nextSibling;\n      }\n\n      /** @returns {Node[]} */\n      get childNodes() {\n        // return slice of realParent's current childNodes, based on previousSibling and nextSibling\n        const nodes = [];\n        let cursor = this.previousSibling\n          ? this.previousSibling.nextSibling\n          : this.realParentNode.firstChild;\n        while (cursor && cursor != this.nextSibling) {\n          nodes.push(cursor);\n          cursor = cursor.nextSibling;\n        }\n        return nodes;\n      }\n\n      /**\n       * @param {string} selector\n       * @returns {Element[]}\n       */\n      querySelectorAll(selector) {\n        return this.childNodes.reduce((results, node) => {\n          if (node instanceof Element) {\n            if (node.matches(selector)) results.push(node);\n            const nodeList = node.querySelectorAll(selector);\n            for (let i = 0; i < nodeList.length; i++) {\n              results.push(nodeList[i]);\n            }\n          }\n          return results;\n        }, /** @type {Element[]} */ ([]));\n      }\n\n      /**\n       * @param {Node} node\n       * @param {Node} referenceNode\n       * @returns {Node}\n       */\n      insertBefore(node, referenceNode) {\n        return this.realParentNode.insertBefore(node, referenceNode);\n      }\n\n      /**\n       * @param {Node} node\n       * @param {Node} referenceNode\n       * @returns {Node}\n       */\n      moveBefore(node, referenceNode) {\n        // @ts-ignore - use new moveBefore feature\n        return this.realParentNode.moveBefore(node, referenceNode);\n      }\n\n      /**\n       * for later use with populateIdMapWithTree to halt upwards iteration\n       * @returns {Node}\n       */\n      get __idiomorphRoot() {\n        return this.originalNode;\n      }\n    }\n\n    /**\n     *\n     * @param {string} newContent\n     * @returns {Node | null | DocumentFragment}\n     */\n    function parseContent(newContent) {\n      let parser = new DOMParser();\n\n      // remove svgs to avoid false-positive matches on head, etc.\n      let contentWithSvgsRemoved = newContent.replace(\n        /<svg(\\s[^>]*>|>)([\\s\\S]*?)<\\/svg>/gim,\n        \"\",\n      );\n\n      // if the newContent contains a html, head or body tag, we can simply parse it w/o wrapping\n      if (\n        contentWithSvgsRemoved.match(/<\\/html>/) ||\n        contentWithSvgsRemoved.match(/<\\/head>/) ||\n        contentWithSvgsRemoved.match(/<\\/body>/)\n      ) {\n        let content = parser.parseFromString(newContent, \"text/html\");\n        // if it is a full HTML document, return the document itself as the parent container\n        if (contentWithSvgsRemoved.match(/<\\/html>/)) {\n          generatedByIdiomorph.add(content);\n          return content;\n        } else {\n          // otherwise return the html element as the parent container\n          let htmlElement = content.firstChild;\n          if (htmlElement) {\n            generatedByIdiomorph.add(htmlElement);\n          }\n          return htmlElement;\n        }\n      } else {\n        // if it is partial HTML, wrap it in a template tag to provide a parent element and also to help\n        // deal with touchy tags like tr, tbody, etc.\n        let responseDoc = parser.parseFromString(\n          \"<body><template>\" + newContent + \"</template></body>\",\n          \"text/html\",\n        );\n        let content = /** @type {HTMLTemplateElement} */ (\n          responseDoc.body.querySelector(\"template\")\n        ).content;\n        generatedByIdiomorph.add(content);\n        return content;\n      }\n    }\n\n    return { normalizeElement, normalizeParent };\n  })();\n\n  //=============================================================================\n  // This is what ends up becoming the Idiomorph global object\n  //=============================================================================\n  return {\n    morph,\n    defaults,\n  };\n})();\n(function () {\n  function createMorphConfig(swapStyle) {\n    if (swapStyle === \"morph\" || swapStyle === \"morph:outerHTML\") {\n      return { morphStyle: \"outerHTML\" };\n    } else if (swapStyle === \"morph:innerHTML\") {\n      return { morphStyle: \"innerHTML\" };\n    } else if (swapStyle.startsWith(\"morph:\")) {\n      return Function(\"return (\" + swapStyle.slice(6) + \")\")();\n    }\n  }\n\n  htmx.defineExtension(\"morph\", {\n    isInlineSwap: function (swapStyle) {\n      let config = createMorphConfig(swapStyle);\n      return config?.morphStyle === \"outerHTML\" || config?.morphStyle == null;\n    },\n    handleSwap: function (swapStyle, target, fragment) {\n      let config = createMorphConfig(swapStyle);\n      if (config) {\n        return Idiomorph.morph(target, fragment.children, config);\n      }\n    },\n  });\n})();\n\nexport {Idiomorph};\n","// The module cache\nconst __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tconst cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tconst module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter/value functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tif(Array.isArray(definition)) {\n\t\tvar i = 0;\n\t\twhile(i < definition.length) {\n\t\t\tvar key = definition[i++];\n\t\t\tvar binding = definition[i++];\n\t\t\tif(!__webpack_require__.o(exports, key)) {\n\t\t\t\tif(binding === 0) {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, value: definition[i++] });\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: binding });\n\t\t\t\t}\n\t\t\t} else if(binding === 0) { i++; }\n\t\t}\n\t} else {\n\t\tfor(var key in definition) {\n\t\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t\t}\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","require(\"htmx.org\");\nrequire(\"idiomorph/htmx\");\n"],"names":["htmx","onLoad","process","on","off","trigger","ajax","find","findAll","closest","values","elt","type","getInputValues","remove","addClass","removeClass","toggleClass","takeClass","swap","defineExtension","removeExtension","logAll","logNone","logger","config","historyEnabled","historyCacheSize","refreshOnHistoryMiss","defaultSwapStyle","defaultSwapDelay","defaultSettleDelay","includeIndicatorStyles","indicatorClass","requestClass","addedClass","settlingClass","swappingClass","allowEval","allowScriptTags","inlineScriptNonce","inlineStyleNonce","attributesToSettle","withCredentials","timeout","wsReconnectDelay","wsBinaryType","disableSelector","scrollBehavior","defaultFocusScroll","getCacheBusterParam","globalViewTransitions","methodsThatUseUrlParams","selfRequestsOnly","ignoreTitle","scrollIntoViewOnBoost","triggerSpecsCache","disableInheritance","responseHandling","code","error","allowNestedOobSwaps","historyRestoreAsHxRequest","reportValidityOfForms","parseInterval","location","_","version","onLoadHelper","processNode","addEventListenerImpl","removeEventListenerImpl","triggerEvent","ajaxHelper","removeElement","addClassToElement","removeClassFromElement","toggleClassOnElement","takeClassForElement","internalEval","internalAPI","addTriggerHandler","bodyContains","canAccessLocalStorage","findThisElement","filterValues","hasAttribute","getAttributeValue","getClosestAttributeValue","getClosestMatch","getExpressionVars","getHeaders","getInternalData","getSwapSpecification","getTriggerSpecs","getTarget","makeFragment","mergeObjects","makeSettleInfo","oobSwap","querySelectorExt","settleImmediately","shouldCancel","triggerErrorEvent","withExtensions","VERBS","VERB_SELECTOR","map","verb","join","str","undefined","interval","NaN","slice","parseFloat","isNaN","getRawAttribute","name","Element","getAttribute","qualifiedName","parentElt","parent","parentElement","parentNode","ShadowRoot","getDocument","document","getRootNode","global","composed","condition","getAttributeValueWithDisinheritance","initialElement","ancestor","attributeName","attributeValue","disinherit","inherit","split","indexOf","closestAttr","e","asElement","matches","selector","getStartTag","match","exec","toLowerCase","parseHTML","resp","Document","parseHTMLUnsafe","DOMParser","parseFromString","takeChildrenFor","fragment","childNodes","length","append","duplicateScript","script","newScript","createElement","forEach","attributes","attr","setAttribute","value","textContent","async","nonce","isJavaScriptScriptNode","normalizeScriptTags","Array","from","querySelectorAll","insertBefore","logError","response","responseWithNoHead","replace","startTag","DocumentFragment","doc","body","title","querySelector","titleElement","innerText","maybeCall","func","isType","o","Object","prototype","toString","call","isFunction","isRawObject","dataProp","data","toArray","arr","returnArr","i","push","isScrolledIntoView","el","rect","getBoundingClientRect","elemTop","top","elemBottom","bottom","window","innerHeight","splitOnWhitespace","trim","obj1","obj2","key","hasOwnProperty","parseJSON","jString","JSON","parse","test","sessionStorage","setItem","removeItem","normalizePath","path","url","URL","href","pathname","search","maybeEval","eval","callback","evt","detail","event","console","log","eltOrSelector","getWindow","delay","resolveTarget","setTimeout","removeChild","asHtmlElement","HTMLElement","asString","asParentNode","clazz","classList","add","node","removeAttribute","toggle","children","child","startsWith","prefix","substring","endsWith","suffix","normalizeSelector","trimmedSelector","querySelectorAllExt","parts","chevronsCount","offset","char","result","unprocessedParts","shift","item","nextElementSibling","scanForwardQuery","previousElementSibling","scanBackwardsQuery","host","standardSelector","rootNode","start","results","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_FOLLOWING","context","processEventArgs","arg1","arg2","arg3","arg4","target","listener","options","ready","eventArgs","addEventListener","removeEventListener","DUMMY_ELT","findAttributeTargets","attrName","attrTarget","eltToInheritFrom","attribute","targetStr","boosted","shouldSettleAttribute","includes","cloneAttributes","mergeTo","mergeFrom","isInlineSwap","swapStyle","extensions","getExtensions","extension","oobValue","oobElement","settleInfo","CSS","escape","targets","oobElementClone","cloneNode","createDocumentFragment","appendChild","beforeSwapDetails","shouldSwap","handlePreservedElements","swapWithStyle","restorePreservedElements","elts","content","pantry","preservedElt","existingElement","id","moveBefore","getElementById","insertAdjacentHTML","replaceChild","handleAttributes","newNode","oldNode","tagName","newAttributes","tasks","makeAjaxLoadTask","processFocus","autofocus","autoFocusedElt","focus","insertNodesBefore","firstChild","nodeType","TEXT_NODE","COMMENT_NODE","stringHash","string","hash","charCodeAt","attributeHash","deInitOnHandlers","internalData","onHandlers","handlerInfo","deInitNode","element","clearTimeout","listenerInfos","info","keys","cleanUpElement","swapOuterHTML","swapInnerHTML","newElt","eltBeforeNewContent","previousSibling","nextSibling","filter","swapAfterBegin","swapBeforeBegin","swapBeforeEnd","swapAfterEnd","swapDelete","ext","newElements","handleSwap","isArray","j","findAndSwapOobElements","oobElts","swapSpec","swapOptions","settleResolve","settleReject","doSwap","beforeSwapCallback","contextElement","activeElt","activeElement","selectionInfo","selectionStart","end","selectionEnd","historyRequest","selectOOB","oobSelectValues","oobSelectValue","template","select","newFragment","newActiveElt","focusOptions","preventScroll","focusScroll","setSelectionRange","eventInfo","afterSwapCallback","handleTitle","doSettle","task","anchor","anchorTarget","scrollIntoView","block","behavior","updateScrollState","afterSettleCallback","settleDelay","shouldTransition","transition","Promise","startViewTransition","settlePromise","_resolve","_reject","innerDoSwap","swapDelay","handleTriggerHeader","xhr","header","triggerBody","getResponseHeader","triggers","eventName","eventNames","WHITESPACE","WHITESPACE_OR_COMMA","SYMBOL_START","SYMBOL_CONT","STRINGISH_START","NOT_WHITESPACE","COMBINED_SELECTOR_START","COMBINED_SELECTOR_END","tokenizeString","tokens","position","charAt","startPosition","startChar","symbol","isPossibleRelativeReference","token","last","paramName","maybeGenerateConditional","bracketCount","conditionalSource","conditionFunction","Function","source","consumeUntil","consumeCSSSelector","INPUT_SELECTOR","parseAndCacheTrigger","explicitTrigger","cache","triggerSpecs","initialLength","every","pollInterval","eventFilter","triggerSpec","changed","once","consume","from_arg","throttle","queue","cancelPolling","cancelled","processPolling","handler","spec","nodeData","maybeFilterEvent","makeEvent","isLocalLink","hostname","eltIsDisabled","boostElement","HTMLAnchorElement","String","rawAttribute","issueAjaxRequest","btn","form","link","samePageAnchor","ignoreBoostedAnchorCtrlClick","ctrlKey","metaKey","explicitCancel","elementData","eltsToListenOn","lastValue","WeakMap","eltToListenOn","has","set","get","eventListener","preventDefault","eventData","handledFor","stopPropagation","triggeredOnce","delayed","windowIsScrolling","scrollHandler","initScrollHandler","setInterval","maybeReveal","initHash","loadImmediately","load","loaded","processVerbs","explicitAction","observerOptions","root","threshold","IntersectionObserver","entries","isIntersecting","observe","firstInitCompleted","polling","shouldProcessHxOn","HX_ON_QUERY","XPathEvaluator","createExpression","processHXOnRoot","elements","iter","evaluate","iterateNext","findHxOnWildcardElements","findElementsToProcess","boostedSelector","extensionSelectors","getSelectors","selectors","flat","s","maybeSetLastButtonClicked","getTargetButton","getRelatedFormData","lastButtonClicked","maybeUnsetLastButtonClicked","getRelatedForm","initButtonTracking","addHxOnEventHandler","processHxOnWildcard","afterOnPosition","nextChar","initNode","maybeDeInitAndHash","elementsToInit","kebabEventName","CustomEvent","bubbles","cancelable","ignoreEventForLogging","toDo","extensionsToIgnore","msg","errorInfo","eventResult","dispatchEvent","kebabName","kebabedEvent","onEvent","defaultPrevented","currentPathForHistory","setCurrentPathForHistory","getHistoryElement","saveToHistoryCache","rootElt","innerHTML","cleanInnerHtmlForHistory","scroll","scrollY","historyCache","getItem","splice","newHistoryItem","stringify","cause","getCachedHistory","className","clone","saveCurrentPageToHistory","historyElt","history","replaceState","pushUrlIntoHistory","pushState","replaceUrlInHistory","loadHistoryFromServer","request","XMLHttpRequest","details","open","setRequestHeader","onload","this","status","cacheMiss","serverResponse","send","restoreHistory","cached","reload","addRequestIndicatorClasses","indicators","ic","requestCount","disableElements","disabledElts","disabledElement","removeRequestIndicators","disabled","concat","ele","haveSeenNode","processed","isSameNode","shouldInclude","checked","addValueToFormData","formData","v","removeValueFromFormData","getAll","delete","getValueFromInput","HTMLSelectElement","multiple","HTMLInputElement","files","processInputValue","errors","validate","validateElement","HTMLFormElement","input","FormData","File","willValidate","checkValidity","message","validationMessage","validity","reportValidity","overrideFormData","receiver","donor","priorityFormData","noValidate","formNoValidate","button","descendant","formDataProxy","appendParam","returnStr","realValue","encodeURIComponent","urlEncode","formDataFromObject","prompt","headers","getValuesForElement","inputValues","paramsValue","newValues","isAnchorLink","swapInfoOverride","swapInfo","show","scrollVal","splitSpec","pop","selectorVal","scrollTarget","showVal","showTarget","focusScrollVal","usesFormData","encodeParamsForBody","filteredParameters","encodedParameters","encodeParameters","first","scrollTop","scrollHeight","scrollTo","evalAsDefault","varsValues","evaluateValue","toEval","defaultVal","getHXVarsForElement","expressionVars","getHXValsForElement","safelySetHeaderValue","headerValue","getPathFromResponse","responseURL","hasHeader","regexp","getAllResponseHeaders","targetOverride","returnPromise","resolvedTarget","swapOverride","hierarchyForElt","verifyPath","requestConfig","protocol","origin","sameHost","obj","Blob","formDataArrayProxy","array","Proxy","apply","arguments","index","Reflect","fromEntries","deleteProperty","ownKeys","getOwnPropertyDescriptor","prop","etc","confirmed","resolve","reject","promise","responseHandler","handleAjaxResponse","eltData","submitter","buttonPath","buttonVerb","confirmQuestion","triggeringEvent","issueRequest","skipConfirmation","question","syncElt","syncStrategy","queueStrategy","abortable","syncStrings","queuedRequests","endRequestLock","queuedRequest","promptQuestion","promptResponse","confirm","rawFormData","allFormData","filteredFormData","requestAttrValues","eltIsBoosted","useUrlParams","parameters","unfilteredFormData","unfilteredParameters","credentials","splitPath","pathNoAnchor","finalPath","next","done","toUpperCase","overrideMimeType","noHeaders","responseInfo","pathInfo","requestPath","finalRequestPath","responsePath","hierarchy","keepIndicators","disableElts","secondaryTriggerElt","parentEltInHierarchy","onerror","onabort","ontimeout","upload","lengthComputable","total","params","determineHistoryUpdates","pathFromHeaders","typeFromHeaders","pushUrl","replaceUrl","elementIsBoosted","saveType","codeMatches","responseHandlingConfig","RegExp","resolveResponseHandling","responseHandlingElement","titleElt","resolveRetarget","Error","responseInfoSelect","redirectPath","redirectSwapSpec","shouldRefresh","historyUpdate","isError","selectOverride","failed","successful","transformResponse","finalElt","extensionBase","init","api","text","extensionsToReturn","extensionsForElement","extensionName","isReady","fn","readyState","insertIndicatorStyles","nonceAttribute","indicator","head","getMetaConfig","mergeMetaConfig","metaConfig","restoredElts","abort","originalPopstate","onpopstate","bind","state","__WEBPACK_DEFAULT_EXPORT__","Idiomorph","noOp","defaults","morphStyle","callbacks","beforeNodeAdded","afterNodeAdded","beforeNodeMorphed","afterNodeMorphed","beforeNodeRemoved","afterNodeRemoved","beforeAttributeUpdated","style","shouldPreserve","shouldReAppend","shouldRemove","afterHeadMorphed","restoreFocus","morphChildren","createNode","oldParent","newChild","insertionPoint","ctx","idMap","newEmptyChild","morphNode","newClonedChild","importNode","findBestMatch","isIdSetMatch","oldSet","newSet","isSoftMatch","oldElt","startPoint","endPoint","softMatch","siblingSoftMatchCount","cursor","activeElementAndParents","removeNode","removeNodesBetween","startInclusive","endExclusive","tempNode","moveBeforeById","after","idSet","size","removeElementFromAncestorsIdMaps","newParent","HTMLTemplateElement","bestMatch","newChildId","persistentIds","movedChild","insertedNode","syncBooleanAttribute","oldElement","newElement","newLiveValue","ignoreUpdate","ignoreAttribute","updateType","ignoreActiveValue","ignoreValueOfActiveElement","possibleActiveElement","newContent","ignoreActive","HTMLHeadElement","ignore","handleHeadElement","oldAttributes","newAttribute","oldAttribute","newValue","oldValue","HTMLOptionElement","HTMLTextAreaElement","nodeValue","syncInputValue","morphAttributes","oldHead","newHead","added","removed","preserved","nodesToAppend","srcToNewHeadNodes","Map","newHeadChild","outerHTML","currentHeadElt","inNewContent","isReAppended","isPreserved","promises","createRange","createContextualFragment","src","removedElement","kept","createMorphContext","createPantry","hidden","insertAdjacentElement","createActiveElementAndParents","contains","findIdElements","populateIdMapWithTree","current","Set","oldContent","oldIdElements","newIdElements","duplicateIds","oldIdTagNameMap","createPersistentIds","__idiomorphRoot","createIdMaps","mergedConfig","finalConfig","assign","mergeDefaults","normalizeElement","normalizeParent","generatedByIdiomorph","WeakSet","SlicedParentNode","constructor","originalNode","realParentNode","nodes","reduce","nodeList","referenceNode","documentElement","parser","contentWithSvgsRemoved","htmlElement","parseContent","dummyParent","morph","morphedNodes","activeElementId","saveAndRestoreFocus","all","then","newCtx","withHeadBlocking","morphOuterHTML","createMorphConfig","htmx_org__WEBPACK_IMPORTED_MODULE_0__","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","exports","module","__webpack_modules__","d","definition","binding","defineProperty","enumerable","r","Symbol","toStringTag"],"sourceRoot":""}