{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/@babel/runtime/regenerator/index.js","webpack:///./node_modules/js-cookie/src/js.cookie.js","webpack:///./node_modules/sweetalert2/dist/sweetalert2.all.js","webpack:///./node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack:///./biz_battles/static/js/ProgramDetailPage.js","webpack:///./node_modules/@babel/runtime/node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/fuse.js/dist/fuse.mjs","webpack:///./node_modules/htmx.org/dist/htmx.esm.js","webpack:///./biz_battles/static/js/utils.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","factory","OldCookies","window","Cookies","api","noConflict","extend","result","arguments","length","attributes","decode","replace","decodeURIComponent","init","converter","set","document","path","defaults","expires","Date","toUTCString","JSON","stringify","test","e","write","encodeURIComponent","String","escape","stringifiedAttributes","attributeName","split","cookie","json","jar","cookies","parts","slice","join","charAt","read","parse","getJSON","remove","withConverter","_assertClassBrand","has","TypeError","_classPrivateFieldGet2","a","_classPrivateFieldInitSpec","_checkPrivateRedeclaration","globalState","restoreActiveElement","returnFocus","Promise","resolve","x","scrollX","y","scrollY","restoreFocusTimeout","setTimeout","previousActiveElement","HTMLElement","focus","body","scrollTo","swalClasses","reduce","acc","className","iconTypes","icon","capitalizeFirstLetter","str","toUpperCase","warn","message","console","error","previousWarnOnceMessages","warnOnce","includes","push","warnAboutDeprecation","deprecatedParam","useInstead","undefined","callIfFunction","arg","hasToPromiseFn","toPromise","asPromise","isPromise","getContainer","querySelector","container","elementBySelector","selectorString","elementByClass","getPopup","popup","getIcon","getTitle","title","getHtmlContainer","getImage","image","getProgressSteps","getValidationMessage","getConfirmButton","actions","confirm","getCancelButton","cancel","getDenyButton","deny","getLoader","loader","getActions","getFooter","footer","getTimerProgressBar","getCloseButton","close","getFocusableElements","focusableElementsWithTabindex","querySelectorAll","focusableElementsWithTabindexSorted","Array","from","sort","b","tabindexA","parseInt","getAttribute","tabindexB","otherFocusableElements","otherFocusableElementsFiltered","filter","el","Set","concat","isVisible$1","isModal","hasClass","shown","isToast","toast","setInnerHtml","elem","html","textContent","parser","DOMParser","parsed","parseFromString","head","childNodes","forEach","child","appendChild","HTMLVideoElement","HTMLAudioElement","cloneNode","classList","contains","applyCustomClass","params","values","showClass","removeCustomClasses","customClass","addClass","getInput$1","inputClass","checkbox","radio","range","input","focusInput","type","val","toggleClass","target","condition","Boolean","isArray","add","removeClass","getDirectChildByClass","children","applyNumericalStyle","style","setProperty","removeProperty","show","display","hide","showWhenInnerHtmlPresent","MutationObserver","toggle","innerHTML","observe","childList","subtree","setStyle","parent","selector","offsetWidth","offsetHeight","getClientRects","isScrollable","scrollHeight","clientHeight","hasCssAnimation","getComputedStyle","animDuration","parseFloat","getPropertyValue","transDuration","animateTimerProgressBar","timer","reset","timerProgressBar","transition","width","sweetHTML","file","select","label","textarea","resetValidationMessage$1","currentInstance","resetValidationMessage","oldContainerExisted","oldContainer","documentElement","resetOldContainer","isNodeEnv","createElement","dataset","theme","targetElement","getTarget","setAttribute","setupAccessibility","direction","rtl","setupRTL","rangeOutput","oninput","onchange","addInputChangeListeners","parseHtmlToContainer","param","handleObject","jquery","handleJqueryElem","toString","renderActions","instance","showConfirmButton","showDenyButton","showCancelButton","confirmButton","denyButton","cancelButton","renderButton","buttonsStyling","styled","confirmButtonColor","backgroundColor","denyButtonColor","cancelButtonColor","handleButtonsStyling","reverseButtons","insertBefore","renderButtons","loaderHtml","button","buttonType","buttonName","renderContainer","backdrop","background","handleBackdropParam","position","center","handlePositionParam","grow","handleGrowParam","privateProps","innerParams","WeakMap","domCache","inputClasses","showInput","renderInputType","keys","inputContainer","getInputContainer","inputAutoFocus","setAttributes","inputAttributes","attrName","removeAttribute","removeAttributes","attr","setCustomClass","setInputPlaceholder","placeholder","inputPlaceholder","setInputLabel","prependTo","inputLabel","labelClass","id","innerText","insertAdjacentElement","inputType","checkAndSetInputValue","inputValue","text","email","password","number","tel","url","search","date","time","week","month","rangeInput","disabled","selected","checkboxContainer","checked","initialPopupWidth","textareaResizeHandler","textareaWidth","marginLeft","marginRight","getMargin","attributeFilter","renderContent","htmlContainer","rerender","renderInput","applyStyles","iconType","iconClassName","entries","setColor","adjustSuccessIconBackgroundColor","popupBackgroundColor","successIconParts","setContent","iconHtml","oldContent","newContent","iconContent","defaultIconHtml","question","warning","info","trim","iconColor","color","borderColor","sel","content","dragging","mousedownX","mousedownY","initialX","initialY","down","event","clientXY","getClientXY","clientX","clientY","insetInlineStart","insetBlockStart","move","up","startsWith","touches","renderPopup","padding","addClasses$1","draggable","addEventListener","addDraggableListeners","removeEventListener","removeDraggableListeners","modal","createStepElement","step","stepEl","createLineElement","lineEl","progressStepsDistance","render","progressStepsContainer","progressSteps","currentProgressStep","index","renderProgressSteps","indexOf","matchMedia","renderIcon","imageUrl","imageAlt","imageWidth","imageHeight","renderImage","titleText","renderTitle","closeButton","closeButtonHtml","showCloseButton","closeButtonAriaLabel","renderCloseButton","renderFooter","didRender","eventEmitter","emit","clickConfirm","_dom$getConfirmButton","click","DismissReason","freeze","esc","removeKeydownHandler","keydownTarget","keydownHandlerAdded","keydownHandler","capture","keydownListenerCapture","setFocus","increment","_dom$getPopup","focusableElements","arrowKeysNextButton","arrowKeysPreviousButton","dismissWith","isComposing","keyCode","stopKeydownPropagation","stopPropagation","handleEnter","handleTab","handleArrows","handleEsc","allowEnterKey","outerHTML","preventDefault","btnIndex","shiftKey","buttons","activeElement","sibling","buttonToFocus","HTMLButtonElement","allowEscapeKey","privateMethods","swalPromiseResolve","swalPromiseReject","unsetAriaHidden","bodyChildren","hasAttribute","isSafariOrIOS","GestureEvent","lockBodyScroll","preventTouchMove","ontouchstart","shouldPreventTouchMove","ontouchmove","isStylus","isZoom","tagName","touchType","undoIOSfix","iosfix","offset","top","scrollTop","previousBodyPadding","replaceScrollbarWithPadding","initialBodyOverflow","innerHeight","paddingRight","scrollDiv","scrollbarWidth","getBoundingClientRect","clientWidth","removeChild","measureScrollbar","undoReplaceScrollbarWithPadding","removePopupAndResetState","didClose","triggerDidCloseAndDispose","then","resolveValue","prepareResolveValue","this","triggerClosePopup","isAwaitingPromise","isDismissed","handleAwaitingPromise","hideClass","handlePopupAnimation","rejectPromise","_destroy","isConfirmed","isDenied","assign","_globalState$eventEmi","animationIsSupported","willClose","animatePopup","swalCloseEventFinishedCallback","swalCloseAnimationFinished","_globalState$swalClos","_globalState$eventEmi2","showLoading","buttonToReplace","Swal","replaceButton","loading","getCheckboxValue","getRadioValue","getFileValue","files","handleInputOptions","processInputOptions","inputOptions","renderOption","optionLabel","optionValue","option","isSelected","inputOption","optgroup","populateSelectOptions","formatInputOptions","radioValue","radioLabel","radioInput","radioLabelElement","radios","populateRadioOptions","hideLoading","handleInputValue","getInput","catch","err","Map","valueFormatted","handleConfirmOrDenyWithInput","inputAutoTrim","getInputValue","inputValidator","handleInputValidator","checkValidity","enableButtons","showValidationMessage","validationMessage","disableInput","validationPromise","enableInput","showLoaderOnDeny","preDeny","preDenyPromise","preDenyValue","rejectWith","succeedWith","showLoaderOnConfirm","preConfirm","preConfirmPromise","preConfirmValue","showRelatedButton","getElementsByClassName","allButtonsAreHidden","setButtonsDisabled","setInputDisabled","disableButtons","inputerror","defaultParams","template","animation","heightAuto","allowOutsideClick","confirmButtonText","confirmButtonAriaLabel","denyButtonText","denyButtonAriaLabel","cancelButtonText","cancelButtonAriaLabel","focusConfirm","focusDeny","focusCancel","returnInputValueOnDeny","willOpen","didOpen","didDestroy","scrollbarPadding","updatableParams","deprecatedParams","toastIncompatibleParams","isValidParameter","paramName","isUpdatableParameter","isDeprecatedParameter","checkIfParamIsValid","checkIfToastParamIsValid","checkIfParamIsDeprecated","isDeprecated","showWarningsForParams","update","validUpdatableParams","filterValidParams","updatedParams","defineProperties","writable","disposeSwal","disposeWeakMaps","unsetWeakMaps","disableLoading","closePopup","closeModal","closeToast","obj","delete","instanceMethods","__proto__","handleToastClick","onclick","isAnyButtonShown","ignoreOutsideClick","handleModalMousedown","onmousedown","onmouseup","handleContainerMousedown","handleModalClick","isElement","Element","isJqueryElement","stopTimer","timeout","timerProgressBarWidth","timerProgressBarFullWidth","timerProgressBarPercent","stopTimerProgressBar","stop","resumeTimer","remaining","start","bodyClickListenerAdded","clickHandlers","bodyClickListener","parentNode","fire","events","eventName","eventHandler","currentHandlers","_getHandlersByEventName","_this","onceFn","removeListener","_len","args","_key","apply","on","_len2","_key2","splice","staticMethods","argsToParams","bindClickHandler","clickCancel","_dom$getCancelButton","clickDeny","_dom$getDenyButton","enableLoading","getIconContent","getInputLabel","getTimerLeft","increaseTimer","ms","increase","isLoading","isTimerRunning","isRunning","isVisible","mixin","mixinParams","priorityMixinParams","super","_main","off","removeAllListeners","once","toggleTimer","running","Timer","callback","delay","started","clearTimeout","getTime","swalStringParams","getSwalParams","templateContent","swalParams","showWarningsForAttributes","getSwalFunctionParams","swalFunctions","Function","getSwalButtons","swalButtons","getSwalImage","getSwalIcon","getSwalInput","optionName","getSwalStringParams","paramNames","tag","showWarningsForElements","allowedElements","toLowerCase","allowedAttributes","attribute","openPopup","bodyStyles","overflowY","addClasses","setScrollingVisibility","fixScrollContainer","setAriaHidden","swalOpenAnimationFinished","iOSfix","defaultInputValidators","string","setParameters","setDefaultInputValidators","validateCustomTargetElement","_promise","SweetAlert","outerParams","constructor","userParams","prepareParams","populateDomCache","swalPromise","onFulfilled","onFinally","finally","reject","dismiss","handleConfirmButtonClick","handleDenyButtonClick","handleCancelButtonClick","handlePopupClick","addKeydownHandler","some","handleInputOptionsAndValue","setupTimer","initFocus","templateParams","getTemplateParams","focusAutofocus","focusButton","blurActiveElement","autofocusElements","autofocusElement","blur","navigator","language","location","host","match","now","initiationDate","localStorage","getItem","pointerEvents","ukrainianAnthem","src","loop","play","setItem","version","default","Sweetalert2","swal","sweetAlert","getElementsByTagName","styleSheet","cssText","asyncGeneratorStep","gen","_next","_throw","done","fn","self","storeGeoLocation","coords","latitude","longitude","secure","_checkGeolocationPermission","_asyncToGenerator","_regeneratorRuntime","mark","_callee","permissionStatus","wrap","_context","prev","next","permissions","query","sent","abrupt","state","t0","setLocationIfPermissionsGranted","checkGeolocationPermission","status","geolocation","getCurrentPosition","showNoSearchResultsTxt","noResultsText","getElementById","htmx","fuse","setupSearchOffers","searchInput","allItems","SEARCH_DATA","map","element","Fuse","threshold","minMatchCharLength","fuseResult","matchedIds","res","item","_ref","size","$","ready","locationRequested","shareBtn","evt","battleId","hasCookie","trigger","showErrorMessage","errBattleId","section","btn","searchContainer","showSearch","setupSearchBtnListener","emailInput","isValidEmail","setupWaitlistSubmission","href","share","log","runtime","Op","hasOwn","$Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","context","Context","_invoke","GenStateSuspendedStart","method","GenStateExecuting","Error","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","setPrototypeOf","awrap","async","iter","reverse","pop","skipTempReset","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","getTag","INFINITY","baseToString","isString","isNumber","isBoolean","isObject","isObjectLike","isDefined","isBlank","INCORRECT_INDEX_TYPE","LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY","PATTERN_LENGTH_TOO_LARGE","max","MISSING_KEY_PROPERTY","INVALID_KEY_WEIGHT_VALUE","KeyStore","_keys","_keyMap","totalWeight","createKey","weight","keyId","getFn","createKeyPath","createKeyId","Config","isCaseSensitive","ignoreDiacritics","includeScore","shouldSort","sortFn","score","idx","includeMatches","findAllMatches","distance","useExtendedSearch","list","arr","deepGet","len","ignoreLocation","ignoreFieldNorm","fieldNormWeight","SPACE","FuseIndex","norm","mantissa","cache","Math","pow","numTokens","round","clear","isCreated","setIndexRecords","docs","records","_keysMap","doc","docIndex","_addString","_addObject","v","keyIndex","subRecords","stack","nestedArrIndex","subRecord","k","createIndex","myIndex","setKeys","setSources","computeScore$1","pattern","errors","currentLocation","expectedLocation","accuracy","proximity","abs","MAX_BITS","patternAlphabet","patternLen","textLen","min","currentThreshold","bestLocation","computeMatches","matchMask","lastBitArr","finalScore","binMax","mask","binMin","binMid","floor","bitArr","j","charMatch","isMatch","indices","matchmask","end","convertMaskToIndices","createPatternAlphabet","char","stripDiacritics","normalize","BitapSearch","options","chunks","addChunk","startIndex","alphabet","remainder","substr","allIndices","totalScore","hasMatches","BaseMatch","getMatch","multiRegex","singleRegex","exp","matches","FuzzyMatch","_bitapSearch","searchIn","IncludeMatch","searchers","endsWith","searchersLen","SPACE_RE","OR_TOKEN","MultiMatchSet","ExtendedSearch","results","queryItem","found","searcher","token","isMultiMatch","isSingleMatch","parseQuery","_","numMatches","qLen","pLen","registeredSearchers","createSearcher","searcherClass","LogicalOperator","AND","OR","KeyType","PATH","PATTERN","isExpression","isPath","isLeaf","convertToExplicit","auto","isQueryPath","node","operator","transformMatches","data","refIndex","transformScore","_keyStore","setCollection","_docs","_myIndex","predicate","removeAt","limit","_searchStringList","_searchObjectList","_searchLogical","Number","EPSILON","computeScore","transformers","transformer","format","expression","evaluate","_findMatches","getValueForItemAtKeyId","resultMap","expResults","parseIndex","config","register","onLoad","process","ajax","find","findAll","closest","elt","getInputValues","takeClass","swap","defineExtension","removeExtension","logAll","logNone","logger","historyEnabled","historyCacheSize","refreshOnHistoryMiss","defaultSwapStyle","defaultSwapDelay","defaultSettleDelay","includeIndicatorStyles","indicatorClass","requestClass","addedClass","settlingClass","swappingClass","allowEval","allowScriptTags","inlineScriptNonce","inlineStyleNonce","attributesToSettle","withCredentials","wsReconnectDelay","wsBinaryType","disableSelector","scrollBehavior","defaultFocusScroll","getCacheBusterParam","globalViewTransitions","methodsThatUseUrlParams","selfRequestsOnly","ignoreTitle","scrollIntoViewOnBoost","triggerSpecsCache","disableInheritance","responseHandling","code","allowNestedOobSwaps","parseInterval","onLoadHelper","processNode","addEventListenerImpl","removeEventListenerImpl","triggerEvent","ajaxHelper","removeElement","addClassToElement","removeClassFromElement","toggleClassOnElement","takeClassForElement","internalEval","internalAPI","addTriggerHandler","bodyContains","canAccessLocalStorage","findThisElement","filterValues","getAttributeValue","getClosestAttributeValue","getClosestMatch","getExpressionVars","getHeaders","getInternalData","getSwapSpecification","getTriggerSpecs","makeFragment","mergeObjects","makeSettleInfo","oobSwap","querySelectorExt","settleImmediately","shouldCancel","triggerErrorEvent","withExtensions","VERBS","VERB_SELECTOR","verb","interval","NaN","getRawAttribute","qualifiedName","parentElt","parentElement","ShadowRoot","getDocument","getRootNode","global","composed","getAttributeValueWithDisinheritance","initialElement","ancestor","attributeValue","disinherit","inherit","closestAttr","asElement","matchesFunction","matchesSelector","msMatchesSelector","mozMatchesSelector","webkitMatchesSelector","oMatchesSelector","getStartTag","exec","parseHTML","resp","takeChildrenFor","fragment","append","duplicateScript","script","newScript","nonce","isJavaScriptScriptNode","normalizeScriptTags","logError","response","responseWithNoHead","startTag","DocumentFragment","titleElement","maybeCall","func","isType","isFunction","isRawObject","toArray","returnArr","isScrolledIntoView","rect","elemTop","elemBottom","bottom","splitOnWhitespace","obj1","obj2","parseJSON","jString","removeItem","normalizePath","URL","pathname","maybeEval","eval","detail","eltOrSelector","getWindow","resolveTarget","asHtmlElement","asString","asParentNode","Document","clazz","prefix","substring","suffix","normalizeSelector","trimmedSelector","querySelectorAllExt","chevronsCount","unprocessedParts","shift","nextElementSibling","scanForwardQuery","previousElementSibling","scanBackwardsQuery","standardSelector","rootNode","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","DOCUMENT_POSITION_FOLLOWING","processEventArgs","arg1","arg2","arg3","arg4","listener","eventArgs","DUMMY_ELT","findAttributeTargets","attrTarget","targetStr","boosted","shouldSettleAttribute","cloneAttributes","mergeTo","mergeFrom","isInlineSwap","swapStyle","extensions","getExtensions","extension","oobValue","oobElement","settleInfo","targets","oobElementClone","createDocumentFragment","beforeSwapDetails","shouldSwap","handlePreservedElements","swapWithStyle","restorePreservedElements","elts","pantry","preservedElt","existingElement","moveBefore","insertAdjacentHTML","replaceChild","handleAttributes","newNode","normalizedId","normalizedTag","oldNode","newAttributes","tasks","makeAjaxLoadTask","processFocus","autoFocusedElt","insertNodesBefore","firstChild","nodeType","TEXT_NODE","COMMENT_NODE","stringHash","hash","charCodeAt","attributeHash","deInitOnHandlers","internalData","onHandlers","handlerInfo","deInitNode","listenerInfos","cleanUpElement","swapOuterHTML","swapInnerHTML","newElt","eltBeforeNewContent","previousSibling","nextSibling","swapAfterBegin","swapBeforeBegin","swapBeforeEnd","swapAfterEnd","swapDelete","ext","newElements","handleSwap","findAndSwapOobElements","oobElts","swapSpec","swapOptions","contextElement","activeElt","selectionInfo","selectionStart","selectionEnd","selectOOB","oobSelectValues","oobSelectValue","newFragment","newActiveElt","focusOptions","preventScroll","focusScroll","setSelectionRange","eventInfo","afterSwapCallback","handleTitle","doSettle","task","anchor","anchorTarget","scrollIntoView","block","behavior","updateScrollState","afterSettleCallback","settleDelay","handleTriggerHeader","xhr","header","triggerBody","getResponseHeader","triggers","eventNames","WHITESPACE","WHITESPACE_OR_COMMA","SYMBOL_START","SYMBOL_CONT","STRINGISH_START","NOT_WHITESPACE","COMBINED_SELECTOR_START","COMBINED_SELECTOR_END","tokenizeString","tokens","startPosition","startChar","symbol","isPossibleRelativeReference","last","maybeGenerateConditional","bracketCount","conditionalSource","conditionFunction","source","consumeUntil","consumeCSSSelector","INPUT_SELECTOR","parseAndCacheTrigger","explicitTrigger","triggerSpecs","initialLength","every","pollInterval","eventFilter","triggerSpec","changed","consume","from_arg","throttle","queue","cancelPolling","cancelled","processPolling","handler","spec","nodeData","maybeFilterEvent","makeEvent","isLocalLink","hostname","eltIsDisabled","boostElement","HTMLAnchorElement","rawAttribute","issueAjaxRequest","ignoreBoostedAnchorCtrlClick","ctrlKey","metaKey","explicitCancel","elementData","eltsToListenOn","lastValue","eltToListenOn","eventListener","eventData","handledFor","triggeredOnce","delayed","windowIsScrolling","scrollHandler","initScrollHandler","setInterval","maybeReveal","initHash","loadImmediately","load","loaded","processVerbs","explicitAction","observerOptions","root","IntersectionObserver","isIntersecting","firstInitCompleted","polling","shouldProcessHxOn","HX_ON_QUERY","XPathEvaluator","createExpression","processHXOnRoot","elements","iterateNext","findHxOnWildcardElements","findElementsToProcess","boostedSelector","extensionSelectors","getSelectors","selectors","flat","maybeSetLastButtonClicked","getRelatedFormData","lastButtonClicked","maybeUnsetLastButtonClicked","form","initButtonTracking","addHxOnEventHandler","processHxOnWildcard","afterOnPosition","nextChar","initNode","attrHash","kebabEventName","CustomEvent","bubbles","cancelable","createEvent","initCustomEvent","ignoreEventForLogging","toDo","msg","errorInfo","eventResult","dispatchEvent","kebabName","kebabedEvent","onEvent","defaultPrevented","currentPathForHistory","getHistoryElement","saveToHistoryCache","rootElt","cleanInnerHtmlForHistory","scroll","historyCache","newHistoryItem","cause","getCachedHistory","clone","saveCurrentPageToHistory","disableHistoryCache","historyElt","history","replaceState","pushUrlIntoHistory","pushState","replaceUrlInHistory","loadHistoryFromServer","request","XMLHttpRequest","details","open","setRequestHeader","onload","historyElement","cacheMiss","serverResponse","send","restoreHistory","cached","reload","addRequestIndicatorClasses","indicators","ic","requestCount","disableElements","disabledElts","disabledElement","removeRequestIndicators","ele","haveSeenNode","processed","isSameNode","shouldInclude","addValueToFormData","formData","removeValueFromFormData","getAll","processInputValue","validate","HTMLSelectElement","multiple","HTMLInputElement","validateElement","HTMLFormElement","FormData","File","willValidate","validity","overrideFormData","receiver","donor","priorityFormData","noValidate","formNoValidate","descendant","formDataProxy","appendParam","returnStr","realValue","urlEncode","formDataFromObject","prompt","headers","getValuesForElement","inputValues","paramsValue","newValues","isAnchorLink","swapInfoOverride","swapInfo","swapDelay","scrollVal","splitSpec","selectorVal","scrollTarget","showVal","showTarget","focusScrollVal","usesFormData","encodeParamsForBody","filteredParameters","encodedParameters","encodeParameters","first","evalAsDefault","varsValues","evaluateValue","toEval","defaultVal","getHXVarsForElement","expressionVars","getHXValsForElement","safelySetHeaderValue","headerValue","getPathFromResponse","responseURL","hasHeader","regexp","getAllResponseHeaders","targetOverride","returnPromise","resolvedTarget","swapOverride","hierarchyForElt","verifyPath","requestConfig","sameHost","origin","Blob","formDataArrayProxy","array","Proxy","Reflect","fromEntries","deleteProperty","ownKeys","getOwnPropertyDescriptor","prop","etc","confirmed","promise","_resolve","_reject","responseHandler","handleAjaxResponse","eltData","submitter","buttonPath","buttonVerb","confirmQuestion","triggeringEvent","issueRequest","skipConfirmation","syncElt","syncStrategy","queueStrategy","abortable","syncStrings","queuedRequests","endRequestLock","queuedRequest","promptQuestion","promptResponse","rawFormData","allFormData","filteredFormData","requestAttrValues","eltIsBoosted","useUrlParams","parameters","unfilteredFormData","unfilteredParameters","credentials","splitPath","pathNoAnchor","finalPath","overrideMimeType","noHeaders","responseInfo","pathInfo","requestPath","finalRequestPath","responsePath","hierarchy","keepIndicators","disableElts","secondaryTriggerElt","parentEltInHierarchy","onerror","onabort","ontimeout","upload","lengthComputable","total","determineHistoryUpdates","pathFromHeaders","typeFromHeaders","pushUrl","replaceUrl","elementIsBoosted","saveType","codeMatches","responseHandlingConfig","RegExp","resolveResponseHandling","responseHandlingElement","titleElt","responseInfoSelect","redirectPath","redirectSwapSpec","shouldRefresh","historyUpdate","isError","selectOverride","failed","successful","transformResponse","settleResolve","settleReject","doSwap","finalElt","shouldTransition","startViewTransition","settlePromise","innerDoSwap","extensionBase","extensionsToReturn","extensionsToIgnore","extensionsForElement","extensionName","isReady","readyState","insertIndicatorStyles","nonceAttribute","getMetaConfig","mergeMetaConfig","metaConfig","restoredElts","abort","originalPopstate","onpopstate","removeQueryParam","searchParams","isPWA","standalone","buttonStyling","showUnexpectedErrorMessage"],"mappings":"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","file":"program_detail.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 208);\n","module.exports = require(\"regenerator-runtime\");\n","/*!\n * JavaScript Cookie v2.2.1\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader;\n\tif (typeof define === 'function' && define.amd) {\n\t\tdefine(factory);\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (typeof exports === 'object') {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction decode (s) {\n\t\treturn s.replace(/(%[0-9A-Z]{2})+/g, decodeURIComponent);\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api() {}\n\n\t\tfunction set (key, value, attributes) {\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tattributes = extend({\n\t\t\t\tpath: '/'\n\t\t\t}, api.defaults, attributes);\n\n\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\tattributes.expires = new Date(new Date() * 1 + attributes.expires * 864e+5);\n\t\t\t}\n\n\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\ttry {\n\t\t\t\tvar result = JSON.stringify(value);\n\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\tvalue = result;\n\t\t\t\t}\n\t\t\t} catch (e) {}\n\n\t\t\tvalue = converter.write ?\n\t\t\t\tconverter.write(value, key) :\n\t\t\t\tencodeURIComponent(String(value))\n\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\n\t\t\tkey = encodeURIComponent(String(key))\n\t\t\t\t.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent)\n\t\t\t\t.replace(/[\\(\\)]/g, escape);\n\n\t\t\tvar stringifiedAttributes = '';\n\t\t\tfor (var attributeName in attributes) {\n\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Considers RFC 6265 section 5.2:\n\t\t\t\t// ...\n\t\t\t\t// 3.  If the remaining unparsed-attributes contains a %x3B (\";\")\n\t\t\t\t//     character:\n\t\t\t\t// Consume the characters of the unparsed-attributes up to,\n\t\t\t\t// not including, the first %x3B (\";\") character.\n\t\t\t\t// ...\n\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName].split(';')[0];\n\t\t\t}\n\n\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t}\n\n\t\tfunction get (key, json) {\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar jar = {};\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all.\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (!json && cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = decode(parts[0]);\n\t\t\t\t\tcookie = (converter.read || converter)(cookie, name) ||\n\t\t\t\t\t\tdecode(cookie);\n\n\t\t\t\t\tif (json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tjar[name] = cookie;\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn key ? jar[key] : jar;\n\t\t}\n\n\t\tapi.set = set;\n\t\tapi.get = function (key) {\n\t\t\treturn get(key, false /* read as raw */);\n\t\t};\n\t\tapi.getJSON = function (key) {\n\t\t\treturn get(key, true /* read as json */);\n\t\t};\n\t\tapi.remove = function (key, attributes) {\n\t\t\tset(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.defaults = {};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n","/*!\n* sweetalert2 v11.17.2\n* Released under the MIT License.\n*/\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Sweetalert2 = factory());\n})(this, (function () { 'use strict';\n\n  function _assertClassBrand(e, t, n) {\n    if (\"function\" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;\n    throw new TypeError(\"Private element is not present on this object\");\n  }\n  function _checkPrivateRedeclaration(e, t) {\n    if (t.has(e)) throw new TypeError(\"Cannot initialize the same private elements twice on an object\");\n  }\n  function _classPrivateFieldGet2(s, a) {\n    return s.get(_assertClassBrand(s, a));\n  }\n  function _classPrivateFieldInitSpec(e, t, a) {\n    _checkPrivateRedeclaration(e, t), t.set(e, a);\n  }\n  function _classPrivateFieldSet2(s, a, r) {\n    return s.set(_assertClassBrand(s, a), r), r;\n  }\n\n  const RESTORE_FOCUS_TIMEOUT = 100;\n\n  /** @type {GlobalState} */\n  const globalState = {};\n  const focusPreviousActiveElement = () => {\n    if (globalState.previousActiveElement instanceof HTMLElement) {\n      globalState.previousActiveElement.focus();\n      globalState.previousActiveElement = null;\n    } else if (document.body) {\n      document.body.focus();\n    }\n  };\n\n  /**\n   * Restore previous active (focused) element\n   *\n   * @param {boolean} returnFocus\n   * @returns {Promise<void>}\n   */\n  const restoreActiveElement = returnFocus => {\n    return new Promise(resolve => {\n      if (!returnFocus) {\n        return resolve();\n      }\n      const x = window.scrollX;\n      const y = window.scrollY;\n      globalState.restoreFocusTimeout = setTimeout(() => {\n        focusPreviousActiveElement();\n        resolve();\n      }, RESTORE_FOCUS_TIMEOUT); // issues/900\n\n      window.scrollTo(x, y);\n    });\n  };\n\n  const swalPrefix = 'swal2-';\n\n  /**\n   * @typedef {Record<SwalClass, string>} SwalClasses\n   */\n\n  /**\n   * @typedef {'success' | 'warning' | 'info' | 'question' | 'error'} SwalIcon\n   * @typedef {Record<SwalIcon, string>} SwalIcons\n   */\n\n  /** @type {SwalClass[]} */\n  const classNames = ['container', 'shown', 'height-auto', 'iosfix', 'popup', 'modal', 'no-backdrop', 'no-transition', 'toast', 'toast-shown', 'show', 'hide', 'close', 'title', 'html-container', 'actions', 'confirm', 'deny', 'cancel', 'default-outline', 'footer', 'icon', 'icon-content', 'image', 'input', 'file', 'range', 'select', 'radio', 'checkbox', 'label', 'textarea', 'inputerror', 'input-label', 'validation-message', 'progress-steps', 'active-progress-step', 'progress-step', 'progress-step-line', 'loader', 'loading', 'styled', 'top', 'top-start', 'top-end', 'top-left', 'top-right', 'center', 'center-start', 'center-end', 'center-left', 'center-right', 'bottom', 'bottom-start', 'bottom-end', 'bottom-left', 'bottom-right', 'grow-row', 'grow-column', 'grow-fullscreen', 'rtl', 'timer-progress-bar', 'timer-progress-bar-container', 'scrollbar-measure', 'icon-success', 'icon-warning', 'icon-info', 'icon-question', 'icon-error', 'draggable', 'dragging'];\n  const swalClasses = classNames.reduce((acc, className) => {\n    acc[className] = swalPrefix + className;\n    return acc;\n  }, /** @type {SwalClasses} */{});\n\n  /** @type {SwalIcon[]} */\n  const icons = ['success', 'warning', 'info', 'question', 'error'];\n  const iconTypes = icons.reduce((acc, icon) => {\n    acc[icon] = swalPrefix + icon;\n    return acc;\n  }, /** @type {SwalIcons} */{});\n\n  const consolePrefix = 'SweetAlert2:';\n\n  /**\n   * Capitalize the first letter of a string\n   *\n   * @param {string} str\n   * @returns {string}\n   */\n  const capitalizeFirstLetter = str => str.charAt(0).toUpperCase() + str.slice(1);\n\n  /**\n   * Standardize console warnings\n   *\n   * @param {string | string[]} message\n   */\n  const warn = message => {\n    console.warn(`${consolePrefix} ${typeof message === 'object' ? message.join(' ') : message}`);\n  };\n\n  /**\n   * Standardize console errors\n   *\n   * @param {string} message\n   */\n  const error = message => {\n    console.error(`${consolePrefix} ${message}`);\n  };\n\n  /**\n   * Private global state for `warnOnce`\n   *\n   * @type {string[]}\n   * @private\n   */\n  const previousWarnOnceMessages = [];\n\n  /**\n   * Show a console warning, but only if it hasn't already been shown\n   *\n   * @param {string} message\n   */\n  const warnOnce = message => {\n    if (!previousWarnOnceMessages.includes(message)) {\n      previousWarnOnceMessages.push(message);\n      warn(message);\n    }\n  };\n\n  /**\n   * Show a one-time console warning about deprecated params/methods\n   *\n   * @param {string} deprecatedParam\n   * @param {string?} useInstead\n   */\n  const warnAboutDeprecation = function (deprecatedParam) {\n    let useInstead = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    warnOnce(`\"${deprecatedParam}\" is deprecated and will be removed in the next major release.${useInstead ? ` Use \"${useInstead}\" instead.` : ''}`);\n  };\n\n  /**\n   * If `arg` is a function, call it (with no arguments or context) and return the result.\n   * Otherwise, just pass the value through\n   *\n   * @param {Function | any} arg\n   * @returns {any}\n   */\n  const callIfFunction = arg => typeof arg === 'function' ? arg() : arg;\n\n  /**\n   * @param {any} arg\n   * @returns {boolean}\n   */\n  const hasToPromiseFn = arg => arg && typeof arg.toPromise === 'function';\n\n  /**\n   * @param {any} arg\n   * @returns {Promise<any>}\n   */\n  const asPromise = arg => hasToPromiseFn(arg) ? arg.toPromise() : Promise.resolve(arg);\n\n  /**\n   * @param {any} arg\n   * @returns {boolean}\n   */\n  const isPromise = arg => arg && Promise.resolve(arg) === arg;\n\n  /**\n   * Gets the popup container which contains the backdrop and the popup itself.\n   *\n   * @returns {HTMLElement | null}\n   */\n  const getContainer = () => document.body.querySelector(`.${swalClasses.container}`);\n\n  /**\n   * @param {string} selectorString\n   * @returns {HTMLElement | null}\n   */\n  const elementBySelector = selectorString => {\n    const container = getContainer();\n    return container ? container.querySelector(selectorString) : null;\n  };\n\n  /**\n   * @param {string} className\n   * @returns {HTMLElement | null}\n   */\n  const elementByClass = className => {\n    return elementBySelector(`.${className}`);\n  };\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getPopup = () => elementByClass(swalClasses.popup);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getIcon = () => elementByClass(swalClasses.icon);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getIconContent = () => elementByClass(swalClasses['icon-content']);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getTitle = () => elementByClass(swalClasses.title);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getHtmlContainer = () => elementByClass(swalClasses['html-container']);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getImage = () => elementByClass(swalClasses.image);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getProgressSteps = () => elementByClass(swalClasses['progress-steps']);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getValidationMessage = () => elementByClass(swalClasses['validation-message']);\n\n  /**\n   * @returns {HTMLButtonElement | null}\n   */\n  const getConfirmButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.confirm}`));\n\n  /**\n   * @returns {HTMLButtonElement | null}\n   */\n  const getCancelButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.cancel}`));\n\n  /**\n   * @returns {HTMLButtonElement | null}\n   */\n  const getDenyButton = () => (/** @type {HTMLButtonElement} */elementBySelector(`.${swalClasses.actions} .${swalClasses.deny}`));\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getInputLabel = () => elementByClass(swalClasses['input-label']);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getLoader = () => elementBySelector(`.${swalClasses.loader}`);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getActions = () => elementByClass(swalClasses.actions);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getFooter = () => elementByClass(swalClasses.footer);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getTimerProgressBar = () => elementByClass(swalClasses['timer-progress-bar']);\n\n  /**\n   * @returns {HTMLElement | null}\n   */\n  const getCloseButton = () => elementByClass(swalClasses.close);\n\n  // https://github.com/jkup/focusable/blob/master/index.js\n  const focusable = `\n  a[href],\n  area[href],\n  input:not([disabled]),\n  select:not([disabled]),\n  textarea:not([disabled]),\n  button:not([disabled]),\n  iframe,\n  object,\n  embed,\n  [tabindex=\"0\"],\n  [contenteditable],\n  audio[controls],\n  video[controls],\n  summary\n`;\n  /**\n   * @returns {HTMLElement[]}\n   */\n  const getFocusableElements = () => {\n    const popup = getPopup();\n    if (!popup) {\n      return [];\n    }\n    /** @type {NodeListOf<HTMLElement>} */\n    const focusableElementsWithTabindex = popup.querySelectorAll('[tabindex]:not([tabindex=\"-1\"]):not([tabindex=\"0\"])');\n    const focusableElementsWithTabindexSorted = Array.from(focusableElementsWithTabindex)\n    // sort according to tabindex\n    .sort((a, b) => {\n      const tabindexA = parseInt(a.getAttribute('tabindex') || '0');\n      const tabindexB = parseInt(b.getAttribute('tabindex') || '0');\n      if (tabindexA > tabindexB) {\n        return 1;\n      } else if (tabindexA < tabindexB) {\n        return -1;\n      }\n      return 0;\n    });\n\n    /** @type {NodeListOf<HTMLElement>} */\n    const otherFocusableElements = popup.querySelectorAll(focusable);\n    const otherFocusableElementsFiltered = Array.from(otherFocusableElements).filter(el => el.getAttribute('tabindex') !== '-1');\n    return [...new Set(focusableElementsWithTabindexSorted.concat(otherFocusableElementsFiltered))].filter(el => isVisible$1(el));\n  };\n\n  /**\n   * @returns {boolean}\n   */\n  const isModal = () => {\n    return hasClass(document.body, swalClasses.shown) && !hasClass(document.body, swalClasses['toast-shown']) && !hasClass(document.body, swalClasses['no-backdrop']);\n  };\n\n  /**\n   * @returns {boolean}\n   */\n  const isToast = () => {\n    const popup = getPopup();\n    if (!popup) {\n      return false;\n    }\n    return hasClass(popup, swalClasses.toast);\n  };\n\n  /**\n   * @returns {boolean}\n   */\n  const isLoading = () => {\n    const popup = getPopup();\n    if (!popup) {\n      return false;\n    }\n    return popup.hasAttribute('data-loading');\n  };\n\n  /**\n   * Securely set innerHTML of an element\n   * https://github.com/sweetalert2/sweetalert2/issues/1926\n   *\n   * @param {HTMLElement} elem\n   * @param {string} html\n   */\n  const setInnerHtml = (elem, html) => {\n    elem.textContent = '';\n    if (html) {\n      const parser = new DOMParser();\n      const parsed = parser.parseFromString(html, `text/html`);\n      const head = parsed.querySelector('head');\n      if (head) {\n        Array.from(head.childNodes).forEach(child => {\n          elem.appendChild(child);\n        });\n      }\n      const body = parsed.querySelector('body');\n      if (body) {\n        Array.from(body.childNodes).forEach(child => {\n          if (child instanceof HTMLVideoElement || child instanceof HTMLAudioElement) {\n            elem.appendChild(child.cloneNode(true)); // https://github.com/sweetalert2/sweetalert2/issues/2507\n          } else {\n            elem.appendChild(child);\n          }\n        });\n      }\n    }\n  };\n\n  /**\n   * @param {HTMLElement} elem\n   * @param {string} className\n   * @returns {boolean}\n   */\n  const hasClass = (elem, className) => {\n    if (!className) {\n      return false;\n    }\n    const classList = className.split(/\\s+/);\n    for (let i = 0; i < classList.length; i++) {\n      if (!elem.classList.contains(classList[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n\n  /**\n   * @param {HTMLElement} elem\n   * @param {SweetAlertOptions} params\n   */\n  const removeCustomClasses = (elem, params) => {\n    Array.from(elem.classList).forEach(className => {\n      if (!Object.values(swalClasses).includes(className) && !Object.values(iconTypes).includes(className) && !Object.values(params.showClass || {}).includes(className)) {\n        elem.classList.remove(className);\n      }\n    });\n  };\n\n  /**\n   * @param {HTMLElement} elem\n   * @param {SweetAlertOptions} params\n   * @param {string} className\n   */\n  const applyCustomClass = (elem, params, className) => {\n    removeCustomClasses(elem, params);\n    if (!params.customClass) {\n      return;\n    }\n    const customClass = params.customClass[(/** @type {keyof SweetAlertCustomClass} */className)];\n    if (!customClass) {\n      return;\n    }\n    if (typeof customClass !== 'string' && !customClass.forEach) {\n      warn(`Invalid type of customClass.${className}! Expected string or iterable object, got \"${typeof customClass}\"`);\n      return;\n    }\n    addClass(elem, customClass);\n  };\n\n  /**\n   * @param {HTMLElement} popup\n   * @param {import('./renderers/renderInput').InputClass | SweetAlertInput} inputClass\n   * @returns {HTMLInputElement | null}\n   */\n  const getInput$1 = (popup, inputClass) => {\n    if (!inputClass) {\n      return null;\n    }\n    switch (inputClass) {\n      case 'select':\n      case 'textarea':\n      case 'file':\n        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses[inputClass]}`);\n      case 'checkbox':\n        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.checkbox} input`);\n      case 'radio':\n        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:checked`) || popup.querySelector(`.${swalClasses.popup} > .${swalClasses.radio} input:first-child`);\n      case 'range':\n        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.range} input`);\n      default:\n        return popup.querySelector(`.${swalClasses.popup} > .${swalClasses.input}`);\n    }\n  };\n\n  /**\n   * @param {HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement} input\n   */\n  const focusInput = input => {\n    input.focus();\n\n    // place cursor at end of text in text input\n    if (input.type !== 'file') {\n      // http://stackoverflow.com/a/2345915\n      const val = input.value;\n      input.value = '';\n      input.value = val;\n    }\n  };\n\n  /**\n   * @param {HTMLElement | HTMLElement[] | null} target\n   * @param {string | string[] | readonly string[] | undefined} classList\n   * @param {boolean} condition\n   */\n  const toggleClass = (target, classList, condition) => {\n    if (!target || !classList) {\n      return;\n    }\n    if (typeof classList === 'string') {\n      classList = classList.split(/\\s+/).filter(Boolean);\n    }\n    classList.forEach(className => {\n      if (Array.isArray(target)) {\n        target.forEach(elem => {\n          if (condition) {\n            elem.classList.add(className);\n          } else {\n            elem.classList.remove(className);\n          }\n        });\n      } else {\n        if (condition) {\n          target.classList.add(className);\n        } else {\n          target.classList.remove(className);\n        }\n      }\n    });\n  };\n\n  /**\n   * @param {HTMLElement | HTMLElement[] | null} target\n   * @param {string | string[] | readonly string[] | undefined} classList\n   */\n  const addClass = (target, classList) => {\n    toggleClass(target, classList, true);\n  };\n\n  /**\n   * @param {HTMLElement | HTMLElement[] | null} target\n   * @param {string | string[] | readonly string[] | undefined} classList\n   */\n  const removeClass = (target, classList) => {\n    toggleClass(target, classList, false);\n  };\n\n  /**\n   * Get direct child of an element by class name\n   *\n   * @param {HTMLElement} elem\n   * @param {string} className\n   * @returns {HTMLElement | undefined}\n   */\n  const getDirectChildByClass = (elem, className) => {\n    const children = Array.from(elem.children);\n    for (let i = 0; i < children.length; i++) {\n      const child = children[i];\n      if (child instanceof HTMLElement && hasClass(child, className)) {\n        return child;\n      }\n    }\n  };\n\n  /**\n   * @param {HTMLElement} elem\n   * @param {string} property\n   * @param {*} value\n   */\n  const applyNumericalStyle = (elem, property, value) => {\n    if (value === `${parseInt(value)}`) {\n      value = parseInt(value);\n    }\n    if (value || parseInt(value) === 0) {\n      elem.style.setProperty(property, typeof value === 'number' ? `${value}px` : value);\n    } else {\n      elem.style.removeProperty(property);\n    }\n  };\n\n  /**\n   * @param {HTMLElement | null} elem\n   * @param {string} display\n   */\n  const show = function (elem) {\n    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'flex';\n    if (!elem) {\n      return;\n    }\n    elem.style.display = display;\n  };\n\n  /**\n   * @param {HTMLElement | null} elem\n   */\n  const hide = elem => {\n    if (!elem) {\n      return;\n    }\n    elem.style.display = 'none';\n  };\n\n  /**\n   * @param {HTMLElement | null} elem\n   * @param {string} display\n   */\n  const showWhenInnerHtmlPresent = function (elem) {\n    let display = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'block';\n    if (!elem) {\n      return;\n    }\n    new MutationObserver(() => {\n      toggle(elem, elem.innerHTML, display);\n    }).observe(elem, {\n      childList: true,\n      subtree: true\n    });\n  };\n\n  /**\n   * @param {HTMLElement} parent\n   * @param {string} selector\n   * @param {string} property\n   * @param {string} value\n   */\n  const setStyle = (parent, selector, property, value) => {\n    /** @type {HTMLElement | null} */\n    const el = parent.querySelector(selector);\n    if (el) {\n      el.style.setProperty(property, value);\n    }\n  };\n\n  /**\n   * @param {HTMLElement} elem\n   * @param {any} condition\n   * @param {string} display\n   */\n  const toggle = function (elem, condition) {\n    let display = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex';\n    if (condition) {\n      show(elem, display);\n    } else {\n      hide(elem);\n    }\n  };\n\n  /**\n   * borrowed from jquery $(elem).is(':visible') implementation\n   *\n   * @param {HTMLElement | null} elem\n   * @returns {boolean}\n   */\n  const isVisible$1 = elem => !!(elem && (elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length));\n\n  /**\n   * @returns {boolean}\n   */\n  const allButtonsAreHidden = () => !isVisible$1(getConfirmButton()) && !isVisible$1(getDenyButton()) && !isVisible$1(getCancelButton());\n\n  /**\n   * @param {HTMLElement} elem\n   * @returns {boolean}\n   */\n  const isScrollable = elem => !!(elem.scrollHeight > elem.clientHeight);\n\n  /**\n   * borrowed from https://stackoverflow.com/a/46352119\n   *\n   * @param {HTMLElement} elem\n   * @returns {boolean}\n   */\n  const hasCssAnimation = elem => {\n    const style = window.getComputedStyle(elem);\n    const animDuration = parseFloat(style.getPropertyValue('animation-duration') || '0');\n    const transDuration = parseFloat(style.getPropertyValue('transition-duration') || '0');\n    return animDuration > 0 || transDuration > 0;\n  };\n\n  /**\n   * @param {number} timer\n   * @param {boolean} reset\n   */\n  const animateTimerProgressBar = function (timer) {\n    let reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    const timerProgressBar = getTimerProgressBar();\n    if (!timerProgressBar) {\n      return;\n    }\n    if (isVisible$1(timerProgressBar)) {\n      if (reset) {\n        timerProgressBar.style.transition = 'none';\n        timerProgressBar.style.width = '100%';\n      }\n      setTimeout(() => {\n        timerProgressBar.style.transition = `width ${timer / 1000}s linear`;\n        timerProgressBar.style.width = '0%';\n      }, 10);\n    }\n  };\n  const stopTimerProgressBar = () => {\n    const timerProgressBar = getTimerProgressBar();\n    if (!timerProgressBar) {\n      return;\n    }\n    const timerProgressBarWidth = parseInt(window.getComputedStyle(timerProgressBar).width);\n    timerProgressBar.style.removeProperty('transition');\n    timerProgressBar.style.width = '100%';\n    const timerProgressBarFullWidth = parseInt(window.getComputedStyle(timerProgressBar).width);\n    const timerProgressBarPercent = timerProgressBarWidth / timerProgressBarFullWidth * 100;\n    timerProgressBar.style.width = `${timerProgressBarPercent}%`;\n  };\n\n  /**\n   * Detect Node env\n   *\n   * @returns {boolean}\n   */\n  const isNodeEnv = () => typeof window === 'undefined' || typeof document === 'undefined';\n\n  const sweetHTML = `\n <div aria-labelledby=\"${swalClasses.title}\" aria-describedby=\"${swalClasses['html-container']}\" class=\"${swalClasses.popup}\" tabindex=\"-1\">\n   <button type=\"button\" class=\"${swalClasses.close}\"></button>\n   <ul class=\"${swalClasses['progress-steps']}\"></ul>\n   <div class=\"${swalClasses.icon}\"></div>\n   <img class=\"${swalClasses.image}\" />\n   <h2 class=\"${swalClasses.title}\" id=\"${swalClasses.title}\"></h2>\n   <div class=\"${swalClasses['html-container']}\" id=\"${swalClasses['html-container']}\"></div>\n   <input class=\"${swalClasses.input}\" id=\"${swalClasses.input}\" />\n   <input type=\"file\" class=\"${swalClasses.file}\" />\n   <div class=\"${swalClasses.range}\">\n     <input type=\"range\" />\n     <output></output>\n   </div>\n   <select class=\"${swalClasses.select}\" id=\"${swalClasses.select}\"></select>\n   <div class=\"${swalClasses.radio}\"></div>\n   <label class=\"${swalClasses.checkbox}\">\n     <input type=\"checkbox\" id=\"${swalClasses.checkbox}\" />\n     <span class=\"${swalClasses.label}\"></span>\n   </label>\n   <textarea class=\"${swalClasses.textarea}\" id=\"${swalClasses.textarea}\"></textarea>\n   <div class=\"${swalClasses['validation-message']}\" id=\"${swalClasses['validation-message']}\"></div>\n   <div class=\"${swalClasses.actions}\">\n     <div class=\"${swalClasses.loader}\"></div>\n     <button type=\"button\" class=\"${swalClasses.confirm}\"></button>\n     <button type=\"button\" class=\"${swalClasses.deny}\"></button>\n     <button type=\"button\" class=\"${swalClasses.cancel}\"></button>\n   </div>\n   <div class=\"${swalClasses.footer}\"></div>\n   <div class=\"${swalClasses['timer-progress-bar-container']}\">\n     <div class=\"${swalClasses['timer-progress-bar']}\"></div>\n   </div>\n </div>\n`.replace(/(^|\\n)\\s*/g, '');\n\n  /**\n   * @returns {boolean}\n   */\n  const resetOldContainer = () => {\n    const oldContainer = getContainer();\n    if (!oldContainer) {\n      return false;\n    }\n    oldContainer.remove();\n    removeClass([document.documentElement, document.body], [swalClasses['no-backdrop'], swalClasses['toast-shown'], swalClasses['has-column']]);\n    return true;\n  };\n  const resetValidationMessage$1 = () => {\n    globalState.currentInstance.resetValidationMessage();\n  };\n  const addInputChangeListeners = () => {\n    const popup = getPopup();\n    const input = getDirectChildByClass(popup, swalClasses.input);\n    const file = getDirectChildByClass(popup, swalClasses.file);\n    /** @type {HTMLInputElement} */\n    const range = popup.querySelector(`.${swalClasses.range} input`);\n    /** @type {HTMLOutputElement} */\n    const rangeOutput = popup.querySelector(`.${swalClasses.range} output`);\n    const select = getDirectChildByClass(popup, swalClasses.select);\n    /** @type {HTMLInputElement} */\n    const checkbox = popup.querySelector(`.${swalClasses.checkbox} input`);\n    const textarea = getDirectChildByClass(popup, swalClasses.textarea);\n    input.oninput = resetValidationMessage$1;\n    file.onchange = resetValidationMessage$1;\n    select.onchange = resetValidationMessage$1;\n    checkbox.onchange = resetValidationMessage$1;\n    textarea.oninput = resetValidationMessage$1;\n    range.oninput = () => {\n      resetValidationMessage$1();\n      rangeOutput.value = range.value;\n    };\n    range.onchange = () => {\n      resetValidationMessage$1();\n      rangeOutput.value = range.value;\n    };\n  };\n\n  /**\n   * @param {string | HTMLElement} target\n   * @returns {HTMLElement}\n   */\n  const getTarget = target => typeof target === 'string' ? document.querySelector(target) : target;\n\n  /**\n   * @param {SweetAlertOptions} params\n   */\n  const setupAccessibility = params => {\n    const popup = getPopup();\n    popup.setAttribute('role', params.toast ? 'alert' : 'dialog');\n    popup.setAttribute('aria-live', params.toast ? 'polite' : 'assertive');\n    if (!params.toast) {\n      popup.setAttribute('aria-modal', 'true');\n    }\n  };\n\n  /**\n   * @param {HTMLElement} targetElement\n   */\n  const setupRTL = targetElement => {\n    if (window.getComputedStyle(targetElement).direction === 'rtl') {\n      addClass(getContainer(), swalClasses.rtl);\n    }\n  };\n\n  /**\n   * Add modal + backdrop + no-war message for Russians to DOM\n   *\n   * @param {SweetAlertOptions} params\n   */\n  const init = params => {\n    // Clean up the old popup container if it exists\n    const oldContainerExisted = resetOldContainer();\n    if (isNodeEnv()) {\n      error('SweetAlert2 requires document to initialize');\n      return;\n    }\n    const container = document.createElement('div');\n    container.className = swalClasses.container;\n    if (oldContainerExisted) {\n      addClass(container, swalClasses['no-transition']);\n    }\n    setInnerHtml(container, sweetHTML);\n    container.dataset['swal2Theme'] = params.theme;\n    const targetElement = getTarget(params.target);\n    targetElement.appendChild(container);\n    setupAccessibility(params);\n    setupRTL(targetElement);\n    addInputChangeListeners();\n  };\n\n  /**\n   * @param {HTMLElement | object | string} param\n   * @param {HTMLElement} target\n   */\n  const parseHtmlToContainer = (param, target) => {\n    // DOM element\n    if (param instanceof HTMLElement) {\n      target.appendChild(param);\n    }\n\n    // Object\n    else if (typeof param === 'object') {\n      handleObject(param, target);\n    }\n\n    // Plain string\n    else if (param) {\n      setInnerHtml(target, param);\n    }\n  };\n\n  /**\n   * @param {any} param\n   * @param {HTMLElement} target\n   */\n  const handleObject = (param, target) => {\n    // JQuery element(s)\n    if (param.jquery) {\n      handleJqueryElem(target, param);\n    }\n\n    // For other objects use their string representation\n    else {\n      setInnerHtml(target, param.toString());\n    }\n  };\n\n  /**\n   * @param {HTMLElement} target\n   * @param {any} elem\n   */\n  const handleJqueryElem = (target, elem) => {\n    target.textContent = '';\n    if (0 in elem) {\n      for (let i = 0; i in elem; i++) {\n        target.appendChild(elem[i].cloneNode(true));\n      }\n    } else {\n      target.appendChild(elem.cloneNode(true));\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderActions = (instance, params) => {\n    const actions = getActions();\n    const loader = getLoader();\n    if (!actions || !loader) {\n      return;\n    }\n\n    // Actions (buttons) wrapper\n    if (!params.showConfirmButton && !params.showDenyButton && !params.showCancelButton) {\n      hide(actions);\n    } else {\n      show(actions);\n    }\n\n    // Custom class\n    applyCustomClass(actions, params, 'actions');\n\n    // Render all the buttons\n    renderButtons(actions, loader, params);\n\n    // Loader\n    setInnerHtml(loader, params.loaderHtml || '');\n    applyCustomClass(loader, params, 'loader');\n  };\n\n  /**\n   * @param {HTMLElement} actions\n   * @param {HTMLElement} loader\n   * @param {SweetAlertOptions} params\n   */\n  function renderButtons(actions, loader, params) {\n    const confirmButton = getConfirmButton();\n    const denyButton = getDenyButton();\n    const cancelButton = getCancelButton();\n    if (!confirmButton || !denyButton || !cancelButton) {\n      return;\n    }\n\n    // Render buttons\n    renderButton(confirmButton, 'confirm', params);\n    renderButton(denyButton, 'deny', params);\n    renderButton(cancelButton, 'cancel', params);\n    handleButtonsStyling(confirmButton, denyButton, cancelButton, params);\n    if (params.reverseButtons) {\n      if (params.toast) {\n        actions.insertBefore(cancelButton, confirmButton);\n        actions.insertBefore(denyButton, confirmButton);\n      } else {\n        actions.insertBefore(cancelButton, loader);\n        actions.insertBefore(denyButton, loader);\n        actions.insertBefore(confirmButton, loader);\n      }\n    }\n  }\n\n  /**\n   * @param {HTMLElement} confirmButton\n   * @param {HTMLElement} denyButton\n   * @param {HTMLElement} cancelButton\n   * @param {SweetAlertOptions} params\n   */\n  function handleButtonsStyling(confirmButton, denyButton, cancelButton, params) {\n    if (!params.buttonsStyling) {\n      removeClass([confirmButton, denyButton, cancelButton], swalClasses.styled);\n      return;\n    }\n    addClass([confirmButton, denyButton, cancelButton], swalClasses.styled);\n\n    // Buttons background colors\n    if (params.confirmButtonColor) {\n      confirmButton.style.backgroundColor = params.confirmButtonColor;\n      addClass(confirmButton, swalClasses['default-outline']);\n    }\n    if (params.denyButtonColor) {\n      denyButton.style.backgroundColor = params.denyButtonColor;\n      addClass(denyButton, swalClasses['default-outline']);\n    }\n    if (params.cancelButtonColor) {\n      cancelButton.style.backgroundColor = params.cancelButtonColor;\n      addClass(cancelButton, swalClasses['default-outline']);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} button\n   * @param {'confirm' | 'deny' | 'cancel'} buttonType\n   * @param {SweetAlertOptions} params\n   */\n  function renderButton(button, buttonType, params) {\n    const buttonName = /** @type {'Confirm' | 'Deny' | 'Cancel'} */capitalizeFirstLetter(buttonType);\n    toggle(button, params[`show${buttonName}Button`], 'inline-block');\n    setInnerHtml(button, params[`${buttonType}ButtonText`] || ''); // Set caption text\n    button.setAttribute('aria-label', params[`${buttonType}ButtonAriaLabel`] || ''); // ARIA label\n\n    // Add buttons custom classes\n    button.className = swalClasses[buttonType];\n    applyCustomClass(button, params, `${buttonType}Button`);\n  }\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderCloseButton = (instance, params) => {\n    const closeButton = getCloseButton();\n    if (!closeButton) {\n      return;\n    }\n    setInnerHtml(closeButton, params.closeButtonHtml || '');\n\n    // Custom class\n    applyCustomClass(closeButton, params, 'closeButton');\n    toggle(closeButton, params.showCloseButton);\n    closeButton.setAttribute('aria-label', params.closeButtonAriaLabel || '');\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderContainer = (instance, params) => {\n    const container = getContainer();\n    if (!container) {\n      return;\n    }\n    handleBackdropParam(container, params.backdrop);\n    handlePositionParam(container, params.position);\n    handleGrowParam(container, params.grow);\n\n    // Custom class\n    applyCustomClass(container, params, 'container');\n  };\n\n  /**\n   * @param {HTMLElement} container\n   * @param {SweetAlertOptions['backdrop']} backdrop\n   */\n  function handleBackdropParam(container, backdrop) {\n    if (typeof backdrop === 'string') {\n      container.style.background = backdrop;\n    } else if (!backdrop) {\n      addClass([document.documentElement, document.body], swalClasses['no-backdrop']);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} container\n   * @param {SweetAlertOptions['position']} position\n   */\n  function handlePositionParam(container, position) {\n    if (!position) {\n      return;\n    }\n    if (position in swalClasses) {\n      addClass(container, swalClasses[position]);\n    } else {\n      warn('The \"position\" parameter is not valid, defaulting to \"center\"');\n      addClass(container, swalClasses.center);\n    }\n  }\n\n  /**\n   * @param {HTMLElement} container\n   * @param {SweetAlertOptions['grow']} grow\n   */\n  function handleGrowParam(container, grow) {\n    if (!grow) {\n      return;\n    }\n    addClass(container, swalClasses[`grow-${grow}`]);\n  }\n\n  /**\n   * This module contains `WeakMap`s for each effectively-\"private  property\" that a `Swal` has.\n   * For example, to set the private property \"foo\" of `this` to \"bar\", you can `privateProps.foo.set(this, 'bar')`\n   * This is the approach that Babel will probably take to implement private methods/fields\n   *   https://github.com/tc39/proposal-private-methods\n   *   https://github.com/babel/babel/pull/7555\n   * Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*\n   *   then we can use that language feature.\n   */\n\n  var privateProps = {\n    innerParams: new WeakMap(),\n    domCache: new WeakMap()\n  };\n\n  /// <reference path=\"../../../../sweetalert2.d.ts\"/>\n\n\n  /** @type {InputClass[]} */\n  const inputClasses = ['input', 'file', 'range', 'select', 'radio', 'checkbox', 'textarea'];\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderInput = (instance, params) => {\n    const popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    const innerParams = privateProps.innerParams.get(instance);\n    const rerender = !innerParams || params.input !== innerParams.input;\n    inputClasses.forEach(inputClass => {\n      const inputContainer = getDirectChildByClass(popup, swalClasses[inputClass]);\n      if (!inputContainer) {\n        return;\n      }\n\n      // set attributes\n      setAttributes(inputClass, params.inputAttributes);\n\n      // set class\n      inputContainer.className = swalClasses[inputClass];\n      if (rerender) {\n        hide(inputContainer);\n      }\n    });\n    if (params.input) {\n      if (rerender) {\n        showInput(params);\n      }\n      // set custom class\n      setCustomClass(params);\n    }\n  };\n\n  /**\n   * @param {SweetAlertOptions} params\n   */\n  const showInput = params => {\n    if (!params.input) {\n      return;\n    }\n    if (!renderInputType[params.input]) {\n      error(`Unexpected type of input! Expected ${Object.keys(renderInputType).join(' | ')}, got \"${params.input}\"`);\n      return;\n    }\n    const inputContainer = getInputContainer(params.input);\n    if (!inputContainer) {\n      return;\n    }\n    const input = renderInputType[params.input](inputContainer, params);\n    show(inputContainer);\n\n    // input autofocus\n    if (params.inputAutoFocus) {\n      setTimeout(() => {\n        focusInput(input);\n      });\n    }\n  };\n\n  /**\n   * @param {HTMLInputElement} input\n   */\n  const removeAttributes = input => {\n    for (let i = 0; i < input.attributes.length; i++) {\n      const attrName = input.attributes[i].name;\n      if (!['id', 'type', 'value', 'style'].includes(attrName)) {\n        input.removeAttribute(attrName);\n      }\n    }\n  };\n\n  /**\n   * @param {InputClass} inputClass\n   * @param {SweetAlertOptions['inputAttributes']} inputAttributes\n   */\n  const setAttributes = (inputClass, inputAttributes) => {\n    const popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    const input = getInput$1(popup, inputClass);\n    if (!input) {\n      return;\n    }\n    removeAttributes(input);\n    for (const attr in inputAttributes) {\n      input.setAttribute(attr, inputAttributes[attr]);\n    }\n  };\n\n  /**\n   * @param {SweetAlertOptions} params\n   */\n  const setCustomClass = params => {\n    if (!params.input) {\n      return;\n    }\n    const inputContainer = getInputContainer(params.input);\n    if (inputContainer) {\n      applyCustomClass(inputContainer, params, 'input');\n    }\n  };\n\n  /**\n   * @param {HTMLInputElement | HTMLTextAreaElement} input\n   * @param {SweetAlertOptions} params\n   */\n  const setInputPlaceholder = (input, params) => {\n    if (!input.placeholder && params.inputPlaceholder) {\n      input.placeholder = params.inputPlaceholder;\n    }\n  };\n\n  /**\n   * @param {Input} input\n   * @param {Input} prependTo\n   * @param {SweetAlertOptions} params\n   */\n  const setInputLabel = (input, prependTo, params) => {\n    if (params.inputLabel) {\n      const label = document.createElement('label');\n      const labelClass = swalClasses['input-label'];\n      label.setAttribute('for', input.id);\n      label.className = labelClass;\n      if (typeof params.customClass === 'object') {\n        addClass(label, params.customClass.inputLabel);\n      }\n      label.innerText = params.inputLabel;\n      prependTo.insertAdjacentElement('beforebegin', label);\n    }\n  };\n\n  /**\n   * @param {SweetAlertInput} inputType\n   * @returns {HTMLElement | undefined}\n   */\n  const getInputContainer = inputType => {\n    const popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    return getDirectChildByClass(popup, swalClasses[(/** @type {SwalClass} */inputType)] || swalClasses.input);\n  };\n\n  /**\n   * @param {HTMLInputElement | HTMLOutputElement | HTMLTextAreaElement} input\n   * @param {SweetAlertOptions['inputValue']} inputValue\n   */\n  const checkAndSetInputValue = (input, inputValue) => {\n    if (['string', 'number'].includes(typeof inputValue)) {\n      input.value = `${inputValue}`;\n    } else if (!isPromise(inputValue)) {\n      warn(`Unexpected type of inputValue! Expected \"string\", \"number\" or \"Promise\", got \"${typeof inputValue}\"`);\n    }\n  };\n\n  /** @type {Record<SweetAlertInput, (input: Input | HTMLElement, params: SweetAlertOptions) => Input>} */\n  const renderInputType = {};\n\n  /**\n   * @param {HTMLInputElement} input\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLInputElement}\n   */\n  renderInputType.text = renderInputType.email = renderInputType.password = renderInputType.number = renderInputType.tel = renderInputType.url = renderInputType.search = renderInputType.date = renderInputType['datetime-local'] = renderInputType.time = renderInputType.week = renderInputType.month = /** @type {(input: Input | HTMLElement, params: SweetAlertOptions) => Input} */\n  (input, params) => {\n    checkAndSetInputValue(input, params.inputValue);\n    setInputLabel(input, input, params);\n    setInputPlaceholder(input, params);\n    input.type = params.input;\n    return input;\n  };\n\n  /**\n   * @param {HTMLInputElement} input\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLInputElement}\n   */\n  renderInputType.file = (input, params) => {\n    setInputLabel(input, input, params);\n    setInputPlaceholder(input, params);\n    return input;\n  };\n\n  /**\n   * @param {HTMLInputElement} range\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLInputElement}\n   */\n  renderInputType.range = (range, params) => {\n    const rangeInput = range.querySelector('input');\n    const rangeOutput = range.querySelector('output');\n    checkAndSetInputValue(rangeInput, params.inputValue);\n    rangeInput.type = params.input;\n    checkAndSetInputValue(rangeOutput, params.inputValue);\n    setInputLabel(rangeInput, range, params);\n    return range;\n  };\n\n  /**\n   * @param {HTMLSelectElement} select\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLSelectElement}\n   */\n  renderInputType.select = (select, params) => {\n    select.textContent = '';\n    if (params.inputPlaceholder) {\n      const placeholder = document.createElement('option');\n      setInnerHtml(placeholder, params.inputPlaceholder);\n      placeholder.value = '';\n      placeholder.disabled = true;\n      placeholder.selected = true;\n      select.appendChild(placeholder);\n    }\n    setInputLabel(select, select, params);\n    return select;\n  };\n\n  /**\n   * @param {HTMLInputElement} radio\n   * @returns {HTMLInputElement}\n   */\n  renderInputType.radio = radio => {\n    radio.textContent = '';\n    return radio;\n  };\n\n  /**\n   * @param {HTMLLabelElement} checkboxContainer\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLInputElement}\n   */\n  renderInputType.checkbox = (checkboxContainer, params) => {\n    const checkbox = getInput$1(getPopup(), 'checkbox');\n    checkbox.value = '1';\n    checkbox.checked = Boolean(params.inputValue);\n    const label = checkboxContainer.querySelector('span');\n    setInnerHtml(label, params.inputPlaceholder || params.inputLabel);\n    return checkbox;\n  };\n\n  /**\n   * @param {HTMLTextAreaElement} textarea\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLTextAreaElement}\n   */\n  renderInputType.textarea = (textarea, params) => {\n    checkAndSetInputValue(textarea, params.inputValue);\n    setInputPlaceholder(textarea, params);\n    setInputLabel(textarea, textarea, params);\n\n    /**\n     * @param {HTMLElement} el\n     * @returns {number}\n     */\n    const getMargin = el => parseInt(window.getComputedStyle(el).marginLeft) + parseInt(window.getComputedStyle(el).marginRight);\n\n    // https://github.com/sweetalert2/sweetalert2/issues/2291\n    setTimeout(() => {\n      // https://github.com/sweetalert2/sweetalert2/issues/1699\n      if ('MutationObserver' in window) {\n        const initialPopupWidth = parseInt(window.getComputedStyle(getPopup()).width);\n        const textareaResizeHandler = () => {\n          // check if texarea is still in document (i.e. popup wasn't closed in the meantime)\n          if (!document.body.contains(textarea)) {\n            return;\n          }\n          const textareaWidth = textarea.offsetWidth + getMargin(textarea);\n          if (textareaWidth > initialPopupWidth) {\n            getPopup().style.width = `${textareaWidth}px`;\n          } else {\n            applyNumericalStyle(getPopup(), 'width', params.width);\n          }\n        };\n        new MutationObserver(textareaResizeHandler).observe(textarea, {\n          attributes: true,\n          attributeFilter: ['style']\n        });\n      }\n    });\n    return textarea;\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderContent = (instance, params) => {\n    const htmlContainer = getHtmlContainer();\n    if (!htmlContainer) {\n      return;\n    }\n    showWhenInnerHtmlPresent(htmlContainer);\n    applyCustomClass(htmlContainer, params, 'htmlContainer');\n\n    // Content as HTML\n    if (params.html) {\n      parseHtmlToContainer(params.html, htmlContainer);\n      show(htmlContainer, 'block');\n    }\n\n    // Content as plain text\n    else if (params.text) {\n      htmlContainer.textContent = params.text;\n      show(htmlContainer, 'block');\n    }\n\n    // No content\n    else {\n      hide(htmlContainer);\n    }\n    renderInput(instance, params);\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderFooter = (instance, params) => {\n    const footer = getFooter();\n    if (!footer) {\n      return;\n    }\n    showWhenInnerHtmlPresent(footer);\n    toggle(footer, params.footer, 'block');\n    if (params.footer) {\n      parseHtmlToContainer(params.footer, footer);\n    }\n\n    // Custom class\n    applyCustomClass(footer, params, 'footer');\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderIcon = (instance, params) => {\n    const innerParams = privateProps.innerParams.get(instance);\n    const icon = getIcon();\n    if (!icon) {\n      return;\n    }\n\n    // if the given icon already rendered, apply the styling without re-rendering the icon\n    if (innerParams && params.icon === innerParams.icon) {\n      // Custom or default content\n      setContent(icon, params);\n      applyStyles(icon, params);\n      return;\n    }\n    if (!params.icon && !params.iconHtml) {\n      hide(icon);\n      return;\n    }\n    if (params.icon && Object.keys(iconTypes).indexOf(params.icon) === -1) {\n      error(`Unknown icon! Expected \"success\", \"error\", \"warning\", \"info\" or \"question\", got \"${params.icon}\"`);\n      hide(icon);\n      return;\n    }\n    show(icon);\n\n    // Custom or default content\n    setContent(icon, params);\n    applyStyles(icon, params);\n\n    // Animate icon\n    addClass(icon, params.showClass && params.showClass.icon);\n\n    // Re-adjust the success icon on system theme change\n    const colorSchemeQueryList = window.matchMedia('(prefers-color-scheme: dark)');\n    colorSchemeQueryList.addEventListener('change', adjustSuccessIconBackgroundColor);\n  };\n\n  /**\n   * @param {HTMLElement} icon\n   * @param {SweetAlertOptions} params\n   */\n  const applyStyles = (icon, params) => {\n    for (const [iconType, iconClassName] of Object.entries(iconTypes)) {\n      if (params.icon !== iconType) {\n        removeClass(icon, iconClassName);\n      }\n    }\n    addClass(icon, params.icon && iconTypes[params.icon]);\n\n    // Icon color\n    setColor(icon, params);\n\n    // Success icon background color\n    adjustSuccessIconBackgroundColor();\n\n    // Custom class\n    applyCustomClass(icon, params, 'icon');\n  };\n\n  // Adjust success icon background color to match the popup background color\n  const adjustSuccessIconBackgroundColor = () => {\n    const popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    const popupBackgroundColor = window.getComputedStyle(popup).getPropertyValue('background-color');\n    /** @type {NodeListOf<HTMLElement>} */\n    const successIconParts = popup.querySelectorAll('[class^=swal2-success-circular-line], .swal2-success-fix');\n    for (let i = 0; i < successIconParts.length; i++) {\n      successIconParts[i].style.backgroundColor = popupBackgroundColor;\n    }\n  };\n  const successIconHtml = `\n  <div class=\"swal2-success-circular-line-left\"></div>\n  <span class=\"swal2-success-line-tip\"></span> <span class=\"swal2-success-line-long\"></span>\n  <div class=\"swal2-success-ring\"></div> <div class=\"swal2-success-fix\"></div>\n  <div class=\"swal2-success-circular-line-right\"></div>\n`;\n  const errorIconHtml = `\n  <span class=\"swal2-x-mark\">\n    <span class=\"swal2-x-mark-line-left\"></span>\n    <span class=\"swal2-x-mark-line-right\"></span>\n  </span>\n`;\n\n  /**\n   * @param {HTMLElement} icon\n   * @param {SweetAlertOptions} params\n   */\n  const setContent = (icon, params) => {\n    if (!params.icon && !params.iconHtml) {\n      return;\n    }\n    let oldContent = icon.innerHTML;\n    let newContent = '';\n    if (params.iconHtml) {\n      newContent = iconContent(params.iconHtml);\n    } else if (params.icon === 'success') {\n      newContent = successIconHtml;\n      oldContent = oldContent.replace(/ style=\".*?\"/g, ''); // undo adjustSuccessIconBackgroundColor()\n    } else if (params.icon === 'error') {\n      newContent = errorIconHtml;\n    } else if (params.icon) {\n      const defaultIconHtml = {\n        question: '?',\n        warning: '!',\n        info: 'i'\n      };\n      newContent = iconContent(defaultIconHtml[params.icon]);\n    }\n    if (oldContent.trim() !== newContent.trim()) {\n      setInnerHtml(icon, newContent);\n    }\n  };\n\n  /**\n   * @param {HTMLElement} icon\n   * @param {SweetAlertOptions} params\n   */\n  const setColor = (icon, params) => {\n    if (!params.iconColor) {\n      return;\n    }\n    icon.style.color = params.iconColor;\n    icon.style.borderColor = params.iconColor;\n    for (const sel of ['.swal2-success-line-tip', '.swal2-success-line-long', '.swal2-x-mark-line-left', '.swal2-x-mark-line-right']) {\n      setStyle(icon, sel, 'background-color', params.iconColor);\n    }\n    setStyle(icon, '.swal2-success-ring', 'border-color', params.iconColor);\n  };\n\n  /**\n   * @param {string} content\n   * @returns {string}\n   */\n  const iconContent = content => `<div class=\"${swalClasses['icon-content']}\">${content}</div>`;\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderImage = (instance, params) => {\n    const image = getImage();\n    if (!image) {\n      return;\n    }\n    if (!params.imageUrl) {\n      hide(image);\n      return;\n    }\n    show(image, '');\n\n    // Src, alt\n    image.setAttribute('src', params.imageUrl);\n    image.setAttribute('alt', params.imageAlt || '');\n\n    // Width, height\n    applyNumericalStyle(image, 'width', params.imageWidth);\n    applyNumericalStyle(image, 'height', params.imageHeight);\n\n    // Class\n    image.className = swalClasses.image;\n    applyCustomClass(image, params, 'image');\n  };\n\n  let dragging = false;\n  let mousedownX = 0;\n  let mousedownY = 0;\n  let initialX = 0;\n  let initialY = 0;\n\n  /**\n   * @param {HTMLElement} popup\n   */\n  const addDraggableListeners = popup => {\n    popup.addEventListener('mousedown', down);\n    document.body.addEventListener('mousemove', move);\n    popup.addEventListener('mouseup', up);\n    popup.addEventListener('touchstart', down);\n    document.body.addEventListener('touchmove', move);\n    popup.addEventListener('touchend', up);\n  };\n\n  /**\n   * @param {HTMLElement} popup\n   */\n  const removeDraggableListeners = popup => {\n    popup.removeEventListener('mousedown', down);\n    document.body.removeEventListener('mousemove', move);\n    popup.removeEventListener('mouseup', up);\n    popup.removeEventListener('touchstart', down);\n    document.body.removeEventListener('touchmove', move);\n    popup.removeEventListener('touchend', up);\n  };\n\n  /**\n   * @param {MouseEvent | TouchEvent} event\n   */\n  const down = event => {\n    const popup = getPopup();\n    if (event.target === popup || getIcon().contains(/** @type {HTMLElement} */event.target)) {\n      dragging = true;\n      const clientXY = getClientXY(event);\n      mousedownX = clientXY.clientX;\n      mousedownY = clientXY.clientY;\n      initialX = parseInt(popup.style.insetInlineStart) || 0;\n      initialY = parseInt(popup.style.insetBlockStart) || 0;\n      addClass(popup, 'swal2-dragging');\n    }\n  };\n\n  /**\n   * @param {MouseEvent | TouchEvent} event\n   */\n  const move = event => {\n    const popup = getPopup();\n    if (dragging) {\n      let {\n        clientX,\n        clientY\n      } = getClientXY(event);\n      popup.style.insetInlineStart = `${initialX + (clientX - mousedownX)}px`;\n      popup.style.insetBlockStart = `${initialY + (clientY - mousedownY)}px`;\n    }\n  };\n  const up = () => {\n    const popup = getPopup();\n    dragging = false;\n    removeClass(popup, 'swal2-dragging');\n  };\n\n  /**\n   * @param {MouseEvent | TouchEvent} event\n   * @returns {{ clientX: number, clientY: number }}\n   */\n  const getClientXY = event => {\n    let clientX = 0,\n      clientY = 0;\n    if (event.type.startsWith('mouse')) {\n      clientX = /** @type {MouseEvent} */event.clientX;\n      clientY = /** @type {MouseEvent} */event.clientY;\n    } else if (event.type.startsWith('touch')) {\n      clientX = /** @type {TouchEvent} */event.touches[0].clientX;\n      clientY = /** @type {TouchEvent} */event.touches[0].clientY;\n    }\n    return {\n      clientX,\n      clientY\n    };\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderPopup = (instance, params) => {\n    const container = getContainer();\n    const popup = getPopup();\n    if (!container || !popup) {\n      return;\n    }\n\n    // Width\n    // https://github.com/sweetalert2/sweetalert2/issues/2170\n    if (params.toast) {\n      applyNumericalStyle(container, 'width', params.width);\n      popup.style.width = '100%';\n      const loader = getLoader();\n      if (loader) {\n        popup.insertBefore(loader, getIcon());\n      }\n    } else {\n      applyNumericalStyle(popup, 'width', params.width);\n    }\n\n    // Padding\n    applyNumericalStyle(popup, 'padding', params.padding);\n\n    // Color\n    if (params.color) {\n      popup.style.color = params.color;\n    }\n\n    // Background\n    if (params.background) {\n      popup.style.background = params.background;\n    }\n    hide(getValidationMessage());\n\n    // Classes\n    addClasses$1(popup, params);\n    if (params.draggable && !params.toast) {\n      addClass(popup, swalClasses.draggable);\n      addDraggableListeners(popup);\n    } else {\n      removeClass(popup, swalClasses.draggable);\n      removeDraggableListeners(popup);\n    }\n  };\n\n  /**\n   * @param {HTMLElement} popup\n   * @param {SweetAlertOptions} params\n   */\n  const addClasses$1 = (popup, params) => {\n    const showClass = params.showClass || {};\n    // Default Class + showClass when updating Swal.update({})\n    popup.className = `${swalClasses.popup} ${isVisible$1(popup) ? showClass.popup : ''}`;\n    if (params.toast) {\n      addClass([document.documentElement, document.body], swalClasses['toast-shown']);\n      addClass(popup, swalClasses.toast);\n    } else {\n      addClass(popup, swalClasses.modal);\n    }\n\n    // Custom class\n    applyCustomClass(popup, params, 'popup');\n    // TODO: remove in the next major\n    if (typeof params.customClass === 'string') {\n      addClass(popup, params.customClass);\n    }\n\n    // Icon class (#1842)\n    if (params.icon) {\n      addClass(popup, swalClasses[`icon-${params.icon}`]);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderProgressSteps = (instance, params) => {\n    const progressStepsContainer = getProgressSteps();\n    if (!progressStepsContainer) {\n      return;\n    }\n    const {\n      progressSteps,\n      currentProgressStep\n    } = params;\n    if (!progressSteps || progressSteps.length === 0 || currentProgressStep === undefined) {\n      hide(progressStepsContainer);\n      return;\n    }\n    show(progressStepsContainer);\n    progressStepsContainer.textContent = '';\n    if (currentProgressStep >= progressSteps.length) {\n      warn('Invalid currentProgressStep parameter, it should be less than progressSteps.length ' + '(currentProgressStep like JS arrays starts from 0)');\n    }\n    progressSteps.forEach((step, index) => {\n      const stepEl = createStepElement(step);\n      progressStepsContainer.appendChild(stepEl);\n      if (index === currentProgressStep) {\n        addClass(stepEl, swalClasses['active-progress-step']);\n      }\n      if (index !== progressSteps.length - 1) {\n        const lineEl = createLineElement(params);\n        progressStepsContainer.appendChild(lineEl);\n      }\n    });\n  };\n\n  /**\n   * @param {string} step\n   * @returns {HTMLLIElement}\n   */\n  const createStepElement = step => {\n    const stepEl = document.createElement('li');\n    addClass(stepEl, swalClasses['progress-step']);\n    setInnerHtml(stepEl, step);\n    return stepEl;\n  };\n\n  /**\n   * @param {SweetAlertOptions} params\n   * @returns {HTMLLIElement}\n   */\n  const createLineElement = params => {\n    const lineEl = document.createElement('li');\n    addClass(lineEl, swalClasses['progress-step-line']);\n    if (params.progressStepsDistance) {\n      applyNumericalStyle(lineEl, 'width', params.progressStepsDistance);\n    }\n    return lineEl;\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const renderTitle = (instance, params) => {\n    const title = getTitle();\n    if (!title) {\n      return;\n    }\n    showWhenInnerHtmlPresent(title);\n    toggle(title, params.title || params.titleText, 'block');\n    if (params.title) {\n      parseHtmlToContainer(params.title, title);\n    }\n    if (params.titleText) {\n      title.innerText = params.titleText;\n    }\n\n    // Custom class\n    applyCustomClass(title, params, 'title');\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const render = (instance, params) => {\n    renderPopup(instance, params);\n    renderContainer(instance, params);\n    renderProgressSteps(instance, params);\n    renderIcon(instance, params);\n    renderImage(instance, params);\n    renderTitle(instance, params);\n    renderCloseButton(instance, params);\n    renderContent(instance, params);\n    renderActions(instance, params);\n    renderFooter(instance, params);\n    const popup = getPopup();\n    if (typeof params.didRender === 'function' && popup) {\n      params.didRender(popup);\n    }\n    globalState.eventEmitter.emit('didRender', popup);\n  };\n\n  /*\n   * Global function to determine if SweetAlert2 popup is shown\n   */\n  const isVisible = () => {\n    return isVisible$1(getPopup());\n  };\n\n  /*\n   * Global function to click 'Confirm' button\n   */\n  const clickConfirm = () => {\n    var _dom$getConfirmButton;\n    return (_dom$getConfirmButton = getConfirmButton()) === null || _dom$getConfirmButton === void 0 ? void 0 : _dom$getConfirmButton.click();\n  };\n\n  /*\n   * Global function to click 'Deny' button\n   */\n  const clickDeny = () => {\n    var _dom$getDenyButton;\n    return (_dom$getDenyButton = getDenyButton()) === null || _dom$getDenyButton === void 0 ? void 0 : _dom$getDenyButton.click();\n  };\n\n  /*\n   * Global function to click 'Cancel' button\n   */\n  const clickCancel = () => {\n    var _dom$getCancelButton;\n    return (_dom$getCancelButton = getCancelButton()) === null || _dom$getCancelButton === void 0 ? void 0 : _dom$getCancelButton.click();\n  };\n\n  /** @typedef {'cancel' | 'backdrop' | 'close' | 'esc' | 'timer'} DismissReason */\n\n  /** @type {Record<DismissReason, DismissReason>} */\n  const DismissReason = Object.freeze({\n    cancel: 'cancel',\n    backdrop: 'backdrop',\n    close: 'close',\n    esc: 'esc',\n    timer: 'timer'\n  });\n\n  /**\n   * @param {GlobalState} globalState\n   */\n  const removeKeydownHandler = globalState => {\n    if (globalState.keydownTarget && globalState.keydownHandlerAdded) {\n      globalState.keydownTarget.removeEventListener('keydown', globalState.keydownHandler, {\n        capture: globalState.keydownListenerCapture\n      });\n      globalState.keydownHandlerAdded = false;\n    }\n  };\n\n  /**\n   * @param {GlobalState} globalState\n   * @param {SweetAlertOptions} innerParams\n   * @param {*} dismissWith\n   */\n  const addKeydownHandler = (globalState, innerParams, dismissWith) => {\n    removeKeydownHandler(globalState);\n    if (!innerParams.toast) {\n      globalState.keydownHandler = e => keydownHandler(innerParams, e, dismissWith);\n      globalState.keydownTarget = innerParams.keydownListenerCapture ? window : getPopup();\n      globalState.keydownListenerCapture = innerParams.keydownListenerCapture;\n      globalState.keydownTarget.addEventListener('keydown', globalState.keydownHandler, {\n        capture: globalState.keydownListenerCapture\n      });\n      globalState.keydownHandlerAdded = true;\n    }\n  };\n\n  /**\n   * @param {number} index\n   * @param {number} increment\n   */\n  const setFocus = (index, increment) => {\n    var _dom$getPopup;\n    const focusableElements = getFocusableElements();\n    // search for visible elements and select the next possible match\n    if (focusableElements.length) {\n      index = index + increment;\n\n      // rollover to first item\n      if (index === focusableElements.length) {\n        index = 0;\n\n        // go to last item\n      } else if (index === -1) {\n        index = focusableElements.length - 1;\n      }\n      focusableElements[index].focus();\n      return;\n    }\n    // no visible focusable elements, focus the popup\n    (_dom$getPopup = getPopup()) === null || _dom$getPopup === void 0 || _dom$getPopup.focus();\n  };\n  const arrowKeysNextButton = ['ArrowRight', 'ArrowDown'];\n  const arrowKeysPreviousButton = ['ArrowLeft', 'ArrowUp'];\n\n  /**\n   * @param {SweetAlertOptions} innerParams\n   * @param {KeyboardEvent} event\n   * @param {Function} dismissWith\n   */\n  const keydownHandler = (innerParams, event, dismissWith) => {\n    if (!innerParams) {\n      return; // This instance has already been destroyed\n    }\n\n    // Ignore keydown during IME composition\n    // https://developer.mozilla.org/en-US/docs/Web/API/Document/keydown_event#ignoring_keydown_during_ime_composition\n    // https://github.com/sweetalert2/sweetalert2/issues/720\n    // https://github.com/sweetalert2/sweetalert2/issues/2406\n    if (event.isComposing || event.keyCode === 229) {\n      return;\n    }\n    if (innerParams.stopKeydownPropagation) {\n      event.stopPropagation();\n    }\n\n    // ENTER\n    if (event.key === 'Enter') {\n      handleEnter(event, innerParams);\n    }\n\n    // TAB\n    else if (event.key === 'Tab') {\n      handleTab(event);\n    }\n\n    // ARROWS - switch focus between buttons\n    else if ([...arrowKeysNextButton, ...arrowKeysPreviousButton].includes(event.key)) {\n      handleArrows(event.key);\n    }\n\n    // ESC\n    else if (event.key === 'Escape') {\n      handleEsc(event, innerParams, dismissWith);\n    }\n  };\n\n  /**\n   * @param {KeyboardEvent} event\n   * @param {SweetAlertOptions} innerParams\n   */\n  const handleEnter = (event, innerParams) => {\n    // https://github.com/sweetalert2/sweetalert2/issues/2386\n    if (!callIfFunction(innerParams.allowEnterKey)) {\n      return;\n    }\n    const input = getInput$1(getPopup(), innerParams.input);\n    if (event.target && input && event.target instanceof HTMLElement && event.target.outerHTML === input.outerHTML) {\n      if (['textarea', 'file'].includes(innerParams.input)) {\n        return; // do not submit\n      }\n      clickConfirm();\n      event.preventDefault();\n    }\n  };\n\n  /**\n   * @param {KeyboardEvent} event\n   */\n  const handleTab = event => {\n    const targetElement = event.target;\n    const focusableElements = getFocusableElements();\n    let btnIndex = -1;\n    for (let i = 0; i < focusableElements.length; i++) {\n      if (targetElement === focusableElements[i]) {\n        btnIndex = i;\n        break;\n      }\n    }\n\n    // Cycle to the next button\n    if (!event.shiftKey) {\n      setFocus(btnIndex, 1);\n    }\n\n    // Cycle to the prev button\n    else {\n      setFocus(btnIndex, -1);\n    }\n    event.stopPropagation();\n    event.preventDefault();\n  };\n\n  /**\n   * @param {string} key\n   */\n  const handleArrows = key => {\n    const actions = getActions();\n    const confirmButton = getConfirmButton();\n    const denyButton = getDenyButton();\n    const cancelButton = getCancelButton();\n    if (!actions || !confirmButton || !denyButton || !cancelButton) {\n      return;\n    }\n    /** @type HTMLElement[] */\n    const buttons = [confirmButton, denyButton, cancelButton];\n    if (document.activeElement instanceof HTMLElement && !buttons.includes(document.activeElement)) {\n      return;\n    }\n    const sibling = arrowKeysNextButton.includes(key) ? 'nextElementSibling' : 'previousElementSibling';\n    let buttonToFocus = document.activeElement;\n    if (!buttonToFocus) {\n      return;\n    }\n    for (let i = 0; i < actions.children.length; i++) {\n      buttonToFocus = buttonToFocus[sibling];\n      if (!buttonToFocus) {\n        return;\n      }\n      if (buttonToFocus instanceof HTMLButtonElement && isVisible$1(buttonToFocus)) {\n        break;\n      }\n    }\n    if (buttonToFocus instanceof HTMLButtonElement) {\n      buttonToFocus.focus();\n    }\n  };\n\n  /**\n   * @param {KeyboardEvent} event\n   * @param {SweetAlertOptions} innerParams\n   * @param {Function} dismissWith\n   */\n  const handleEsc = (event, innerParams, dismissWith) => {\n    if (callIfFunction(innerParams.allowEscapeKey)) {\n      event.preventDefault();\n      dismissWith(DismissReason.esc);\n    }\n  };\n\n  /**\n   * This module contains `WeakMap`s for each effectively-\"private  property\" that a `Swal` has.\n   * For example, to set the private property \"foo\" of `this` to \"bar\", you can `privateProps.foo.set(this, 'bar')`\n   * This is the approach that Babel will probably take to implement private methods/fields\n   *   https://github.com/tc39/proposal-private-methods\n   *   https://github.com/babel/babel/pull/7555\n   * Once we have the changes from that PR in Babel, and our core class fits reasonable in *one module*\n   *   then we can use that language feature.\n   */\n\n  var privateMethods = {\n    swalPromiseResolve: new WeakMap(),\n    swalPromiseReject: new WeakMap()\n  };\n\n  // From https://developer.paciellogroup.com/blog/2018/06/the-current-state-of-modal-dialog-accessibility/\n  // Adding aria-hidden=\"true\" to elements outside of the active modal dialog ensures that\n  // elements not within the active modal dialog will not be surfaced if a user opens a screen\n  // reader’s list of elements (headings, form controls, landmarks, etc.) in the document.\n\n  const setAriaHidden = () => {\n    const container = getContainer();\n    const bodyChildren = Array.from(document.body.children);\n    bodyChildren.forEach(el => {\n      if (el.contains(container)) {\n        return;\n      }\n      if (el.hasAttribute('aria-hidden')) {\n        el.setAttribute('data-previous-aria-hidden', el.getAttribute('aria-hidden') || '');\n      }\n      el.setAttribute('aria-hidden', 'true');\n    });\n  };\n  const unsetAriaHidden = () => {\n    const bodyChildren = Array.from(document.body.children);\n    bodyChildren.forEach(el => {\n      if (el.hasAttribute('data-previous-aria-hidden')) {\n        el.setAttribute('aria-hidden', el.getAttribute('data-previous-aria-hidden') || '');\n        el.removeAttribute('data-previous-aria-hidden');\n      } else {\n        el.removeAttribute('aria-hidden');\n      }\n    });\n  };\n\n  // @ts-ignore\n  const isSafariOrIOS = typeof window !== 'undefined' && !!window.GestureEvent; // true for Safari desktop + all iOS browsers https://stackoverflow.com/a/70585394\n\n  /**\n   * Fix iOS scrolling\n   * http://stackoverflow.com/q/39626302\n   */\n  const iOSfix = () => {\n    if (isSafariOrIOS && !hasClass(document.body, swalClasses.iosfix)) {\n      const offset = document.body.scrollTop;\n      document.body.style.top = `${offset * -1}px`;\n      addClass(document.body, swalClasses.iosfix);\n      lockBodyScroll();\n    }\n  };\n\n  /**\n   * https://github.com/sweetalert2/sweetalert2/issues/1246\n   */\n  const lockBodyScroll = () => {\n    const container = getContainer();\n    if (!container) {\n      return;\n    }\n    /** @type {boolean} */\n    let preventTouchMove;\n    /**\n     * @param {TouchEvent} event\n     */\n    container.ontouchstart = event => {\n      preventTouchMove = shouldPreventTouchMove(event);\n    };\n    /**\n     * @param {TouchEvent} event\n     */\n    container.ontouchmove = event => {\n      if (preventTouchMove) {\n        event.preventDefault();\n        event.stopPropagation();\n      }\n    };\n  };\n\n  /**\n   * @param {TouchEvent} event\n   * @returns {boolean}\n   */\n  const shouldPreventTouchMove = event => {\n    const target = event.target;\n    const container = getContainer();\n    const htmlContainer = getHtmlContainer();\n    if (!container || !htmlContainer) {\n      return false;\n    }\n    if (isStylus(event) || isZoom(event)) {\n      return false;\n    }\n    if (target === container) {\n      return true;\n    }\n    if (!isScrollable(container) && target instanceof HTMLElement && target.tagName !== 'INPUT' &&\n    // #1603\n    target.tagName !== 'TEXTAREA' &&\n    // #2266\n    !(isScrollable(htmlContainer) &&\n    // #1944\n    htmlContainer.contains(target))) {\n      return true;\n    }\n    return false;\n  };\n\n  /**\n   * https://github.com/sweetalert2/sweetalert2/issues/1786\n   *\n   * @param {*} event\n   * @returns {boolean}\n   */\n  const isStylus = event => {\n    return event.touches && event.touches.length && event.touches[0].touchType === 'stylus';\n  };\n\n  /**\n   * https://github.com/sweetalert2/sweetalert2/issues/1891\n   *\n   * @param {TouchEvent} event\n   * @returns {boolean}\n   */\n  const isZoom = event => {\n    return event.touches && event.touches.length > 1;\n  };\n  const undoIOSfix = () => {\n    if (hasClass(document.body, swalClasses.iosfix)) {\n      const offset = parseInt(document.body.style.top, 10);\n      removeClass(document.body, swalClasses.iosfix);\n      document.body.style.top = '';\n      document.body.scrollTop = offset * -1;\n    }\n  };\n\n  /**\n   * Measure scrollbar width for padding body during modal show/hide\n   * https://github.com/twbs/bootstrap/blob/master/js/src/modal.js\n   *\n   * @returns {number}\n   */\n  const measureScrollbar = () => {\n    const scrollDiv = document.createElement('div');\n    scrollDiv.className = swalClasses['scrollbar-measure'];\n    document.body.appendChild(scrollDiv);\n    const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;\n    document.body.removeChild(scrollDiv);\n    return scrollbarWidth;\n  };\n\n  /**\n   * Remember state in cases where opening and handling a modal will fiddle with it.\n   * @type {number | null}\n   */\n  let previousBodyPadding = null;\n\n  /**\n   * @param {string} initialBodyOverflow\n   */\n  const replaceScrollbarWithPadding = initialBodyOverflow => {\n    // for queues, do not do this more than once\n    if (previousBodyPadding !== null) {\n      return;\n    }\n    // if the body has overflow\n    if (document.body.scrollHeight > window.innerHeight || initialBodyOverflow === 'scroll' // https://github.com/sweetalert2/sweetalert2/issues/2663\n    ) {\n      // add padding so the content doesn't shift after removal of scrollbar\n      previousBodyPadding = parseInt(window.getComputedStyle(document.body).getPropertyValue('padding-right'));\n      document.body.style.paddingRight = `${previousBodyPadding + measureScrollbar()}px`;\n    }\n  };\n  const undoReplaceScrollbarWithPadding = () => {\n    if (previousBodyPadding !== null) {\n      document.body.style.paddingRight = `${previousBodyPadding}px`;\n      previousBodyPadding = null;\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {HTMLElement} container\n   * @param {boolean} returnFocus\n   * @param {Function} didClose\n   */\n  function removePopupAndResetState(instance, container, returnFocus, didClose) {\n    if (isToast()) {\n      triggerDidCloseAndDispose(instance, didClose);\n    } else {\n      restoreActiveElement(returnFocus).then(() => triggerDidCloseAndDispose(instance, didClose));\n      removeKeydownHandler(globalState);\n    }\n\n    // workaround for https://github.com/sweetalert2/sweetalert2/issues/2088\n    // for some reason removing the container in Safari will scroll the document to bottom\n    if (isSafariOrIOS) {\n      container.setAttribute('style', 'display:none !important');\n      container.removeAttribute('class');\n      container.innerHTML = '';\n    } else {\n      container.remove();\n    }\n    if (isModal()) {\n      undoReplaceScrollbarWithPadding();\n      undoIOSfix();\n      unsetAriaHidden();\n    }\n    removeBodyClasses();\n  }\n\n  /**\n   * Remove SweetAlert2 classes from body\n   */\n  function removeBodyClasses() {\n    removeClass([document.documentElement, document.body], [swalClasses.shown, swalClasses['height-auto'], swalClasses['no-backdrop'], swalClasses['toast-shown']]);\n  }\n\n  /**\n   * Instance method to close sweetAlert\n   *\n   * @param {any} resolveValue\n   */\n  function close(resolveValue) {\n    resolveValue = prepareResolveValue(resolveValue);\n    const swalPromiseResolve = privateMethods.swalPromiseResolve.get(this);\n    const didClose = triggerClosePopup(this);\n    if (this.isAwaitingPromise) {\n      // A swal awaiting for a promise (after a click on Confirm or Deny) cannot be dismissed anymore #2335\n      if (!resolveValue.isDismissed) {\n        handleAwaitingPromise(this);\n        swalPromiseResolve(resolveValue);\n      }\n    } else if (didClose) {\n      // Resolve Swal promise\n      swalPromiseResolve(resolveValue);\n    }\n  }\n  const triggerClosePopup = instance => {\n    const popup = getPopup();\n    if (!popup) {\n      return false;\n    }\n    const innerParams = privateProps.innerParams.get(instance);\n    if (!innerParams || hasClass(popup, innerParams.hideClass.popup)) {\n      return false;\n    }\n    removeClass(popup, innerParams.showClass.popup);\n    addClass(popup, innerParams.hideClass.popup);\n    const backdrop = getContainer();\n    removeClass(backdrop, innerParams.showClass.backdrop);\n    addClass(backdrop, innerParams.hideClass.backdrop);\n    handlePopupAnimation(instance, popup, innerParams);\n    return true;\n  };\n\n  /**\n   * @param {any} error\n   */\n  function rejectPromise(error) {\n    const rejectPromise = privateMethods.swalPromiseReject.get(this);\n    handleAwaitingPromise(this);\n    if (rejectPromise) {\n      // Reject Swal promise\n      rejectPromise(error);\n    }\n  }\n\n  /**\n   * @param {SweetAlert} instance\n   */\n  const handleAwaitingPromise = instance => {\n    if (instance.isAwaitingPromise) {\n      delete instance.isAwaitingPromise;\n      // The instance might have been previously partly destroyed, we must resume the destroy process in this case #2335\n      if (!privateProps.innerParams.get(instance)) {\n        instance._destroy();\n      }\n    }\n  };\n\n  /**\n   * @param {any} resolveValue\n   * @returns {SweetAlertResult}\n   */\n  const prepareResolveValue = resolveValue => {\n    // When user calls Swal.close()\n    if (typeof resolveValue === 'undefined') {\n      return {\n        isConfirmed: false,\n        isDenied: false,\n        isDismissed: true\n      };\n    }\n    return Object.assign({\n      isConfirmed: false,\n      isDenied: false,\n      isDismissed: false\n    }, resolveValue);\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {HTMLElement} popup\n   * @param {SweetAlertOptions} innerParams\n   */\n  const handlePopupAnimation = (instance, popup, innerParams) => {\n    var _globalState$eventEmi;\n    const container = getContainer();\n    // If animation is supported, animate\n    const animationIsSupported = hasCssAnimation(popup);\n    if (typeof innerParams.willClose === 'function') {\n      innerParams.willClose(popup);\n    }\n    (_globalState$eventEmi = globalState.eventEmitter) === null || _globalState$eventEmi === void 0 || _globalState$eventEmi.emit('willClose', popup);\n    if (animationIsSupported) {\n      animatePopup(instance, popup, container, innerParams.returnFocus, innerParams.didClose);\n    } else {\n      // Otherwise, remove immediately\n      removePopupAndResetState(instance, container, innerParams.returnFocus, innerParams.didClose);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {HTMLElement} popup\n   * @param {HTMLElement} container\n   * @param {boolean} returnFocus\n   * @param {Function} didClose\n   */\n  const animatePopup = (instance, popup, container, returnFocus, didClose) => {\n    globalState.swalCloseEventFinishedCallback = removePopupAndResetState.bind(null, instance, container, returnFocus, didClose);\n    /**\n     * @param {AnimationEvent | TransitionEvent} e\n     */\n    const swalCloseAnimationFinished = function (e) {\n      if (e.target === popup) {\n        var _globalState$swalClos;\n        (_globalState$swalClos = globalState.swalCloseEventFinishedCallback) === null || _globalState$swalClos === void 0 || _globalState$swalClos.call(globalState);\n        delete globalState.swalCloseEventFinishedCallback;\n        popup.removeEventListener('animationend', swalCloseAnimationFinished);\n        popup.removeEventListener('transitionend', swalCloseAnimationFinished);\n      }\n    };\n    popup.addEventListener('animationend', swalCloseAnimationFinished);\n    popup.addEventListener('transitionend', swalCloseAnimationFinished);\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {Function} didClose\n   */\n  const triggerDidCloseAndDispose = (instance, didClose) => {\n    setTimeout(() => {\n      var _globalState$eventEmi2;\n      if (typeof didClose === 'function') {\n        didClose.bind(instance.params)();\n      }\n      (_globalState$eventEmi2 = globalState.eventEmitter) === null || _globalState$eventEmi2 === void 0 || _globalState$eventEmi2.emit('didClose');\n      // instance might have been destroyed already\n      if (instance._destroy) {\n        instance._destroy();\n      }\n    });\n  };\n\n  /**\n   * Shows loader (spinner), this is useful with AJAX requests.\n   * By default the loader be shown instead of the \"Confirm\" button.\n   *\n   * @param {HTMLButtonElement | null} [buttonToReplace]\n   */\n  const showLoading = buttonToReplace => {\n    let popup = getPopup();\n    if (!popup) {\n      new Swal();\n    }\n    popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    const loader = getLoader();\n    if (isToast()) {\n      hide(getIcon());\n    } else {\n      replaceButton(popup, buttonToReplace);\n    }\n    show(loader);\n    popup.setAttribute('data-loading', 'true');\n    popup.setAttribute('aria-busy', 'true');\n    popup.focus();\n  };\n\n  /**\n   * @param {HTMLElement} popup\n   * @param {HTMLButtonElement | null} [buttonToReplace]\n   */\n  const replaceButton = (popup, buttonToReplace) => {\n    const actions = getActions();\n    const loader = getLoader();\n    if (!actions || !loader) {\n      return;\n    }\n    if (!buttonToReplace && isVisible$1(getConfirmButton())) {\n      buttonToReplace = getConfirmButton();\n    }\n    show(actions);\n    if (buttonToReplace) {\n      hide(buttonToReplace);\n      loader.setAttribute('data-button-to-replace', buttonToReplace.className);\n      actions.insertBefore(loader, buttonToReplace);\n    }\n    addClass([popup, actions], swalClasses.loading);\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const handleInputOptionsAndValue = (instance, params) => {\n    if (params.input === 'select' || params.input === 'radio') {\n      handleInputOptions(instance, params);\n    } else if (['text', 'email', 'number', 'tel', 'textarea'].some(i => i === params.input) && (hasToPromiseFn(params.inputValue) || isPromise(params.inputValue))) {\n      showLoading(getConfirmButton());\n      handleInputValue(instance, params);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} innerParams\n   * @returns {SweetAlertInputValue}\n   */\n  const getInputValue = (instance, innerParams) => {\n    const input = instance.getInput();\n    if (!input) {\n      return null;\n    }\n    switch (innerParams.input) {\n      case 'checkbox':\n        return getCheckboxValue(input);\n      case 'radio':\n        return getRadioValue(input);\n      case 'file':\n        return getFileValue(input);\n      default:\n        return innerParams.inputAutoTrim ? input.value.trim() : input.value;\n    }\n  };\n\n  /**\n   * @param {HTMLInputElement} input\n   * @returns {number}\n   */\n  const getCheckboxValue = input => input.checked ? 1 : 0;\n\n  /**\n   * @param {HTMLInputElement} input\n   * @returns {string | null}\n   */\n  const getRadioValue = input => input.checked ? input.value : null;\n\n  /**\n   * @param {HTMLInputElement} input\n   * @returns {FileList | File | null}\n   */\n  const getFileValue = input => input.files && input.files.length ? input.getAttribute('multiple') !== null ? input.files : input.files[0] : null;\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const handleInputOptions = (instance, params) => {\n    const popup = getPopup();\n    if (!popup) {\n      return;\n    }\n    /**\n     * @param {Record<string, any>} inputOptions\n     */\n    const processInputOptions = inputOptions => {\n      if (params.input === 'select') {\n        populateSelectOptions(popup, formatInputOptions(inputOptions), params);\n      } else if (params.input === 'radio') {\n        populateRadioOptions(popup, formatInputOptions(inputOptions), params);\n      }\n    };\n    if (hasToPromiseFn(params.inputOptions) || isPromise(params.inputOptions)) {\n      showLoading(getConfirmButton());\n      asPromise(params.inputOptions).then(inputOptions => {\n        instance.hideLoading();\n        processInputOptions(inputOptions);\n      });\n    } else if (typeof params.inputOptions === 'object') {\n      processInputOptions(params.inputOptions);\n    } else {\n      error(`Unexpected type of inputOptions! Expected object, Map or Promise, got ${typeof params.inputOptions}`);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertOptions} params\n   */\n  const handleInputValue = (instance, params) => {\n    const input = instance.getInput();\n    if (!input) {\n      return;\n    }\n    hide(input);\n    asPromise(params.inputValue).then(inputValue => {\n      input.value = params.input === 'number' ? `${parseFloat(inputValue) || 0}` : `${inputValue}`;\n      show(input);\n      input.focus();\n      instance.hideLoading();\n    }).catch(err => {\n      error(`Error in inputValue promise: ${err}`);\n      input.value = '';\n      show(input);\n      input.focus();\n      instance.hideLoading();\n    });\n  };\n\n  /**\n   * @param {HTMLElement} popup\n   * @param {InputOptionFlattened[]} inputOptions\n   * @param {SweetAlertOptions} params\n   */\n  function populateSelectOptions(popup, inputOptions, params) {\n    const select = getDirectChildByClass(popup, swalClasses.select);\n    if (!select) {\n      return;\n    }\n    /**\n     * @param {HTMLElement} parent\n     * @param {string} optionLabel\n     * @param {string} optionValue\n     */\n    const renderOption = (parent, optionLabel, optionValue) => {\n      const option = document.createElement('option');\n      option.value = optionValue;\n      setInnerHtml(option, optionLabel);\n      option.selected = isSelected(optionValue, params.inputValue);\n      parent.appendChild(option);\n    };\n    inputOptions.forEach(inputOption => {\n      const optionValue = inputOption[0];\n      const optionLabel = inputOption[1];\n      // <optgroup> spec:\n      // https://www.w3.org/TR/html401/interact/forms.html#h-17.6\n      // \"...all OPTGROUP elements must be specified directly within a SELECT element (i.e., groups may not be nested)...\"\n      // check whether this is a <optgroup>\n      if (Array.isArray(optionLabel)) {\n        // if it is an array, then it is an <optgroup>\n        const optgroup = document.createElement('optgroup');\n        optgroup.label = optionValue;\n        optgroup.disabled = false; // not configurable for now\n        select.appendChild(optgroup);\n        optionLabel.forEach(o => renderOption(optgroup, o[1], o[0]));\n      } else {\n        // case of <option>\n        renderOption(select, optionLabel, optionValue);\n      }\n    });\n    select.focus();\n  }\n\n  /**\n   * @param {HTMLElement} popup\n   * @param {InputOptionFlattened[]} inputOptions\n   * @param {SweetAlertOptions} params\n   */\n  function populateRadioOptions(popup, inputOptions, params) {\n    const radio = getDirectChildByClass(popup, swalClasses.radio);\n    if (!radio) {\n      return;\n    }\n    inputOptions.forEach(inputOption => {\n      const radioValue = inputOption[0];\n      const radioLabel = inputOption[1];\n      const radioInput = document.createElement('input');\n      const radioLabelElement = document.createElement('label');\n      radioInput.type = 'radio';\n      radioInput.name = swalClasses.radio;\n      radioInput.value = radioValue;\n      if (isSelected(radioValue, params.inputValue)) {\n        radioInput.checked = true;\n      }\n      const label = document.createElement('span');\n      setInnerHtml(label, radioLabel);\n      label.className = swalClasses.label;\n      radioLabelElement.appendChild(radioInput);\n      radioLabelElement.appendChild(label);\n      radio.appendChild(radioLabelElement);\n    });\n    const radios = radio.querySelectorAll('input');\n    if (radios.length) {\n      radios[0].focus();\n    }\n  }\n\n  /**\n   * Converts `inputOptions` into an array of `[value, label]`s\n   *\n   * @param {Record<string, any>} inputOptions\n   * @typedef {string[]} InputOptionFlattened\n   * @returns {InputOptionFlattened[]}\n   */\n  const formatInputOptions = inputOptions => {\n    /** @type {InputOptionFlattened[]} */\n    const result = [];\n    if (inputOptions instanceof Map) {\n      inputOptions.forEach((value, key) => {\n        let valueFormatted = value;\n        if (typeof valueFormatted === 'object') {\n          // case of <optgroup>\n          valueFormatted = formatInputOptions(valueFormatted);\n        }\n        result.push([key, valueFormatted]);\n      });\n    } else {\n      Object.keys(inputOptions).forEach(key => {\n        let valueFormatted = inputOptions[key];\n        if (typeof valueFormatted === 'object') {\n          // case of <optgroup>\n          valueFormatted = formatInputOptions(valueFormatted);\n        }\n        result.push([key, valueFormatted]);\n      });\n    }\n    return result;\n  };\n\n  /**\n   * @param {string} optionValue\n   * @param {SweetAlertInputValue} inputValue\n   * @returns {boolean}\n   */\n  const isSelected = (optionValue, inputValue) => {\n    return !!inputValue && inputValue.toString() === optionValue.toString();\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   */\n  const handleConfirmButtonClick = instance => {\n    const innerParams = privateProps.innerParams.get(instance);\n    instance.disableButtons();\n    if (innerParams.input) {\n      handleConfirmOrDenyWithInput(instance, 'confirm');\n    } else {\n      confirm(instance, true);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   */\n  const handleDenyButtonClick = instance => {\n    const innerParams = privateProps.innerParams.get(instance);\n    instance.disableButtons();\n    if (innerParams.returnInputValueOnDeny) {\n      handleConfirmOrDenyWithInput(instance, 'deny');\n    } else {\n      deny(instance, false);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {Function} dismissWith\n   */\n  const handleCancelButtonClick = (instance, dismissWith) => {\n    instance.disableButtons();\n    dismissWith(DismissReason.cancel);\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {'confirm' | 'deny'} type\n   */\n  const handleConfirmOrDenyWithInput = (instance, type) => {\n    const innerParams = privateProps.innerParams.get(instance);\n    if (!innerParams.input) {\n      error(`The \"input\" parameter is needed to be set when using returnInputValueOn${capitalizeFirstLetter(type)}`);\n      return;\n    }\n    const input = instance.getInput();\n    const inputValue = getInputValue(instance, innerParams);\n    if (innerParams.inputValidator) {\n      handleInputValidator(instance, inputValue, type);\n    } else if (input && !input.checkValidity()) {\n      instance.enableButtons();\n      instance.showValidationMessage(innerParams.validationMessage || input.validationMessage);\n    } else if (type === 'deny') {\n      deny(instance, inputValue);\n    } else {\n      confirm(instance, inputValue);\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {SweetAlertInputValue} inputValue\n   * @param {'confirm' | 'deny'} type\n   */\n  const handleInputValidator = (instance, inputValue, type) => {\n    const innerParams = privateProps.innerParams.get(instance);\n    instance.disableInput();\n    const validationPromise = Promise.resolve().then(() => asPromise(innerParams.inputValidator(inputValue, innerParams.validationMessage)));\n    validationPromise.then(validationMessage => {\n      instance.enableButtons();\n      instance.enableInput();\n      if (validationMessage) {\n        instance.showValidationMessage(validationMessage);\n      } else if (type === 'deny') {\n        deny(instance, inputValue);\n      } else {\n        confirm(instance, inputValue);\n      }\n    });\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {any} value\n   */\n  const deny = (instance, value) => {\n    const innerParams = privateProps.innerParams.get(instance || undefined);\n    if (innerParams.showLoaderOnDeny) {\n      showLoading(getDenyButton());\n    }\n    if (innerParams.preDeny) {\n      instance.isAwaitingPromise = true; // Flagging the instance as awaiting a promise so it's own promise's reject/resolve methods doesn't get destroyed until the result from this preDeny's promise is received\n      const preDenyPromise = Promise.resolve().then(() => asPromise(innerParams.preDeny(value, innerParams.validationMessage)));\n      preDenyPromise.then(preDenyValue => {\n        if (preDenyValue === false) {\n          instance.hideLoading();\n          handleAwaitingPromise(instance);\n        } else {\n          instance.close({\n            isDenied: true,\n            value: typeof preDenyValue === 'undefined' ? value : preDenyValue\n          });\n        }\n      }).catch(error => rejectWith(instance || undefined, error));\n    } else {\n      instance.close({\n        isDenied: true,\n        value\n      });\n    }\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {any} value\n   */\n  const succeedWith = (instance, value) => {\n    instance.close({\n      isConfirmed: true,\n      value\n    });\n  };\n\n  /**\n   *\n   * @param {SweetAlert} instance\n   * @param {string} error\n   */\n  const rejectWith = (instance, error) => {\n    instance.rejectPromise(error);\n  };\n\n  /**\n   *\n   * @param {SweetAlert} instance\n   * @param {any} value\n   */\n  const confirm = (instance, value) => {\n    const innerParams = privateProps.innerParams.get(instance || undefined);\n    if (innerParams.showLoaderOnConfirm) {\n      showLoading();\n    }\n    if (innerParams.preConfirm) {\n      instance.resetValidationMessage();\n      instance.isAwaitingPromise = true; // Flagging the instance as awaiting a promise so it's own promise's reject/resolve methods doesn't get destroyed until the result from this preConfirm's promise is received\n      const preConfirmPromise = Promise.resolve().then(() => asPromise(innerParams.preConfirm(value, innerParams.validationMessage)));\n      preConfirmPromise.then(preConfirmValue => {\n        if (isVisible$1(getValidationMessage()) || preConfirmValue === false) {\n          instance.hideLoading();\n          handleAwaitingPromise(instance);\n        } else {\n          succeedWith(instance, typeof preConfirmValue === 'undefined' ? value : preConfirmValue);\n        }\n      }).catch(error => rejectWith(instance || undefined, error));\n    } else {\n      succeedWith(instance, value);\n    }\n  };\n\n  /**\n   * Hides loader and shows back the button which was hidden by .showLoading()\n   */\n  function hideLoading() {\n    // do nothing if popup is closed\n    const innerParams = privateProps.innerParams.get(this);\n    if (!innerParams) {\n      return;\n    }\n    const domCache = privateProps.domCache.get(this);\n    hide(domCache.loader);\n    if (isToast()) {\n      if (innerParams.icon) {\n        show(getIcon());\n      }\n    } else {\n      showRelatedButton(domCache);\n    }\n    removeClass([domCache.popup, domCache.actions], swalClasses.loading);\n    domCache.popup.removeAttribute('aria-busy');\n    domCache.popup.removeAttribute('data-loading');\n    domCache.confirmButton.disabled = false;\n    domCache.denyButton.disabled = false;\n    domCache.cancelButton.disabled = false;\n  }\n  const showRelatedButton = domCache => {\n    const buttonToReplace = domCache.popup.getElementsByClassName(domCache.loader.getAttribute('data-button-to-replace'));\n    if (buttonToReplace.length) {\n      show(buttonToReplace[0], 'inline-block');\n    } else if (allButtonsAreHidden()) {\n      hide(domCache.actions);\n    }\n  };\n\n  /**\n   * Gets the input DOM node, this method works with input parameter.\n   *\n   * @returns {HTMLInputElement | null}\n   */\n  function getInput() {\n    const innerParams = privateProps.innerParams.get(this);\n    const domCache = privateProps.domCache.get(this);\n    if (!domCache) {\n      return null;\n    }\n    return getInput$1(domCache.popup, innerParams.input);\n  }\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {string[]} buttons\n   * @param {boolean} disabled\n   */\n  function setButtonsDisabled(instance, buttons, disabled) {\n    const domCache = privateProps.domCache.get(instance);\n    buttons.forEach(button => {\n      domCache[button].disabled = disabled;\n    });\n  }\n\n  /**\n   * @param {HTMLInputElement | null} input\n   * @param {boolean} disabled\n   */\n  function setInputDisabled(input, disabled) {\n    const popup = getPopup();\n    if (!popup || !input) {\n      return;\n    }\n    if (input.type === 'radio') {\n      /** @type {NodeListOf<HTMLInputElement>} */\n      const radios = popup.querySelectorAll(`[name=\"${swalClasses.radio}\"]`);\n      for (let i = 0; i < radios.length; i++) {\n        radios[i].disabled = disabled;\n      }\n    } else {\n      input.disabled = disabled;\n    }\n  }\n\n  /**\n   * Enable all the buttons\n   * @this {SweetAlert}\n   */\n  function enableButtons() {\n    setButtonsDisabled(this, ['confirmButton', 'denyButton', 'cancelButton'], false);\n  }\n\n  /**\n   * Disable all the buttons\n   * @this {SweetAlert}\n   */\n  function disableButtons() {\n    setButtonsDisabled(this, ['confirmButton', 'denyButton', 'cancelButton'], true);\n  }\n\n  /**\n   * Enable the input field\n   * @this {SweetAlert}\n   */\n  function enableInput() {\n    setInputDisabled(this.getInput(), false);\n  }\n\n  /**\n   * Disable the input field\n   * @this {SweetAlert}\n   */\n  function disableInput() {\n    setInputDisabled(this.getInput(), true);\n  }\n\n  /**\n   * Show block with validation message\n   *\n   * @param {string} error\n   * @this {SweetAlert}\n   */\n  function showValidationMessage(error) {\n    const domCache = privateProps.domCache.get(this);\n    const params = privateProps.innerParams.get(this);\n    setInnerHtml(domCache.validationMessage, error);\n    domCache.validationMessage.className = swalClasses['validation-message'];\n    if (params.customClass && params.customClass.validationMessage) {\n      addClass(domCache.validationMessage, params.customClass.validationMessage);\n    }\n    show(domCache.validationMessage);\n    const input = this.getInput();\n    if (input) {\n      input.setAttribute('aria-invalid', 'true');\n      input.setAttribute('aria-describedby', swalClasses['validation-message']);\n      focusInput(input);\n      addClass(input, swalClasses.inputerror);\n    }\n  }\n\n  /**\n   * Hide block with validation message\n   *\n   * @this {SweetAlert}\n   */\n  function resetValidationMessage() {\n    const domCache = privateProps.domCache.get(this);\n    if (domCache.validationMessage) {\n      hide(domCache.validationMessage);\n    }\n    const input = this.getInput();\n    if (input) {\n      input.removeAttribute('aria-invalid');\n      input.removeAttribute('aria-describedby');\n      removeClass(input, swalClasses.inputerror);\n    }\n  }\n\n  const defaultParams = {\n    title: '',\n    titleText: '',\n    text: '',\n    html: '',\n    footer: '',\n    icon: undefined,\n    iconColor: undefined,\n    iconHtml: undefined,\n    template: undefined,\n    toast: false,\n    draggable: false,\n    animation: true,\n    theme: 'light',\n    showClass: {\n      popup: 'swal2-show',\n      backdrop: 'swal2-backdrop-show',\n      icon: 'swal2-icon-show'\n    },\n    hideClass: {\n      popup: 'swal2-hide',\n      backdrop: 'swal2-backdrop-hide',\n      icon: 'swal2-icon-hide'\n    },\n    customClass: {},\n    target: 'body',\n    color: undefined,\n    backdrop: true,\n    heightAuto: true,\n    allowOutsideClick: true,\n    allowEscapeKey: true,\n    allowEnterKey: true,\n    stopKeydownPropagation: true,\n    keydownListenerCapture: false,\n    showConfirmButton: true,\n    showDenyButton: false,\n    showCancelButton: false,\n    preConfirm: undefined,\n    preDeny: undefined,\n    confirmButtonText: 'OK',\n    confirmButtonAriaLabel: '',\n    confirmButtonColor: undefined,\n    denyButtonText: 'No',\n    denyButtonAriaLabel: '',\n    denyButtonColor: undefined,\n    cancelButtonText: 'Cancel',\n    cancelButtonAriaLabel: '',\n    cancelButtonColor: undefined,\n    buttonsStyling: true,\n    reverseButtons: false,\n    focusConfirm: true,\n    focusDeny: false,\n    focusCancel: false,\n    returnFocus: true,\n    showCloseButton: false,\n    closeButtonHtml: '&times;',\n    closeButtonAriaLabel: 'Close this dialog',\n    loaderHtml: '',\n    showLoaderOnConfirm: false,\n    showLoaderOnDeny: false,\n    imageUrl: undefined,\n    imageWidth: undefined,\n    imageHeight: undefined,\n    imageAlt: '',\n    timer: undefined,\n    timerProgressBar: false,\n    width: undefined,\n    padding: undefined,\n    background: undefined,\n    input: undefined,\n    inputPlaceholder: '',\n    inputLabel: '',\n    inputValue: '',\n    inputOptions: {},\n    inputAutoFocus: true,\n    inputAutoTrim: true,\n    inputAttributes: {},\n    inputValidator: undefined,\n    returnInputValueOnDeny: false,\n    validationMessage: undefined,\n    grow: false,\n    position: 'center',\n    progressSteps: [],\n    currentProgressStep: undefined,\n    progressStepsDistance: undefined,\n    willOpen: undefined,\n    didOpen: undefined,\n    didRender: undefined,\n    willClose: undefined,\n    didClose: undefined,\n    didDestroy: undefined,\n    scrollbarPadding: true\n  };\n  const updatableParams = ['allowEscapeKey', 'allowOutsideClick', 'background', 'buttonsStyling', 'cancelButtonAriaLabel', 'cancelButtonColor', 'cancelButtonText', 'closeButtonAriaLabel', 'closeButtonHtml', 'color', 'confirmButtonAriaLabel', 'confirmButtonColor', 'confirmButtonText', 'currentProgressStep', 'customClass', 'denyButtonAriaLabel', 'denyButtonColor', 'denyButtonText', 'didClose', 'didDestroy', 'draggable', 'footer', 'hideClass', 'html', 'icon', 'iconColor', 'iconHtml', 'imageAlt', 'imageHeight', 'imageUrl', 'imageWidth', 'preConfirm', 'preDeny', 'progressSteps', 'returnFocus', 'reverseButtons', 'showCancelButton', 'showCloseButton', 'showConfirmButton', 'showDenyButton', 'text', 'title', 'titleText', 'theme', 'willClose'];\n\n  /** @type {Record<string, string | undefined>} */\n  const deprecatedParams = {\n    allowEnterKey: undefined\n  };\n  const toastIncompatibleParams = ['allowOutsideClick', 'allowEnterKey', 'backdrop', 'draggable', 'focusConfirm', 'focusDeny', 'focusCancel', 'returnFocus', 'heightAuto', 'keydownListenerCapture'];\n\n  /**\n   * Is valid parameter\n   *\n   * @param {string} paramName\n   * @returns {boolean}\n   */\n  const isValidParameter = paramName => {\n    return Object.prototype.hasOwnProperty.call(defaultParams, paramName);\n  };\n\n  /**\n   * Is valid parameter for Swal.update() method\n   *\n   * @param {string} paramName\n   * @returns {boolean}\n   */\n  const isUpdatableParameter = paramName => {\n    return updatableParams.indexOf(paramName) !== -1;\n  };\n\n  /**\n   * Is deprecated parameter\n   *\n   * @param {string} paramName\n   * @returns {string | undefined}\n   */\n  const isDeprecatedParameter = paramName => {\n    return deprecatedParams[paramName];\n  };\n\n  /**\n   * @param {string} param\n   */\n  const checkIfParamIsValid = param => {\n    if (!isValidParameter(param)) {\n      warn(`Unknown parameter \"${param}\"`);\n    }\n  };\n\n  /**\n   * @param {string} param\n   */\n  const checkIfToastParamIsValid = param => {\n    if (toastIncompatibleParams.includes(param)) {\n      warn(`The parameter \"${param}\" is incompatible with toasts`);\n    }\n  };\n\n  /**\n   * @param {string} param\n   */\n  const checkIfParamIsDeprecated = param => {\n    const isDeprecated = isDeprecatedParameter(param);\n    if (isDeprecated) {\n      warnAboutDeprecation(param, isDeprecated);\n    }\n  };\n\n  /**\n   * Show relevant warnings for given params\n   *\n   * @param {SweetAlertOptions} params\n   */\n  const showWarningsForParams = params => {\n    if (params.backdrop === false && params.allowOutsideClick) {\n      warn('\"allowOutsideClick\" parameter requires `backdrop` parameter to be set to `true`');\n    }\n    if (params.theme && !['light', 'dark', 'auto', 'borderless'].includes(params.theme)) {\n      warn(`Invalid theme \"${params.theme}\". Expected \"light\", \"dark\", \"auto\", or \"borderless\"`);\n    }\n    for (const param in params) {\n      checkIfParamIsValid(param);\n      if (params.toast) {\n        checkIfToastParamIsValid(param);\n      }\n      checkIfParamIsDeprecated(param);\n    }\n  };\n\n  /**\n   * Updates popup parameters.\n   *\n   * @param {SweetAlertOptions} params\n   */\n  function update(params) {\n    const container = getContainer();\n    const popup = getPopup();\n    const innerParams = privateProps.innerParams.get(this);\n    if (!popup || hasClass(popup, innerParams.hideClass.popup)) {\n      warn(`You're trying to update the closed or closing popup, that won't work. Use the update() method in preConfirm parameter or show a new popup.`);\n      return;\n    }\n    const validUpdatableParams = filterValidParams(params);\n    const updatedParams = Object.assign({}, innerParams, validUpdatableParams);\n    showWarningsForParams(updatedParams);\n    container.dataset['swal2Theme'] = updatedParams.theme;\n    render(this, updatedParams);\n    privateProps.innerParams.set(this, updatedParams);\n    Object.defineProperties(this, {\n      params: {\n        value: Object.assign({}, this.params, params),\n        writable: false,\n        enumerable: true\n      }\n    });\n  }\n\n  /**\n   * @param {SweetAlertOptions} params\n   * @returns {SweetAlertOptions}\n   */\n  const filterValidParams = params => {\n    const validUpdatableParams = {};\n    Object.keys(params).forEach(param => {\n      if (isUpdatableParameter(param)) {\n        validUpdatableParams[param] = params[param];\n      } else {\n        warn(`Invalid parameter to update: ${param}`);\n      }\n    });\n    return validUpdatableParams;\n  };\n\n  /**\n   * Dispose the current SweetAlert2 instance\n   */\n  function _destroy() {\n    const domCache = privateProps.domCache.get(this);\n    const innerParams = privateProps.innerParams.get(this);\n    if (!innerParams) {\n      disposeWeakMaps(this); // The WeakMaps might have been partly destroyed, we must recall it to dispose any remaining WeakMaps #2335\n      return; // This instance has already been destroyed\n    }\n\n    // Check if there is another Swal closing\n    if (domCache.popup && globalState.swalCloseEventFinishedCallback) {\n      globalState.swalCloseEventFinishedCallback();\n      delete globalState.swalCloseEventFinishedCallback;\n    }\n    if (typeof innerParams.didDestroy === 'function') {\n      innerParams.didDestroy();\n    }\n    globalState.eventEmitter.emit('didDestroy');\n    disposeSwal(this);\n  }\n\n  /**\n   * @param {SweetAlert} instance\n   */\n  const disposeSwal = instance => {\n    disposeWeakMaps(instance);\n    // Unset this.params so GC will dispose it (#1569)\n    delete instance.params;\n    // Unset globalState props so GC will dispose globalState (#1569)\n    delete globalState.keydownHandler;\n    delete globalState.keydownTarget;\n    // Unset currentInstance\n    delete globalState.currentInstance;\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   */\n  const disposeWeakMaps = instance => {\n    // If the current instance is awaiting a promise result, we keep the privateMethods to call them once the promise result is retrieved #2335\n    if (instance.isAwaitingPromise) {\n      unsetWeakMaps(privateProps, instance);\n      instance.isAwaitingPromise = true;\n    } else {\n      unsetWeakMaps(privateMethods, instance);\n      unsetWeakMaps(privateProps, instance);\n      delete instance.isAwaitingPromise;\n      // Unset instance methods\n      delete instance.disableButtons;\n      delete instance.enableButtons;\n      delete instance.getInput;\n      delete instance.disableInput;\n      delete instance.enableInput;\n      delete instance.hideLoading;\n      delete instance.disableLoading;\n      delete instance.showValidationMessage;\n      delete instance.resetValidationMessage;\n      delete instance.close;\n      delete instance.closePopup;\n      delete instance.closeModal;\n      delete instance.closeToast;\n      delete instance.rejectPromise;\n      delete instance.update;\n      delete instance._destroy;\n    }\n  };\n\n  /**\n   * @param {object} obj\n   * @param {SweetAlert} instance\n   */\n  const unsetWeakMaps = (obj, instance) => {\n    for (const i in obj) {\n      obj[i].delete(instance);\n    }\n  };\n\n  var instanceMethods = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    _destroy: _destroy,\n    close: close,\n    closeModal: close,\n    closePopup: close,\n    closeToast: close,\n    disableButtons: disableButtons,\n    disableInput: disableInput,\n    disableLoading: hideLoading,\n    enableButtons: enableButtons,\n    enableInput: enableInput,\n    getInput: getInput,\n    handleAwaitingPromise: handleAwaitingPromise,\n    hideLoading: hideLoading,\n    rejectPromise: rejectPromise,\n    resetValidationMessage: resetValidationMessage,\n    showValidationMessage: showValidationMessage,\n    update: update\n  });\n\n  /**\n   * @param {SweetAlertOptions} innerParams\n   * @param {DomCache} domCache\n   * @param {Function} dismissWith\n   */\n  const handlePopupClick = (innerParams, domCache, dismissWith) => {\n    if (innerParams.toast) {\n      handleToastClick(innerParams, domCache, dismissWith);\n    } else {\n      // Ignore click events that had mousedown on the popup but mouseup on the container\n      // This can happen when the user drags a slider\n      handleModalMousedown(domCache);\n\n      // Ignore click events that had mousedown on the container but mouseup on the popup\n      handleContainerMousedown(domCache);\n      handleModalClick(innerParams, domCache, dismissWith);\n    }\n  };\n\n  /**\n   * @param {SweetAlertOptions} innerParams\n   * @param {DomCache} domCache\n   * @param {Function} dismissWith\n   */\n  const handleToastClick = (innerParams, domCache, dismissWith) => {\n    // Closing toast by internal click\n    domCache.popup.onclick = () => {\n      if (innerParams && (isAnyButtonShown(innerParams) || innerParams.timer || innerParams.input)) {\n        return;\n      }\n      dismissWith(DismissReason.close);\n    };\n  };\n\n  /**\n   * @param {SweetAlertOptions} innerParams\n   * @returns {boolean}\n   */\n  const isAnyButtonShown = innerParams => {\n    return !!(innerParams.showConfirmButton || innerParams.showDenyButton || innerParams.showCancelButton || innerParams.showCloseButton);\n  };\n  let ignoreOutsideClick = false;\n\n  /**\n   * @param {DomCache} domCache\n   */\n  const handleModalMousedown = domCache => {\n    domCache.popup.onmousedown = () => {\n      domCache.container.onmouseup = function (e) {\n        domCache.container.onmouseup = () => {};\n        // We only check if the mouseup target is the container because usually it doesn't\n        // have any other direct children aside of the popup\n        if (e.target === domCache.container) {\n          ignoreOutsideClick = true;\n        }\n      };\n    };\n  };\n\n  /**\n   * @param {DomCache} domCache\n   */\n  const handleContainerMousedown = domCache => {\n    domCache.container.onmousedown = e => {\n      // prevent the modal text from being selected on double click on the container (allowOutsideClick: false)\n      if (e.target === domCache.container) {\n        e.preventDefault();\n      }\n      domCache.popup.onmouseup = function (e) {\n        domCache.popup.onmouseup = () => {};\n        // We also need to check if the mouseup target is a child of the popup\n        if (e.target === domCache.popup || e.target instanceof HTMLElement && domCache.popup.contains(e.target)) {\n          ignoreOutsideClick = true;\n        }\n      };\n    };\n  };\n\n  /**\n   * @param {SweetAlertOptions} innerParams\n   * @param {DomCache} domCache\n   * @param {Function} dismissWith\n   */\n  const handleModalClick = (innerParams, domCache, dismissWith) => {\n    domCache.container.onclick = e => {\n      if (ignoreOutsideClick) {\n        ignoreOutsideClick = false;\n        return;\n      }\n      if (e.target === domCache.container && callIfFunction(innerParams.allowOutsideClick)) {\n        dismissWith(DismissReason.backdrop);\n      }\n    };\n  };\n\n  const isJqueryElement = elem => typeof elem === 'object' && elem.jquery;\n  const isElement = elem => elem instanceof Element || isJqueryElement(elem);\n  const argsToParams = args => {\n    const params = {};\n    if (typeof args[0] === 'object' && !isElement(args[0])) {\n      Object.assign(params, args[0]);\n    } else {\n      ['title', 'html', 'icon'].forEach((name, index) => {\n        const arg = args[index];\n        if (typeof arg === 'string' || isElement(arg)) {\n          params[name] = arg;\n        } else if (arg !== undefined) {\n          error(`Unexpected type of ${name}! Expected \"string\" or \"Element\", got ${typeof arg}`);\n        }\n      });\n    }\n    return params;\n  };\n\n  /**\n   * Main method to create a new SweetAlert2 popup\n   *\n   * @param  {...SweetAlertOptions} args\n   * @returns {Promise<SweetAlertResult>}\n   */\n  function fire() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return new this(...args);\n  }\n\n  /**\n   * Returns an extended version of `Swal` containing `params` as defaults.\n   * Useful for reusing Swal configuration.\n   *\n   * For example:\n   *\n   * Before:\n   * const textPromptOptions = { input: 'text', showCancelButton: true }\n   * const {value: firstName} = await Swal.fire({ ...textPromptOptions, title: 'What is your first name?' })\n   * const {value: lastName} = await Swal.fire({ ...textPromptOptions, title: 'What is your last name?' })\n   *\n   * After:\n   * const TextPrompt = Swal.mixin({ input: 'text', showCancelButton: true })\n   * const {value: firstName} = await TextPrompt('What is your first name?')\n   * const {value: lastName} = await TextPrompt('What is your last name?')\n   *\n   * @param {SweetAlertOptions} mixinParams\n   * @returns {SweetAlert}\n   */\n  function mixin(mixinParams) {\n    class MixinSwal extends this {\n      _main(params, priorityMixinParams) {\n        return super._main(params, Object.assign({}, mixinParams, priorityMixinParams));\n      }\n    }\n    // @ts-ignore\n    return MixinSwal;\n  }\n\n  /**\n   * If `timer` parameter is set, returns number of milliseconds of timer remained.\n   * Otherwise, returns undefined.\n   *\n   * @returns {number | undefined}\n   */\n  const getTimerLeft = () => {\n    return globalState.timeout && globalState.timeout.getTimerLeft();\n  };\n\n  /**\n   * Stop timer. Returns number of milliseconds of timer remained.\n   * If `timer` parameter isn't set, returns undefined.\n   *\n   * @returns {number | undefined}\n   */\n  const stopTimer = () => {\n    if (globalState.timeout) {\n      stopTimerProgressBar();\n      return globalState.timeout.stop();\n    }\n  };\n\n  /**\n   * Resume timer. Returns number of milliseconds of timer remained.\n   * If `timer` parameter isn't set, returns undefined.\n   *\n   * @returns {number | undefined}\n   */\n  const resumeTimer = () => {\n    if (globalState.timeout) {\n      const remaining = globalState.timeout.start();\n      animateTimerProgressBar(remaining);\n      return remaining;\n    }\n  };\n\n  /**\n   * Resume timer. Returns number of milliseconds of timer remained.\n   * If `timer` parameter isn't set, returns undefined.\n   *\n   * @returns {number | undefined}\n   */\n  const toggleTimer = () => {\n    const timer = globalState.timeout;\n    return timer && (timer.running ? stopTimer() : resumeTimer());\n  };\n\n  /**\n   * Increase timer. Returns number of milliseconds of an updated timer.\n   * If `timer` parameter isn't set, returns undefined.\n   *\n   * @param {number} ms\n   * @returns {number | undefined}\n   */\n  const increaseTimer = ms => {\n    if (globalState.timeout) {\n      const remaining = globalState.timeout.increase(ms);\n      animateTimerProgressBar(remaining, true);\n      return remaining;\n    }\n  };\n\n  /**\n   * Check if timer is running. Returns true if timer is running\n   * or false if timer is paused or stopped.\n   * If `timer` parameter isn't set, returns undefined\n   *\n   * @returns {boolean}\n   */\n  const isTimerRunning = () => {\n    return !!(globalState.timeout && globalState.timeout.isRunning());\n  };\n\n  let bodyClickListenerAdded = false;\n  const clickHandlers = {};\n\n  /**\n   * @param {string} attr\n   */\n  function bindClickHandler() {\n    let attr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'data-swal-template';\n    clickHandlers[attr] = this;\n    if (!bodyClickListenerAdded) {\n      document.body.addEventListener('click', bodyClickListener);\n      bodyClickListenerAdded = true;\n    }\n  }\n  const bodyClickListener = event => {\n    for (let el = event.target; el && el !== document; el = el.parentNode) {\n      for (const attr in clickHandlers) {\n        const template = el.getAttribute(attr);\n        if (template) {\n          clickHandlers[attr].fire({\n            template\n          });\n          return;\n        }\n      }\n    }\n  };\n\n  // Source: https://gist.github.com/mudge/5830382?permalink_comment_id=2691957#gistcomment-2691957\n\n  class EventEmitter {\n    constructor() {\n      /** @type {Events} */\n      this.events = {};\n    }\n\n    /**\n     * @param {string} eventName\n     * @returns {EventHandlers}\n     */\n    _getHandlersByEventName(eventName) {\n      if (typeof this.events[eventName] === 'undefined') {\n        // not Set because we need to keep the FIFO order\n        // https://github.com/sweetalert2/sweetalert2/pull/2763#discussion_r1748990334\n        this.events[eventName] = [];\n      }\n      return this.events[eventName];\n    }\n\n    /**\n     * @param {string} eventName\n     * @param {EventHandler} eventHandler\n     */\n    on(eventName, eventHandler) {\n      const currentHandlers = this._getHandlersByEventName(eventName);\n      if (!currentHandlers.includes(eventHandler)) {\n        currentHandlers.push(eventHandler);\n      }\n    }\n\n    /**\n     * @param {string} eventName\n     * @param {EventHandler} eventHandler\n     */\n    once(eventName, eventHandler) {\n      var _this = this;\n      /**\n       * @param {Array} args\n       */\n      const onceFn = function () {\n        _this.removeListener(eventName, onceFn);\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n        eventHandler.apply(_this, args);\n      };\n      this.on(eventName, onceFn);\n    }\n\n    /**\n     * @param {string} eventName\n     * @param {Array} args\n     */\n    emit(eventName) {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n      this._getHandlersByEventName(eventName).forEach(\n      /**\n       * @param {EventHandler} eventHandler\n       */\n      eventHandler => {\n        try {\n          eventHandler.apply(this, args);\n        } catch (error) {\n          console.error(error);\n        }\n      });\n    }\n\n    /**\n     * @param {string} eventName\n     * @param {EventHandler} eventHandler\n     */\n    removeListener(eventName, eventHandler) {\n      const currentHandlers = this._getHandlersByEventName(eventName);\n      const index = currentHandlers.indexOf(eventHandler);\n      if (index > -1) {\n        currentHandlers.splice(index, 1);\n      }\n    }\n\n    /**\n     * @param {string} eventName\n     */\n    removeAllListeners(eventName) {\n      if (this.events[eventName] !== undefined) {\n        // https://github.com/sweetalert2/sweetalert2/pull/2763#discussion_r1749239222\n        this.events[eventName].length = 0;\n      }\n    }\n    reset() {\n      this.events = {};\n    }\n  }\n\n  globalState.eventEmitter = new EventEmitter();\n\n  /**\n   * @param {string} eventName\n   * @param {EventHandler} eventHandler\n   */\n  const on = (eventName, eventHandler) => {\n    globalState.eventEmitter.on(eventName, eventHandler);\n  };\n\n  /**\n   * @param {string} eventName\n   * @param {EventHandler} eventHandler\n   */\n  const once = (eventName, eventHandler) => {\n    globalState.eventEmitter.once(eventName, eventHandler);\n  };\n\n  /**\n   * @param {string} [eventName]\n   * @param {EventHandler} [eventHandler]\n   */\n  const off = (eventName, eventHandler) => {\n    // Remove all handlers for all events\n    if (!eventName) {\n      globalState.eventEmitter.reset();\n      return;\n    }\n    if (eventHandler) {\n      // Remove a specific handler\n      globalState.eventEmitter.removeListener(eventName, eventHandler);\n    } else {\n      // Remove all handlers for a specific event\n      globalState.eventEmitter.removeAllListeners(eventName);\n    }\n  };\n\n  var staticMethods = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    argsToParams: argsToParams,\n    bindClickHandler: bindClickHandler,\n    clickCancel: clickCancel,\n    clickConfirm: clickConfirm,\n    clickDeny: clickDeny,\n    enableLoading: showLoading,\n    fire: fire,\n    getActions: getActions,\n    getCancelButton: getCancelButton,\n    getCloseButton: getCloseButton,\n    getConfirmButton: getConfirmButton,\n    getContainer: getContainer,\n    getDenyButton: getDenyButton,\n    getFocusableElements: getFocusableElements,\n    getFooter: getFooter,\n    getHtmlContainer: getHtmlContainer,\n    getIcon: getIcon,\n    getIconContent: getIconContent,\n    getImage: getImage,\n    getInputLabel: getInputLabel,\n    getLoader: getLoader,\n    getPopup: getPopup,\n    getProgressSteps: getProgressSteps,\n    getTimerLeft: getTimerLeft,\n    getTimerProgressBar: getTimerProgressBar,\n    getTitle: getTitle,\n    getValidationMessage: getValidationMessage,\n    increaseTimer: increaseTimer,\n    isDeprecatedParameter: isDeprecatedParameter,\n    isLoading: isLoading,\n    isTimerRunning: isTimerRunning,\n    isUpdatableParameter: isUpdatableParameter,\n    isValidParameter: isValidParameter,\n    isVisible: isVisible,\n    mixin: mixin,\n    off: off,\n    on: on,\n    once: once,\n    resumeTimer: resumeTimer,\n    showLoading: showLoading,\n    stopTimer: stopTimer,\n    toggleTimer: toggleTimer\n  });\n\n  class Timer {\n    /**\n     * @param {Function} callback\n     * @param {number} delay\n     */\n    constructor(callback, delay) {\n      this.callback = callback;\n      this.remaining = delay;\n      this.running = false;\n      this.start();\n    }\n\n    /**\n     * @returns {number}\n     */\n    start() {\n      if (!this.running) {\n        this.running = true;\n        this.started = new Date();\n        this.id = setTimeout(this.callback, this.remaining);\n      }\n      return this.remaining;\n    }\n\n    /**\n     * @returns {number}\n     */\n    stop() {\n      if (this.started && this.running) {\n        this.running = false;\n        clearTimeout(this.id);\n        this.remaining -= new Date().getTime() - this.started.getTime();\n      }\n      return this.remaining;\n    }\n\n    /**\n     * @param {number} n\n     * @returns {number}\n     */\n    increase(n) {\n      const running = this.running;\n      if (running) {\n        this.stop();\n      }\n      this.remaining += n;\n      if (running) {\n        this.start();\n      }\n      return this.remaining;\n    }\n\n    /**\n     * @returns {number}\n     */\n    getTimerLeft() {\n      if (this.running) {\n        this.stop();\n        this.start();\n      }\n      return this.remaining;\n    }\n\n    /**\n     * @returns {boolean}\n     */\n    isRunning() {\n      return this.running;\n    }\n  }\n\n  const swalStringParams = ['swal-title', 'swal-html', 'swal-footer'];\n\n  /**\n   * @param {SweetAlertOptions} params\n   * @returns {SweetAlertOptions}\n   */\n  const getTemplateParams = params => {\n    const template = typeof params.template === 'string' ? (/** @type {HTMLTemplateElement} */document.querySelector(params.template)) : params.template;\n    if (!template) {\n      return {};\n    }\n    /** @type {DocumentFragment} */\n    const templateContent = template.content;\n    showWarningsForElements(templateContent);\n    const result = Object.assign(getSwalParams(templateContent), getSwalFunctionParams(templateContent), getSwalButtons(templateContent), getSwalImage(templateContent), getSwalIcon(templateContent), getSwalInput(templateContent), getSwalStringParams(templateContent, swalStringParams));\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Record<string, any>}\n   */\n  const getSwalParams = templateContent => {\n    /** @type {Record<string, any>} */\n    const result = {};\n    /** @type {HTMLElement[]} */\n    const swalParams = Array.from(templateContent.querySelectorAll('swal-param'));\n    swalParams.forEach(param => {\n      showWarningsForAttributes(param, ['name', 'value']);\n      const paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');\n      const value = param.getAttribute('value');\n      if (!paramName || !value) {\n        return;\n      }\n      if (typeof defaultParams[paramName] === 'boolean') {\n        result[paramName] = value !== 'false';\n      } else if (typeof defaultParams[paramName] === 'object') {\n        result[paramName] = JSON.parse(value);\n      } else {\n        result[paramName] = value;\n      }\n    });\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Record<string, any>}\n   */\n  const getSwalFunctionParams = templateContent => {\n    /** @type {Record<string, any>} */\n    const result = {};\n    /** @type {HTMLElement[]} */\n    const swalFunctions = Array.from(templateContent.querySelectorAll('swal-function-param'));\n    swalFunctions.forEach(param => {\n      const paramName = /** @type {keyof SweetAlertOptions} */param.getAttribute('name');\n      const value = param.getAttribute('value');\n      if (!paramName || !value) {\n        return;\n      }\n      result[paramName] = new Function(`return ${value}`)();\n    });\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Record<string, any>}\n   */\n  const getSwalButtons = templateContent => {\n    /** @type {Record<string, any>} */\n    const result = {};\n    /** @type {HTMLElement[]} */\n    const swalButtons = Array.from(templateContent.querySelectorAll('swal-button'));\n    swalButtons.forEach(button => {\n      showWarningsForAttributes(button, ['type', 'color', 'aria-label']);\n      const type = button.getAttribute('type');\n      if (!type || !['confirm', 'cancel', 'deny'].includes(type)) {\n        return;\n      }\n      result[`${type}ButtonText`] = button.innerHTML;\n      result[`show${capitalizeFirstLetter(type)}Button`] = true;\n      if (button.hasAttribute('color')) {\n        result[`${type}ButtonColor`] = button.getAttribute('color');\n      }\n      if (button.hasAttribute('aria-label')) {\n        result[`${type}ButtonAriaLabel`] = button.getAttribute('aria-label');\n      }\n    });\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Pick<SweetAlertOptions, 'imageUrl' | 'imageWidth' | 'imageHeight' | 'imageAlt'>}\n   */\n  const getSwalImage = templateContent => {\n    const result = {};\n    /** @type {HTMLElement | null} */\n    const image = templateContent.querySelector('swal-image');\n    if (image) {\n      showWarningsForAttributes(image, ['src', 'width', 'height', 'alt']);\n      if (image.hasAttribute('src')) {\n        result.imageUrl = image.getAttribute('src') || undefined;\n      }\n      if (image.hasAttribute('width')) {\n        result.imageWidth = image.getAttribute('width') || undefined;\n      }\n      if (image.hasAttribute('height')) {\n        result.imageHeight = image.getAttribute('height') || undefined;\n      }\n      if (image.hasAttribute('alt')) {\n        result.imageAlt = image.getAttribute('alt') || undefined;\n      }\n    }\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Record<string, any>}\n   */\n  const getSwalIcon = templateContent => {\n    const result = {};\n    /** @type {HTMLElement | null} */\n    const icon = templateContent.querySelector('swal-icon');\n    if (icon) {\n      showWarningsForAttributes(icon, ['type', 'color']);\n      if (icon.hasAttribute('type')) {\n        result.icon = icon.getAttribute('type');\n      }\n      if (icon.hasAttribute('color')) {\n        result.iconColor = icon.getAttribute('color');\n      }\n      result.iconHtml = icon.innerHTML;\n    }\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @returns {Record<string, any>}\n   */\n  const getSwalInput = templateContent => {\n    /** @type {Record<string, any>} */\n    const result = {};\n    /** @type {HTMLElement | null} */\n    const input = templateContent.querySelector('swal-input');\n    if (input) {\n      showWarningsForAttributes(input, ['type', 'label', 'placeholder', 'value']);\n      result.input = input.getAttribute('type') || 'text';\n      if (input.hasAttribute('label')) {\n        result.inputLabel = input.getAttribute('label');\n      }\n      if (input.hasAttribute('placeholder')) {\n        result.inputPlaceholder = input.getAttribute('placeholder');\n      }\n      if (input.hasAttribute('value')) {\n        result.inputValue = input.getAttribute('value');\n      }\n    }\n    /** @type {HTMLElement[]} */\n    const inputOptions = Array.from(templateContent.querySelectorAll('swal-input-option'));\n    if (inputOptions.length) {\n      result.inputOptions = {};\n      inputOptions.forEach(option => {\n        showWarningsForAttributes(option, ['value']);\n        const optionValue = option.getAttribute('value');\n        if (!optionValue) {\n          return;\n        }\n        const optionName = option.innerHTML;\n        result.inputOptions[optionValue] = optionName;\n      });\n    }\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   * @param {string[]} paramNames\n   * @returns {Record<string, any>}\n   */\n  const getSwalStringParams = (templateContent, paramNames) => {\n    /** @type {Record<string, any>} */\n    const result = {};\n    for (const i in paramNames) {\n      const paramName = paramNames[i];\n      /** @type {HTMLElement | null} */\n      const tag = templateContent.querySelector(paramName);\n      if (tag) {\n        showWarningsForAttributes(tag, []);\n        result[paramName.replace(/^swal-/, '')] = tag.innerHTML.trim();\n      }\n    }\n    return result;\n  };\n\n  /**\n   * @param {DocumentFragment} templateContent\n   */\n  const showWarningsForElements = templateContent => {\n    const allowedElements = swalStringParams.concat(['swal-param', 'swal-function-param', 'swal-button', 'swal-image', 'swal-icon', 'swal-input', 'swal-input-option']);\n    Array.from(templateContent.children).forEach(el => {\n      const tagName = el.tagName.toLowerCase();\n      if (!allowedElements.includes(tagName)) {\n        warn(`Unrecognized element <${tagName}>`);\n      }\n    });\n  };\n\n  /**\n   * @param {HTMLElement} el\n   * @param {string[]} allowedAttributes\n   */\n  const showWarningsForAttributes = (el, allowedAttributes) => {\n    Array.from(el.attributes).forEach(attribute => {\n      if (allowedAttributes.indexOf(attribute.name) === -1) {\n        warn([`Unrecognized attribute \"${attribute.name}\" on <${el.tagName.toLowerCase()}>.`, `${allowedAttributes.length ? `Allowed attributes are: ${allowedAttributes.join(', ')}` : 'To set the value, use HTML within the element.'}`]);\n      }\n    });\n  };\n\n  const SHOW_CLASS_TIMEOUT = 10;\n\n  /**\n   * Open popup, add necessary classes and styles, fix scrollbar\n   *\n   * @param {SweetAlertOptions} params\n   */\n  const openPopup = params => {\n    const container = getContainer();\n    const popup = getPopup();\n    if (typeof params.willOpen === 'function') {\n      params.willOpen(popup);\n    }\n    globalState.eventEmitter.emit('willOpen', popup);\n    const bodyStyles = window.getComputedStyle(document.body);\n    const initialBodyOverflow = bodyStyles.overflowY;\n    addClasses(container, popup, params);\n\n    // scrolling is 'hidden' until animation is done, after that 'auto'\n    setTimeout(() => {\n      setScrollingVisibility(container, popup);\n    }, SHOW_CLASS_TIMEOUT);\n    if (isModal()) {\n      fixScrollContainer(container, params.scrollbarPadding, initialBodyOverflow);\n      setAriaHidden();\n    }\n    if (!isToast() && !globalState.previousActiveElement) {\n      globalState.previousActiveElement = document.activeElement;\n    }\n    if (typeof params.didOpen === 'function') {\n      setTimeout(() => params.didOpen(popup));\n    }\n    globalState.eventEmitter.emit('didOpen', popup);\n    removeClass(container, swalClasses['no-transition']);\n  };\n\n  /**\n   * @param {AnimationEvent} event\n   */\n  const swalOpenAnimationFinished = event => {\n    const popup = getPopup();\n    if (event.target !== popup) {\n      return;\n    }\n    const container = getContainer();\n    popup.removeEventListener('animationend', swalOpenAnimationFinished);\n    popup.removeEventListener('transitionend', swalOpenAnimationFinished);\n    container.style.overflowY = 'auto';\n  };\n\n  /**\n   * @param {HTMLElement} container\n   * @param {HTMLElement} popup\n   */\n  const setScrollingVisibility = (container, popup) => {\n    if (hasCssAnimation(popup)) {\n      container.style.overflowY = 'hidden';\n      popup.addEventListener('animationend', swalOpenAnimationFinished);\n      popup.addEventListener('transitionend', swalOpenAnimationFinished);\n    } else {\n      container.style.overflowY = 'auto';\n    }\n  };\n\n  /**\n   * @param {HTMLElement} container\n   * @param {boolean} scrollbarPadding\n   * @param {string} initialBodyOverflow\n   */\n  const fixScrollContainer = (container, scrollbarPadding, initialBodyOverflow) => {\n    iOSfix();\n    if (scrollbarPadding && initialBodyOverflow !== 'hidden') {\n      replaceScrollbarWithPadding(initialBodyOverflow);\n    }\n\n    // sweetalert2/issues/1247\n    setTimeout(() => {\n      container.scrollTop = 0;\n    });\n  };\n\n  /**\n   * @param {HTMLElement} container\n   * @param {HTMLElement} popup\n   * @param {SweetAlertOptions} params\n   */\n  const addClasses = (container, popup, params) => {\n    addClass(container, params.showClass.backdrop);\n    if (params.animation) {\n      // this workaround with opacity is needed for https://github.com/sweetalert2/sweetalert2/issues/2059\n      popup.style.setProperty('opacity', '0', 'important');\n      show(popup, 'grid');\n      setTimeout(() => {\n        // Animate popup right after showing it\n        addClass(popup, params.showClass.popup);\n        // and remove the opacity workaround\n        popup.style.removeProperty('opacity');\n      }, SHOW_CLASS_TIMEOUT); // 10ms in order to fix #2062\n    } else {\n      show(popup, 'grid');\n    }\n    addClass([document.documentElement, document.body], swalClasses.shown);\n    if (params.heightAuto && params.backdrop && !params.toast) {\n      addClass([document.documentElement, document.body], swalClasses['height-auto']);\n    }\n  };\n\n  var defaultInputValidators = {\n    /**\n     * @param {string} string\n     * @param {string} [validationMessage]\n     * @returns {Promise<string | void>}\n     */\n    email: (string, validationMessage) => {\n      return /^[a-zA-Z0-9.+_'-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z0-9-]+$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid email address');\n    },\n    /**\n     * @param {string} string\n     * @param {string} [validationMessage]\n     * @returns {Promise<string | void>}\n     */\n    url: (string, validationMessage) => {\n      // taken from https://stackoverflow.com/a/3809435 with a small change from #1306 and #2013\n      return /^https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\\.[a-z]{2,63}\\b([-a-zA-Z0-9@:%_+.~#?&/=]*)$/.test(string) ? Promise.resolve() : Promise.resolve(validationMessage || 'Invalid URL');\n    }\n  };\n\n  /**\n   * @param {SweetAlertOptions} params\n   */\n  function setDefaultInputValidators(params) {\n    // Use default `inputValidator` for supported input types if not provided\n    if (params.inputValidator) {\n      return;\n    }\n    if (params.input === 'email') {\n      params.inputValidator = defaultInputValidators['email'];\n    }\n    if (params.input === 'url') {\n      params.inputValidator = defaultInputValidators['url'];\n    }\n  }\n\n  /**\n   * @param {SweetAlertOptions} params\n   */\n  function validateCustomTargetElement(params) {\n    // Determine if the custom target element is valid\n    if (!params.target || typeof params.target === 'string' && !document.querySelector(params.target) || typeof params.target !== 'string' && !params.target.appendChild) {\n      warn('Target parameter is not valid, defaulting to \"body\"');\n      params.target = 'body';\n    }\n  }\n\n  /**\n   * Set type, text and actions on popup\n   *\n   * @param {SweetAlertOptions} params\n   */\n  function setParameters(params) {\n    setDefaultInputValidators(params);\n\n    // showLoaderOnConfirm && preConfirm\n    if (params.showLoaderOnConfirm && !params.preConfirm) {\n      warn('showLoaderOnConfirm is set to true, but preConfirm is not defined.\\n' + 'showLoaderOnConfirm should be used together with preConfirm, see usage example:\\n' + 'https://sweetalert2.github.io/#ajax-request');\n    }\n    validateCustomTargetElement(params);\n\n    // Replace newlines with <br> in title\n    if (typeof params.title === 'string') {\n      params.title = params.title.split('\\n').join('<br />');\n    }\n    init(params);\n  }\n\n  /** @type {SweetAlert} */\n  let currentInstance;\n  var _promise = /*#__PURE__*/new WeakMap();\n  class SweetAlert {\n    /**\n     * @param {...any} args\n     * @this {SweetAlert}\n     */\n    constructor() {\n      /**\n       * @type {Promise<SweetAlertResult>}\n       */\n      _classPrivateFieldInitSpec(this, _promise, void 0);\n      // Prevent run in Node env\n      if (typeof window === 'undefined') {\n        return;\n      }\n      currentInstance = this;\n\n      // @ts-ignore\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n      const outerParams = Object.freeze(this.constructor.argsToParams(args));\n\n      /** @type {Readonly<SweetAlertOptions>} */\n      this.params = outerParams;\n\n      /** @type {boolean} */\n      this.isAwaitingPromise = false;\n      _classPrivateFieldSet2(_promise, this, this._main(currentInstance.params));\n    }\n    _main(userParams) {\n      let mixinParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      showWarningsForParams(Object.assign({}, mixinParams, userParams));\n      if (globalState.currentInstance) {\n        const swalPromiseResolve = privateMethods.swalPromiseResolve.get(globalState.currentInstance);\n        const {\n          isAwaitingPromise\n        } = globalState.currentInstance;\n        globalState.currentInstance._destroy();\n        if (!isAwaitingPromise) {\n          swalPromiseResolve({\n            isDismissed: true\n          });\n        }\n        if (isModal()) {\n          unsetAriaHidden();\n        }\n      }\n      globalState.currentInstance = currentInstance;\n      const innerParams = prepareParams(userParams, mixinParams);\n      setParameters(innerParams);\n      Object.freeze(innerParams);\n\n      // clear the previous timer\n      if (globalState.timeout) {\n        globalState.timeout.stop();\n        delete globalState.timeout;\n      }\n\n      // clear the restore focus timeout\n      clearTimeout(globalState.restoreFocusTimeout);\n      const domCache = populateDomCache(currentInstance);\n      render(currentInstance, innerParams);\n      privateProps.innerParams.set(currentInstance, innerParams);\n      return swalPromise(currentInstance, domCache, innerParams);\n    }\n\n    // `catch` cannot be the name of a module export, so we define our thenable methods here instead\n    then(onFulfilled) {\n      return _classPrivateFieldGet2(_promise, this).then(onFulfilled);\n    }\n    finally(onFinally) {\n      return _classPrivateFieldGet2(_promise, this).finally(onFinally);\n    }\n  }\n\n  /**\n   * @param {SweetAlert} instance\n   * @param {DomCache} domCache\n   * @param {SweetAlertOptions} innerParams\n   * @returns {Promise}\n   */\n  const swalPromise = (instance, domCache, innerParams) => {\n    return new Promise((resolve, reject) => {\n      // functions to handle all closings/dismissals\n      /**\n       * @param {DismissReason} dismiss\n       */\n      const dismissWith = dismiss => {\n        instance.close({\n          isDismissed: true,\n          dismiss\n        });\n      };\n      privateMethods.swalPromiseResolve.set(instance, resolve);\n      privateMethods.swalPromiseReject.set(instance, reject);\n      domCache.confirmButton.onclick = () => {\n        handleConfirmButtonClick(instance);\n      };\n      domCache.denyButton.onclick = () => {\n        handleDenyButtonClick(instance);\n      };\n      domCache.cancelButton.onclick = () => {\n        handleCancelButtonClick(instance, dismissWith);\n      };\n      domCache.closeButton.onclick = () => {\n        dismissWith(DismissReason.close);\n      };\n      handlePopupClick(innerParams, domCache, dismissWith);\n      addKeydownHandler(globalState, innerParams, dismissWith);\n      handleInputOptionsAndValue(instance, innerParams);\n      openPopup(innerParams);\n      setupTimer(globalState, innerParams, dismissWith);\n      initFocus(domCache, innerParams);\n\n      // Scroll container to top on open (#1247, #1946)\n      setTimeout(() => {\n        domCache.container.scrollTop = 0;\n      });\n    });\n  };\n\n  /**\n   * @param {SweetAlertOptions} userParams\n   * @param {SweetAlertOptions} mixinParams\n   * @returns {SweetAlertOptions}\n   */\n  const prepareParams = (userParams, mixinParams) => {\n    const templateParams = getTemplateParams(userParams);\n    const params = Object.assign({}, defaultParams, mixinParams, templateParams, userParams); // precedence is described in #2131\n    params.showClass = Object.assign({}, defaultParams.showClass, params.showClass);\n    params.hideClass = Object.assign({}, defaultParams.hideClass, params.hideClass);\n    if (params.animation === false) {\n      params.showClass = {\n        backdrop: 'swal2-noanimation'\n      };\n      params.hideClass = {};\n    }\n    return params;\n  };\n\n  /**\n   * @param {SweetAlert} instance\n   * @returns {DomCache}\n   */\n  const populateDomCache = instance => {\n    const domCache = {\n      popup: getPopup(),\n      container: getContainer(),\n      actions: getActions(),\n      confirmButton: getConfirmButton(),\n      denyButton: getDenyButton(),\n      cancelButton: getCancelButton(),\n      loader: getLoader(),\n      closeButton: getCloseButton(),\n      validationMessage: getValidationMessage(),\n      progressSteps: getProgressSteps()\n    };\n    privateProps.domCache.set(instance, domCache);\n    return domCache;\n  };\n\n  /**\n   * @param {GlobalState} globalState\n   * @param {SweetAlertOptions} innerParams\n   * @param {Function} dismissWith\n   */\n  const setupTimer = (globalState, innerParams, dismissWith) => {\n    const timerProgressBar = getTimerProgressBar();\n    hide(timerProgressBar);\n    if (innerParams.timer) {\n      globalState.timeout = new Timer(() => {\n        dismissWith('timer');\n        delete globalState.timeout;\n      }, innerParams.timer);\n      if (innerParams.timerProgressBar) {\n        show(timerProgressBar);\n        applyCustomClass(timerProgressBar, innerParams, 'timerProgressBar');\n        setTimeout(() => {\n          if (globalState.timeout && globalState.timeout.running) {\n            // timer can be already stopped or unset at this point\n            animateTimerProgressBar(innerParams.timer);\n          }\n        });\n      }\n    }\n  };\n\n  /**\n   * Initialize focus in the popup:\n   *\n   * 1. If `toast` is `true`, don't steal focus from the document.\n   * 2. Else if there is an [autofocus] element, focus it.\n   * 3. Else if `focusConfirm` is `true` and confirm button is visible, focus it.\n   * 4. Else if `focusDeny` is `true` and deny button is visible, focus it.\n   * 5. Else if `focusCancel` is `true` and cancel button is visible, focus it.\n   * 6. Else focus the first focusable element in a popup (if any).\n   *\n   * @param {DomCache} domCache\n   * @param {SweetAlertOptions} innerParams\n   */\n  const initFocus = (domCache, innerParams) => {\n    if (innerParams.toast) {\n      return;\n    }\n    // TODO: this is dumb, remove `allowEnterKey` param in the next major version\n    if (!callIfFunction(innerParams.allowEnterKey)) {\n      warnAboutDeprecation('allowEnterKey');\n      blurActiveElement();\n      return;\n    }\n    if (focusAutofocus(domCache)) {\n      return;\n    }\n    if (focusButton(domCache, innerParams)) {\n      return;\n    }\n    setFocus(-1, 1);\n  };\n\n  /**\n   * @param {DomCache} domCache\n   * @returns {boolean}\n   */\n  const focusAutofocus = domCache => {\n    const autofocusElements = Array.from(domCache.popup.querySelectorAll('[autofocus]'));\n    for (const autofocusElement of autofocusElements) {\n      if (autofocusElement instanceof HTMLElement && isVisible$1(autofocusElement)) {\n        autofocusElement.focus();\n        return true;\n      }\n    }\n    return false;\n  };\n\n  /**\n   * @param {DomCache} domCache\n   * @param {SweetAlertOptions} innerParams\n   * @returns {boolean}\n   */\n  const focusButton = (domCache, innerParams) => {\n    if (innerParams.focusDeny && isVisible$1(domCache.denyButton)) {\n      domCache.denyButton.focus();\n      return true;\n    }\n    if (innerParams.focusCancel && isVisible$1(domCache.cancelButton)) {\n      domCache.cancelButton.focus();\n      return true;\n    }\n    if (innerParams.focusConfirm && isVisible$1(domCache.confirmButton)) {\n      domCache.confirmButton.focus();\n      return true;\n    }\n    return false;\n  };\n  const blurActiveElement = () => {\n    if (document.activeElement instanceof HTMLElement && typeof document.activeElement.blur === 'function') {\n      document.activeElement.blur();\n    }\n  };\n\n  // Dear russian users visiting russian sites. Let's have fun.\n  if (typeof window !== 'undefined' && /^ru\\b/.test(navigator.language) && location.host.match(/\\.(ru|su|by|xn--p1ai)$/)) {\n    const now = new Date();\n    const initiationDate = localStorage.getItem('swal-initiation');\n    if (!initiationDate) {\n      localStorage.setItem('swal-initiation', `${now}`);\n    } else if ((now.getTime() - Date.parse(initiationDate)) / (1000 * 60 * 60 * 24) > 3) {\n      setTimeout(() => {\n        document.body.style.pointerEvents = 'none';\n        const ukrainianAnthem = document.createElement('audio');\n        ukrainianAnthem.src = 'https://flag-gimn.ru/wp-content/uploads/2021/09/Ukraina.mp3';\n        ukrainianAnthem.loop = true;\n        document.body.appendChild(ukrainianAnthem);\n        setTimeout(() => {\n          ukrainianAnthem.play().catch(() => {\n            // ignore\n          });\n        }, 2500);\n      }, 500);\n    }\n  }\n\n  // Assign instance methods from src/instanceMethods/*.js to prototype\n  SweetAlert.prototype.disableButtons = disableButtons;\n  SweetAlert.prototype.enableButtons = enableButtons;\n  SweetAlert.prototype.getInput = getInput;\n  SweetAlert.prototype.disableInput = disableInput;\n  SweetAlert.prototype.enableInput = enableInput;\n  SweetAlert.prototype.hideLoading = hideLoading;\n  SweetAlert.prototype.disableLoading = hideLoading;\n  SweetAlert.prototype.showValidationMessage = showValidationMessage;\n  SweetAlert.prototype.resetValidationMessage = resetValidationMessage;\n  SweetAlert.prototype.close = close;\n  SweetAlert.prototype.closePopup = close;\n  SweetAlert.prototype.closeModal = close;\n  SweetAlert.prototype.closeToast = close;\n  SweetAlert.prototype.rejectPromise = rejectPromise;\n  SweetAlert.prototype.update = update;\n  SweetAlert.prototype._destroy = _destroy;\n\n  // Assign static methods from src/staticMethods/*.js to constructor\n  Object.assign(SweetAlert, staticMethods);\n\n  // Proxy to instance methods to constructor, for now, for backwards compatibility\n  Object.keys(instanceMethods).forEach(key => {\n    /**\n     * @param {...any} args\n     * @returns {any | undefined}\n     */\n    SweetAlert[key] = function () {\n      if (currentInstance && currentInstance[key]) {\n        return currentInstance[key](...arguments);\n      }\n      return null;\n    };\n  });\n  SweetAlert.DismissReason = DismissReason;\n  SweetAlert.version = '11.17.2';\n\n  const Swal = SweetAlert;\n  // @ts-ignore\n  Swal.default = Swal;\n\n  return Swal;\n\n}));\nif (typeof this !== 'undefined' && this.Sweetalert2){this.swal = this.sweetAlert = this.Swal = this.SweetAlert = this.Sweetalert2}\n\"undefined\"!=typeof document&&function(e,t){var n=e.createElement(\"style\");if(e.getElementsByTagName(\"head\")[0].appendChild(n),n.styleSheet)n.styleSheet.disabled||(n.styleSheet.cssText=t);else try{n.innerHTML=t}catch(e){n.innerText=t}}(document,\":root{--swal2-container-padding: 0.625em;--swal2-backdrop: rgba(0, 0, 0, 0.4);--swal2-width: 32em;--swal2-padding: 0 0 1.25em;--swal2-border: none;--swal2-border-radius: 0.3125rem;--swal2-background: white;--swal2-color: #545454;--swal2-footer-border-color: #eee;--swal2-show-animation: swal2-show 0.3s;--swal2-hide-animation: swal2-hide 0.15s forwards;--swal2-input-background: transparent;--swal2-progress-step-background: #add8e6;--swal2-validation-message-background: #f0f0f0;--swal2-validation-message-color: #666;--swal2-close-button-position: initial;--swal2-close-button-inset: auto;--swal2-close-button-font-size: 2.5em;--swal2-close-button-color: #ccc}[data-swal2-theme=dark]{--swal2-dark-theme-black: #19191a;--swal2-dark-theme-white: #e1e1e1;--swal2-background: var(--swal2-dark-theme-black);--swal2-color: var(--swal2-dark-theme-white);--swal2-footer-border-color: #555;--swal2-input-background: color-mix(in srgb, var(--swal2-dark-theme-black), var(--swal2-dark-theme-white) 10%);--swal2-validation-message-background: color-mix( in srgb, var(--swal2-dark-theme-black), var(--swal2-dark-theme-white) 10% );--swal2-validation-message-color: var(--swal2-dark-theme-white)}@media(prefers-color-scheme: dark){[data-swal2-theme=auto]{--swal2-dark-theme-black: #19191a;--swal2-dark-theme-white: #e1e1e1;--swal2-background: var(--swal2-dark-theme-black);--swal2-color: var(--swal2-dark-theme-white);--swal2-footer-border-color: #555;--swal2-input-background: color-mix(in srgb, var(--swal2-dark-theme-black), var(--swal2-dark-theme-white) 10%);--swal2-validation-message-background: color-mix( in srgb, var(--swal2-dark-theme-black), var(--swal2-dark-theme-white) 10% );--swal2-validation-message-color: var(--swal2-dark-theme-white)}}body.swal2-shown:not(.swal2-no-backdrop,.swal2-toast-shown){overflow:hidden}body.swal2-height-auto{height:auto !important}body.swal2-no-backdrop .swal2-container{background-color:rgba(0,0,0,0) !important;pointer-events:none}body.swal2-no-backdrop .swal2-container .swal2-popup{pointer-events:all}body.swal2-no-backdrop .swal2-container .swal2-modal{box-shadow:0 0 10px var(--swal2-backdrop)}body.swal2-toast-shown .swal2-container{box-sizing:border-box;width:360px;max-width:100%;background-color:rgba(0,0,0,0);pointer-events:none}body.swal2-toast-shown .swal2-container.swal2-top{inset:0 auto auto 50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-top-end,body.swal2-toast-shown .swal2-container.swal2-top-right{inset:0 0 auto auto}body.swal2-toast-shown .swal2-container.swal2-top-start,body.swal2-toast-shown .swal2-container.swal2-top-left{inset:0 auto auto 0}body.swal2-toast-shown .swal2-container.swal2-center-start,body.swal2-toast-shown .swal2-container.swal2-center-left{inset:50% auto auto 0;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-center{inset:50% auto auto 50%;transform:translate(-50%, -50%)}body.swal2-toast-shown .swal2-container.swal2-center-end,body.swal2-toast-shown .swal2-container.swal2-center-right{inset:50% 0 auto auto;transform:translateY(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-start,body.swal2-toast-shown .swal2-container.swal2-bottom-left{inset:auto auto 0 0}body.swal2-toast-shown .swal2-container.swal2-bottom{inset:auto auto 0 50%;transform:translateX(-50%)}body.swal2-toast-shown .swal2-container.swal2-bottom-end,body.swal2-toast-shown .swal2-container.swal2-bottom-right{inset:auto 0 0 auto}@media print{body.swal2-shown:not(.swal2-no-backdrop,.swal2-toast-shown){overflow-y:scroll !important}body.swal2-shown:not(.swal2-no-backdrop,.swal2-toast-shown)>[aria-hidden=true]{display:none}body.swal2-shown:not(.swal2-no-backdrop,.swal2-toast-shown) .swal2-container{position:static !important}}div:where(.swal2-container){display:grid;position:fixed;z-index:1060;inset:0;box-sizing:border-box;grid-template-areas:\\\"top-start     top            top-end\\\" \\\"center-start  center         center-end\\\" \\\"bottom-start  bottom-center  bottom-end\\\";grid-template-rows:minmax(min-content, auto) minmax(min-content, auto) minmax(min-content, auto);height:100%;padding:var(--swal2-container-padding);overflow-x:hidden;transition:background-color .1s;-webkit-overflow-scrolling:touch}div:where(.swal2-container).swal2-backdrop-show,div:where(.swal2-container).swal2-noanimation{background:var(--swal2-backdrop)}div:where(.swal2-container).swal2-backdrop-hide{background:rgba(0,0,0,0) !important}div:where(.swal2-container).swal2-top-start,div:where(.swal2-container).swal2-center-start,div:where(.swal2-container).swal2-bottom-start{grid-template-columns:minmax(0, 1fr) auto auto}div:where(.swal2-container).swal2-top,div:where(.swal2-container).swal2-center,div:where(.swal2-container).swal2-bottom{grid-template-columns:auto minmax(0, 1fr) auto}div:where(.swal2-container).swal2-top-end,div:where(.swal2-container).swal2-center-end,div:where(.swal2-container).swal2-bottom-end{grid-template-columns:auto auto minmax(0, 1fr)}div:where(.swal2-container).swal2-top-start>.swal2-popup{align-self:start}div:where(.swal2-container).swal2-top>.swal2-popup{grid-column:2;place-self:start center}div:where(.swal2-container).swal2-top-end>.swal2-popup,div:where(.swal2-container).swal2-top-right>.swal2-popup{grid-column:3;place-self:start end}div:where(.swal2-container).swal2-center-start>.swal2-popup,div:where(.swal2-container).swal2-center-left>.swal2-popup{grid-row:2;align-self:center}div:where(.swal2-container).swal2-center>.swal2-popup{grid-column:2;grid-row:2;place-self:center center}div:where(.swal2-container).swal2-center-end>.swal2-popup,div:where(.swal2-container).swal2-center-right>.swal2-popup{grid-column:3;grid-row:2;place-self:center end}div:where(.swal2-container).swal2-bottom-start>.swal2-popup,div:where(.swal2-container).swal2-bottom-left>.swal2-popup{grid-column:1;grid-row:3;align-self:end}div:where(.swal2-container).swal2-bottom>.swal2-popup{grid-column:2;grid-row:3;place-self:end center}div:where(.swal2-container).swal2-bottom-end>.swal2-popup,div:where(.swal2-container).swal2-bottom-right>.swal2-popup{grid-column:3;grid-row:3;place-self:end end}div:where(.swal2-container).swal2-grow-row>.swal2-popup,div:where(.swal2-container).swal2-grow-fullscreen>.swal2-popup{grid-column:1/4;width:100%}div:where(.swal2-container).swal2-grow-column>.swal2-popup,div:where(.swal2-container).swal2-grow-fullscreen>.swal2-popup{grid-row:1/4;align-self:stretch}div:where(.swal2-container).swal2-no-transition{transition:none !important}div:where(.swal2-container) div:where(.swal2-popup){display:none;position:relative;box-sizing:border-box;grid-template-columns:minmax(0, 100%);width:var(--swal2-width);max-width:100%;padding:var(--swal2-padding);border:var(--swal2-border);border-radius:var(--swal2-border-radius);background:var(--swal2-background);color:var(--swal2-color);font-family:inherit;font-size:1rem}div:where(.swal2-container) div:where(.swal2-popup):focus{outline:none}div:where(.swal2-container) div:where(.swal2-popup).swal2-loading{overflow-y:hidden}div:where(.swal2-container) div:where(.swal2-popup).swal2-draggable{cursor:grab}div:where(.swal2-container) div:where(.swal2-popup).swal2-draggable div:where(.swal2-icon){cursor:grab}div:where(.swal2-container) div:where(.swal2-popup).swal2-dragging{cursor:grabbing}div:where(.swal2-container) div:where(.swal2-popup).swal2-dragging div:where(.swal2-icon){cursor:grabbing}div:where(.swal2-container) h2:where(.swal2-title){position:relative;max-width:100%;margin:0;padding:.8em 1em 0;color:inherit;font-size:1.875em;font-weight:600;text-align:center;text-transform:none;word-wrap:break-word;cursor:initial}div:where(.swal2-container) div:where(.swal2-actions){display:flex;z-index:1;box-sizing:border-box;flex-wrap:wrap;align-items:center;justify-content:center;width:auto;margin:1.25em auto 0;padding:0}div:where(.swal2-container) div:where(.swal2-actions):not(.swal2-loading) .swal2-styled[disabled]{opacity:.4}div:where(.swal2-container) div:where(.swal2-actions):not(.swal2-loading) .swal2-styled:hover{background-image:linear-gradient(rgba(0, 0, 0, 0.1), rgba(0, 0, 0, 0.1))}div:where(.swal2-container) div:where(.swal2-actions):not(.swal2-loading) .swal2-styled:active{background-image:linear-gradient(rgba(0, 0, 0, 0.2), rgba(0, 0, 0, 0.2))}div:where(.swal2-container) div:where(.swal2-loader){display:none;align-items:center;justify-content:center;width:2.2em;height:2.2em;margin:0 1.875em;animation:swal2-rotate-loading 1.5s linear 0s infinite normal;border-width:.25em;border-style:solid;border-radius:100%;border-color:#2778c4 rgba(0,0,0,0) #2778c4 rgba(0,0,0,0)}div:where(.swal2-container) button:where(.swal2-styled){margin:.3125em;padding:.625em 1.1em;transition:box-shadow .1s;box-shadow:0 0 0 3px rgba(0,0,0,0);font-weight:500}div:where(.swal2-container) button:where(.swal2-styled):not([disabled]){cursor:pointer}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-confirm){border:0;border-radius:.25em;background:initial;background-color:#7066e0;color:#fff;font-size:1em}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-confirm):focus-visible{box-shadow:0 0 0 3px rgba(112,102,224,.5)}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-deny){border:0;border-radius:.25em;background:initial;background-color:#dc3741;color:#fff;font-size:1em}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-deny):focus-visible{box-shadow:0 0 0 3px rgba(220,55,65,.5)}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-cancel){border:0;border-radius:.25em;background:initial;background-color:#6e7881;color:#fff;font-size:1em}div:where(.swal2-container) button:where(.swal2-styled):where(.swal2-cancel):focus-visible{box-shadow:0 0 0 3px rgba(110,120,129,.5)}div:where(.swal2-container) button:where(.swal2-styled).swal2-default-outline:focus-visible{box-shadow:0 0 0 3px rgba(100,150,200,.5)}div:where(.swal2-container) button:where(.swal2-styled):focus-visible{outline:none}div:where(.swal2-container) button:where(.swal2-styled)::-moz-focus-inner{border:0}div:where(.swal2-container) div:where(.swal2-footer){margin:1em 0 0;padding:1em 1em 0;border-top:1px solid var(--swal2-footer-border-color);color:inherit;font-size:1em;text-align:center;cursor:initial}div:where(.swal2-container) .swal2-timer-progress-bar-container{position:absolute;right:0;bottom:0;left:0;grid-column:auto !important;overflow:hidden;border-bottom-right-radius:var(--swal2-border-radius);border-bottom-left-radius:var(--swal2-border-radius)}div:where(.swal2-container) div:where(.swal2-timer-progress-bar){width:100%;height:.25em;background:rgba(0,0,0,.2)}div:where(.swal2-container) img:where(.swal2-image){max-width:100%;margin:2em auto 1em;cursor:initial}div:where(.swal2-container) button:where(.swal2-close){position:var(--swal2-close-button-position);inset:var(--swal2-close-button-inset);z-index:2;align-items:center;justify-content:center;width:1.2em;height:1.2em;margin-top:0;margin-right:0;margin-bottom:-1.2em;padding:0;overflow:hidden;transition:color .1s,box-shadow .1s;border:none;border-radius:var(--swal2-border-radius);background:rgba(0,0,0,0);color:var(--swal2-close-button-color);font-family:monospace;font-size:var(--swal2-close-button-font-size);cursor:pointer;justify-self:end}div:where(.swal2-container) button:where(.swal2-close):hover{transform:none;background:rgba(0,0,0,0);color:#f27474}div:where(.swal2-container) button:where(.swal2-close):focus-visible{outline:none;box-shadow:inset 0 0 0 3px rgba(100,150,200,.5)}div:where(.swal2-container) button:where(.swal2-close)::-moz-focus-inner{border:0}div:where(.swal2-container) div:where(.swal2-html-container){z-index:1;justify-content:center;margin:0;padding:1em 1.6em .3em;overflow:auto;color:inherit;font-size:1.125em;font-weight:normal;line-height:normal;text-align:center;word-wrap:break-word;word-break:break-word;cursor:initial}div:where(.swal2-container) input:where(.swal2-input),div:where(.swal2-container) input:where(.swal2-file),div:where(.swal2-container) textarea:where(.swal2-textarea),div:where(.swal2-container) select:where(.swal2-select),div:where(.swal2-container) div:where(.swal2-radio),div:where(.swal2-container) label:where(.swal2-checkbox){margin:1em 2em 3px}div:where(.swal2-container) input:where(.swal2-input),div:where(.swal2-container) input:where(.swal2-file),div:where(.swal2-container) textarea:where(.swal2-textarea){box-sizing:border-box;width:auto;transition:border-color .1s,box-shadow .1s;border:1px solid #d9d9d9;border-radius:.1875em;background:var(--swal2-input-background);box-shadow:inset 0 1px 1px rgba(0,0,0,.06),0 0 0 3px rgba(0,0,0,0);color:inherit;font-size:1.125em}div:where(.swal2-container) input:where(.swal2-input).swal2-inputerror,div:where(.swal2-container) input:where(.swal2-file).swal2-inputerror,div:where(.swal2-container) textarea:where(.swal2-textarea).swal2-inputerror{border-color:#f27474 !important;box-shadow:0 0 2px #f27474 !important}div:where(.swal2-container) input:where(.swal2-input):focus,div:where(.swal2-container) input:where(.swal2-file):focus,div:where(.swal2-container) textarea:where(.swal2-textarea):focus{border:1px solid #b4dbed;outline:none;box-shadow:inset 0 1px 1px rgba(0,0,0,.06),0 0 0 3px rgba(100,150,200,.5)}div:where(.swal2-container) input:where(.swal2-input)::placeholder,div:where(.swal2-container) input:where(.swal2-file)::placeholder,div:where(.swal2-container) textarea:where(.swal2-textarea)::placeholder{color:#ccc}div:where(.swal2-container) .swal2-range{margin:1em 2em 3px;background:var(--swal2-background)}div:where(.swal2-container) .swal2-range input{width:80%}div:where(.swal2-container) .swal2-range output{width:20%;color:inherit;font-weight:600;text-align:center}div:where(.swal2-container) .swal2-range input,div:where(.swal2-container) .swal2-range output{height:2.625em;padding:0;font-size:1.125em;line-height:2.625em}div:where(.swal2-container) .swal2-input{height:2.625em;padding:0 .75em}div:where(.swal2-container) .swal2-file{width:75%;margin-right:auto;margin-left:auto;background:var(--swal2-input-background);font-size:1.125em}div:where(.swal2-container) .swal2-textarea{height:6.75em;padding:.75em}div:where(.swal2-container) .swal2-select{min-width:50%;max-width:100%;padding:.375em .625em;background:var(--swal2-input-background);color:inherit;font-size:1.125em}div:where(.swal2-container) .swal2-radio,div:where(.swal2-container) .swal2-checkbox{align-items:center;justify-content:center;background:var(--swal2-background);color:inherit}div:where(.swal2-container) .swal2-radio label,div:where(.swal2-container) .swal2-checkbox label{margin:0 .6em;font-size:1.125em}div:where(.swal2-container) .swal2-radio input,div:where(.swal2-container) .swal2-checkbox input{flex-shrink:0;margin:0 .4em}div:where(.swal2-container) label:where(.swal2-input-label){display:flex;justify-content:center;margin:1em auto 0}div:where(.swal2-container) div:where(.swal2-validation-message){align-items:center;justify-content:center;margin:1em 0 0;padding:.625em;overflow:hidden;background:var(--swal2-validation-message-background);color:var(--swal2-validation-message-color);font-size:1em;font-weight:300}div:where(.swal2-container) div:where(.swal2-validation-message)::before{content:\\\"!\\\";display:inline-block;width:1.5em;min-width:1.5em;height:1.5em;margin:0 .625em;border-radius:50%;background-color:#f27474;color:#fff;font-weight:600;line-height:1.5em;text-align:center}div:where(.swal2-container) .swal2-progress-steps{flex-wrap:wrap;align-items:center;max-width:100%;margin:1.25em auto;padding:0;background:rgba(0,0,0,0);font-weight:600}div:where(.swal2-container) .swal2-progress-steps li{display:inline-block;position:relative}div:where(.swal2-container) .swal2-progress-steps .swal2-progress-step{z-index:20;flex-shrink:0;width:2em;height:2em;border-radius:2em;background:#2778c4;color:#fff;line-height:2em;text-align:center}div:where(.swal2-container) .swal2-progress-steps .swal2-progress-step.swal2-active-progress-step{background:#2778c4}div:where(.swal2-container) .swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step{background:var(--swal2-progress-step-background);color:#fff}div:where(.swal2-container) .swal2-progress-steps .swal2-progress-step.swal2-active-progress-step~.swal2-progress-step-line{background:var(--swal2-progress-step-background)}div:where(.swal2-container) .swal2-progress-steps .swal2-progress-step-line{z-index:10;flex-shrink:0;width:2.5em;height:.4em;margin:0 -1px;background:#2778c4}div:where(.swal2-icon){position:relative;box-sizing:content-box;justify-content:center;width:5em;height:5em;margin:2.5em auto .6em;border:.25em solid rgba(0,0,0,0);border-radius:50%;border-color:#000;font-family:inherit;line-height:5em;cursor:default;user-select:none}div:where(.swal2-icon) .swal2-icon-content{display:flex;align-items:center;font-size:3.75em}div:where(.swal2-icon).swal2-error{border-color:#f27474;color:#f27474}div:where(.swal2-icon).swal2-error .swal2-x-mark{position:relative;flex-grow:1}div:where(.swal2-icon).swal2-error [class^=swal2-x-mark-line]{display:block;position:absolute;top:2.3125em;width:2.9375em;height:.3125em;border-radius:.125em;background-color:#f27474}div:where(.swal2-icon).swal2-error [class^=swal2-x-mark-line][class$=left]{left:1.0625em;transform:rotate(45deg)}div:where(.swal2-icon).swal2-error [class^=swal2-x-mark-line][class$=right]{right:1em;transform:rotate(-45deg)}div:where(.swal2-icon).swal2-error.swal2-icon-show{animation:swal2-animate-error-icon .5s}div:where(.swal2-icon).swal2-error.swal2-icon-show .swal2-x-mark{animation:swal2-animate-error-x-mark .5s}div:where(.swal2-icon).swal2-warning{border-color:#f8bb86;color:#f8bb86}div:where(.swal2-icon).swal2-warning.swal2-icon-show{animation:swal2-animate-error-icon .5s}div:where(.swal2-icon).swal2-warning.swal2-icon-show .swal2-icon-content{animation:swal2-animate-i-mark .5s}div:where(.swal2-icon).swal2-info{border-color:#3fc3ee;color:#3fc3ee}div:where(.swal2-icon).swal2-info.swal2-icon-show{animation:swal2-animate-error-icon .5s}div:where(.swal2-icon).swal2-info.swal2-icon-show .swal2-icon-content{animation:swal2-animate-i-mark .8s}div:where(.swal2-icon).swal2-question{border-color:#87adbd;color:#87adbd}div:where(.swal2-icon).swal2-question.swal2-icon-show{animation:swal2-animate-error-icon .5s}div:where(.swal2-icon).swal2-question.swal2-icon-show .swal2-icon-content{animation:swal2-animate-question-mark .8s}div:where(.swal2-icon).swal2-success{border-color:#a5dc86;color:#a5dc86}div:where(.swal2-icon).swal2-success [class^=swal2-success-circular-line]{position:absolute;width:3.75em;height:7.5em;border-radius:50%}div:where(.swal2-icon).swal2-success [class^=swal2-success-circular-line][class$=left]{top:-0.4375em;left:-2.0635em;transform:rotate(-45deg);transform-origin:3.75em 3.75em;border-radius:7.5em 0 0 7.5em}div:where(.swal2-icon).swal2-success [class^=swal2-success-circular-line][class$=right]{top:-0.6875em;left:1.875em;transform:rotate(-45deg);transform-origin:0 3.75em;border-radius:0 7.5em 7.5em 0}div:where(.swal2-icon).swal2-success .swal2-success-ring{position:absolute;z-index:2;top:-0.25em;left:-0.25em;box-sizing:content-box;width:100%;height:100%;border:.25em solid rgba(165,220,134,.3);border-radius:50%}div:where(.swal2-icon).swal2-success .swal2-success-fix{position:absolute;z-index:1;top:.5em;left:1.625em;width:.4375em;height:5.625em;transform:rotate(-45deg)}div:where(.swal2-icon).swal2-success [class^=swal2-success-line]{display:block;position:absolute;z-index:2;height:.3125em;border-radius:.125em;background-color:#a5dc86}div:where(.swal2-icon).swal2-success [class^=swal2-success-line][class$=tip]{top:2.875em;left:.8125em;width:1.5625em;transform:rotate(45deg)}div:where(.swal2-icon).swal2-success [class^=swal2-success-line][class$=long]{top:2.375em;right:.5em;width:2.9375em;transform:rotate(-45deg)}div:where(.swal2-icon).swal2-success.swal2-icon-show .swal2-success-line-tip{animation:swal2-animate-success-line-tip .75s}div:where(.swal2-icon).swal2-success.swal2-icon-show .swal2-success-line-long{animation:swal2-animate-success-line-long .75s}div:where(.swal2-icon).swal2-success.swal2-icon-show .swal2-success-circular-line-right{animation:swal2-rotate-success-circular-line 4.25s ease-in}[class^=swal2]{-webkit-tap-highlight-color:rgba(0,0,0,0)}.swal2-show{animation:var(--swal2-show-animation)}.swal2-hide{animation:var(--swal2-hide-animation)}.swal2-noanimation{transition:none}.swal2-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}.swal2-rtl .swal2-close{margin-right:initial;margin-left:0}.swal2-rtl .swal2-timer-progress-bar{right:0;left:auto}.swal2-toast{box-sizing:border-box;grid-column:1/4 !important;grid-row:1/4 !important;grid-template-columns:min-content auto min-content;padding:1em;overflow-y:hidden;background:var(--swal2-background);box-shadow:0 0 1px rgba(0,0,0,.075),0 1px 2px rgba(0,0,0,.075),1px 2px 4px rgba(0,0,0,.075),1px 3px 8px rgba(0,0,0,.075),2px 4px 16px rgba(0,0,0,.075);pointer-events:all}.swal2-toast>*{grid-column:2}.swal2-toast h2:where(.swal2-title){margin:.5em 1em;padding:0;font-size:1em;text-align:initial}.swal2-toast .swal2-loading{justify-content:center}.swal2-toast input:where(.swal2-input){height:2em;margin:.5em;font-size:1em}.swal2-toast .swal2-validation-message{font-size:1em}.swal2-toast div:where(.swal2-footer){margin:.5em 0 0;padding:.5em 0 0;font-size:.8em}.swal2-toast button:where(.swal2-close){grid-column:3/3;grid-row:1/99;align-self:center;width:.8em;height:.8em;margin:0;font-size:2em}.swal2-toast div:where(.swal2-html-container){margin:.5em 1em;padding:0;overflow:initial;font-size:1em;text-align:initial}.swal2-toast div:where(.swal2-html-container):empty{padding:0}.swal2-toast .swal2-loader{grid-column:1;grid-row:1/99;align-self:center;width:2em;height:2em;margin:.25em}.swal2-toast .swal2-icon{grid-column:1;grid-row:1/99;align-self:center;width:2em;min-width:2em;height:2em;margin:0 .5em 0 0}.swal2-toast .swal2-icon .swal2-icon-content{display:flex;align-items:center;font-size:1.8em;font-weight:bold}.swal2-toast .swal2-icon.swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line]{top:.875em;width:1.375em}.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=left]{left:.3125em}.swal2-toast .swal2-icon.swal2-error [class^=swal2-x-mark-line][class$=right]{right:.3125em}.swal2-toast div:where(.swal2-actions){justify-content:flex-start;height:auto;margin:0;margin-top:.5em;padding:0 .5em}.swal2-toast button:where(.swal2-styled){margin:.25em .5em;padding:.4em .6em;font-size:1em}.swal2-toast .swal2-success{border-color:#a5dc86}.swal2-toast .swal2-success [class^=swal2-success-circular-line]{position:absolute;width:1.6em;height:3em;border-radius:50%}.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=left]{top:-0.8em;left:-0.5em;transform:rotate(-45deg);transform-origin:2em 2em;border-radius:4em 0 0 4em}.swal2-toast .swal2-success [class^=swal2-success-circular-line][class$=right]{top:-0.25em;left:.9375em;transform-origin:0 1.5em;border-radius:0 4em 4em 0}.swal2-toast .swal2-success .swal2-success-ring{width:2em;height:2em}.swal2-toast .swal2-success .swal2-success-fix{top:0;left:.4375em;width:.4375em;height:2.6875em}.swal2-toast .swal2-success [class^=swal2-success-line]{height:.3125em}.swal2-toast .swal2-success [class^=swal2-success-line][class$=tip]{top:1.125em;left:.1875em;width:.75em}.swal2-toast .swal2-success [class^=swal2-success-line][class$=long]{top:.9375em;right:.1875em;width:1.375em}.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-tip{animation:swal2-toast-animate-success-line-tip .75s}.swal2-toast .swal2-success.swal2-icon-show .swal2-success-line-long{animation:swal2-toast-animate-success-line-long .75s}.swal2-toast.swal2-show{animation:swal2-toast-show .5s}.swal2-toast.swal2-hide{animation:swal2-toast-hide .1s forwards}@keyframes swal2-show{0%{transform:scale(0.7)}45%{transform:scale(1.05)}80%{transform:scale(0.95)}100%{transform:scale(1)}}@keyframes swal2-hide{0%{transform:scale(1);opacity:1}100%{transform:scale(0.5);opacity:0}}@keyframes swal2-animate-success-line-tip{0%{top:1.1875em;left:.0625em;width:0}54%{top:1.0625em;left:.125em;width:0}70%{top:2.1875em;left:-0.375em;width:3.125em}84%{top:3em;left:1.3125em;width:1.0625em}100%{top:2.8125em;left:.8125em;width:1.5625em}}@keyframes swal2-animate-success-line-long{0%{top:3.375em;right:2.875em;width:0}65%{top:3.375em;right:2.875em;width:0}84%{top:2.1875em;right:0;width:3.4375em}100%{top:2.375em;right:.5em;width:2.9375em}}@keyframes swal2-rotate-success-circular-line{0%{transform:rotate(-45deg)}5%{transform:rotate(-45deg)}12%{transform:rotate(-405deg)}100%{transform:rotate(-405deg)}}@keyframes swal2-animate-error-x-mark{0%{margin-top:1.625em;transform:scale(0.4);opacity:0}50%{margin-top:1.625em;transform:scale(0.4);opacity:0}80%{margin-top:-0.375em;transform:scale(1.15)}100%{margin-top:0;transform:scale(1);opacity:1}}@keyframes swal2-animate-error-icon{0%{transform:rotateX(100deg);opacity:0}100%{transform:rotateX(0deg);opacity:1}}@keyframes swal2-rotate-loading{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}@keyframes swal2-animate-question-mark{0%{transform:rotateY(-360deg)}100%{transform:rotateY(0)}}@keyframes swal2-animate-i-mark{0%{transform:rotateZ(45deg);opacity:0}25%{transform:rotateZ(-25deg);opacity:.4}50%{transform:rotateZ(15deg);opacity:.8}75%{transform:rotateZ(-5deg);opacity:1}100%{transform:rotateX(0);opacity:1}}@keyframes swal2-toast-show{0%{transform:translateY(-0.625em) rotateZ(2deg)}33%{transform:translateY(0) rotateZ(-2deg)}66%{transform:translateY(0.3125em) rotateZ(2deg)}100%{transform:translateY(0) rotateZ(0deg)}}@keyframes swal2-toast-hide{100%{transform:rotateZ(1deg);opacity:0}}@keyframes swal2-toast-animate-success-line-tip{0%{top:.5625em;left:.0625em;width:0}54%{top:.125em;left:.125em;width:0}70%{top:.625em;left:-0.25em;width:1.625em}84%{top:1.0625em;left:.75em;width:.5em}100%{top:1.125em;left:.1875em;width:.75em}}@keyframes swal2-toast-animate-success-line-long{0%{top:1.625em;right:1.375em;width:0}65%{top:1.25em;right:.9375em;width:0}84%{top:.9375em;right:0;width:1.125em}100%{top:.9375em;right:.1875em;width:1.375em}}\");","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}\n\nmodule.exports = _asyncToGenerator;","import htmx from \"htmx.org\";\nimport { showErrorMessage } from \"./utils\";\nimport Cookies from 'js-cookie';\nimport Fuse from 'fuse.js';\nwindow.htmx = htmx\n\nfunction setupSortAndFilterSelectors() {\n    let locationRequested = false; // to prevent repeated prompts\n\n    document.body.addEventListener('htmx:beforeRequest', function(evt) {\n\n        const in2Hours = 1/12;\n        // Set cookies for sort and filter selections so its sticky\n        if (evt.target.id === 'offer-sort-select') {\n            const val = evt.target.value;\n            const battleId = evt.target.getAttribute(\"data-battle-id\");\n            Cookies.set(`battle_${battleId}_offer_sort`, val, { secure: true, expires: in2Hours });\n        }\n        if (evt.target.id === 'offer-filter-select') {\n            const val = evt.target.value;\n            const battleId = evt.target.getAttribute(\"data-battle-id\");\n            Cookies.set(`battle_${battleId}_offer_filter`, val, { secure: true, expires: in2Hours });\n        }\n\n        // Set up sort by distance listener\n        const hasCookie = Cookies.get(\"cb_geo\") !== undefined;\n        if (evt.target.id === \"offer-sort-select\" && evt.target.value === \"distance\" && !hasCookie && !locationRequested) {\n\n            evt.preventDefault();  // cancel the current request\n            locationRequested = true;  // mark that we've requested location\n\n            if (navigator.geolocation) {\n                navigator.geolocation.getCurrentPosition(\n                    function(position) {\n                        storeGeoLocation(position);\n                        locationRequested = false;\n                        // Programmatically trigger a change event to reissue the request.\n                        window.htmx.trigger(evt.target, \"change\");\n                    },\n                    function(error) {\n                        // user denied access\n                        document.getElementById(\"offer-sort-select\").value = \"alpha\";\n                        showErrorMessage(\"Please enable location access to sort by distance.\", \"🧭\");\n                        locationRequested = false;\n                        const errBattleId = evt.target.getAttribute(\"data-battle-id\");\n                        Cookies.remove(`battle_${errBattleId}_offer_sort`);\n                    }\n                );\n            } else {\n                document.getElementById(\"offer-sort-select\").value = \"alpha\";\n                showErrorMessage(\"Geolocation is not supported by your browser.\", \"🧭\");\n            }\n        }\n    });\n}\n\nfunction setupAfterFilterOffersListener() {\n    document.body.addEventListener('htmx:afterSwap', function(evt) {\n        if (evt.target.id === 'offer-list') {\n            setupSearchOffers();  // resetup the search since we have new results\n            const searchInput = document.getElementById(\"offer-search-input\");\n            if (searchInput) {\n                searchInput.value = \"\";  // clear the search input\n                showNoSearchResultsTxt(false);  // hide no results text\n            }\n        }\n    });\n}\n\nfunction storeGeoLocation(position) {\n    Cookies.set(\"cb_geo\", `${position.coords.latitude},${position.coords.longitude}`, { secure: true });\n}\n\nasync function checkGeolocationPermission() {\n    try {\n        const permissionStatus = await navigator.permissions.query({ name: 'geolocation' });\n        return permissionStatus.state; // \"granted\", \"prompt\", or \"denied\"\n    } catch (error) {\n        return 'not-supported';\n    }\n}\n\n\nfunction setLocationIfPermissionsGranted() {\n    // If they have already given access, update the cookie with most recent location\n    checkGeolocationPermission().then(status => {\n        if (status === 'granted') {\n            // Geolocation permission is granted\n            navigator.geolocation.getCurrentPosition(\n                function(position) {\n                    storeGeoLocation(position);\n                },\n                function(error) {\n                    // user denied access\n                    console.error('Could not get geolocation');\n                }\n            );\n        }\n    });\n}\n\nfunction setupTruncatableTextListeners() {\n    document.querySelectorAll(\".truncatable-text-section\").forEach((section) => {\n        const btn = section.querySelector(\".truncatable-toggle-btn\");\n        const content = section.querySelector(\".truncatable-content\");\n        if (!btn || !content) {\n            return;\n        }\n        btn.addEventListener(\"click\", () => {\n            content.classList.toggle(\"truncate\");\n            btn.innerHTML = content.classList.contains(\"truncate\") ? \"show more\" : \"show less\";\n        });\n    });\n}\n\nfunction setupSearchBtnListener() {\n    const btn = document.getElementById(\"search-offers-btn\");\n    if (!btn) {\n        return;\n    }\n    const searchContainer = document.getElementById(\"offer-search-container\");\n    const searchInput = document.getElementById(\"offer-search-input\");\n\n    let showSearch = false;\n\n    btn.addEventListener(\"click\", () => {\n        showSearch = !showSearch;\n        if (showSearch) {\n            searchContainer.classList.remove(\"d-none\");\n            searchContainer.classList.add(\"d-flex\");\n            searchInput.focus();\n        }\n        else {\n            searchContainer.classList.add(\"d-none\");\n            searchContainer.classList.remove(\"d-flex\");\n        }\n    });\n}\n\nfunction showNoSearchResultsTxt(show) {\n    const noResultsText = document.getElementById(\"no-search-results\");\n    if (show) {\n        noResultsText.classList.remove(\"d-none\");\n    } else {\n        noResultsText.classList.add(\"d-none\");\n    }\n}\n\n\nlet fuse = null;\n\nfunction setupSearchOffers() {\n    const searchInput = document.getElementById(\"offer-search-input\");\n\n    if (!searchInput) {\n        return;\n    }\n\n    const allItems = Array.from(\n        document.querySelectorAll(\".offer-list .offer-card\")\n    );\n    const SEARCH_DATA = allItems.map((element) => {\n        return {\n        id: element.getAttribute('data-biz-slug'),\n        name: element.getAttribute('data-biz-name'),\n        // Keep a reference to the el itself:\n        element: element,\n        };\n    });\n\n    // 3) Configure Fuse.js options:\n    //    - keys: [\"name\"] → tell Fuse to fuzzy-search the \"name\" field.\n    //    - threshold: 0.4 (default ~0.6). Lower → more exact matches; higher → more fuzzy.\n    const fuseOptions = {\n        keys: [\"name\"],\n        threshold: 0.3,      // adjust for how “fuzzy” you want it\n        minMatchCharLength: 2, // only search once user typed ≥2 chars\n    };\n\n    fuse = new Fuse(SEARCH_DATA, fuseOptions);\n\n    // 5) Add an input listener to do the search:\n    searchInput.addEventListener(\"input\", function (e) {\n        const query = e.target.value.trim();\n\n        if (query.length == 1) {\n            return;\n        }\n\n        // If input is empty, show all items and exit early:\n        if (query === \"\") {\n            allItems.forEach((el) => (el.classList.remove(\"d-none\")));\n            return;\n        }\n\n        // Otherwise, run Fuse search:\n        const fuseResult = fuse.search(query);\n        // fuseResult is an array of objects: each has { item: {...}, refIndex: <number>, ... }\n\n        // Build a Set of IDs or elements that matched:\n        const matchedIds = new Set(fuseResult.map((res) => res.item.id));\n\n        // Show/hide:\n        SEARCH_DATA.forEach(({ id, element }) => {\n        if (matchedIds.has(id)) {\n            element.style.display = \"\"; // show\n            element.classList.remove(\"d-none\");\n        } else {\n            element.classList.add(\"d-none\");\n        }\n        });\n\n        if (matchedIds.size === 0) {\n            showNoSearchResultsTxt(true);\n        }\n        else {\n            showNoSearchResultsTxt(false);\n        }\n    });\n}\n\nfunction isValidEmail(email) {\n    const pattern = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n    return pattern.test(email);\n}\n\nfunction setupWaitlistSubmission() {\n    const btn = document.getElementById(\"join-waitlist-btn\");\n    if (!btn) {\n        return;\n    }\n\n    const emailInput = document.getElementById(\"waitlist-email-input\");\n    if (!emailInput) {\n        return;\n    }\n\n    // disable btn until email is valid\n    emailInput.addEventListener(\"input\", () => {\n        const email = emailInput.value.trim();\n        if (email.length > 0 && isValidEmail(email)) {\n            btn.disabled = false;\n        } else {\n            btn.disabled = true;\n        }\n    });\n}\n\nfunction setupShareBtnListener() {\n    const shareBtn = document.getElementById(\"program-share-btn\");\n    if (!shareBtn) {\n        return;\n    }\n\n    shareBtn.addEventListener(\"click\", () => {\n        const url = window.location.href;\n        const title = document.title;\n\n        if (navigator.share) {\n            navigator.share({\n                title: title,\n                url: url\n            }).then(() => {\n                console.log('Share successful');\n            }).catch((error) => {\n                console.error('Error sharing:', error);\n            });\n        } else {\n            showErrorMessage(\"Sharing is not supported in your browser.\");\n        }\n    });\n}\n\n\n$(document).ready(function() {\n    setupSortAndFilterSelectors();\n    setLocationIfPermissionsGranted();\n    setupTruncatableTextListeners();\n    setupAfterFilterOffersListener();\n    setupSearchBtnListener();\n    setupSearchOffers();\n    setupWaitlistSubmission();\n    setupShareBtnListener();\n});\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","/**\n * Fuse.js v7.1.0 - Lightweight fuzzy-search (http://fusejs.io)\n *\n * Copyright (c) 2025 Kiro Risk (http://kiro.me)\n * All Rights Reserved. Apache Software License 2.0\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n */\n\nfunction isArray(value) {\n  return !Array.isArray\n    ? getTag(value) === '[object Array]'\n    : Array.isArray(value)\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js\nconst INFINITY = 1 / 0;\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value\n  }\n  let result = value + '';\n  return result == '0' && 1 / value == -INFINITY ? '-0' : result\n}\n\nfunction toString(value) {\n  return value == null ? '' : baseToString(value)\n}\n\nfunction isString(value) {\n  return typeof value === 'string'\n}\n\nfunction isNumber(value) {\n  return typeof value === 'number'\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js\nfunction isBoolean(value) {\n  return (\n    value === true ||\n    value === false ||\n    (isObjectLike(value) && getTag(value) == '[object Boolean]')\n  )\n}\n\nfunction isObject(value) {\n  return typeof value === 'object'\n}\n\n// Checks if `value` is object-like.\nfunction isObjectLike(value) {\n  return isObject(value) && value !== null\n}\n\nfunction isDefined(value) {\n  return value !== undefined && value !== null\n}\n\nfunction isBlank(value) {\n  return !value.trim().length\n}\n\n// Gets the `toStringTag` of `value`.\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js\nfunction getTag(value) {\n  return value == null\n    ? value === undefined\n      ? '[object Undefined]'\n      : '[object Null]'\n    : Object.prototype.toString.call(value)\n}\n\nconst EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';\n\nconst INCORRECT_INDEX_TYPE = \"Incorrect 'index' type\";\n\nconst LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) =>\n  `Invalid value for key ${key}`;\n\nconst PATTERN_LENGTH_TOO_LARGE = (max) =>\n  `Pattern length exceeds max of ${max}.`;\n\nconst MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;\n\nconst INVALID_KEY_WEIGHT_VALUE = (key) =>\n  `Property 'weight' in key '${key}' must be a positive integer`;\n\nconst hasOwn = Object.prototype.hasOwnProperty;\n\nclass KeyStore {\n  constructor(keys) {\n    this._keys = [];\n    this._keyMap = {};\n\n    let totalWeight = 0;\n\n    keys.forEach((key) => {\n      let obj = createKey(key);\n\n      this._keys.push(obj);\n      this._keyMap[obj.id] = obj;\n\n      totalWeight += obj.weight;\n    });\n\n    // Normalize weights so that their sum is equal to 1\n    this._keys.forEach((key) => {\n      key.weight /= totalWeight;\n    });\n  }\n  get(keyId) {\n    return this._keyMap[keyId]\n  }\n  keys() {\n    return this._keys\n  }\n  toJSON() {\n    return JSON.stringify(this._keys)\n  }\n}\n\nfunction createKey(key) {\n  let path = null;\n  let id = null;\n  let src = null;\n  let weight = 1;\n  let getFn = null;\n\n  if (isString(key) || isArray(key)) {\n    src = key;\n    path = createKeyPath(key);\n    id = createKeyId(key);\n  } else {\n    if (!hasOwn.call(key, 'name')) {\n      throw new Error(MISSING_KEY_PROPERTY('name'))\n    }\n\n    const name = key.name;\n    src = name;\n\n    if (hasOwn.call(key, 'weight')) {\n      weight = key.weight;\n\n      if (weight <= 0) {\n        throw new Error(INVALID_KEY_WEIGHT_VALUE(name))\n      }\n    }\n\n    path = createKeyPath(name);\n    id = createKeyId(name);\n    getFn = key.getFn;\n  }\n\n  return { path, id, weight, src, getFn }\n}\n\nfunction createKeyPath(key) {\n  return isArray(key) ? key : key.split('.')\n}\n\nfunction createKeyId(key) {\n  return isArray(key) ? key.join('.') : key\n}\n\nfunction get(obj, path) {\n  let list = [];\n  let arr = false;\n\n  const deepGet = (obj, path, index) => {\n    if (!isDefined(obj)) {\n      return\n    }\n    if (!path[index]) {\n      // If there's no path left, we've arrived at the object we care about.\n      list.push(obj);\n    } else {\n      let key = path[index];\n\n      const value = obj[key];\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      // If we're at the last value in the path, and if it's a string/number/bool,\n      // add it to the list\n      if (\n        index === path.length - 1 &&\n        (isString(value) || isNumber(value) || isBoolean(value))\n      ) {\n        list.push(toString(value));\n      } else if (isArray(value)) {\n        arr = true;\n        // Search each item in the array.\n        for (let i = 0, len = value.length; i < len; i += 1) {\n          deepGet(value[i], path, index + 1);\n        }\n      } else if (path.length) {\n        // An object. Recurse further.\n        deepGet(value, path, index + 1);\n      }\n    }\n  };\n\n  // Backwards compatibility (since path used to be a string)\n  deepGet(obj, isString(path) ? path.split('.') : path, 0);\n\n  return arr ? list : list[0]\n}\n\nconst MatchOptions = {\n  // Whether the matches should be included in the result set. When `true`, each record in the result\n  // set will include the indices of the matched characters.\n  // These can consequently be used for highlighting purposes.\n  includeMatches: false,\n  // When `true`, the matching function will continue to the end of a search pattern even if\n  // a perfect match has already been located in the string.\n  findAllMatches: false,\n  // Minimum number of characters that must be matched before a result is considered a match\n  minMatchCharLength: 1\n};\n\nconst BasicOptions = {\n  // When `true`, the algorithm continues searching to the end of the input even if a perfect\n  // match is found before the end of the same input.\n  isCaseSensitive: false,\n  // When `true`, the algorithm will ignore diacritics (accents) in comparisons\n  ignoreDiacritics: false,\n  // When true, the matching function will continue to the end of a search pattern even if\n  includeScore: false,\n  // List of properties that will be searched. This also supports nested properties.\n  keys: [],\n  // Whether to sort the result list, by score\n  shouldSort: true,\n  // Default sort function: sort by ascending score, ascending index\n  sortFn: (a, b) =>\n    a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1\n};\n\nconst FuzzyOptions = {\n  // Approximately where in the text is the pattern expected to be found?\n  location: 0,\n  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match\n  // (of both letters and location), a threshold of '1.0' would match anything.\n  threshold: 0.6,\n  // Determines how close the match must be to the fuzzy location (specified above).\n  // An exact letter match which is 'distance' characters away from the fuzzy location\n  // would score as a complete mismatch. A distance of '0' requires the match be at\n  // the exact location specified, a threshold of '1000' would require a perfect match\n  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.\n  distance: 100\n};\n\nconst AdvancedOptions = {\n  // When `true`, it enables the use of unix-like search commands\n  useExtendedSearch: false,\n  // The get function to use when fetching an object's properties.\n  // The default will search nested paths *ie foo.bar.baz*\n  getFn: get,\n  // When `true`, search will ignore `location` and `distance`, so it won't matter\n  // where in the string the pattern appears.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score\n  ignoreLocation: false,\n  // When `true`, the calculation for the relevance score (used for sorting) will\n  // ignore the field-length norm.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm\n  ignoreFieldNorm: false,\n  // The weight to determine how much field length norm effects scoring.\n  fieldNormWeight: 1\n};\n\nvar Config = {\n  ...BasicOptions,\n  ...MatchOptions,\n  ...FuzzyOptions,\n  ...AdvancedOptions\n};\n\nconst SPACE = /[^ ]+/g;\n\n// Field-length norm: the shorter the field, the higher the weight.\n// Set to 3 decimals to reduce index size.\nfunction norm(weight = 1, mantissa = 3) {\n  const cache = new Map();\n  const m = Math.pow(10, mantissa);\n\n  return {\n    get(value) {\n      const numTokens = value.match(SPACE).length;\n\n      if (cache.has(numTokens)) {\n        return cache.get(numTokens)\n      }\n\n      // Default function is 1/sqrt(x), weight makes that variable\n      const norm = 1 / Math.pow(numTokens, 0.5 * weight);\n\n      // In place of `toFixed(mantissa)`, for faster computation\n      const n = parseFloat(Math.round(norm * m) / m);\n\n      cache.set(numTokens, n);\n\n      return n\n    },\n    clear() {\n      cache.clear();\n    }\n  }\n}\n\nclass FuseIndex {\n  constructor({\n    getFn = Config.getFn,\n    fieldNormWeight = Config.fieldNormWeight\n  } = {}) {\n    this.norm = norm(fieldNormWeight, 3);\n    this.getFn = getFn;\n    this.isCreated = false;\n\n    this.setIndexRecords();\n  }\n  setSources(docs = []) {\n    this.docs = docs;\n  }\n  setIndexRecords(records = []) {\n    this.records = records;\n  }\n  setKeys(keys = []) {\n    this.keys = keys;\n    this._keysMap = {};\n    keys.forEach((key, idx) => {\n      this._keysMap[key.id] = idx;\n    });\n  }\n  create() {\n    if (this.isCreated || !this.docs.length) {\n      return\n    }\n\n    this.isCreated = true;\n\n    // List is Array<String>\n    if (isString(this.docs[0])) {\n      this.docs.forEach((doc, docIndex) => {\n        this._addString(doc, docIndex);\n      });\n    } else {\n      // List is Array<Object>\n      this.docs.forEach((doc, docIndex) => {\n        this._addObject(doc, docIndex);\n      });\n    }\n\n    this.norm.clear();\n  }\n  // Adds a doc to the end of the index\n  add(doc) {\n    const idx = this.size();\n\n    if (isString(doc)) {\n      this._addString(doc, idx);\n    } else {\n      this._addObject(doc, idx);\n    }\n  }\n  // Removes the doc at the specified index of the index\n  removeAt(idx) {\n    this.records.splice(idx, 1);\n\n    // Change ref index of every subsquent doc\n    for (let i = idx, len = this.size(); i < len; i += 1) {\n      this.records[i].i -= 1;\n    }\n  }\n  getValueForItemAtKeyId(item, keyId) {\n    return item[this._keysMap[keyId]]\n  }\n  size() {\n    return this.records.length\n  }\n  _addString(doc, docIndex) {\n    if (!isDefined(doc) || isBlank(doc)) {\n      return\n    }\n\n    let record = {\n      v: doc,\n      i: docIndex,\n      n: this.norm.get(doc)\n    };\n\n    this.records.push(record);\n  }\n  _addObject(doc, docIndex) {\n    let record = { i: docIndex, $: {} };\n\n    // Iterate over every key (i.e, path), and fetch the value at that key\n    this.keys.forEach((key, keyIndex) => {\n      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      if (isArray(value)) {\n        let subRecords = [];\n        const stack = [{ nestedArrIndex: -1, value }];\n\n        while (stack.length) {\n          const { nestedArrIndex, value } = stack.pop();\n\n          if (!isDefined(value)) {\n            continue\n          }\n\n          if (isString(value) && !isBlank(value)) {\n            let subRecord = {\n              v: value,\n              i: nestedArrIndex,\n              n: this.norm.get(value)\n            };\n\n            subRecords.push(subRecord);\n          } else if (isArray(value)) {\n            value.forEach((item, k) => {\n              stack.push({\n                nestedArrIndex: k,\n                value: item\n              });\n            });\n          } else ;\n        }\n        record.$[keyIndex] = subRecords;\n      } else if (isString(value) && !isBlank(value)) {\n        let subRecord = {\n          v: value,\n          n: this.norm.get(value)\n        };\n\n        record.$[keyIndex] = subRecord;\n      }\n    });\n\n    this.records.push(record);\n  }\n  toJSON() {\n    return {\n      keys: this.keys,\n      records: this.records\n    }\n  }\n}\n\nfunction createIndex(\n  keys,\n  docs,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys.map(createKey));\n  myIndex.setSources(docs);\n  myIndex.create();\n  return myIndex\n}\n\nfunction parseIndex(\n  data,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const { keys, records } = data;\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys);\n  myIndex.setIndexRecords(records);\n  return myIndex\n}\n\nfunction computeScore$1(\n  pattern,\n  {\n    errors = 0,\n    currentLocation = 0,\n    expectedLocation = 0,\n    distance = Config.distance,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  const accuracy = errors / pattern.length;\n\n  if (ignoreLocation) {\n    return accuracy\n  }\n\n  const proximity = Math.abs(expectedLocation - currentLocation);\n\n  if (!distance) {\n    // Dodge divide by zero error.\n    return proximity ? 1.0 : accuracy\n  }\n\n  return accuracy + proximity / distance\n}\n\nfunction convertMaskToIndices(\n  matchmask = [],\n  minMatchCharLength = Config.minMatchCharLength\n) {\n  let indices = [];\n  let start = -1;\n  let end = -1;\n  let i = 0;\n\n  for (let len = matchmask.length; i < len; i += 1) {\n    let match = matchmask[i];\n    if (match && start === -1) {\n      start = i;\n    } else if (!match && start !== -1) {\n      end = i - 1;\n      if (end - start + 1 >= minMatchCharLength) {\n        indices.push([start, end]);\n      }\n      start = -1;\n    }\n  }\n\n  // (i-1 - start) + 1 => i - start\n  if (matchmask[i - 1] && i - start >= minMatchCharLength) {\n    indices.push([start, i - 1]);\n  }\n\n  return indices\n}\n\n// Machine word size\nconst MAX_BITS = 32;\n\nfunction search(\n  text,\n  pattern,\n  patternAlphabet,\n  {\n    location = Config.location,\n    distance = Config.distance,\n    threshold = Config.threshold,\n    findAllMatches = Config.findAllMatches,\n    minMatchCharLength = Config.minMatchCharLength,\n    includeMatches = Config.includeMatches,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  if (pattern.length > MAX_BITS) {\n    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS))\n  }\n\n  const patternLen = pattern.length;\n  // Set starting location at beginning text and initialize the alphabet.\n  const textLen = text.length;\n  // Handle the case when location > text.length\n  const expectedLocation = Math.max(0, Math.min(location, textLen));\n  // Highest score beyond which we give up.\n  let currentThreshold = threshold;\n  // Is there a nearby exact match? (speedup)\n  let bestLocation = expectedLocation;\n\n  // Performance: only computer matches when the minMatchCharLength > 1\n  // OR if `includeMatches` is true.\n  const computeMatches = minMatchCharLength > 1 || includeMatches;\n  // A mask of the matches, used for building the indices\n  const matchMask = computeMatches ? Array(textLen) : [];\n\n  let index;\n\n  // Get all exact matches, here for speed up\n  while ((index = text.indexOf(pattern, bestLocation)) > -1) {\n    let score = computeScore$1(pattern, {\n      currentLocation: index,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    currentThreshold = Math.min(score, currentThreshold);\n    bestLocation = index + patternLen;\n\n    if (computeMatches) {\n      let i = 0;\n      while (i < patternLen) {\n        matchMask[index + i] = 1;\n        i += 1;\n      }\n    }\n  }\n\n  // Reset the best location\n  bestLocation = -1;\n\n  let lastBitArr = [];\n  let finalScore = 1;\n  let binMax = patternLen + textLen;\n\n  const mask = 1 << (patternLen - 1);\n\n  for (let i = 0; i < patternLen; i += 1) {\n    // Scan for the best match; each iteration allows for one more error.\n    // Run a binary search to determine how far from the match location we can stray\n    // at this error level.\n    let binMin = 0;\n    let binMid = binMax;\n\n    while (binMin < binMid) {\n      const score = computeScore$1(pattern, {\n        errors: i,\n        currentLocation: expectedLocation + binMid,\n        expectedLocation,\n        distance,\n        ignoreLocation\n      });\n\n      if (score <= currentThreshold) {\n        binMin = binMid;\n      } else {\n        binMax = binMid;\n      }\n\n      binMid = Math.floor((binMax - binMin) / 2 + binMin);\n    }\n\n    // Use the result from this iteration as the maximum for the next.\n    binMax = binMid;\n\n    let start = Math.max(1, expectedLocation - binMid + 1);\n    let finish = findAllMatches\n      ? textLen\n      : Math.min(expectedLocation + binMid, textLen) + patternLen;\n\n    // Initialize the bit array\n    let bitArr = Array(finish + 2);\n\n    bitArr[finish + 1] = (1 << i) - 1;\n\n    for (let j = finish; j >= start; j -= 1) {\n      let currentLocation = j - 1;\n      let charMatch = patternAlphabet[text.charAt(currentLocation)];\n\n      if (computeMatches) {\n        // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)\n        matchMask[currentLocation] = +!!charMatch;\n      }\n\n      // First pass: exact match\n      bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch;\n\n      // Subsequent passes: fuzzy match\n      if (i) {\n        bitArr[j] |=\n          ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];\n      }\n\n      if (bitArr[j] & mask) {\n        finalScore = computeScore$1(pattern, {\n          errors: i,\n          currentLocation,\n          expectedLocation,\n          distance,\n          ignoreLocation\n        });\n\n        // This match will almost certainly be better than any existing match.\n        // But check anyway.\n        if (finalScore <= currentThreshold) {\n          // Indeed it is\n          currentThreshold = finalScore;\n          bestLocation = currentLocation;\n\n          // Already passed `loc`, downhill from here on in.\n          if (bestLocation <= expectedLocation) {\n            break\n          }\n\n          // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.\n          start = Math.max(1, 2 * expectedLocation - bestLocation);\n        }\n      }\n    }\n\n    // No hope for a (better) match at greater error levels.\n    const score = computeScore$1(pattern, {\n      errors: i + 1,\n      currentLocation: expectedLocation,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    if (score > currentThreshold) {\n      break\n    }\n\n    lastBitArr = bitArr;\n  }\n\n  const result = {\n    isMatch: bestLocation >= 0,\n    // Count exact matches (those with a score of 0) to be \"almost\" exact\n    score: Math.max(0.001, finalScore)\n  };\n\n  if (computeMatches) {\n    const indices = convertMaskToIndices(matchMask, minMatchCharLength);\n    if (!indices.length) {\n      result.isMatch = false;\n    } else if (includeMatches) {\n      result.indices = indices;\n    }\n  }\n\n  return result\n}\n\nfunction createPatternAlphabet(pattern) {\n  let mask = {};\n\n  for (let i = 0, len = pattern.length; i < len; i += 1) {\n    const char = pattern.charAt(i);\n    mask[char] = (mask[char] || 0) | (1 << (len - i - 1));\n  }\n\n  return mask\n}\n\nconst stripDiacritics = String.prototype.normalize\n    ? ((str) => str.normalize('NFD').replace(/[\\u0300-\\u036F\\u0483-\\u0489\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u09FE\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0AFA-\\u0AFF\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C00-\\u0C04\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81-\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D00-\\u0D03\\u0D3B\\u0D3C\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D82\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F\\u109A-\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F\\u1AB0-\\u1ABE\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF2-\\u1CF4\\u1CF7-\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u20D0-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F-\\uA672\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA880\\uA881\\uA8B4-\\uA8C5\\uA8E0-\\uA8F1\\uA8FF\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uA9E5\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA7B-\\uAA7D\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F]/g, ''))\n    : ((str) => str);\n\nclass BitapSearch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    this.options = {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreDiacritics,\n      ignoreLocation\n    };\n\n    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;\n    this.pattern = pattern;\n\n    this.chunks = [];\n\n    if (!this.pattern.length) {\n      return\n    }\n\n    const addChunk = (pattern, startIndex) => {\n      this.chunks.push({\n        pattern,\n        alphabet: createPatternAlphabet(pattern),\n        startIndex\n      });\n    };\n\n    const len = this.pattern.length;\n\n    if (len > MAX_BITS) {\n      let i = 0;\n      const remainder = len % MAX_BITS;\n      const end = len - remainder;\n\n      while (i < end) {\n        addChunk(this.pattern.substr(i, MAX_BITS), i);\n        i += MAX_BITS;\n      }\n\n      if (remainder) {\n        const startIndex = len - MAX_BITS;\n        addChunk(this.pattern.substr(startIndex), startIndex);\n      }\n    } else {\n      addChunk(this.pattern, 0);\n    }\n  }\n\n  searchIn(text) {\n    const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;\n\n    text = isCaseSensitive ? text : text.toLowerCase();\n    text = ignoreDiacritics ? stripDiacritics(text) : text;\n\n    // Exact match\n    if (this.pattern === text) {\n      let result = {\n        isMatch: true,\n        score: 0\n      };\n\n      if (includeMatches) {\n        result.indices = [[0, text.length - 1]];\n      }\n\n      return result\n    }\n\n    // Otherwise, use Bitap algorithm\n    const {\n      location,\n      distance,\n      threshold,\n      findAllMatches,\n      minMatchCharLength,\n      ignoreLocation\n    } = this.options;\n\n    let allIndices = [];\n    let totalScore = 0;\n    let hasMatches = false;\n\n    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {\n      const { isMatch, score, indices } = search(text, pattern, alphabet, {\n        location: location + startIndex,\n        distance,\n        threshold,\n        findAllMatches,\n        minMatchCharLength,\n        includeMatches,\n        ignoreLocation\n      });\n\n      if (isMatch) {\n        hasMatches = true;\n      }\n\n      totalScore += score;\n\n      if (isMatch && indices) {\n        allIndices = [...allIndices, ...indices];\n      }\n    });\n\n    let result = {\n      isMatch: hasMatches,\n      score: hasMatches ? totalScore / this.chunks.length : 1\n    };\n\n    if (hasMatches && includeMatches) {\n      result.indices = allIndices;\n    }\n\n    return result\n  }\n}\n\nclass BaseMatch {\n  constructor(pattern) {\n    this.pattern = pattern;\n  }\n  static isMultiMatch(pattern) {\n    return getMatch(pattern, this.multiRegex)\n  }\n  static isSingleMatch(pattern) {\n    return getMatch(pattern, this.singleRegex)\n  }\n  search(/*text*/) {}\n}\n\nfunction getMatch(pattern, exp) {\n  const matches = pattern.match(exp);\n  return matches ? matches[1] : null\n}\n\n// Token: 'file\n\nclass ExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'exact'\n  }\n  static get multiRegex() {\n    return /^=\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^=(.*)$/\n  }\n  search(text) {\n    const isMatch = text === this.pattern;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !fire\n\nclass InverseExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!(.*)$/\n  }\n  search(text) {\n    const index = text.indexOf(this.pattern);\n    const isMatch = index === -1;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: ^file\n\nclass PrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'prefix-exact'\n  }\n  static get multiRegex() {\n    return /^\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !^fire\n\nclass InversePrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-prefix-exact'\n  }\n  static get multiRegex() {\n    return /^!\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = !text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: .file$\n\nclass SuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'suffix-exact'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = text.endsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [text.length - this.pattern.length, text.length - 1]\n    }\n  }\n}\n\n// Token: !.file$\n\nclass InverseSuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-suffix-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^!(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = !text.endsWith(this.pattern);\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\nclass FuzzyMatch extends BaseMatch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    super(pattern);\n    this._bitapSearch = new BitapSearch(pattern, {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreDiacritics,\n      ignoreLocation\n    });\n  }\n  static get type() {\n    return 'fuzzy'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^(.*)$/\n  }\n  search(text) {\n    return this._bitapSearch.searchIn(text)\n  }\n}\n\n// Token: 'file\n\nclass IncludeMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'include'\n  }\n  static get multiRegex() {\n    return /^'\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^'(.*)$/\n  }\n  search(text) {\n    let location = 0;\n    let index;\n\n    const indices = [];\n    const patternLen = this.pattern.length;\n\n    // Get all exact matches\n    while ((index = text.indexOf(this.pattern, location)) > -1) {\n      location = index + patternLen;\n      indices.push([index, location - 1]);\n    }\n\n    const isMatch = !!indices.length;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices\n    }\n  }\n}\n\n// ❗Order is important. DO NOT CHANGE.\nconst searchers = [\n  ExactMatch,\n  IncludeMatch,\n  PrefixExactMatch,\n  InversePrefixExactMatch,\n  InverseSuffixExactMatch,\n  SuffixExactMatch,\n  InverseExactMatch,\n  FuzzyMatch\n];\n\nconst searchersLen = searchers.length;\n\n// Regex to split by spaces, but keep anything in quotes together\nconst SPACE_RE = / +(?=(?:[^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)/;\nconst OR_TOKEN = '|';\n\n// Return a 2D array representation of the query, for simpler parsing.\n// Example:\n// \"^core go$ | rb$ | py$ xy$\" => [[\"^core\", \"go$\"], [\"rb$\"], [\"py$\", \"xy$\"]]\nfunction parseQuery(pattern, options = {}) {\n  return pattern.split(OR_TOKEN).map((item) => {\n    let query = item\n      .trim()\n      .split(SPACE_RE)\n      .filter((item) => item && !!item.trim());\n\n    let results = [];\n    for (let i = 0, len = query.length; i < len; i += 1) {\n      const queryItem = query[i];\n\n      // 1. Handle multiple query match (i.e, once that are quoted, like `\"hello world\"`)\n      let found = false;\n      let idx = -1;\n      while (!found && ++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isMultiMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          found = true;\n        }\n      }\n\n      if (found) {\n        continue\n      }\n\n      // 2. Handle single query matches (i.e, once that are *not* quoted)\n      idx = -1;\n      while (++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isSingleMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          break\n        }\n      }\n    }\n\n    return results\n  })\n}\n\n// These extended matchers can return an array of matches, as opposed\n// to a singl match\nconst MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);\n\n/**\n * Command-like searching\n * ======================\n *\n * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,\n * search in a given text.\n *\n * Search syntax:\n *\n * | Token       | Match type                 | Description                            |\n * | ----------- | -------------------------- | -------------------------------------- |\n * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |\n * | `=scheme`   | exact-match                | Items that are `scheme`                |\n * | `'python`   | include-match              | Items that include `python`            |\n * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |\n * | `^java`     | prefix-exact-match         | Items that start with `java`           |\n * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |\n * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |\n * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |\n *\n * A single pipe character acts as an OR operator. For example, the following\n * query matches entries that start with `core` and end with either`go`, `rb`,\n * or`py`.\n *\n * ```\n * ^core go$ | rb$ | py$\n * ```\n */\nclass ExtendedSearch {\n  constructor(\n    pattern,\n    {\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      includeMatches = Config.includeMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      ignoreLocation = Config.ignoreLocation,\n      findAllMatches = Config.findAllMatches,\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance\n    } = {}\n  ) {\n    this.query = null;\n    this.options = {\n      isCaseSensitive,\n      ignoreDiacritics,\n      includeMatches,\n      minMatchCharLength,\n      findAllMatches,\n      ignoreLocation,\n      location,\n      threshold,\n      distance\n    };\n\n    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;\n    this.pattern = pattern;\n    this.query = parseQuery(this.pattern, this.options);\n  }\n\n  static condition(_, options) {\n    return options.useExtendedSearch\n  }\n\n  searchIn(text) {\n    const query = this.query;\n\n    if (!query) {\n      return {\n        isMatch: false,\n        score: 1\n      }\n    }\n\n    const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;\n\n    text = isCaseSensitive ? text : text.toLowerCase();\n    text = ignoreDiacritics ? stripDiacritics(text) : text;\n\n    let numMatches = 0;\n    let allIndices = [];\n    let totalScore = 0;\n\n    // ORs\n    for (let i = 0, qLen = query.length; i < qLen; i += 1) {\n      const searchers = query[i];\n\n      // Reset indices\n      allIndices.length = 0;\n      numMatches = 0;\n\n      // ANDs\n      for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {\n        const searcher = searchers[j];\n        const { isMatch, indices, score } = searcher.search(text);\n\n        if (isMatch) {\n          numMatches += 1;\n          totalScore += score;\n          if (includeMatches) {\n            const type = searcher.constructor.type;\n            if (MultiMatchSet.has(type)) {\n              allIndices = [...allIndices, ...indices];\n            } else {\n              allIndices.push(indices);\n            }\n          }\n        } else {\n          totalScore = 0;\n          numMatches = 0;\n          allIndices.length = 0;\n          break\n        }\n      }\n\n      // OR condition, so if TRUE, return\n      if (numMatches) {\n        let result = {\n          isMatch: true,\n          score: totalScore / numMatches\n        };\n\n        if (includeMatches) {\n          result.indices = allIndices;\n        }\n\n        return result\n      }\n    }\n\n    // Nothing was matched\n    return {\n      isMatch: false,\n      score: 1\n    }\n  }\n}\n\nconst registeredSearchers = [];\n\nfunction register(...args) {\n  registeredSearchers.push(...args);\n}\n\nfunction createSearcher(pattern, options) {\n  for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {\n    let searcherClass = registeredSearchers[i];\n    if (searcherClass.condition(pattern, options)) {\n      return new searcherClass(pattern, options)\n    }\n  }\n\n  return new BitapSearch(pattern, options)\n}\n\nconst LogicalOperator = {\n  AND: '$and',\n  OR: '$or'\n};\n\nconst KeyType = {\n  PATH: '$path',\n  PATTERN: '$val'\n};\n\nconst isExpression = (query) =>\n  !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);\n\nconst isPath = (query) => !!query[KeyType.PATH];\n\nconst isLeaf = (query) =>\n  !isArray(query) && isObject(query) && !isExpression(query);\n\nconst convertToExplicit = (query) => ({\n  [LogicalOperator.AND]: Object.keys(query).map((key) => ({\n    [key]: query[key]\n  }))\n});\n\n// When `auto` is `true`, the parse function will infer and initialize and add\n// the appropriate `Searcher` instance\nfunction parse(query, options, { auto = true } = {}) {\n  const next = (query) => {\n    let keys = Object.keys(query);\n\n    const isQueryPath = isPath(query);\n\n    if (!isQueryPath && keys.length > 1 && !isExpression(query)) {\n      return next(convertToExplicit(query))\n    }\n\n    if (isLeaf(query)) {\n      const key = isQueryPath ? query[KeyType.PATH] : keys[0];\n\n      const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];\n\n      if (!isString(pattern)) {\n        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key))\n      }\n\n      const obj = {\n        keyId: createKeyId(key),\n        pattern\n      };\n\n      if (auto) {\n        obj.searcher = createSearcher(pattern, options);\n      }\n\n      return obj\n    }\n\n    let node = {\n      children: [],\n      operator: keys[0]\n    };\n\n    keys.forEach((key) => {\n      const value = query[key];\n\n      if (isArray(value)) {\n        value.forEach((item) => {\n          node.children.push(next(item));\n        });\n      }\n    });\n\n    return node\n  };\n\n  if (!isExpression(query)) {\n    query = convertToExplicit(query);\n  }\n\n  return next(query)\n}\n\n// Practical scoring function\nfunction computeScore(\n  results,\n  { ignoreFieldNorm = Config.ignoreFieldNorm }\n) {\n  results.forEach((result) => {\n    let totalScore = 1;\n\n    result.matches.forEach(({ key, norm, score }) => {\n      const weight = key ? key.weight : null;\n\n      totalScore *= Math.pow(\n        score === 0 && weight ? Number.EPSILON : score,\n        (weight || 1) * (ignoreFieldNorm ? 1 : norm)\n      );\n    });\n\n    result.score = totalScore;\n  });\n}\n\nfunction transformMatches(result, data) {\n  const matches = result.matches;\n  data.matches = [];\n\n  if (!isDefined(matches)) {\n    return\n  }\n\n  matches.forEach((match) => {\n    if (!isDefined(match.indices) || !match.indices.length) {\n      return\n    }\n\n    const { indices, value } = match;\n\n    let obj = {\n      indices,\n      value\n    };\n\n    if (match.key) {\n      obj.key = match.key.src;\n    }\n\n    if (match.idx > -1) {\n      obj.refIndex = match.idx;\n    }\n\n    data.matches.push(obj);\n  });\n}\n\nfunction transformScore(result, data) {\n  data.score = result.score;\n}\n\nfunction format(\n  results,\n  docs,\n  {\n    includeMatches = Config.includeMatches,\n    includeScore = Config.includeScore\n  } = {}\n) {\n  const transformers = [];\n\n  if (includeMatches) transformers.push(transformMatches);\n  if (includeScore) transformers.push(transformScore);\n\n  return results.map((result) => {\n    const { idx } = result;\n\n    const data = {\n      item: docs[idx],\n      refIndex: idx\n    };\n\n    if (transformers.length) {\n      transformers.forEach((transformer) => {\n        transformer(result, data);\n      });\n    }\n\n    return data\n  })\n}\n\nclass Fuse {\n  constructor(docs, options = {}, index) {\n    this.options = { ...Config, ...options };\n\n    if (\n      this.options.useExtendedSearch &&\n      !true\n    ) {\n      throw new Error(EXTENDED_SEARCH_UNAVAILABLE)\n    }\n\n    this._keyStore = new KeyStore(this.options.keys);\n\n    this.setCollection(docs, index);\n  }\n\n  setCollection(docs, index) {\n    this._docs = docs;\n\n    if (index && !(index instanceof FuseIndex)) {\n      throw new Error(INCORRECT_INDEX_TYPE)\n    }\n\n    this._myIndex =\n      index ||\n      createIndex(this.options.keys, this._docs, {\n        getFn: this.options.getFn,\n        fieldNormWeight: this.options.fieldNormWeight\n      });\n  }\n\n  add(doc) {\n    if (!isDefined(doc)) {\n      return\n    }\n\n    this._docs.push(doc);\n    this._myIndex.add(doc);\n  }\n\n  remove(predicate = (/* doc, idx */) => false) {\n    const results = [];\n\n    for (let i = 0, len = this._docs.length; i < len; i += 1) {\n      const doc = this._docs[i];\n      if (predicate(doc, i)) {\n        this.removeAt(i);\n        i -= 1;\n        len -= 1;\n\n        results.push(doc);\n      }\n    }\n\n    return results\n  }\n\n  removeAt(idx) {\n    this._docs.splice(idx, 1);\n    this._myIndex.removeAt(idx);\n  }\n\n  getIndex() {\n    return this._myIndex\n  }\n\n  search(query, { limit = -1 } = {}) {\n    const {\n      includeMatches,\n      includeScore,\n      shouldSort,\n      sortFn,\n      ignoreFieldNorm\n    } = this.options;\n\n    let results = isString(query)\n      ? isString(this._docs[0])\n        ? this._searchStringList(query)\n        : this._searchObjectList(query)\n      : this._searchLogical(query);\n\n    computeScore(results, { ignoreFieldNorm });\n\n    if (shouldSort) {\n      results.sort(sortFn);\n    }\n\n    if (isNumber(limit) && limit > -1) {\n      results = results.slice(0, limit);\n    }\n\n    return format(results, this._docs, {\n      includeMatches,\n      includeScore\n    })\n  }\n\n  _searchStringList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { records } = this._myIndex;\n    const results = [];\n\n    // Iterate over every string in the index\n    records.forEach(({ v: text, i: idx, n: norm }) => {\n      if (!isDefined(text)) {\n        return\n      }\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        results.push({\n          item: text,\n          idx,\n          matches: [{ score, value: text, norm, indices }]\n        });\n      }\n    });\n\n    return results\n  }\n\n  _searchLogical(query) {\n\n    const expression = parse(query, this.options);\n\n    const evaluate = (node, item, idx) => {\n      if (!node.children) {\n        const { keyId, searcher } = node;\n\n        const matches = this._findMatches({\n          key: this._keyStore.get(keyId),\n          value: this._myIndex.getValueForItemAtKeyId(item, keyId),\n          searcher\n        });\n\n        if (matches && matches.length) {\n          return [\n            {\n              idx,\n              item,\n              matches\n            }\n          ]\n        }\n\n        return []\n      }\n\n      const res = [];\n      for (let i = 0, len = node.children.length; i < len; i += 1) {\n        const child = node.children[i];\n        const result = evaluate(child, item, idx);\n        if (result.length) {\n          res.push(...result);\n        } else if (node.operator === LogicalOperator.AND) {\n          return []\n        }\n      }\n      return res\n    };\n\n    const records = this._myIndex.records;\n    const resultMap = {};\n    const results = [];\n\n    records.forEach(({ $: item, i: idx }) => {\n      if (isDefined(item)) {\n        let expResults = evaluate(expression, item, idx);\n\n        if (expResults.length) {\n          // Dedupe when adding\n          if (!resultMap[idx]) {\n            resultMap[idx] = { idx, item, matches: [] };\n            results.push(resultMap[idx]);\n          }\n          expResults.forEach(({ matches }) => {\n            resultMap[idx].matches.push(...matches);\n          });\n        }\n      }\n    });\n\n    return results\n  }\n\n  _searchObjectList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { keys, records } = this._myIndex;\n    const results = [];\n\n    // List is Array<Object>\n    records.forEach(({ $: item, i: idx }) => {\n      if (!isDefined(item)) {\n        return\n      }\n\n      let matches = [];\n\n      // Iterate over every key (i.e, path), and fetch the value at that key\n      keys.forEach((key, keyIndex) => {\n        matches.push(\n          ...this._findMatches({\n            key,\n            value: item[keyIndex],\n            searcher\n          })\n        );\n      });\n\n      if (matches.length) {\n        results.push({\n          idx,\n          item,\n          matches\n        });\n      }\n    });\n\n    return results\n  }\n  _findMatches({ key, value, searcher }) {\n    if (!isDefined(value)) {\n      return []\n    }\n\n    let matches = [];\n\n    if (isArray(value)) {\n      value.forEach(({ v: text, i: idx, n: norm }) => {\n        if (!isDefined(text)) {\n          return\n        }\n\n        const { isMatch, score, indices } = searcher.searchIn(text);\n\n        if (isMatch) {\n          matches.push({\n            score,\n            key,\n            value: text,\n            idx,\n            norm,\n            indices\n          });\n        }\n      });\n    } else {\n      const { v: text, n: norm } = value;\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        matches.push({ score, key, value: text, norm, indices });\n      }\n    }\n\n    return matches\n  }\n}\n\nFuse.version = '7.1.0';\nFuse.createIndex = createIndex;\nFuse.parseIndex = parseIndex;\nFuse.config = Config;\n\n{\n  Fuse.parseQuery = parse;\n}\n\n{\n  register(ExtendedSearch);\n}\n\nexport { Fuse as default };\n","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 **localStorage** 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    /** @type {typeof parseInterval} */\n    parseInterval: null,\n    /** @type {typeof internalEval} */\n    _: null,\n    version: '2.0.4'\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    // @ts-ignore: non-standard properties for browser compatibility\n    // noinspection JSUnresolvedVariable\n    const matchesFunction = elt instanceof Element && (elt.matches || elt.matchesSelector || elt.msMatchesSelector || elt.mozMatchesSelector || elt.webkitMatchesSelector || elt.oMatchesSelector)\n    return !!matchesFunction && matchesFunction.call(elt, selector)\n  }\n\n  /**\n   * @param {string} str\n   * @returns {string}\n   */\n  function getStartTag(str) {\n    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    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:localStorageTest'\n    try {\n      localStorage.setItem(test, test)\n      localStorage.removeItem(test)\n      return true\n    } catch (e) {\n      return false\n    }\n  }\n\n  /**\n   * @param {string} path\n   * @returns {string}\n   */\n  function normalizePath(path) {\n    try {\n      const url = new URL(path)\n      if (url) {\n        path = url.pathname + url.search\n      }\n      // remove trailing slash, unless index page\n      if (!(/^\\/$/.test(path))) {\n        path = path.replace(/\\/+$/, '')\n      }\n      return path\n    } catch (e) {\n      // be kind to IE11, which doesn't support URL()\n      return path\n    }\n  }\n\n  //= =========================================================================================\n  // public API\n  //= =========================================================================================\n\n  /**\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 && elt.closest) {\n      return elt.closest(selector)\n    } else {\n      // TODO remove when IE goes away\n      do {\n        if (elt == null || matches(elt, selector)) {\n          return elt\n        }\n      }\n      while (elt = elt && asElement(parentElt(elt)))\n      return null\n    }\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.substr(8)))\n      } else if (selector.indexOf('find ') === 0) {\n        item = find(asParentNode(elt), normalizeSelector(selector.substr(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.substr(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.substr(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        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    const attributesToSettle = htmx.config.attributesToSettle\n    for (let i = 0; i < attributesToSettle.length; i++) {\n      if (name === attributesToSettle[i]) {\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * @param {Element} mergeTo\n   * @param {Element} mergeFrom\n   */\n  function cloneAttributes(mergeTo, mergeFrom) {\n    forEach(mergeTo.attributes, function(attr) {\n      if (!mergeFrom.hasAttribute(attr.name) && shouldSettleAttribute(attr.name)) {\n        mergeTo.removeAttribute(attr.name)\n      }\n    })\n    forEach(mergeFrom.attributes, function(attr) {\n      if (shouldSettleAttribute(attr.name)) {\n        mergeTo.setAttribute(attr.name, attr.value)\n      }\n    })\n  }\n\n  /**\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 = '#' + 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) {\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 })\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 normalizedId = id.replace(\"'\", \"\\\\'\")\n        const normalizedTag = newNode.tagName.replace(':', '\\\\:')\n        const parentElt = asParentNode(parentNode)\n        const oldNode = parentElt && parentElt.querySelector(normalizedTag + \"[id='\" + normalizedId + \"']\")\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    // IE fix\n    if (elt.attributes) {\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    }\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 IE11 code\n    // noinspection JSUnresolvedReference\n    if (element.children) { // IE\n      // @ts-ignore\n      forEach(element.children, function(child) { cleanUpElement(child) })\n    }\n  }\n\n  /**\n   * @param {Node} target\n   * @param {ParentNode} fragment\n   * @param {HtmxSettleInfo} settleInfo\n   */\n  function swapOuterHTML(target, fragment, settleInfo) {\n    if (target instanceof Element && 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    if (target instanceof Element) {\n      target.remove()\n    } else {\n      target.parentNode.removeChild(target)\n    }\n  }\n\n  /**\n   * @param {Node} 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 {Node} 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 {Node} 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 {Node} 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 {Node} 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 {Node} 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 {Node} 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: 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\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    try {\n      selectionInfo = {\n        elt: activeElt,\n        // @ts-ignore\n        start: activeElt ? activeElt.selectionStart : null,\n        // @ts-ignore\n        end: activeElt ? activeElt.selectionEnd : null\n      }\n    } catch (e) {\n      // safari issue - see https://github.com/microsoft/playwright/issues/5894\n    }\n    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 = fragment.title\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    target.classList.remove(htmx.config.swappingClass)\n    forEach(settleInfo.elts, function(elt) {\n      if (elt.classList) {\n        elt.classList.add(htmx.config.settlingClass)\n      }\n      triggerEvent(elt, 'htmx:afterSwap', swapOptions.eventInfo)\n    })\n    if (swapOptions.afterSwapCallback) {\n      swapOptions.afterSwapCallback()\n    }\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          elt.classList.remove(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      if (swapOptions.afterSettleCallback) {\n        swapOptions.afterSettleCallback()\n      }\n    }\n\n    if (swapSpec.settleDelay > 0) {\n      getWindow().setTimeout(doSettle, swapSpec.settleDelay)\n    } else {\n      doSettle()\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 = getDocument().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 {Node} node\n   * @returns {boolean}\n   */\n  function shouldCancel(evt, node) {\n    const elt = asElement(node)\n    if (!elt) {\n      return false\n    }\n    if (evt.type === 'submit' || evt.type === 'click') {\n      if (elt.tagName === 'FORM') {\n        return true\n      }\n      if (matches(elt, 'input[type=\"submit\"], button') &&\n        (matches(elt, '[form]') || closest(elt, 'form') !== null)) {\n        return true\n      }\n      if (elt instanceof HTMLAnchorElement && elt.href &&\n        (elt.getAttribute('href') === '#' || elt.getAttribute('href').indexOf('#') !== 0)) {\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 {Node} 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, elt)) {\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 = event.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 (closest(elt, htmx.config.disableSelector)) {\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 {Node} elt\n   * @param {Event} [evt]\n   */\n\n  /**\n   * @param {Node} 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 = /** @type {HTMLButtonElement|HTMLInputElement} */ (closest(asElement(evt.target), \"button, input[type='submit']\"))\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 {Event} evt\n   * @returns {HtmxNodeInternalData|undefined}\n   */\n  function getRelatedFormData(evt) {\n    const elt = closest(asElement(evt.target), \"button, input[type='submit']\")\n    if (!elt) {\n      return\n    }\n    const form = resolveTarget('#' + getRawAttribute(elt, 'form'), elt.getRootNode()) || closest(elt, 'form')\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    if (closest(elt, htmx.config.disableSelector)) {\n      cleanUpElement(elt)\n      return\n    }\n    const nodeData = getInternalData(elt)\n    const attrHash = attributeHash(elt)\n    if (nodeData.initHash !== attrHash) {\n      // clean up any previously processed info\n      deInitNode(elt)\n\n      nodeData.initHash = attrHash\n\n      triggerEvent(elt, 'htmx:beforeProcessNode')\n\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  /**\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 (closest(elt, htmx.config.disableSelector)) {\n      cleanUpElement(elt)\n      return\n    }\n    initNode(elt)\n    forEach(findElementsToProcess(elt), function(child) { initNode(child) })\n    forEach(findHxOnWildcardElements(elt), processHxOnWildcard)\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    let evt\n    if (window.CustomEvent && typeof window.CustomEvent === 'function') {\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      evt = new CustomEvent(eventName, { bubbles: true, cancelable: true, composed: true, detail })\n    } else {\n      evt = getDocument().createEvent('CustomEvent')\n      evt.initCustomEvent(eventName, true, true, detail)\n    }\n    return evt\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.  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   * @returns void\n   */\n  function withExtensions(elt, toDo) {\n    forEach(getExtensions(elt), function(extension) {\n      try {\n        toDo(extension)\n      } catch (e) {\n        logError(e)\n      }\n    })\n  }\n\n  function logError(msg) {\n    if (console.error) {\n      console.error(msg)\n    } else if (console.log) {\n      console.log('ERROR: ', msg)\n    }\n  }\n\n  /**\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)\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 = 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      localStorage.removeItem('htmx-history-cache')\n      return\n    }\n\n    url = normalizePath(url)\n\n    const historyCache = parseJSON(localStorage.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        localStorage.setItem('htmx-history-cache', JSON.stringify(historyCache))\n        break\n      } catch (e) {\n        triggerErrorEvent(getDocument().body, 'htmx:historyCacheError', { cause: e, cache: historyCache })\n        historyCache.shift() // shrink the cache and retry\n      }\n    }\n  }\n\n  /**\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(localStorage.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    const path = currentPathForHistory || location.pathname + location.search\n\n    // Allow history snapshot feature to be disabled where hx-history=\"false\"\n    // is present *anywhere* in the current document we're about to save,\n    // so we can prevent privileged data entering the cache.\n    // The page will still be reachable as a history entry, but htmx will fetch it\n    // live from the server onpopstate rather than look in the localStorage cache\n    let disableHistoryCache\n    try {\n      disableHistoryCache = getDocument().querySelector('[hx-history=\"false\" i],[data-hx-history=\"false\" i]')\n    } catch (e) {\n    // IE11: insensitive modifier not supported so fallback to case sensitive selector\n      disableHistoryCache = getDocument().querySelector('[hx-history=\"false\"],[data-hx-history=\"false\"]')\n    }\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, window.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    currentPathForHistory = path\n  }\n\n  /**\n   * @param {string} path\n   */\n  function replaceUrlInHistory(path) {\n    if (htmx.config.historyEnabled) history.replaceState({ htmx: true }, '', path)\n    currentPathForHistory = 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 details = { path, xhr: request }\n    triggerEvent(getDocument().body, 'htmx:historyCacheMiss', details)\n    request.open('GET', path, true)\n    request.setRequestHeader('HX-Request', 'true')\n    request.setRequestHeader('HX-History-Restore-Request', 'true')\n    request.setRequestHeader('HX-Current-URL', getDocument().location.href)\n    request.onload = function() {\n      if (this.status >= 200 && this.status < 400) {\n        triggerEvent(getDocument().body, 'htmx:historyCacheMissLoad', details)\n        const fragment = makeFragment(this.response)\n        /** @type ParentNode */\n        const content = fragment.querySelector('[hx-history-elt],[data-hx-history-elt]') || fragment\n        const historyElement = getHistoryElement()\n        const settleInfo = makeSettleInfo(historyElement)\n        handleTitle(fragment.title)\n\n        handlePreservedElements(fragment)\n        swapInnerHTML(historyElement, content, settleInfo)\n        restorePreservedElements()\n        settleImmediately(settleInfo.tasks)\n        currentPathForHistory = path\n        triggerEvent(getDocument().body, 'htmx:historyRestore', { path, cacheMiss: true, serverResponse: this.response })\n      } else {\n        triggerErrorEvent(getDocument().body, 'htmx:historyCacheMissLoadError', details)\n      }\n    }\n    request.send()\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 fragment = makeFragment(cached.content)\n      const historyElement = getHistoryElement()\n      const settleInfo = makeSettleInfo(historyElement)\n      handleTitle(cached.title)\n      handlePreservedElements(fragment)\n      swapInnerHTML(historyElement, fragment, settleInfo)\n      restorePreservedElements()\n      settleImmediately(settleInfo.tasks)\n      getWindow().setTimeout(function() {\n        window.scrollTo(0, cached.scroll)\n      }, 0) // next 'tick', so browser has time to render layout\n      currentPathForHistory = path\n      triggerEvent(getDocument().body, 'htmx:historyRestore', { path, item: cached })\n    } else {\n      if (htmx.config.refreshOnHistoryMiss) {\n        // @ts-ignore: optional parameter in reload() function throws error\n        // noinspection JSUnresolvedReference\n        window.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      ic.classList.add.call(ic.classList, 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      disabledElement.setAttribute('disabled', '')\n      disabledElement.setAttribute('data-disabled-by-htmx', '')\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        ic.classList.remove.call(ic.classList, htmx.config.requestClass)\n      }\n    })\n    forEach(disabled, function(disabledElement) {\n      const internalData = getInternalData(disabledElement)\n      if (internalData.requestCount === 0) {\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  /** @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  /** @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[]} 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      // @ts-ignore value will be undefined for non-input elements, which is fine\n      let value = elt.value\n      if (elt instanceof HTMLSelectElement && elt.multiple) {\n        value = 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        value = toArray(elt.files)\n      }\n      addValueToFormData(name, value, 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, input.value, 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   *\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        errors.push({ elt: element, message: element.validationMessage, validity: element.validity })\n        triggerEvent(element, 'htmx:validation:failed', { message: element.validationMessage, validity: element.validity })\n      }\n    }\n  }\n\n  /**\n   * 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 closest form\n    if (verb !== 'get') {\n      processInputValue(processed, priorityFormData, errors, closest(elt, 'form'), 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': getDocument().location.href\n    }\n    getValuesForElement(elt, 'hx-headers', false, headers)\n    if (prompt !== undefined) {\n      headers['HX-Prompt'] = prompt\n    }\n    if (getInternalData(elt).boosted) {\n      headers['HX-Boosted'] = 'true'\n    }\n    return headers\n  }\n\n  /**\n * filterValues takes an object containing form input values\n * and returns a new object that only contains keys that are\n * specified by the closest \"hx-params\" attribute\n * @param {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    }\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 * @returns {Object}\n */\n  function getValuesForElement(elt, attr, evalAsDefault, values) {\n    if (values == null) {\n      values = {}\n    }\n    if (elt == null) {\n      return values\n    }\n    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() { return Function('return (' + str + ')')() }, {})\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)\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 {*?} expressionVars\n * @returns\n */\n  function getHXVarsForElement(elt, expressionVars) {\n    return getValuesForElement(elt, 'hx-vars', true, expressionVars)\n  }\n\n  /**\n * @param {Element} elt\n * @param {*?} expressionVars\n * @returns\n */\n  function getHXValsForElement(elt, expressionVars) {\n    return getValuesForElement(elt, 'hx-vals', false, expressionVars)\n  }\n\n  /**\n * @param {Element} elt\n * @returns {FormData}\n */\n  function getExpressionVars(elt) {\n    return mergeObjects(getHXVarsForElement(elt), getHXValsForElement(elt))\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  // NB: IE11 does not support this stuff\n    if (xhr.responseURL && typeof (URL) !== 'undefined') {\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          })\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    let sameHost\n    let url\n    if (typeof URL === 'function') {\n      url = new URL(path, document.location.href)\n      const origin = document.location.origin\n      sameHost = origin === url.origin\n    } else {\n    // IE11 doesn't support URL\n      url = path\n      sameHost = startsWith(path, document.location.origin)\n    }\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          } else {\n            return target[name]\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: getAttributeValue(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      // ignore buttons with formmethod=\"dialog\"\n        if (buttonVerb.toLowerCase() !== 'dialog') {\n          verb = (/** @type HttpVerb */(buttonVerb))\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))\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 = getDocument().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      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      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        endRequestLock()\n      } catch (e) {\n        triggerErrorEvent(elt, 'htmx:onLoadError', mergeObjects({ error: e }, responseInfo))\n        throw e\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    const pushUrl = getClosestAttributeValue(elt, 'hx-push-url')\n    const replaceUrl = getClosestAttributeValue(elt, 'hx-replace-url')\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    // false indicates no push, return empty object\n      if (path === 'false') {\n        return {}\n      }\n\n      // true indicates we want to follow wherever the server ended up sending us\n      if (path === 'true') {\n        path = responsePath || requestPath // if there is no response path, go with the original request path\n      }\n\n      // restore any anchor associated with the request\n      if (responseInfo.pathInfo.anchor && 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.innerHTML = title\n      } else {\n        window.document.title = title\n      }\n    }\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      saveCurrentPageToHistory()\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      ajaxHelper('get', redirectPath, redirectSwapSpec).then(function() {\n        pushUrlIntoHistory(redirectPath)\n      })\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      location.href = xhr.getResponseHeader('HX-Redirect')\n      shouldRefresh && location.reload()\n      return\n    }\n\n    if (shouldRefresh) {\n      responseInfo.keepIndicators = true\n      location.reload()\n      return\n    }\n\n    if (hasHeader(xhr, /HX-Retarget:/i)) {\n      if (xhr.getResponseHeader('HX-Retarget') === 'this') {\n        responseInfo.target = elt\n      } else {\n        responseInfo.target = asElement(querySelectorExt(elt, xhr.getResponseHeader('HX-Retarget')))\n      }\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 = asElement(querySelectorExt(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      if (xhr.getResponseHeader('HX-Retarget') === 'this') {\n        responseInfo.target = elt\n      } else {\n        responseInfo.target = asElement(querySelectorExt(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      target.classList.add(htmx.config.swappingClass)\n\n      // optional transition API promise callbacks\n      let settleResolve = null\n      let settleReject = null\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 = getClosestAttributeValue(elt, 'hx-select-oob')\n      const select = getClosestAttributeValue(elt, 'hx-select')\n\n      let doSwap = function() {\n        try {\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          swap(target, serverResponse, swapSpec, {\n            select: 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              maybeCall(settleResolve)\n            }\n          })\n        } catch (e) {\n          triggerErrorEvent(elt, 'htmx:swapError', responseInfo)\n          maybeCall(settleReject)\n          throw e\n        }\n      }\n\n      let shouldTransition = htmx.config.globalViewTransitions\n      if (swapSpec.hasOwnProperty('transition')) {\n        shouldTransition = swapSpec.transition\n      }\n\n      if (shouldTransition &&\n              triggerEvent(elt, 'htmx:beforeTransition', responseInfo) &&\n              typeof Promise !== 'undefined' &&\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      if (swapSpec.swapDelay > 0) {\n        getWindow().setTimeout(doSwap, swapSpec.swapDelay)\n      } else {\n        doSwap()\n      }\n    }\n    if (isError) {\n      triggerErrorEvent(elt, 'htmx:responseError', mergeObjects({ error: 'Response Status Error Code ' + xhr.status + ' from ' + responseInfo.pathInfo.requestPath }, responseInfo))\n    }\n  }\n\n  //= ===================================================================\n  // Extensions API\n  //= ===================================================================\n\n  /** @type {Object<string, 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      getDocument().head.insertAdjacentHTML('beforeend',\n        '<style' + nonceAttribute + '>\\\n      .' + htmx.config.indicatorClass + '{opacity:0}\\\n      .' + htmx.config.requestClass + ' .' + htmx.config.indicatorClass + '{opacity:1; transition: opacity 200ms ease-in;}\\\n      .' + htmx.config.requestClass + '.' + htmx.config.indicatorClass + '{opacity:1; transition: opacity 200ms ease-in;}\\\n      </style>')\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 = 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 */\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'} [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/** @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 */\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} 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 */\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: 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 Swal from 'sweetalert2';\n\n\nfunction getStaticImageUrl(name) {\n  return `${STATIC_URL}images/${name}`\n}\n\nfunction removeQueryParam(param) {\n  const url = new URL(window.location.href);\n  url.searchParams.delete(param);\n  // Update the browser's address bar without reloading the page\n  window.history.replaceState(null, '', url);\n}\n\nfunction isPWA() {\n  return (\n    window.navigator.standalone === true ||                       // iOS\n    window.matchMedia('(display-mode: standalone)').matches       // Android\n  );\n}\n\n\nfunction showErrorMessage(msg, title = \"Oops!\") {\n  Swal.fire({\n    title: title,\n    text: msg,\n    footer: '<a href=\"/support\" target=\"_blank\">Need help?</a>',\n    buttonStyling: false,\n    customClass: {\n      confirmButton: \"btn bizbattles-btn primary\",\n    },\n    confirmButtonText: 'Close'\n  });\n}\n\nfunction showUnexpectedErrorMessage() {\n  showErrorMessage('An unexpected error has occured. Please try again')\n}\n\n/**\n * Formats a utc iso datetime string into a specific format\n * @param datetimeStr\n * @param dateOptions to pass into date formatter\n * @returns {string}\n */\nfunction formatDateStr(datetimeStr, dateOptions) {\n  const date = new Date(datetimeStr);\n  return date.toLocaleDateString('en-US', dateOptions)\n}\n\nfunction formatDateRange(startDatetimeStr, endDatetimeStr, hideTimeIfDifferentDays = false) {\n  const start = new Date(startDatetimeStr);\n  const end = new Date(endDatetimeStr);\n  let options = null;\n\n  if (start.toDateString() !== end.toDateString() && hideTimeIfDifferentDays) {\n    options = { weekday: 'short', month: 'short', day: 'numeric'};\n  } else {\n    options = { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: 'numeric' };\n  }\n  const fmt = new Intl.DateTimeFormat(\"en\", options);\n  return fmt.formatRange(start, end);\n}\n\n\nexport {\n  getStaticImageUrl,\n  showErrorMessage,\n  showUnexpectedErrorMessage,\n  formatDateRange,\n  formatDateStr,\n  removeQueryParam,\n  isPWA,\n}\n"],"sourceRoot":""}