{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/alpinejs/dist/alpine.js","webpack:///./resources/assets/app.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","_defineProperty","obj","configurable","writable","ownKeys","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread2","target","arguments","length","source","forEach","getOwnPropertyDescriptors","defineProperties","arrayUnique","array","Array","from","Set","isTesting","navigator","userAgent","includes","checkedAttrLooseCompare","valueA","valueB","warnIfMalformedTemplate","el","directive","tagName","toLowerCase","console","warn","content","childElementCount","camelCase","subject","replace","match","char","toUpperCase","debounce","func","wait","timeout","context","this","args","later","clearTimeout","setTimeout","saferEval","expression","dataContext","additionalHelperVariables","Function","values","xAttrRE","isXAttr","attr","replaceAtAndColonWithStandardSyntax","test","getXAttrs","component","type","directives","attributes","map","parseHtmlAttribute","spreadDirective","spreadObject","$data","concat","entries","directiveOrder","sort","a","b","typeA","indexOf","typeB","sortDirectives","normalizedName","typeMatch","valueMatch","modifiers","startsWith","convertClassStringToArray","classList","filterFn","Boolean","split","transitionIn","show","reject","forceSkip","__x_transition","attrs","showAttr","settingBothSidesOfTransition","index","showCallback","styleValues","duration","modifierValue","origin","first","opacity","scale","second","transitionHelper","transitionHelperIn","some","enter","ensureStringExpression","find","enterStart","enterEnd","transitionClasses","transitionClassesIn","transitionOut","hide","hideCallback","transitionHelperOut","leave","leaveStart","leaveEnd","transitionClassesOut","fallback","rawValue","isNumeric","join","hook1","hook2","cancel","opacityCache","style","transformCache","transform","transformOriginCache","transformOrigin","noModifiers","transitionOpacity","transitionScale","stages","transitionProperty","trim","transitionDuration","transitionTimingFunction","transition","evaluateReturnExpression","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","add","remove","finish","once","isConnected","cleanup","nextFrame","start","during","requestAnimationFrame","Number","getComputedStyle","animationDuration","end","isArray","isNaN","callback","called","handleForDirective","templateEl","initialUpdate","extraVars","iteratorNames","parseForExpression","items","ifAttribute","evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement","currentEl","item","iterationScopeVariables","scopeVariables","collection","getIterationScopeVariables","currentKey","bindKeyAttribute","generateKeyForIteration","nextEl","__x_for_key","tmpNextEl","parentElement","insertBefore","nextElementSibling","undefined","lookAheadForMatchingKeyedElementAndMoveItIfFound","__x_for","updateElements","clone","document","importNode","addElementInLoopAfterCurrentEl","initializeElements","nextElementFromOldLoop","nextElementFromOldLoopImmutable","nextSibling","removeAnyLeftOverElementsFromPreviousUpdate","forIteratorRE","inMatch","res","iteratorMatch","handleAttributeBindingDirective","attrName","attrType","Alpine","ignoreFocusedForValueBinding","activeElement","isSameNode","checked","val","String","arrayWrappedValue","options","option","selected","text","updateSelect","setAttribute","classNames","className","newClasses","removeAttribute","isBooleanAttr","setIfChanged","getAttribute","registerListener","event","passive","handler","e","contains","offsetWidth","offsetHeight","runListenerHandler","removeEventListener","addEventListener","listenerTarget","window","body","isKeyEvent","keyModifiers","debounceIndex","splice","keyToModifier","selectedSystemKeyModifiers","modifier","isListeningForASpecificKeyThatHasntBeenPressed","preventDefault","stopPropagation","then","nextModifier","evaluateCommandExpression","generateModelAssignmentFunction","hasAttribute","currentValue","CustomEvent","detail","newValue","safeParseNumber","multiple","selectedOptions","number","parseFloat","getPrototypeOf","ObjectCreate","ObjectDefineProperty","ObjectDefineProperties","isExtensible","getOwnPropertyNames","preventExtensions","ArrayPush","ArrayConcat","ArrayMap","isUndefined","isFunction","proxyToValueMap","WeakMap","registerProxy","proxy","set","unwrap","replicaOrAny","wrapValue","membrane","valueIsObservable","getProxy","lockShadowTarget","shadowTarget","originalTarget","descriptor","wrapDescriptor","ReactiveProxyHandler","valueObserved","valueMutated","thisArg","argArray","newTarget","shadowIsExtensible","targetIsExtensible","desc","shadowDescriptor","originalDescriptor","unwrapDescriptor","wrapReadOnlyValue","getReadOnlyProxy","ReadOnlyHandler","createShadowTarget","ObjectDotPrototype","defaultValueIsObservable","proto","defaultValueObserved","defaultValueMutated","defaultValueDistortion","getValue","unwrapProxy","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","getReactiveState","readOnly","reactive","distortedValue","reactiveState","reactiveHandler","Proxy","readOnlyHandler","Component","componentForClone","$el","dataAttr","dataExpression","initExpression","dataExtras","canonicalComponentElementReference","magicProperties","unobservedData","getUnobservedData","data","wrapDataInObservable","initReturnedCallback","$refs","getRefsProxy","nextTickStack","$nextTick","watchers","$watch","showDirectiveStack","showDirectiveLastElement","onBeforeComponentInitializeds","pauseReactivity","listenForNewElementsToInitialize","onComponentInitializeds","observable","unwrappedData","copy","unwrap$1","self","updateDom","mutationCallback","wrap","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","is","initializeComponentCallback","walk","node","firstElementChild","__x","rootEl","walkAndSkipNestedComponents","__x_inserted_me","initializeElement","executeAndClearRemainingShowDirectiveStack","executeAndClearNextTickStack","registerListeners","resolveBoundAttributes","updateElement","shift","reverse","Promise","resolve","promiseChain","promise","finishElement","catch","rightSideOfExpression","registerModelListener","output","textContent","handleTextDirective","innerHTML","handleHtmlDirective","display","__x_is_shown","removeProperty","handle","handleShowDirective","expressionResult","elementHasAlreadyBeenAdded","handleIfDirective","$dispatch","getDispatchFunction","AsyncFunction","async","constructor","methodReference","saferEvalNoReturn","dispatchEvent","bubbles","targetNode","MutationObserver","mutations","closestParentComponent","closest","attributeName","rawData","addedNodes","nodeType","matches","observe","childList","subtree","ref","version","pauseMutationObserver","readyState","discoverComponents","initializeComponent","discoverUninitializedComponents","listenForNewUninitializedComponentsAtRunTime","querySelectorAll","rootEls","querySelector","error","newEl","addMagicProperty","onComponentInitialized","onBeforeComponentInitialized","deferLoadingAlpine","factory","require"],"mappings":"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","file":"/assets/app/js/app.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 = 0);\n","(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 multiple element roots. Make sure <template> only has a single child 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  function saferEval(expression, dataContext, additionalHelperVariables = {}) {\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  function saferEvalNoReturn(expression, dataContext, additionalHelperVariables = {}) {\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  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(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 = 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 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 && 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 = 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 && 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    if (modifiers.includes('away')) {\n      let 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      }; // Listen for this event at the root level.\n\n\n      document.addEventListener(event, handler, options);\n    } else {\n      let listenerTarget = modifiers.includes('window') ? window : modifiers.includes('document') ? document : el;\n\n      let 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      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\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(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);\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\n\n      this.initializeElements(this.$el); // 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 = () => {}) {\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);\n      }, el => {\n        el.__x = new Component(el);\n      });\n      this.executeAndClearRemainingShowDirectiveStack();\n      this.executeAndClearNextTickStack(rootEl);\n    }\n\n    initializeElement(el, extraVars) {\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      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(expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n\n    evaluateCommandExpression(el, expression, extraVars = () => {}) {\n      return saferEvalNoReturn(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 rawData = saferEval(mutations[i].target.getAttribute('x-data') || '{}', {\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.7.3\",\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","require('./bootstrap');\n\nrequire('alpinejs');\n"],"sourceRoot":""}