{"version":3,"sources":["webpack:///./node_modules/alpinejs/dist/alpine.js"],"names":["module","exports","_defineProperty","obj","key","value","Object","defineProperty","enumerable","configurable","writable","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread2","target","i","arguments","length","source","forEach","getOwnPropertyDescriptors","defineProperties","domReady","Promise","resolve","document","readyState","addEventListener","arrayUnique","array","Array","from","Set","isTesting","navigator","userAgent","includes","checkedAttrLooseCompare","valueA","valueB","warnIfMalformedTemplate","el","directive","tagName","toLowerCase","console","warn","content","childElementCount","kebabCase","subject","replace","camelCase","match","char","toUpperCase","walk","callback","node","firstElementChild","nextElementSibling","debounce","func","wait","timeout","context","this","args","later","clearTimeout","setTimeout","handleError","expression","error","assign","tryCatch","cb","catch","e","saferEval","dataContext","additionalHelperVariables","call","Function","values","saferEvalNoReturn","AsyncFunction","getPrototypeOf","async","constructor","methodReference","xAttrRE","isXAttr","attr","name","replaceAtAndColonWithStandardSyntax","test","getXAttrs","component","type","directives","attributes","map","parseHtmlAttribute","spreadDirective","spreadObject","$data","concat","entries","sortDirectives","directiveOrder","sort","a","b","typeA","indexOf","typeB","normalizedName","typeMatch","valueMatch","modifiers","isBooleanAttr","attrName","startsWith","convertClassStringToArray","classList","filterFn","Boolean","split","TRANSITION_TYPE_IN","TRANSITION_TYPE_OUT","TRANSITION_CANCELLED","transitionIn","show","reject","forceSkip","__x_transition","attrs","showAttr","settingBothSidesOfTransition","index","transitionHelperIn","some","transitionClassesIn","transitionOut","hide","transitionHelperOut","transitionClassesOut","showCallback","transitionHelper","duration","modifierValue","origin","first","opacity","scale","second","hideCallback","fallback","rawValue","isNumeric","join","hook1","hook2","styleValues","cancel","opacityCache","style","transformCache","transform","transformOriginCache","transformOrigin","noModifiers","transitionOpacity","transitionScale","stages","transitionProperty","trim","transitionDuration","transitionTimingFunction","transition","ensureStringExpression","evaluateReturnExpression","transitionClasses","find","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","add","remove","finish","once","isConnected","cleanup","nextFrame","start","during","requestAnimationFrame","Number","getComputedStyle","animationDuration","end","isArray","isNaN","called","handleForDirective","templateEl","initialUpdate","extraVars","iteratorNames","parseForExpression","items","evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement","currentEl","item","iterationScopeVariables","getIterationScopeVariables","currentKey","generateKeyForIteration","nextEl","lookAheadForMatchingKeyedElementAndMoveItIfFound","__x_for_key","__x_for","updateElements","addElementInLoopAfterCurrentEl","initializeElements","removeAnyLeftOverElementsFromPreviousUpdate","forIteratorRE","stripParensRE","forAliasRE","inMatch","String","res","iteratorMatch","collection","scopeVariables","bindKeyAttribute","ifAttribute","clone","importNode","parentElement","insertBefore","undefined","tmpNextEl","nextElementFromOldLoop","nextElementFromOldLoopImmutable","nextSibling","handleAttributeBindingDirective","attrType","Alpine","ignoreFocusedForValueBinding","activeElement","isSameNode","checked","val","updateSelect","setAttribute","classNames","className","newClasses","removeAttribute","setIfChanged","getAttribute","arrayWrappedValue","options","option","selected","text","handleTextDirective","output","textContent","handleHtmlDirective","innerHTML","handleShowDirective","display","__x_is_shown","removeProperty","handle","showDirectiveLastElement","contains","executeAndClearRemainingShowDirectiveStack","showDirectiveStack","handleIfDirective","expressionResult","elementHasAlreadyBeenAdded","__x_inserted_me","registerListener","event","passive","handler","listenerTarget","offsetWidth","offsetHeight","runListenerHandler","removeEventListener","window","body","isKeyEvent","isListeningForASpecificKeyThatHasntBeenPressed","preventDefault","stopPropagation","then","nextModifier","evaluateCommandExpression","keyModifiers","debounceIndex","splice","keyToModifier","selectedSystemKeyModifiers","modifier","registerModelListener","rightSideOfExpression","generateModelAssignmentFunction","hasAttribute","currentValue","CustomEvent","detail","newValue","safeParseNumber","multiple","selectedOptions","number","parseFloat","create","ObjectCreate","ObjectDefineProperty","ObjectDefineProperties","isExtensible","getOwnPropertyNames","preventExtensions","hasOwnProperty","ArrayPush","ArrayConcat","ArrayMap","prototype","isUndefined","isFunction","isObject","proxyToValueMap","WeakMap","registerProxy","proxy","set","unwrap","replicaOrAny","get","wrapValue","membrane","valueIsObservable","getProxy","unwrapDescriptor","descriptor","lockShadowTarget","shadowTarget","originalTarget","wrapDescriptor","ReactiveProxyHandler","valueObserved","valueMutated","thisArg","argArray","newTarget","shadowIsExtensible","targetIsExtensible","desc","shadowDescriptor","originalDescriptor","wrapReadOnlyValue","getReadOnlyProxy","ReadOnlyHandler","createShadowTarget","ObjectDotPrototype","defaultValueIsObservable","proto","defaultValueObserved","defaultValueMutated","defaultValueDistortion","getValue","unwrapProxy","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","o","getReactiveState","readOnly","reactive","p","distortedValue","reactiveState","reactiveHandler","Proxy","readOnlyHandler","wrap","data","mutationCallback","unwrap$1","observable","unwrappedData","copy","Component","componentForClone","$el","dataAttr","dataExpression","initExpression","dataExtras","canonicalComponentElementReference","magicProperties","unobservedData","getUnobservedData","wrapDataInObservable","initReturnedCallback","$refs","getRefsProxy","nextTickStack","$nextTick","watchers","$watch","property","onBeforeComponentInitializeds","pauseReactivity","listenForNewElementsToInitialize","onComponentInitializeds","self","updateDom","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","is","initializeComponentCallback","__x","rootEl","walkAndSkipNestedComponents","initializeElement","executeAndClearNextTickStack","shouldRegisterListeners","registerListeners","resolveBoundAttributes","updateElement","shift","reverse","promiseChain","promise","finishElement","$dispatch","getDispatchFunction","dispatchEvent","bubbles","targetNode","observerOptions","childList","subtree","MutationObserver","mutations","closestParentComponent","closest","attributeName","xAttr","rawData","addedNodes","nodeType","matches","observe","ref","version","pauseMutationObserver","discoverComponents","initializeComponent","discoverUninitializedComponents","listenForNewUninitializedComponentsAtRunTime","querySelectorAll","rootEls","querySelector","newEl","addMagicProperty","onComponentInitialized","onBeforeComponentInitialized","deferLoadingAlpine","factory"],"mappings":"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","file":"js/443-5415f1a55a1d65eb337f.js","sourcesContent":["(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, global.Alpine = factory());\n}(this, (function () { 'use strict';\n\n  function _defineProperty(obj, key, value) {\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n\n    return obj;\n  }\n\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n\n    if (Object.getOwnPropertySymbols) {\n      var symbols = Object.getOwnPropertySymbols(object);\n      if (enumerableOnly) symbols = symbols.filter(function (sym) {\n        return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n      });\n      keys.push.apply(keys, symbols);\n    }\n\n    return keys;\n  }\n\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\n\n      if (i % 2) {\n        ownKeys(Object(source), true).forEach(function (key) {\n          _defineProperty(target, key, source[key]);\n        });\n      } else if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n      } else {\n        ownKeys(Object(source)).forEach(function (key) {\n          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        });\n      }\n    }\n\n    return target;\n  }\n\n  // Thanks @stimulus:\n  // https://github.com/stimulusjs/stimulus/blob/master/packages/%40stimulus/core/src/application.ts\n  function domReady() {\n    return new Promise(resolve => {\n      if (document.readyState == \"loading\") {\n        document.addEventListener(\"DOMContentLoaded\", resolve);\n      } else {\n        resolve();\n      }\n    });\n  }\n  function arrayUnique(array) {\n    return Array.from(new Set(array));\n  }\n  function isTesting() {\n    return navigator.userAgent.includes(\"Node.js\") || navigator.userAgent.includes(\"jsdom\");\n  }\n  function checkedAttrLooseCompare(valueA, valueB) {\n    return valueA == valueB;\n  }\n  function warnIfMalformedTemplate(el, directive) {\n    if (el.tagName.toLowerCase() !== 'template') {\n      console.warn(`Alpine: [${directive}] directive should only be added to <template> tags. See https://github.com/alpinejs/alpine#${directive}`);\n    } else if (el.content.childElementCount !== 1) {\n      console.warn(`Alpine: <template> tag with [${directive}] encountered with an unexpected number of root elements. Make sure <template> has a single root element. `);\n    }\n  }\n  function kebabCase(subject) {\n    return subject.replace(/([a-z])([A-Z])/g, '$1-$2').replace(/[_\\s]/, '-').toLowerCase();\n  }\n  function camelCase(subject) {\n    return subject.toLowerCase().replace(/-(\\w)/g, (match, char) => char.toUpperCase());\n  }\n  function walk(el, callback) {\n    if (callback(el) === false) return;\n    let node = el.firstElementChild;\n\n    while (node) {\n      walk(node, callback);\n      node = node.nextElementSibling;\n    }\n  }\n  function debounce(func, wait) {\n    var timeout;\n    return function () {\n      var context = this,\n          args = arguments;\n\n      var later = function later() {\n        timeout = null;\n        func.apply(context, args);\n      };\n\n      clearTimeout(timeout);\n      timeout = setTimeout(later, wait);\n    };\n  }\n\n  const handleError = (el, expression, error) => {\n    console.warn(`Alpine Error: \"${error}\"\\n\\nExpression: \"${expression}\"\\nElement:`, el);\n\n    if (!isTesting()) {\n      Object.assign(error, {\n        el,\n        expression\n      });\n      throw error;\n    }\n  };\n\n  function tryCatch(cb, {\n    el,\n    expression\n  }) {\n    try {\n      const value = cb();\n      return value instanceof Promise ? value.catch(e => handleError(el, expression, e)) : value;\n    } catch (e) {\n      handleError(el, expression, e);\n    }\n  }\n\n  function saferEval(el, expression, dataContext, additionalHelperVariables = {}) {\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return expression.call(dataContext);\n      }\n\n      return new Function(['$data', ...Object.keys(additionalHelperVariables)], `var __alpine_result; with($data) { __alpine_result = ${expression} }; return __alpine_result`)(dataContext, ...Object.values(additionalHelperVariables));\n    }, {\n      el,\n      expression\n    });\n  }\n  function saferEvalNoReturn(el, expression, dataContext, additionalHelperVariables = {}) {\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return Promise.resolve(expression.call(dataContext, additionalHelperVariables['$event']));\n      }\n\n      let AsyncFunction = Function;\n      /* MODERN-ONLY:START */\n\n      AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;\n      /* MODERN-ONLY:END */\n      // For the cases when users pass only a function reference to the caller: `x-on:click=\"foo\"`\n      // Where \"foo\" is a function. Also, we'll pass the function the event instance when we call it.\n\n      if (Object.keys(dataContext).includes(expression)) {\n        let methodReference = new Function(['dataContext', ...Object.keys(additionalHelperVariables)], `with(dataContext) { return ${expression} }`)(dataContext, ...Object.values(additionalHelperVariables));\n\n        if (typeof methodReference === 'function') {\n          return Promise.resolve(methodReference.call(dataContext, additionalHelperVariables['$event']));\n        } else {\n          return Promise.resolve();\n        }\n      }\n\n      return Promise.resolve(new AsyncFunction(['dataContext', ...Object.keys(additionalHelperVariables)], `with(dataContext) { ${expression} }`)(dataContext, ...Object.values(additionalHelperVariables)));\n    }, {\n      el,\n      expression\n    });\n  }\n  const xAttrRE = /^x-(on|bind|data|text|html|model|if|for|show|cloak|transition|ref|spread)\\b/;\n  function isXAttr(attr) {\n    const name = replaceAtAndColonWithStandardSyntax(attr.name);\n    return xAttrRE.test(name);\n  }\n  function getXAttrs(el, component, type) {\n    let directives = Array.from(el.attributes).filter(isXAttr).map(parseHtmlAttribute); // Get an object of directives from x-spread.\n\n    let spreadDirective = directives.filter(directive => directive.type === 'spread')[0];\n\n    if (spreadDirective) {\n      let spreadObject = saferEval(el, spreadDirective.expression, component.$data); // Add x-spread directives to the pile of existing directives.\n\n      directives = directives.concat(Object.entries(spreadObject).map(([name, value]) => parseHtmlAttribute({\n        name,\n        value\n      })));\n    }\n\n    if (type) return directives.filter(i => i.type === type);\n    return sortDirectives(directives);\n  }\n\n  function sortDirectives(directives) {\n    let directiveOrder = ['bind', 'model', 'show', 'catch-all'];\n    return directives.sort((a, b) => {\n      let typeA = directiveOrder.indexOf(a.type) === -1 ? 'catch-all' : a.type;\n      let typeB = directiveOrder.indexOf(b.type) === -1 ? 'catch-all' : b.type;\n      return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);\n    });\n  }\n\n  function parseHtmlAttribute({\n    name,\n    value\n  }) {\n    const normalizedName = replaceAtAndColonWithStandardSyntax(name);\n    const typeMatch = normalizedName.match(xAttrRE);\n    const valueMatch = normalizedName.match(/:([a-zA-Z0-9\\-:]+)/);\n    const modifiers = normalizedName.match(/\\.[^.\\]]+(?=[^\\]]*$)/g) || [];\n    return {\n      type: typeMatch ? typeMatch[1] : null,\n      value: valueMatch ? valueMatch[1] : null,\n      modifiers: modifiers.map(i => i.replace('.', '')),\n      expression: value\n    };\n  }\n  function isBooleanAttr(attrName) {\n    // As per HTML spec table https://html.spec.whatwg.org/multipage/indices.html#attributes-3:boolean-attribute\n    // Array roughly ordered by estimated usage\n    const booleanAttributes = ['disabled', 'checked', 'required', 'readonly', 'hidden', 'open', 'selected', 'autofocus', 'itemscope', 'multiple', 'novalidate', 'allowfullscreen', 'allowpaymentrequest', 'formnovalidate', 'autoplay', 'controls', 'loop', 'muted', 'playsinline', 'default', 'ismap', 'reversed', 'async', 'defer', 'nomodule'];\n    return booleanAttributes.includes(attrName);\n  }\n  function replaceAtAndColonWithStandardSyntax(name) {\n    if (name.startsWith('@')) {\n      return name.replace('@', 'x-on:');\n    } else if (name.startsWith(':')) {\n      return name.replace(':', 'x-bind:');\n    }\n\n    return name;\n  }\n  function convertClassStringToArray(classList, filterFn = Boolean) {\n    return classList.split(' ').filter(filterFn);\n  }\n  const TRANSITION_TYPE_IN = 'in';\n  const TRANSITION_TYPE_OUT = 'out';\n  const TRANSITION_CANCELLED = 'cancelled';\n  function transitionIn(el, show, reject, component, forceSkip = false) {\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return show();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_IN) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\n    const attrs = getXAttrs(el, component, 'transition');\n    const showAttr = getXAttrs(el, component, 'show')[0]; // If this is triggered by a x-show.transition.\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      let modifiers = showAttr.modifiers; // If x-show.transition.out, we'll skip the \"in\" transition.\n\n      if (modifiers.includes('out') && !modifiers.includes('in')) return show();\n      const settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out'); // If x-show.transition.in...out... only use \"in\" related modifiers for this transition.\n\n      modifiers = settingBothSidesOfTransition ? modifiers.filter((i, index) => index < modifiers.indexOf('out')) : modifiers;\n      transitionHelperIn(el, modifiers, show, reject); // Otherwise, we can assume x-transition:enter.\n    } else if (attrs.some(attr => ['enter', 'enter-start', 'enter-end'].includes(attr.value))) {\n      transitionClassesIn(el, component, attrs, show, reject);\n    } else {\n      // If neither, just show that damn thing.\n      show();\n    }\n  }\n  function transitionOut(el, hide, reject, component, forceSkip = false) {\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return hide();\n\n    if (el.__x_transition && el.__x_transition.type === TRANSITION_TYPE_OUT) {\n      // there is already a similar transition going on, this was probably triggered by\n      // a change in a different property, let's just leave the previous one doing its job\n      return;\n    }\n\n    const attrs = getXAttrs(el, component, 'transition');\n    const showAttr = getXAttrs(el, component, 'show')[0];\n\n    if (showAttr && showAttr.modifiers.includes('transition')) {\n      let modifiers = showAttr.modifiers;\n      if (modifiers.includes('in') && !modifiers.includes('out')) return hide();\n      const settingBothSidesOfTransition = modifiers.includes('in') && modifiers.includes('out');\n      modifiers = settingBothSidesOfTransition ? modifiers.filter((i, index) => index > modifiers.indexOf('out')) : modifiers;\n      transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hide, reject);\n    } else if (attrs.some(attr => ['leave', 'leave-start', 'leave-end'].includes(attr.value))) {\n      transitionClassesOut(el, component, attrs, hide, reject);\n    } else {\n      hide();\n    }\n  }\n  function transitionHelperIn(el, modifiers, showCallback, reject) {\n    // Default values inspired by: https://material.io/design/motion/speed.html#duration\n    const styleValues = {\n      duration: modifierValue(modifiers, 'duration', 150),\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      },\n      second: {\n        opacity: 1,\n        scale: 100\n      }\n    };\n    transitionHelper(el, modifiers, showCallback, () => {}, reject, styleValues, TRANSITION_TYPE_IN);\n  }\n  function transitionHelperOut(el, modifiers, settingBothSidesOfTransition, hideCallback, reject) {\n    // Make the \"out\" transition .5x slower than the \"in\". (Visually better)\n    // HOWEVER, if they explicitly set a duration for the \"out\" transition,\n    // use that.\n    const duration = settingBothSidesOfTransition ? modifierValue(modifiers, 'duration', 150) : modifierValue(modifiers, 'duration', 150) / 2;\n    const styleValues = {\n      duration: duration,\n      origin: modifierValue(modifiers, 'origin', 'center'),\n      first: {\n        opacity: 1,\n        scale: 100\n      },\n      second: {\n        opacity: 0,\n        scale: modifierValue(modifiers, 'scale', 95)\n      }\n    };\n    transitionHelper(el, modifiers, () => {}, hideCallback, reject, styleValues, TRANSITION_TYPE_OUT);\n  }\n\n  function modifierValue(modifiers, key, fallback) {\n    // If the modifier isn't present, use the default.\n    if (modifiers.indexOf(key) === -1) return fallback; // If it IS present, grab the value after it: x-show.transition.duration.500ms\n\n    const rawValue = modifiers[modifiers.indexOf(key) + 1];\n    if (!rawValue) return fallback;\n\n    if (key === 'scale') {\n      // Check if the very next value is NOT a number and return the fallback.\n      // If x-show.transition.scale, we'll use the default scale value.\n      // That is how a user opts out of the opacity transition.\n      if (!isNumeric(rawValue)) return fallback;\n    }\n\n    if (key === 'duration') {\n      // Support x-show.transition.duration.500ms && duration.500\n      let match = rawValue.match(/([0-9]+)ms/);\n      if (match) return match[1];\n    }\n\n    if (key === 'origin') {\n      // Support chaining origin directions: x-show.transition.top.right\n      if (['top', 'right', 'left', 'center', 'bottom'].includes(modifiers[modifiers.indexOf(key) + 2])) {\n        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(' ');\n      }\n    }\n\n    return rawValue;\n  }\n\n  function transitionHelper(el, modifiers, hook1, hook2, reject, styleValues, type) {\n    // clear the previous transition if exists to avoid caching the wrong styles\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    } // If the user set these style values, we'll put them back when we're done with them.\n\n\n    const opacityCache = el.style.opacity;\n    const transformCache = el.style.transform;\n    const transformOriginCache = el.style.transformOrigin; // If no modifiers are present: x-show.transition, we'll default to both opacity and scale.\n\n    const noModifiers = !modifiers.includes('opacity') && !modifiers.includes('scale');\n    const transitionOpacity = noModifiers || modifiers.includes('opacity');\n    const transitionScale = noModifiers || modifiers.includes('scale'); // These are the explicit stages of a transition (same stages for in and for out).\n    // This way you can get a birds eye view of the hooks, and the differences\n    // between them.\n\n    const stages = {\n      start() {\n        if (transitionOpacity) el.style.opacity = styleValues.first.opacity;\n        if (transitionScale) el.style.transform = `scale(${styleValues.first.scale / 100})`;\n      },\n\n      during() {\n        if (transitionScale) el.style.transformOrigin = styleValues.origin;\n        el.style.transitionProperty = [transitionOpacity ? `opacity` : ``, transitionScale ? `transform` : ``].join(' ').trim();\n        el.style.transitionDuration = `${styleValues.duration / 1000}s`;\n        el.style.transitionTimingFunction = `cubic-bezier(0.4, 0.0, 0.2, 1)`;\n      },\n\n      show() {\n        hook1();\n      },\n\n      end() {\n        if (transitionOpacity) el.style.opacity = styleValues.second.opacity;\n        if (transitionScale) el.style.transform = `scale(${styleValues.second.scale / 100})`;\n      },\n\n      hide() {\n        hook2();\n      },\n\n      cleanup() {\n        if (transitionOpacity) el.style.opacity = opacityCache;\n        if (transitionScale) el.style.transform = transformCache;\n        if (transitionScale) el.style.transformOrigin = transformOriginCache;\n        el.style.transitionProperty = null;\n        el.style.transitionDuration = null;\n        el.style.transitionTimingFunction = null;\n      }\n\n    };\n    transition(el, stages, type, reject);\n  }\n\n  const ensureStringExpression = (expression, el, component) => {\n    return typeof expression === 'function' ? component.evaluateReturnExpression(el, expression) : expression;\n  };\n\n  function transitionClassesIn(el, component, directives, showCallback, reject) {\n    const enter = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter') || {\n      expression: ''\n    }).expression, el, component));\n    const enterStart = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter-start') || {\n      expression: ''\n    }).expression, el, component));\n    const enterEnd = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'enter-end') || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, enter, enterStart, enterEnd, showCallback, () => {}, TRANSITION_TYPE_IN, reject);\n  }\n  function transitionClassesOut(el, component, directives, hideCallback, reject) {\n    const leave = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave') || {\n      expression: ''\n    }).expression, el, component));\n    const leaveStart = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave-start') || {\n      expression: ''\n    }).expression, el, component));\n    const leaveEnd = convertClassStringToArray(ensureStringExpression((directives.find(i => i.value === 'leave-end') || {\n      expression: ''\n    }).expression, el, component));\n    transitionClasses(el, leave, leaveStart, leaveEnd, () => {}, hideCallback, TRANSITION_TYPE_OUT, reject);\n  }\n  function transitionClasses(el, classesDuring, classesStart, classesEnd, hook1, hook2, type, reject) {\n    // clear the previous transition if exists to avoid caching the wrong classes\n    if (el.__x_transition) {\n      el.__x_transition.cancel && el.__x_transition.cancel();\n    }\n\n    const originalClasses = el.__x_original_classes || [];\n    const stages = {\n      start() {\n        el.classList.add(...classesStart);\n      },\n\n      during() {\n        el.classList.add(...classesDuring);\n      },\n\n      show() {\n        hook1();\n      },\n\n      end() {\n        // Don't remove classes that were in the original class attribute.\n        el.classList.remove(...classesStart.filter(i => !originalClasses.includes(i)));\n        el.classList.add(...classesEnd);\n      },\n\n      hide() {\n        hook2();\n      },\n\n      cleanup() {\n        el.classList.remove(...classesDuring.filter(i => !originalClasses.includes(i)));\n        el.classList.remove(...classesEnd.filter(i => !originalClasses.includes(i)));\n      }\n\n    };\n    transition(el, stages, type, reject);\n  }\n  function transition(el, stages, type, reject) {\n    const finish = once(() => {\n      stages.hide(); // Adding an \"isConnected\" check, in case the callback\n      // removed the element from the DOM.\n\n      if (el.isConnected) {\n        stages.cleanup();\n      }\n\n      delete el.__x_transition;\n    });\n    el.__x_transition = {\n      // Set transition type so we can avoid clearing transition if the direction is the same\n      type: type,\n      // create a callback for the last stages of the transition so we can call it\n      // from different point and early terminate it. Once will ensure that function\n      // is only called one time.\n      cancel: once(() => {\n        reject(TRANSITION_CANCELLED);\n        finish();\n      }),\n      finish,\n      // This store the next animation frame so we can cancel it\n      nextFrame: null\n    };\n    stages.start();\n    stages.during();\n    el.__x_transition.nextFrame = requestAnimationFrame(() => {\n      // Note: Safari's transitionDuration property will list out comma separated transition durations\n      // for every single transition property. Let's grab the first one and call it a day.\n      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, '').replace('s', '')) * 1000;\n\n      if (duration === 0) {\n        duration = Number(getComputedStyle(el).animationDuration.replace('s', '')) * 1000;\n      }\n\n      stages.show();\n      el.__x_transition.nextFrame = requestAnimationFrame(() => {\n        stages.end();\n        setTimeout(el.__x_transition.finish, duration);\n      });\n    });\n  }\n  function isNumeric(subject) {\n    return !Array.isArray(subject) && !isNaN(subject);\n  } // Thanks @vuejs\n  // https://github.com/vuejs/vue/blob/4de4649d9637262a9b007720b59f80ac72a5620c/src/shared/util.js\n\n  function once(callback) {\n    let called = false;\n    return function () {\n      if (!called) {\n        called = true;\n        callback.apply(this, arguments);\n      }\n    };\n  }\n\n  function handleForDirective(component, templateEl, expression, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(templateEl, 'x-for');\n    let iteratorNames = typeof expression === 'function' ? parseForExpression(component.evaluateReturnExpression(templateEl, expression)) : parseForExpression(expression);\n    let items = evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, templateEl, iteratorNames, extraVars); // As we walk the array, we'll also walk the DOM (updating/creating as we go).\n\n    let currentEl = templateEl;\n    items.forEach((item, index) => {\n      let iterationScopeVariables = getIterationScopeVariables(iteratorNames, item, index, items, extraVars());\n      let currentKey = generateKeyForIteration(component, templateEl, index, iterationScopeVariables);\n      let nextEl = lookAheadForMatchingKeyedElementAndMoveItIfFound(currentEl.nextElementSibling, currentKey); // If we haven't found a matching key, insert the element at the current position.\n\n      if (!nextEl) {\n        nextEl = addElementInLoopAfterCurrentEl(templateEl, currentEl); // And transition it in if it's not the first page load.\n\n        transitionIn(nextEl, () => {}, () => {}, component, initialUpdate);\n        nextEl.__x_for = iterationScopeVariables;\n        component.initializeElements(nextEl, () => nextEl.__x_for); // Otherwise update the element we found.\n      } else {\n        // Temporarily remove the key indicator to allow the normal \"updateElements\" to work.\n        delete nextEl.__x_for_key;\n        nextEl.__x_for = iterationScopeVariables;\n        component.updateElements(nextEl, () => nextEl.__x_for);\n      }\n\n      currentEl = nextEl;\n      currentEl.__x_for_key = currentKey;\n    });\n    removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component);\n  } // This was taken from VueJS 2.* core. Thanks Vue!\n\n  function parseForExpression(expression) {\n    let forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\n    let stripParensRE = /^\\(|\\)$/g;\n    let forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\n    let inMatch = String(expression).match(forAliasRE);\n    if (!inMatch) return;\n    let res = {};\n    res.items = inMatch[2].trim();\n    let item = inMatch[1].trim().replace(stripParensRE, '');\n    let iteratorMatch = item.match(forIteratorRE);\n\n    if (iteratorMatch) {\n      res.item = item.replace(forIteratorRE, '').trim();\n      res.index = iteratorMatch[1].trim();\n\n      if (iteratorMatch[2]) {\n        res.collection = iteratorMatch[2].trim();\n      }\n    } else {\n      res.item = item;\n    }\n\n    return res;\n  }\n\n  function getIterationScopeVariables(iteratorNames, item, index, items, extraVars) {\n    // We must create a new object, so each iteration has a new scope\n    let scopeVariables = extraVars ? _objectSpread2({}, extraVars) : {};\n    scopeVariables[iteratorNames.item] = item;\n    if (iteratorNames.index) scopeVariables[iteratorNames.index] = index;\n    if (iteratorNames.collection) scopeVariables[iteratorNames.collection] = items;\n    return scopeVariables;\n  }\n\n  function generateKeyForIteration(component, el, index, iterationScopeVariables) {\n    let bindKeyAttribute = getXAttrs(el, component, 'bind').filter(attr => attr.value === 'key')[0]; // If the dev hasn't specified a key, just return the index of the iteration.\n\n    if (!bindKeyAttribute) return index;\n    return component.evaluateReturnExpression(el, bindKeyAttribute.expression, () => iterationScopeVariables);\n  }\n\n  function evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, el, iteratorNames, extraVars) {\n    let ifAttribute = getXAttrs(el, component, 'if')[0];\n\n    if (ifAttribute && !component.evaluateReturnExpression(el, ifAttribute.expression)) {\n      return [];\n    }\n\n    let items = component.evaluateReturnExpression(el, iteratorNames.items, extraVars); // This adds support for the `i in n` syntax.\n\n    if (isNumeric(items) && items >= 0) {\n      items = Array.from(Array(items).keys(), i => i + 1);\n    }\n\n    return items;\n  }\n\n  function addElementInLoopAfterCurrentEl(templateEl, currentEl) {\n    let clone = document.importNode(templateEl.content, true);\n    currentEl.parentElement.insertBefore(clone, currentEl.nextElementSibling);\n    return currentEl.nextElementSibling;\n  }\n\n  function lookAheadForMatchingKeyedElementAndMoveItIfFound(nextEl, currentKey) {\n    if (!nextEl) return; // If we are already past the x-for generated elements, we don't need to look ahead.\n\n    if (nextEl.__x_for_key === undefined) return; // If the the key's DO match, no need to look ahead.\n\n    if (nextEl.__x_for_key === currentKey) return nextEl; // If they don't, we'll look ahead for a match.\n    // If we find it, we'll move it to the current position in the loop.\n\n    let tmpNextEl = nextEl;\n\n    while (tmpNextEl) {\n      if (tmpNextEl.__x_for_key === currentKey) {\n        return tmpNextEl.parentElement.insertBefore(tmpNextEl, nextEl);\n      }\n\n      tmpNextEl = tmpNextEl.nextElementSibling && tmpNextEl.nextElementSibling.__x_for_key !== undefined ? tmpNextEl.nextElementSibling : false;\n    }\n  }\n\n  function removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component) {\n    var nextElementFromOldLoop = currentEl.nextElementSibling && currentEl.nextElementSibling.__x_for_key !== undefined ? currentEl.nextElementSibling : false;\n\n    while (nextElementFromOldLoop) {\n      let nextElementFromOldLoopImmutable = nextElementFromOldLoop;\n      let nextSibling = nextElementFromOldLoop.nextElementSibling;\n      transitionOut(nextElementFromOldLoop, () => {\n        nextElementFromOldLoopImmutable.remove();\n      }, () => {}, component);\n      nextElementFromOldLoop = nextSibling && nextSibling.__x_for_key !== undefined ? nextSibling : false;\n    }\n  }\n\n  function handleAttributeBindingDirective(component, el, attrName, expression, extraVars, attrType, modifiers) {\n    var value = component.evaluateReturnExpression(el, expression, extraVars);\n\n    if (attrName === 'value') {\n      if (Alpine.ignoreFocusedForValueBinding && document.activeElement.isSameNode(el)) return; // If nested model key is undefined, set the default value to empty string.\n\n      if (value === undefined && String(expression).match(/\\./)) {\n        value = '';\n      }\n\n      if (el.type === 'radio') {\n        // Set radio value from x-bind:value, if no \"value\" attribute exists.\n        // If there are any initial state values, radio will have a correct\n        // \"checked\" value since x-bind:value is processed before x-model.\n        if (el.attributes.value === undefined && attrType === 'bind') {\n          el.value = value;\n        } else if (attrType !== 'bind') {\n          el.checked = checkedAttrLooseCompare(el.value, value);\n        }\n      } else if (el.type === 'checkbox') {\n        // If we are explicitly binding a string to the :value, set the string,\n        // If the value is a boolean, leave it alone, it will be set to \"on\"\n        // automatically.\n        if (typeof value !== 'boolean' && ![null, undefined].includes(value) && attrType === 'bind') {\n          el.value = String(value);\n        } else if (attrType !== 'bind') {\n          if (Array.isArray(value)) {\n            // I'm purposely not using Array.includes here because it's\n            // strict, and because of Numeric/String mis-casting, I\n            // want the \"includes\" to be \"fuzzy\".\n            el.checked = value.some(val => checkedAttrLooseCompare(val, el.value));\n          } else {\n            el.checked = !!value;\n          }\n        }\n      } else if (el.tagName === 'SELECT') {\n        updateSelect(el, value);\n      } else {\n        if (el.value === value) return;\n        el.value = value;\n      }\n    } else if (attrName === 'class') {\n      if (Array.isArray(value)) {\n        const originalClasses = el.__x_original_classes || [];\n        el.setAttribute('class', arrayUnique(originalClasses.concat(value)).join(' '));\n      } else if (typeof value === 'object') {\n        // Sorting the keys / class names by their boolean value will ensure that\n        // anything that evaluates to `false` and needs to remove classes is run first.\n        const keysSortedByBooleanValue = Object.keys(value).sort((a, b) => value[a] - value[b]);\n        keysSortedByBooleanValue.forEach(classNames => {\n          if (value[classNames]) {\n            convertClassStringToArray(classNames).forEach(className => el.classList.add(className));\n          } else {\n            convertClassStringToArray(classNames).forEach(className => el.classList.remove(className));\n          }\n        });\n      } else {\n        const originalClasses = el.__x_original_classes || [];\n        const newClasses = value ? convertClassStringToArray(value) : [];\n        el.setAttribute('class', arrayUnique(originalClasses.concat(newClasses)).join(' '));\n      }\n    } else {\n      attrName = modifiers.includes('camel') ? camelCase(attrName) : attrName; // If an attribute's bound value is null, undefined or false, remove the attribute\n\n      if ([null, undefined, false].includes(value)) {\n        el.removeAttribute(attrName);\n      } else {\n        isBooleanAttr(attrName) ? setIfChanged(el, attrName, attrName) : setIfChanged(el, attrName, value);\n      }\n    }\n  }\n\n  function setIfChanged(el, attrName, value) {\n    if (el.getAttribute(attrName) != value) {\n      el.setAttribute(attrName, value);\n    }\n  }\n\n  function updateSelect(el, value) {\n    const arrayWrappedValue = [].concat(value).map(value => {\n      return value + '';\n    });\n    Array.from(el.options).forEach(option => {\n      option.selected = arrayWrappedValue.includes(option.value || option.text);\n    });\n  }\n\n  function handleTextDirective(el, output, expression) {\n    // If nested model key is undefined, set the default value to empty string.\n    if (output === undefined && String(expression).match(/\\./)) {\n      output = '';\n    }\n\n    el.textContent = output;\n  }\n\n  function handleHtmlDirective(component, el, expression, extraVars) {\n    el.innerHTML = component.evaluateReturnExpression(el, expression, extraVars);\n  }\n\n  function handleShowDirective(component, el, value, modifiers, initialUpdate = false) {\n    const hide = () => {\n      el.style.display = 'none';\n      el.__x_is_shown = false;\n    };\n\n    const show = () => {\n      if (el.style.length === 1 && el.style.display === 'none') {\n        el.removeAttribute('style');\n      } else {\n        el.style.removeProperty('display');\n      }\n\n      el.__x_is_shown = true;\n    };\n\n    if (initialUpdate === true) {\n      if (value) {\n        show();\n      } else {\n        hide();\n      }\n\n      return;\n    }\n\n    const handle = (resolve, reject) => {\n      if (value) {\n        if (el.style.display === 'none' || el.__x_transition) {\n          transitionIn(el, () => {\n            show();\n          }, reject, component);\n        }\n\n        resolve(() => {});\n      } else {\n        if (el.style.display !== 'none') {\n          transitionOut(el, () => {\n            resolve(() => {\n              hide();\n            });\n          }, reject, component);\n        } else {\n          resolve(() => {});\n        }\n      }\n    }; // The working of x-show is a bit complex because we need to\n    // wait for any child transitions to finish before hiding\n    // some element. Also, this has to be done recursively.\n    // If x-show.immediate, foregoe the waiting.\n\n\n    if (modifiers.includes('immediate')) {\n      handle(finish => finish(), () => {});\n      return;\n    } // x-show is encountered during a DOM tree walk. If an element\n    // we encounter is NOT a child of another x-show element we\n    // can execute the previous x-show stack (if one exists).\n\n\n    if (component.showDirectiveLastElement && !component.showDirectiveLastElement.contains(el)) {\n      component.executeAndClearRemainingShowDirectiveStack();\n    }\n\n    component.showDirectiveStack.push(handle);\n    component.showDirectiveLastElement = el;\n  }\n\n  function handleIfDirective(component, el, expressionResult, initialUpdate, extraVars) {\n    warnIfMalformedTemplate(el, 'x-if');\n    const elementHasAlreadyBeenAdded = el.nextElementSibling && el.nextElementSibling.__x_inserted_me === true;\n\n    if (expressionResult && (!elementHasAlreadyBeenAdded || el.__x_transition)) {\n      const clone = document.importNode(el.content, true);\n      el.parentElement.insertBefore(clone, el.nextElementSibling);\n      transitionIn(el.nextElementSibling, () => {}, () => {}, component, initialUpdate);\n      component.initializeElements(el.nextElementSibling, extraVars);\n      el.nextElementSibling.__x_inserted_me = true;\n    } else if (!expressionResult && elementHasAlreadyBeenAdded) {\n      transitionOut(el.nextElementSibling, () => {\n        el.nextElementSibling.remove();\n      }, () => {}, component, initialUpdate);\n    }\n  }\n\n  function registerListener(component, el, event, modifiers, expression, extraVars = {}) {\n    const options = {\n      passive: modifiers.includes('passive')\n    };\n\n    if (modifiers.includes('camel')) {\n      event = camelCase(event);\n    }\n\n    let handler, listenerTarget;\n\n    if (modifiers.includes('away')) {\n      listenerTarget = document;\n\n      handler = e => {\n        // Don't do anything if the click came from the element or within it.\n        if (el.contains(e.target)) return; // Don't do anything if this element isn't currently visible.\n\n        if (el.offsetWidth < 1 && el.offsetHeight < 1) return; // Now that we are sure the element is visible, AND the click\n        // is from outside it, let's run the expression.\n\n        runListenerHandler(component, expression, e, extraVars);\n\n        if (modifiers.includes('once')) {\n          document.removeEventListener(event, handler, options);\n        }\n      };\n    } else {\n      listenerTarget = modifiers.includes('window') ? window : modifiers.includes('document') ? document : el;\n\n      handler = e => {\n        // Remove this global event handler if the element that declared it\n        // has been removed. It's now stale.\n        if (listenerTarget === window || listenerTarget === document) {\n          if (!document.body.contains(el)) {\n            listenerTarget.removeEventListener(event, handler, options);\n            return;\n          }\n        }\n\n        if (isKeyEvent(event)) {\n          if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {\n            return;\n          }\n        }\n\n        if (modifiers.includes('prevent')) e.preventDefault();\n        if (modifiers.includes('stop')) e.stopPropagation(); // If the .self modifier isn't present, or if it is present and\n        // the target element matches the element we are registering the\n        // event on, run the handler\n\n        if (!modifiers.includes('self') || e.target === el) {\n          const returnValue = runListenerHandler(component, expression, e, extraVars);\n          returnValue.then(value => {\n            if (value === false) {\n              e.preventDefault();\n            } else {\n              if (modifiers.includes('once')) {\n                listenerTarget.removeEventListener(event, handler, options);\n              }\n            }\n          });\n        }\n      };\n    }\n\n    if (modifiers.includes('debounce')) {\n      let nextModifier = modifiers[modifiers.indexOf('debounce') + 1] || 'invalid-wait';\n      let wait = isNumeric(nextModifier.split('ms')[0]) ? Number(nextModifier.split('ms')[0]) : 250;\n      handler = debounce(handler, wait);\n    }\n\n    listenerTarget.addEventListener(event, handler, options);\n  }\n\n  function runListenerHandler(component, expression, e, extraVars) {\n    return component.evaluateCommandExpression(e.target, expression, () => {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        '$event': e\n      });\n    });\n  }\n\n  function isKeyEvent(event) {\n    return ['keydown', 'keyup'].includes(event);\n  }\n\n  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {\n    let keyModifiers = modifiers.filter(i => {\n      return !['window', 'document', 'prevent', 'stop'].includes(i);\n    });\n\n    if (keyModifiers.includes('debounce')) {\n      let debounceIndex = keyModifiers.indexOf('debounce');\n      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || 'invalid-wait').split('ms')[0]) ? 2 : 1);\n    } // If no modifier is specified, we'll call it a press.\n\n\n    if (keyModifiers.length === 0) return false; // If one is passed, AND it matches the key pressed, we'll call it a press.\n\n    if (keyModifiers.length === 1 && keyModifiers[0] === keyToModifier(e.key)) return false; // The user is listening for key combinations.\n\n    const systemKeyModifiers = ['ctrl', 'shift', 'alt', 'meta', 'cmd', 'super'];\n    const selectedSystemKeyModifiers = systemKeyModifiers.filter(modifier => keyModifiers.includes(modifier));\n    keyModifiers = keyModifiers.filter(i => !selectedSystemKeyModifiers.includes(i));\n\n    if (selectedSystemKeyModifiers.length > 0) {\n      const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter(modifier => {\n        // Alias \"cmd\" and \"super\" to \"meta\"\n        if (modifier === 'cmd' || modifier === 'super') modifier = 'meta';\n        return e[`${modifier}Key`];\n      }); // If all the modifiers selected are pressed, ...\n\n      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {\n        // AND the remaining key is pressed as well. It's a press.\n        if (keyModifiers[0] === keyToModifier(e.key)) return false;\n      }\n    } // We'll call it NOT a valid keypress.\n\n\n    return true;\n  }\n\n  function keyToModifier(key) {\n    switch (key) {\n      case '/':\n        return 'slash';\n\n      case ' ':\n      case 'Spacebar':\n        return 'space';\n\n      default:\n        return key && kebabCase(key);\n    }\n  }\n\n  function registerModelListener(component, el, modifiers, expression, extraVars) {\n    // If the element we are binding to is a select, a radio, or checkbox\n    // we'll listen for the change event instead of the \"input\" event.\n    var event = el.tagName.toLowerCase() === 'select' || ['checkbox', 'radio'].includes(el.type) || modifiers.includes('lazy') ? 'change' : 'input';\n    const listenerExpression = `${expression} = rightSideOfExpression($event, ${expression})`;\n    registerListener(component, el, event, modifiers, listenerExpression, () => {\n      return _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        rightSideOfExpression: generateModelAssignmentFunction(el, modifiers, expression)\n      });\n    });\n  }\n\n  function generateModelAssignmentFunction(el, modifiers, expression) {\n    if (el.type === 'radio') {\n      // Radio buttons only work properly when they share a name attribute.\n      // People might assume we take care of that for them, because\n      // they already set a shared \"x-model\" attribute.\n      if (!el.hasAttribute('name')) el.setAttribute('name', expression);\n    }\n\n    return (event, currentValue) => {\n      // Check for event.detail due to an issue where IE11 handles other events as a CustomEvent.\n      if (event instanceof CustomEvent && event.detail) {\n        return event.detail;\n      } else if (el.type === 'checkbox') {\n        // If the data we are binding to is an array, toggle its value inside the array.\n        if (Array.isArray(currentValue)) {\n          const newValue = modifiers.includes('number') ? safeParseNumber(event.target.value) : event.target.value;\n          return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter(el => !checkedAttrLooseCompare(el, newValue));\n        } else {\n          return event.target.checked;\n        }\n      } else if (el.tagName.toLowerCase() === 'select' && el.multiple) {\n        return modifiers.includes('number') ? Array.from(event.target.selectedOptions).map(option => {\n          const rawValue = option.value || option.text;\n          return safeParseNumber(rawValue);\n        }) : Array.from(event.target.selectedOptions).map(option => {\n          return option.value || option.text;\n        });\n      } else {\n        const rawValue = event.target.value;\n        return modifiers.includes('number') ? safeParseNumber(rawValue) : modifiers.includes('trim') ? rawValue.trim() : rawValue;\n      }\n    };\n  }\n\n  function safeParseNumber(rawValue) {\n    const number = rawValue ? parseFloat(rawValue) : null;\n    return isNumeric(number) ? number : rawValue;\n  }\n\n  /**\n   * Copyright (C) 2017 salesforce.com, inc.\n   */\n  const { isArray } = Array;\n  const { getPrototypeOf, create: ObjectCreate, defineProperty: ObjectDefineProperty, defineProperties: ObjectDefineProperties, isExtensible, getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols, preventExtensions, hasOwnProperty, } = Object;\n  const { push: ArrayPush, concat: ArrayConcat, map: ArrayMap, } = Array.prototype;\n  function isUndefined(obj) {\n      return obj === undefined;\n  }\n  function isFunction(obj) {\n      return typeof obj === 'function';\n  }\n  function isObject(obj) {\n      return typeof obj === 'object';\n  }\n  const proxyToValueMap = new WeakMap();\n  function registerProxy(proxy, value) {\n      proxyToValueMap.set(proxy, value);\n  }\n  const unwrap = (replicaOrAny) => proxyToValueMap.get(replicaOrAny) || replicaOrAny;\n\n  function wrapValue(membrane, value) {\n      return membrane.valueIsObservable(value) ? membrane.getProxy(value) : value;\n  }\n  /**\n   * Unwrap property descriptors will set value on original descriptor\n   * We only need to unwrap if value is specified\n   * @param descriptor external descrpitor provided to define new property on original value\n   */\n  function unwrapDescriptor(descriptor) {\n      if (hasOwnProperty.call(descriptor, 'value')) {\n          descriptor.value = unwrap(descriptor.value);\n      }\n      return descriptor;\n  }\n  function lockShadowTarget(membrane, shadowTarget, originalTarget) {\n      const targetKeys = ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      targetKeys.forEach((key) => {\n          let descriptor = getOwnPropertyDescriptor(originalTarget, key);\n          // We do not need to wrap the descriptor if configurable\n          // Because we can deal with wrapping it when user goes through\n          // Get own property descriptor. There is also a chance that this descriptor\n          // could change sometime in the future, so we can defer wrapping\n          // until we need to\n          if (!descriptor.configurable) {\n              descriptor = wrapDescriptor(membrane, descriptor, wrapValue);\n          }\n          ObjectDefineProperty(shadowTarget, key, descriptor);\n      });\n      preventExtensions(shadowTarget);\n  }\n  class ReactiveProxyHandler {\n      constructor(membrane, value) {\n          this.originalTarget = value;\n          this.membrane = membrane;\n      }\n      get(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const value = originalTarget[key];\n          const { valueObserved } = membrane;\n          valueObserved(originalTarget, key);\n          return membrane.getProxy(value);\n      }\n      set(shadowTarget, key, value) {\n          const { originalTarget, membrane: { valueMutated } } = this;\n          const oldValue = originalTarget[key];\n          if (oldValue !== value) {\n              originalTarget[key] = value;\n              valueMutated(originalTarget, key);\n          }\n          else if (key === 'length' && isArray(originalTarget)) {\n              // fix for issue #236: push will add the new index, and by the time length\n              // is updated, the internal length is already equal to the new length value\n              // therefore, the oldValue is equal to the value. This is the forking logic\n              // to support this use case.\n              valueMutated(originalTarget, key);\n          }\n          return true;\n      }\n      deleteProperty(shadowTarget, key) {\n          const { originalTarget, membrane: { valueMutated } } = this;\n          delete originalTarget[key];\n          valueMutated(originalTarget, key);\n          return true;\n      }\n      apply(shadowTarget, thisArg, argArray) {\n          /* No op */\n      }\n      construct(target, argArray, newTarget) {\n          /* No op */\n      }\n      has(shadowTarget, key) {\n          const { originalTarget, membrane: { valueObserved } } = this;\n          valueObserved(originalTarget, key);\n          return key in originalTarget;\n      }\n      ownKeys(shadowTarget) {\n          const { originalTarget } = this;\n          return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n      isExtensible(shadowTarget) {\n          const shadowIsExtensible = isExtensible(shadowTarget);\n          if (!shadowIsExtensible) {\n              return shadowIsExtensible;\n          }\n          const { originalTarget, membrane } = this;\n          const targetIsExtensible = isExtensible(originalTarget);\n          if (!targetIsExtensible) {\n              lockShadowTarget(membrane, shadowTarget, originalTarget);\n          }\n          return targetIsExtensible;\n      }\n      setPrototypeOf(shadowTarget, prototype) {\n      }\n      getPrototypeOf(shadowTarget) {\n          const { originalTarget } = this;\n          return getPrototypeOf(originalTarget);\n      }\n      getOwnPropertyDescriptor(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const { valueObserved } = this.membrane;\n          // keys looked up via hasOwnProperty need to be reactive\n          valueObserved(originalTarget, key);\n          let desc = getOwnPropertyDescriptor(originalTarget, key);\n          if (isUndefined(desc)) {\n              return desc;\n          }\n          const shadowDescriptor = getOwnPropertyDescriptor(shadowTarget, key);\n          if (!isUndefined(shadowDescriptor)) {\n              return shadowDescriptor;\n          }\n          // Note: by accessing the descriptor, the key is marked as observed\n          // but access to the value, setter or getter (if available) cannot observe\n          // mutations, just like regular methods, in which case we just do nothing.\n          desc = wrapDescriptor(membrane, desc, wrapValue);\n          if (!desc.configurable) {\n              // If descriptor from original target is not configurable,\n              // We must copy the wrapped descriptor over to the shadow target.\n              // Otherwise, proxy will throw an invariant error.\n              // This is our last chance to lock the value.\n              // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n              ObjectDefineProperty(shadowTarget, key, desc);\n          }\n          return desc;\n      }\n      preventExtensions(shadowTarget) {\n          const { originalTarget, membrane } = this;\n          lockShadowTarget(membrane, shadowTarget, originalTarget);\n          preventExtensions(originalTarget);\n          return true;\n      }\n      defineProperty(shadowTarget, key, descriptor) {\n          const { originalTarget, membrane } = this;\n          const { valueMutated } = membrane;\n          const { configurable } = descriptor;\n          // We have to check for value in descriptor\n          // because Object.freeze(proxy) calls this method\n          // with only { configurable: false, writeable: false }\n          // Additionally, method will only be called with writeable:false\n          // if the descriptor has a value, as opposed to getter/setter\n          // So we can just check if writable is present and then see if\n          // value is present. This eliminates getter and setter descriptors\n          if (hasOwnProperty.call(descriptor, 'writable') && !hasOwnProperty.call(descriptor, 'value')) {\n              const originalDescriptor = getOwnPropertyDescriptor(originalTarget, key);\n              descriptor.value = originalDescriptor.value;\n          }\n          ObjectDefineProperty(originalTarget, key, unwrapDescriptor(descriptor));\n          if (configurable === false) {\n              ObjectDefineProperty(shadowTarget, key, wrapDescriptor(membrane, descriptor, wrapValue));\n          }\n          valueMutated(originalTarget, key);\n          return true;\n      }\n  }\n\n  function wrapReadOnlyValue(membrane, value) {\n      return membrane.valueIsObservable(value) ? membrane.getReadOnlyProxy(value) : value;\n  }\n  class ReadOnlyHandler {\n      constructor(membrane, value) {\n          this.originalTarget = value;\n          this.membrane = membrane;\n      }\n      get(shadowTarget, key) {\n          const { membrane, originalTarget } = this;\n          const value = originalTarget[key];\n          const { valueObserved } = membrane;\n          valueObserved(originalTarget, key);\n          return membrane.getReadOnlyProxy(value);\n      }\n      set(shadowTarget, key, value) {\n          return false;\n      }\n      deleteProperty(shadowTarget, key) {\n          return false;\n      }\n      apply(shadowTarget, thisArg, argArray) {\n          /* No op */\n      }\n      construct(target, argArray, newTarget) {\n          /* No op */\n      }\n      has(shadowTarget, key) {\n          const { originalTarget, membrane: { valueObserved } } = this;\n          valueObserved(originalTarget, key);\n          return key in originalTarget;\n      }\n      ownKeys(shadowTarget) {\n          const { originalTarget } = this;\n          return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n      }\n      setPrototypeOf(shadowTarget, prototype) {\n      }\n      getOwnPropertyDescriptor(shadowTarget, key) {\n          const { originalTarget, membrane } = this;\n          const { valueObserved } = membrane;\n          // keys looked up via hasOwnProperty need to be reactive\n          valueObserved(originalTarget, key);\n          let desc = getOwnPropertyDescriptor(originalTarget, key);\n          if (isUndefined(desc)) {\n              return desc;\n          }\n          const shadowDescriptor = getOwnPropertyDescriptor(shadowTarget, key);\n          if (!isUndefined(shadowDescriptor)) {\n              return shadowDescriptor;\n          }\n          // Note: by accessing the descriptor, the key is marked as observed\n          // but access to the value or getter (if available) cannot be observed,\n          // just like regular methods, in which case we just do nothing.\n          desc = wrapDescriptor(membrane, desc, wrapReadOnlyValue);\n          if (hasOwnProperty.call(desc, 'set')) {\n              desc.set = undefined; // readOnly membrane does not allow setters\n          }\n          if (!desc.configurable) {\n              // If descriptor from original target is not configurable,\n              // We must copy the wrapped descriptor over to the shadow target.\n              // Otherwise, proxy will throw an invariant error.\n              // This is our last chance to lock the value.\n              // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor#Invariants\n              ObjectDefineProperty(shadowTarget, key, desc);\n          }\n          return desc;\n      }\n      preventExtensions(shadowTarget) {\n          return false;\n      }\n      defineProperty(shadowTarget, key, descriptor) {\n          return false;\n      }\n  }\n  function createShadowTarget(value) {\n      let shadowTarget = undefined;\n      if (isArray(value)) {\n          shadowTarget = [];\n      }\n      else if (isObject(value)) {\n          shadowTarget = {};\n      }\n      return shadowTarget;\n  }\n  const ObjectDotPrototype = Object.prototype;\n  function defaultValueIsObservable(value) {\n      // intentionally checking for null\n      if (value === null) {\n          return false;\n      }\n      // treat all non-object types, including undefined, as non-observable values\n      if (typeof value !== 'object') {\n          return false;\n      }\n      if (isArray(value)) {\n          return true;\n      }\n      const proto = getPrototypeOf(value);\n      return (proto === ObjectDotPrototype || proto === null || getPrototypeOf(proto) === null);\n  }\n  const defaultValueObserved = (obj, key) => {\n      /* do nothing */\n  };\n  const defaultValueMutated = (obj, key) => {\n      /* do nothing */\n  };\n  const defaultValueDistortion = (value) => value;\n  function wrapDescriptor(membrane, descriptor, getValue) {\n      const { set, get } = descriptor;\n      if (hasOwnProperty.call(descriptor, 'value')) {\n          descriptor.value = getValue(membrane, descriptor.value);\n      }\n      else {\n          if (!isUndefined(get)) {\n              descriptor.get = function () {\n                  // invoking the original getter with the original target\n                  return getValue(membrane, get.call(unwrap(this)));\n              };\n          }\n          if (!isUndefined(set)) {\n              descriptor.set = function (value) {\n                  // At this point we don't have a clear indication of whether\n                  // or not a valid mutation will occur, we don't have the key,\n                  // and we are not sure why and how they are invoking this setter.\n                  // Nevertheless we preserve the original semantics by invoking the\n                  // original setter with the original target and the unwrapped value\n                  set.call(unwrap(this), membrane.unwrapProxy(value));\n              };\n          }\n      }\n      return descriptor;\n  }\n  class ReactiveMembrane {\n      constructor(options) {\n          this.valueDistortion = defaultValueDistortion;\n          this.valueMutated = defaultValueMutated;\n          this.valueObserved = defaultValueObserved;\n          this.valueIsObservable = defaultValueIsObservable;\n          this.objectGraph = new WeakMap();\n          if (!isUndefined(options)) {\n              const { valueDistortion, valueMutated, valueObserved, valueIsObservable } = options;\n              this.valueDistortion = isFunction(valueDistortion) ? valueDistortion : defaultValueDistortion;\n              this.valueMutated = isFunction(valueMutated) ? valueMutated : defaultValueMutated;\n              this.valueObserved = isFunction(valueObserved) ? valueObserved : defaultValueObserved;\n              this.valueIsObservable = isFunction(valueIsObservable) ? valueIsObservable : defaultValueIsObservable;\n          }\n      }\n      getProxy(value) {\n          const unwrappedValue = unwrap(value);\n          const distorted = this.valueDistortion(unwrappedValue);\n          if (this.valueIsObservable(distorted)) {\n              const o = this.getReactiveState(unwrappedValue, distorted);\n              // when trying to extract the writable version of a readonly\n              // we return the readonly.\n              return o.readOnly === value ? value : o.reactive;\n          }\n          return distorted;\n      }\n      getReadOnlyProxy(value) {\n          value = unwrap(value);\n          const distorted = this.valueDistortion(value);\n          if (this.valueIsObservable(distorted)) {\n              return this.getReactiveState(value, distorted).readOnly;\n          }\n          return distorted;\n      }\n      unwrapProxy(p) {\n          return unwrap(p);\n      }\n      getReactiveState(value, distortedValue) {\n          const { objectGraph, } = this;\n          let reactiveState = objectGraph.get(distortedValue);\n          if (reactiveState) {\n              return reactiveState;\n          }\n          const membrane = this;\n          reactiveState = {\n              get reactive() {\n                  const reactiveHandler = new ReactiveProxyHandler(membrane, distortedValue);\n                  // caching the reactive proxy after the first time it is accessed\n                  const proxy = new Proxy(createShadowTarget(distortedValue), reactiveHandler);\n                  registerProxy(proxy, value);\n                  ObjectDefineProperty(this, 'reactive', { value: proxy });\n                  return proxy;\n              },\n              get readOnly() {\n                  const readOnlyHandler = new ReadOnlyHandler(membrane, distortedValue);\n                  // caching the readOnly proxy after the first time it is accessed\n                  const proxy = new Proxy(createShadowTarget(distortedValue), readOnlyHandler);\n                  registerProxy(proxy, value);\n                  ObjectDefineProperty(this, 'readOnly', { value: proxy });\n                  return proxy;\n              }\n          };\n          objectGraph.set(distortedValue, reactiveState);\n          return reactiveState;\n      }\n  }\n  /** version: 0.26.0 */\n\n  function wrap(data, mutationCallback) {\n\n    let membrane = new ReactiveMembrane({\n      valueMutated(target, key) {\n        mutationCallback(target, key);\n      }\n\n    });\n    return {\n      data: membrane.getProxy(data),\n      membrane: membrane\n    };\n  }\n  function unwrap$1(membrane, observable) {\n    let unwrappedData = membrane.unwrapProxy(observable);\n    let copy = {};\n    Object.keys(unwrappedData).forEach(key => {\n      if (['$el', '$refs', '$nextTick', '$watch'].includes(key)) return;\n      copy[key] = unwrappedData[key];\n    });\n    return copy;\n  }\n\n  class Component {\n    constructor(el, componentForClone = null) {\n      this.$el = el;\n      const dataAttr = this.$el.getAttribute('x-data');\n      const dataExpression = dataAttr === '' ? '{}' : dataAttr;\n      const initExpression = this.$el.getAttribute('x-init');\n      let dataExtras = {\n        $el: this.$el\n      };\n      let canonicalComponentElementReference = componentForClone ? componentForClone.$el : this.$el;\n      Object.entries(Alpine.magicProperties).forEach(([name, callback]) => {\n        Object.defineProperty(dataExtras, `$${name}`, {\n          get: function get() {\n            return callback(canonicalComponentElementReference);\n          }\n        });\n      });\n      this.unobservedData = componentForClone ? componentForClone.getUnobservedData() : saferEval(el, dataExpression, dataExtras);\n      // Construct a Proxy-based observable. This will be used to handle reactivity.\n\n      let {\n        membrane,\n        data\n      } = this.wrapDataInObservable(this.unobservedData);\n      this.$data = data;\n      this.membrane = membrane; // After making user-supplied data methods reactive, we can now add\n      // our magic properties to the original data for access.\n\n      this.unobservedData.$el = this.$el;\n      this.unobservedData.$refs = this.getRefsProxy();\n      this.nextTickStack = [];\n\n      this.unobservedData.$nextTick = callback => {\n        this.nextTickStack.push(callback);\n      };\n\n      this.watchers = {};\n\n      this.unobservedData.$watch = (property, callback) => {\n        if (!this.watchers[property]) this.watchers[property] = [];\n        this.watchers[property].push(callback);\n      };\n      /* MODERN-ONLY:START */\n      // We remove this piece of code from the legacy build.\n      // In IE11, we have already defined our helpers at this point.\n      // Register custom magic properties.\n\n\n      Object.entries(Alpine.magicProperties).forEach(([name, callback]) => {\n        Object.defineProperty(this.unobservedData, `$${name}`, {\n          get: function get() {\n            return callback(canonicalComponentElementReference, this.$el);\n          }\n        });\n      });\n      /* MODERN-ONLY:END */\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement;\n      componentForClone || Alpine.onBeforeComponentInitializeds.forEach(callback => callback(this));\n      var initReturnedCallback; // If x-init is present AND we aren't cloning (skip x-init on clone)\n\n      if (initExpression && !componentForClone) {\n        // We want to allow data manipulation, but not trigger DOM updates just yet.\n        // We haven't even initialized the elements with their Alpine bindings. I mean c'mon.\n        this.pauseReactivity = true;\n        initReturnedCallback = this.evaluateReturnExpression(this.$el, initExpression);\n        this.pauseReactivity = false;\n      } // Register all our listeners and set all our attribute bindings.\n      // If we're cloning a component, the third parameter ensures no duplicate\n      // event listeners are registered (the mutation observer will take care of them)\n\n\n      this.initializeElements(this.$el, () => {}, componentForClone); // Use mutation observer to detect new elements being added within this component at run-time.\n      // Alpine's just so darn flexible amirite?\n\n      this.listenForNewElementsToInitialize();\n\n      if (typeof initReturnedCallback === 'function') {\n        // Run the callback returned from the \"x-init\" hook to allow the user to do stuff after\n        // Alpine's got it's grubby little paws all over everything.\n        initReturnedCallback.call(this.$data);\n      }\n\n      componentForClone || setTimeout(() => {\n        Alpine.onComponentInitializeds.forEach(callback => callback(this));\n      }, 0);\n    }\n\n    getUnobservedData() {\n      return unwrap$1(this.membrane, this.$data);\n    }\n\n    wrapDataInObservable(data) {\n      var self = this;\n      let updateDom = debounce(function () {\n        self.updateElements(self.$el);\n      }, 0);\n      return wrap(data, (target, key) => {\n        if (self.watchers[key]) {\n          // If there's a watcher for this specific key, run it.\n          self.watchers[key].forEach(callback => callback(target[key]));\n        } else if (Array.isArray(target)) {\n          // Arrays are special cases, if any of the items change, we consider the array as mutated.\n          Object.keys(self.watchers).forEach(fullDotNotationKey => {\n            let dotNotationParts = fullDotNotationKey.split('.'); // Ignore length mutations since they would result in duplicate calls.\n            // For example, when calling push, we would get a mutation for the item's key\n            // and a second mutation for the length property.\n\n            if (key === 'length') return;\n            dotNotationParts.reduce((comparisonData, part) => {\n              if (Object.is(target, comparisonData[part])) {\n                self.watchers[fullDotNotationKey].forEach(callback => callback(target));\n              }\n\n              return comparisonData[part];\n            }, self.unobservedData);\n          });\n        } else {\n          // Let's walk through the watchers with \"dot-notation\" (foo.bar) and see\n          // if this mutation fits any of them.\n          Object.keys(self.watchers).filter(i => i.includes('.')).forEach(fullDotNotationKey => {\n            let dotNotationParts = fullDotNotationKey.split('.'); // If this dot-notation watcher's last \"part\" doesn't match the current\n            // key, then skip it early for performance reasons.\n\n            if (key !== dotNotationParts[dotNotationParts.length - 1]) return; // Now, walk through the dot-notation \"parts\" recursively to find\n            // a match, and call the watcher if one's found.\n\n            dotNotationParts.reduce((comparisonData, part) => {\n              if (Object.is(target, comparisonData)) {\n                // Run the watchers.\n                self.watchers[fullDotNotationKey].forEach(callback => callback(target[key]));\n              }\n\n              return comparisonData[part];\n            }, self.unobservedData);\n          });\n        } // Don't react to data changes for cases like the `x-created` hook.\n\n\n        if (self.pauseReactivity) return;\n        updateDom();\n      });\n    }\n\n    walkAndSkipNestedComponents(el, callback, initializeComponentCallback = () => {}) {\n      walk(el, el => {\n        // We've hit a component.\n        if (el.hasAttribute('x-data')) {\n          // If it's not the current one.\n          if (!el.isSameNode(this.$el)) {\n            // Initialize it if it's not.\n            if (!el.__x) initializeComponentCallback(el); // Now we'll let that sub-component deal with itself.\n\n            return false;\n          }\n        }\n\n        return callback(el);\n      });\n    }\n\n    initializeElements(rootEl, extraVars = () => {}, componentForClone = false) {\n      this.walkAndSkipNestedComponents(rootEl, el => {\n        // Don't touch spawns from for loop\n        if (el.__x_for_key !== undefined) return false; // Don't touch spawns from if directives\n\n        if (el.__x_inserted_me !== undefined) return false;\n        this.initializeElement(el, extraVars, componentForClone ? false : true);\n      }, el => {\n        if (!componentForClone) el.__x = new Component(el);\n      });\n      this.executeAndClearRemainingShowDirectiveStack();\n      this.executeAndClearNextTickStack(rootEl);\n    }\n\n    initializeElement(el, extraVars, shouldRegisterListeners = true) {\n      // To support class attribute merging, we have to know what the element's\n      // original class attribute looked like for reference.\n      if (el.hasAttribute('class') && getXAttrs(el, this).length > 0) {\n        el.__x_original_classes = convertClassStringToArray(el.getAttribute('class'));\n      }\n\n      shouldRegisterListeners && this.registerListeners(el, extraVars);\n      this.resolveBoundAttributes(el, true, extraVars);\n    }\n\n    updateElements(rootEl, extraVars = () => {}) {\n      this.walkAndSkipNestedComponents(rootEl, el => {\n        // Don't touch spawns from for loop (and check if the root is actually a for loop in a parent, don't skip it.)\n        if (el.__x_for_key !== undefined && !el.isSameNode(this.$el)) return false;\n        this.updateElement(el, extraVars);\n      }, el => {\n        el.__x = new Component(el);\n      });\n      this.executeAndClearRemainingShowDirectiveStack();\n      this.executeAndClearNextTickStack(rootEl);\n    }\n\n    executeAndClearNextTickStack(el) {\n      // Skip spawns from alpine directives\n      if (el === this.$el && this.nextTickStack.length > 0) {\n        // We run the tick stack after the next frame to allow any\n        // running transitions to pass the initial show stage.\n        requestAnimationFrame(() => {\n          while (this.nextTickStack.length > 0) {\n            this.nextTickStack.shift()();\n          }\n        });\n      }\n    }\n\n    executeAndClearRemainingShowDirectiveStack() {\n      // The goal here is to start all the x-show transitions\n      // and build a nested promise chain so that elements\n      // only hide when the children are finished hiding.\n      this.showDirectiveStack.reverse().map(handler => {\n        return new Promise((resolve, reject) => {\n          handler(resolve, reject);\n        });\n      }).reduce((promiseChain, promise) => {\n        return promiseChain.then(() => {\n          return promise.then(finishElement => {\n            finishElement();\n          });\n        });\n      }, Promise.resolve(() => {})).catch(e => {\n        if (e !== TRANSITION_CANCELLED) throw e;\n      }); // We've processed the handler stack. let's clear it.\n\n      this.showDirectiveStack = [];\n      this.showDirectiveLastElement = undefined;\n    }\n\n    updateElement(el, extraVars) {\n      this.resolveBoundAttributes(el, false, extraVars);\n    }\n\n    registerListeners(el, extraVars) {\n      getXAttrs(el, this).forEach(({\n        type,\n        value,\n        modifiers,\n        expression\n      }) => {\n        switch (type) {\n          case 'on':\n            registerListener(this, el, value, modifiers, expression, extraVars);\n            break;\n\n          case 'model':\n            registerModelListener(this, el, modifiers, expression, extraVars);\n            break;\n        }\n      });\n    }\n\n    resolveBoundAttributes(el, initialUpdate = false, extraVars) {\n      let attrs = getXAttrs(el, this);\n      attrs.forEach(({\n        type,\n        value,\n        modifiers,\n        expression\n      }) => {\n        switch (type) {\n          case 'model':\n            handleAttributeBindingDirective(this, el, 'value', expression, extraVars, type, modifiers);\n            break;\n\n          case 'bind':\n            // The :key binding on an x-for is special, ignore it.\n            if (el.tagName.toLowerCase() === 'template' && value === 'key') return;\n            handleAttributeBindingDirective(this, el, value, expression, extraVars, type, modifiers);\n            break;\n\n          case 'text':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleTextDirective(el, output, expression);\n            break;\n\n          case 'html':\n            handleHtmlDirective(this, el, expression, extraVars);\n            break;\n\n          case 'show':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleShowDirective(this, el, output, modifiers, initialUpdate);\n            break;\n\n          case 'if':\n            // If this element also has x-for on it, don't process x-if.\n            // We will let the \"x-for\" directive handle the \"if\"ing.\n            if (attrs.some(i => i.type === 'for')) return;\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleIfDirective(this, el, output, initialUpdate, extraVars);\n            break;\n\n          case 'for':\n            handleForDirective(this, el, expression, initialUpdate, extraVars);\n            break;\n\n          case 'cloak':\n            el.removeAttribute('x-cloak');\n            break;\n        }\n      });\n    }\n\n    evaluateReturnExpression(el, expression, extraVars = () => {}) {\n      return saferEval(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n\n    evaluateCommandExpression(el, expression, extraVars = () => {}) {\n      return saferEvalNoReturn(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n\n    getDispatchFunction(el) {\n      return (event, detail = {}) => {\n        el.dispatchEvent(new CustomEvent(event, {\n          detail,\n          bubbles: true\n        }));\n      };\n    }\n\n    listenForNewElementsToInitialize() {\n      const targetNode = this.$el;\n      const observerOptions = {\n        childList: true,\n        attributes: true,\n        subtree: true\n      };\n      const observer = new MutationObserver(mutations => {\n        for (let i = 0; i < mutations.length; i++) {\n          // Filter out mutations triggered from child components.\n          const closestParentComponent = mutations[i].target.closest('[x-data]');\n          if (!(closestParentComponent && closestParentComponent.isSameNode(this.$el))) continue;\n\n          if (mutations[i].type === 'attributes' && mutations[i].attributeName === 'x-data') {\n            const xAttr = mutations[i].target.getAttribute('x-data') || '{}';\n            const rawData = saferEval(this.$el, xAttr, {\n              $el: this.$el\n            });\n            Object.keys(rawData).forEach(key => {\n              if (this.$data[key] !== rawData[key]) {\n                this.$data[key] = rawData[key];\n              }\n            });\n          }\n\n          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(node => {\n              if (node.nodeType !== 1 || node.__x_inserted_me) return;\n\n              if (node.matches('[x-data]') && !node.__x) {\n                node.__x = new Component(node);\n                return;\n              }\n\n              this.initializeElements(node);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\n    }\n\n    getRefsProxy() {\n      var self = this;\n      var refObj = {};\n      // One of the goals of this is to not hold elements in memory, but rather re-evaluate\n      // the DOM when the system needs something from it. This way, the framework is flexible and\n      // friendly to outside DOM changes from libraries like Vue/Livewire.\n      // For this reason, I'm using an \"on-demand\" proxy to fake a \"$refs\" object.\n\n      return new Proxy(refObj, {\n        get(object, property) {\n          if (property === '$isAlpineProxy') return true;\n          var ref; // We can't just query the DOM because it's hard to filter out refs in\n          // nested components.\n\n          self.walkAndSkipNestedComponents(self.$el, el => {\n            if (el.hasAttribute('x-ref') && el.getAttribute('x-ref') === property) {\n              ref = el;\n            }\n          });\n          return ref;\n        }\n\n      });\n    }\n\n  }\n\n  const Alpine = {\n    version: \"2.8.2\",\n    pauseMutationObserver: false,\n    magicProperties: {},\n    onComponentInitializeds: [],\n    onBeforeComponentInitializeds: [],\n    ignoreFocusedForValueBinding: false,\n    start: async function start() {\n      if (!isTesting()) {\n        await domReady();\n      }\n\n      this.discoverComponents(el => {\n        this.initializeComponent(el);\n      }); // It's easier and more performant to just support Turbolinks than listen\n      // to MutationObserver mutations at the document level.\n\n      document.addEventListener(\"turbolinks:load\", () => {\n        this.discoverUninitializedComponents(el => {\n          this.initializeComponent(el);\n        });\n      });\n      this.listenForNewUninitializedComponentsAtRunTime();\n    },\n    discoverComponents: function discoverComponents(callback) {\n      const rootEls = document.querySelectorAll('[x-data]');\n      rootEls.forEach(rootEl => {\n        callback(rootEl);\n      });\n    },\n    discoverUninitializedComponents: function discoverUninitializedComponents(callback, el = null) {\n      const rootEls = (el || document).querySelectorAll('[x-data]');\n      Array.from(rootEls).filter(el => el.__x === undefined).forEach(rootEl => {\n        callback(rootEl);\n      });\n    },\n    listenForNewUninitializedComponentsAtRunTime: function listenForNewUninitializedComponentsAtRunTime() {\n      const targetNode = document.querySelector('body');\n      const observerOptions = {\n        childList: true,\n        attributes: true,\n        subtree: true\n      };\n      const observer = new MutationObserver(mutations => {\n        if (this.pauseMutationObserver) return;\n\n        for (let i = 0; i < mutations.length; i++) {\n          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(node => {\n              // Discard non-element nodes (like line-breaks)\n              if (node.nodeType !== 1) return; // Discard any changes happening within an existing component.\n              // They will take care of themselves.\n\n              if (node.parentElement && node.parentElement.closest('[x-data]')) return;\n              this.discoverUninitializedComponents(el => {\n                this.initializeComponent(el);\n              }, node.parentElement);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\n    },\n    initializeComponent: function initializeComponent(el) {\n      if (!el.__x) {\n        // Wrap in a try/catch so that we don't prevent other components\n        // from initializing when one component contains an error.\n        try {\n          el.__x = new Component(el);\n        } catch (error) {\n          setTimeout(() => {\n            throw error;\n          }, 0);\n        }\n      }\n    },\n    clone: function clone(component, newEl) {\n      if (!newEl.__x) {\n        newEl.__x = new Component(newEl, component);\n      }\n    },\n    addMagicProperty: function addMagicProperty(name, callback) {\n      this.magicProperties[name] = callback;\n    },\n    onComponentInitialized: function onComponentInitialized(callback) {\n      this.onComponentInitializeds.push(callback);\n    },\n    onBeforeComponentInitialized: function onBeforeComponentInitialized(callback) {\n      this.onBeforeComponentInitializeds.push(callback);\n    }\n  };\n\n  if (!isTesting()) {\n    window.Alpine = Alpine;\n\n    if (window.deferLoadingAlpine) {\n      window.deferLoadingAlpine(function () {\n        window.Alpine.start();\n      });\n    } else {\n      window.Alpine.start();\n    }\n  }\n\n  return Alpine;\n\n})));\n"],"sourceRoot":""}