{"version":3,"file":"js/alpine-e1538deb140596f683ff.js","mappings":"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","sources":["webpack://glass/./node_modules/alpine-turbo-drive-adapter/dist/alpine-turbo-drive-adapter.esm.js","webpack://glass/./node_modules/alpinejs/dist/alpine.js","webpack://glass/webpack/bootstrap","webpack://glass/webpack/runtime/compat get default export","webpack://glass/webpack/runtime/define property getters","webpack://glass/webpack/runtime/hasOwnProperty shorthand"],"sourcesContent":["function isValidVersion(required, current) {\n  var requiredArray = required.split('.');\n  var currentArray = current.split('.');\n  for (var i = 0; i < requiredArray.length; i++) {\n    if (!currentArray[i] || currentArray[i] < requiredArray[i]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction beforeDomReady(callback) {\n  if (document.readyState === 'loading') {\n    document.addEventListener('readystatechange', () => {\n      if (document.readyState === 'interactive') {\n        callback();\n      }\n    });\n  } else {\n    callback();\n  }\n}\nclass Bridge {\n  init() {\n    // Tag all cloaked elements on first page load.\n    document.body.querySelectorAll('[x-cloak]').forEach(el => {\n      var _el$getAttribute;\n      el.setAttribute('data-alpine-was-cloaked', (_el$getAttribute = el.getAttribute('x-cloak')) !== null && _el$getAttribute !== void 0 ? _el$getAttribute : '');\n    });\n    this.configureEventHandlers();\n  }\n  setMutationObserverState(state) {\n    if (!window.Alpine.version || !isValidVersion('2.4.0', window.Alpine.version)) {\n      throw new Error('Invalid Alpine version. Please use Alpine 2.4.0 or above');\n    }\n    window.Alpine.pauseMutationObserver = !state;\n  }\n  configureEventHandlers() {\n    // Once Turbolinks finished is magic, we initialise Alpine on the new page\n    // and resume the observer\n    var renderCallback = () => {\n      // turbo:render fires twice in cached views but we don't want to\n      // try to restore Alpine on the preview.\n      if (document.documentElement.hasAttribute('data-turbo-preview')) {\n        return;\n      }\n      window.Alpine.discoverUninitializedComponents(el => {\n        window.Alpine.initializeComponent(el);\n      });\n      requestAnimationFrame(() => {\n        this.setMutationObserverState(true);\n      });\n    }; // Before swapping the body, clean up any element with x-turbolinks-cached\n    // which do not have any Alpine properties.\n    // Note, at this point all html fragments marked as data-turbolinks-permanent\n    // are already copied over from the previous page so they retain their listener\n    // and custom properties and we don't want to reset them.\n\n    var beforeRenderCallback = event => {\n      var newBody = event.data ? event.data.newBody : event.detail.newBody;\n      newBody.querySelectorAll('[data-alpine-generated-me],[x-cloak]').forEach(el => {\n        if (el.hasAttribute('x-cloak')) {\n          var _el$getAttribute2;\n\n          // When we get a new document body tag any cloaked elements so we can cloak\n          // them again before caching.\n          el.setAttribute('data-alpine-was-cloaked', (_el$getAttribute2 = el.getAttribute('x-cloak')) !== null && _el$getAttribute2 !== void 0 ? _el$getAttribute2 : '');\n        }\n        if (el.hasAttribute('data-alpine-generated-me')) {\n          el.removeAttribute('data-alpine-generated-me');\n          if (typeof el.__x_for_key === 'undefined' && typeof el.__x_inserted_me === 'undefined') {\n            el.remove();\n          }\n        }\n      });\n    }; // Pause the the mutation observer to avoid data races, it will be resumed by the turbolinks:load event.\n    // We mark as `data-alpine-generated-m` all elements that are crated by an Alpine templating directives.\n    // The reason is that turbolinks caches pages using cloneNode which removes listeners and custom properties\n    // So we need to propagate this infomation using a HTML attribute. I know, not ideal but I could not think\n    // of a better option.\n    // Note, we can't remove any Alpine generated element as yet because if they live inside an element\n    // marked as data-turbolinks-permanent they need to be copied into the next page.\n    // The coping process happens somewhere between before-cache and before-render.\n\n    var beforeCacheCallback = () => {\n      this.setMutationObserverState(false);\n      document.body.querySelectorAll('[x-for],[x-if],[data-alpine-was-cloaked]').forEach(el => {\n        // Cloak any elements again that were tagged when the page was loaded\n        if (el.hasAttribute('data-alpine-was-cloaked')) {\n          var _el$getAttribute3;\n          el.setAttribute('x-cloak', (_el$getAttribute3 = el.getAttribute('data-alpine-was-cloaked')) !== null && _el$getAttribute3 !== void 0 ? _el$getAttribute3 : '');\n          el.removeAttribute('data-alpine-was-cloaked');\n        }\n        if (el.hasAttribute('x-for')) {\n          var nextEl = el.nextElementSibling;\n          while (nextEl && typeof nextEl.__x_for_key !== 'undefined') {\n            var currEl = nextEl;\n            nextEl = nextEl.nextElementSibling;\n            currEl.setAttribute('data-alpine-generated-me', true);\n          }\n        } else if (el.hasAttribute('x-if')) {\n          var ifEl = el.nextElementSibling;\n          if (ifEl && typeof ifEl.__x_inserted_me !== 'undefined') {\n            ifEl.setAttribute('data-alpine-generated-me', true);\n          }\n        }\n      });\n    }; // Streams do not trigger a render event and there is no\n    // turbo:after-stream-render so we use turbo:before-stream-render\n    // and we delay 2 ticks to simulate the after-stream-render event\n\n    var beforeStreamFormRenderCallback = () => {\n      requestAnimationFrame(() => {\n        requestAnimationFrame(() => {\n          renderCallback();\n        });\n      });\n    };\n    document.addEventListener('turbo:render', renderCallback);\n    document.addEventListener('turbolinks:load', renderCallback);\n    document.addEventListener('turbo:before-render', beforeRenderCallback);\n    document.addEventListener('turbolinks:before-render', beforeRenderCallback);\n    document.addEventListener('turbo:before-cache', beforeCacheCallback);\n    document.addEventListener('turbolinks:before-cache', beforeCacheCallback);\n    document.addEventListener('turbo:before-stream-render', beforeStreamFormRenderCallback);\n  }\n}\nif (window.Alpine) {\n  console.error('Alpine-turbo-drive-adapter must be included before AlpineJs');\n} // Polyfill for legacy browsers\n\nif (!Object.getOwnPropertyDescriptor(NodeList.prototype, 'forEach')) {\n  Object.defineProperty(NodeList.prototype, 'forEach', Object.getOwnPropertyDescriptor(Array.prototype, 'forEach'));\n} // To better suport x-cloak, we need to init the library when the DOM\n// has been downloaded but before Alpine kicks in\n\nbeforeDomReady(() => {\n  var bridge = new Bridge();\n  bridge.init();\n});","function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }\nfunction _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : \"undefined\" != typeof Symbol && arr[Symbol.iterator] || arr[\"@@iterator\"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global || self, global.Alpine = factory());\n})(this, function () {\n  '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    return obj;\n  }\n  function ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\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    return keys;\n  }\n  function _objectSpread2(target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i] != null ? arguments[i] : {};\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    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    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      var later = function later() {\n        timeout = null;\n        func.apply(context, args);\n      };\n      clearTimeout(timeout);\n      timeout = setTimeout(later, wait);\n    };\n  }\n  const handleError = (el, expression, error) => {\n    console.warn(`Alpine Error: \"${error}\"\\n\\nExpression: \"${expression}\"\\nElement:`, el);\n    if (!isTesting()) {\n      Object.assign(error, {\n        el,\n        expression\n      });\n      throw error;\n    }\n  };\n  function tryCatch(cb, _ref) {\n    let el = _ref.el,\n      expression = _ref.expression;\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  function saferEval(el, expression, dataContext) {\n    let additionalHelperVariables = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return expression.call(dataContext);\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) {\n    let additionalHelperVariables = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n    return tryCatch(() => {\n      if (typeof expression === 'function') {\n        return Promise.resolve(expression.call(dataContext, additionalHelperVariables['$event']));\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        if (typeof methodReference === 'function') {\n          return Promise.resolve(methodReference.call(dataContext, additionalHelperVariables['$event']));\n        } else {\n          return Promise.resolve();\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    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(_ref2 => {\n        let _ref3 = _slicedToArray(_ref2, 2),\n          name = _ref3[0],\n          value = _ref3[1];\n        return parseHtmlAttribute({\n          name,\n          value\n        });\n      }));\n    }\n    if (type) return directives.filter(i => i.type === type);\n    return sortDirectives(directives);\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  function parseHtmlAttribute(_ref4) {\n    let name = _ref4.name,\n      value = _ref4.value;\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    return name;\n  }\n  function convertClassStringToArray(classList) {\n    let filterFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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) {\n    let forceSkip = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return show();\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    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) {\n    let forceSkip = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n    // We don't want to transition on the initial page load.\n    if (forceSkip) return hide();\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    const attrs = getXAttrs(el, component, 'transition');\n    const showAttr = getXAttrs(el, component, 'show')[0];\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  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    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    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    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    return rawValue;\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    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      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      show() {\n        hook1();\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      hide() {\n        hook2();\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    transition(el, stages, type, reject);\n  }\n  const ensureStringExpression = (expression, el, component) => {\n    return typeof expression === 'function' ? component.evaluateReturnExpression(el, expression) : expression;\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    const originalClasses = el.__x_original_classes || [];\n    const stages = {\n      start() {\n        el.classList.add(...classesStart);\n      },\n      during() {\n        el.classList.add(...classesDuring);\n      },\n      show() {\n        hook1();\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      hide() {\n        hook2();\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    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      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      if (duration === 0) {\n        duration = Number(getComputedStyle(el).animationDuration.replace('s', '')) * 1000;\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  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      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    if (iteratorMatch) {\n      res.item = item.replace(forIteratorRE, '').trim();\n      res.index = iteratorMatch[1].trim();\n      if (iteratorMatch[2]) {\n        res.collection = iteratorMatch[2].trim();\n      }\n    } else {\n      res.item = item;\n    }\n    return res;\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  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  function evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement(component, el, iteratorNames, extraVars) {\n    let ifAttribute = getXAttrs(el, component, 'if')[0];\n    if (ifAttribute && !component.evaluateReturnExpression(el, ifAttribute.expression)) {\n      return [];\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    return items;\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  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    while (tmpNextEl) {\n      if (tmpNextEl.__x_for_key === currentKey) {\n        return tmpNextEl.parentElement.insertBefore(tmpNextEl, nextEl);\n      }\n      tmpNextEl = tmpNextEl.nextElementSibling && tmpNextEl.nextElementSibling.__x_for_key !== undefined ? tmpNextEl.nextElementSibling : false;\n    }\n  }\n  function removeAnyLeftOverElementsFromPreviousUpdate(currentEl, component) {\n    var nextElementFromOldLoop = currentEl.nextElementSibling && currentEl.nextElementSibling.__x_for_key !== undefined ? currentEl.nextElementSibling : false;\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  function handleAttributeBindingDirective(component, el, attrName, expression, extraVars, attrType, modifiers) {\n    var value = component.evaluateReturnExpression(el, expression, extraVars);\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      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  function setIfChanged(el, attrName, value) {\n    if (el.getAttribute(attrName) != value) {\n      el.setAttribute(attrName, value);\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  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    el.textContent = output;\n  }\n  function handleHtmlDirective(component, el, expression, extraVars) {\n    el.innerHTML = component.evaluateReturnExpression(el, expression, extraVars);\n  }\n  function handleShowDirective(component, el, value, modifiers) {\n    let initialUpdate = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n    const hide = () => {\n      el.style.display = 'none';\n      el.__x_is_shown = false;\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      el.__x_is_shown = true;\n    };\n    if (initialUpdate === true) {\n      if (value) {\n        show();\n      } else {\n        hide();\n      }\n      return;\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        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    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    if (component.showDirectiveLastElement && !component.showDirectiveLastElement.contains(el)) {\n      component.executeAndClearRemainingShowDirectiveStack();\n    }\n    component.showDirectiveStack.push(handle);\n    component.showDirectiveLastElement = el;\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    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  function registerListener(component, el, event, modifiers, expression) {\n    let extraVars = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};\n    const options = {\n      passive: modifiers.includes('passive')\n    };\n    if (modifiers.includes('camel')) {\n      event = camelCase(event);\n    }\n    let handler, listenerTarget;\n    if (modifiers.includes('away')) {\n      listenerTarget = document;\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        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      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        if (isKeyEvent(event)) {\n          if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {\n            return;\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    listenerTarget.addEventListener(event, handler, options);\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  function isKeyEvent(event) {\n    return ['keydown', 'keyup'].includes(event);\n  }\n  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {\n    let keyModifiers = modifiers.filter(i => {\n      return !['window', 'document', 'prevent', 'stop'].includes(i);\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    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    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    return true;\n  }\n  function keyToModifier(key) {\n    switch (key) {\n      case '/':\n        return 'slash';\n      case ' ':\n      case 'Spacebar':\n        return 'space';\n      default:\n        return key && kebabCase(key);\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  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    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  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.isArray;\n  const getPrototypeOf = Object.getPrototypeOf,\n    ObjectCreate = Object.create,\n    ObjectDefineProperty = Object.defineProperty,\n    ObjectDefineProperties = Object.defineProperties,\n    isExtensible = Object.isExtensible,\n    getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,\n    getOwnPropertyNames = Object.getOwnPropertyNames,\n    getOwnPropertySymbols = Object.getOwnPropertySymbols,\n    preventExtensions = Object.preventExtensions,\n    hasOwnProperty = Object.hasOwnProperty;\n  const _Array$prototype = Array.prototype,\n    ArrayPush = _Array$prototype.push,\n    ArrayConcat = _Array$prototype.concat,\n    ArrayMap = _Array$prototype.map;\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  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 = this.originalTarget,\n        membrane = this.membrane;\n      const value = originalTarget[key];\n      const valueObserved = membrane.valueObserved;\n      valueObserved(originalTarget, key);\n      return membrane.getProxy(value);\n    }\n    set(shadowTarget, key, value) {\n      const originalTarget = this.originalTarget,\n        valueMutated = this.membrane.valueMutated;\n      const oldValue = originalTarget[key];\n      if (oldValue !== value) {\n        originalTarget[key] = value;\n        valueMutated(originalTarget, key);\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 = this.originalTarget,\n        valueMutated = this.membrane.valueMutated;\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 = this.originalTarget,\n        valueObserved = this.membrane.valueObserved;\n      valueObserved(originalTarget, key);\n      return key in originalTarget;\n    }\n    ownKeys(shadowTarget) {\n      const originalTarget = this.originalTarget;\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 = this.originalTarget,\n        membrane = this.membrane;\n      const targetIsExtensible = isExtensible(originalTarget);\n      if (!targetIsExtensible) {\n        lockShadowTarget(membrane, shadowTarget, originalTarget);\n      }\n      return targetIsExtensible;\n    }\n    setPrototypeOf(shadowTarget, prototype) {}\n    getPrototypeOf(shadowTarget) {\n      const originalTarget = this.originalTarget;\n      return getPrototypeOf(originalTarget);\n    }\n    getOwnPropertyDescriptor(shadowTarget, key) {\n      const originalTarget = this.originalTarget,\n        membrane = this.membrane;\n      const valueObserved = this.membrane.valueObserved;\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 = this.originalTarget,\n        membrane = this.membrane;\n      lockShadowTarget(membrane, shadowTarget, originalTarget);\n      preventExtensions(originalTarget);\n      return true;\n    }\n    defineProperty(shadowTarget, key, descriptor) {\n      const originalTarget = this.originalTarget,\n        membrane = this.membrane;\n      const valueMutated = membrane.valueMutated;\n      const configurable = descriptor.configurable;\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  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 = this.membrane,\n        originalTarget = this.originalTarget;\n      const value = originalTarget[key];\n      const valueObserved = membrane.valueObserved;\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 = this.originalTarget,\n        valueObserved = this.membrane.valueObserved;\n      valueObserved(originalTarget, key);\n      return key in originalTarget;\n    }\n    ownKeys(shadowTarget) {\n      const originalTarget = this.originalTarget;\n      return ArrayConcat.call(getOwnPropertyNames(originalTarget), getOwnPropertySymbols(originalTarget));\n    }\n    setPrototypeOf(shadowTarget, prototype) {}\n    getOwnPropertyDescriptor(shadowTarget, key) {\n      const originalTarget = this.originalTarget,\n        membrane = this.membrane;\n      const valueObserved = membrane.valueObserved;\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\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    } 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 = descriptor.set,\n      get = descriptor.get;\n    if (hasOwnProperty.call(descriptor, 'value')) {\n      descriptor.value = getValue(membrane, descriptor.value);\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 = options.valueDistortion,\n          valueMutated = options.valueMutated,\n          valueObserved = options.valueObserved,\n          valueIsObservable = options.valueIsObservable;\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.objectGraph;\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', {\n            value: proxy\n          });\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', {\n            value: proxy\n          });\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    let membrane = new ReactiveMembrane({\n      valueMutated(target, key) {\n        mutationCallback(target, key);\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  class Component {\n    constructor(el) {\n      let componentForClone = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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(_ref5 => {\n        let _ref6 = _slicedToArray(_ref5, 2),\n          name = _ref6[0],\n          callback = _ref6[1];\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 _this$wrapDataInObser = this.wrapDataInObservable(this.unobservedData),\n        membrane = _this$wrapDataInObser.membrane,\n        data = _this$wrapDataInObser.data;\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      this.unobservedData.$nextTick = callback => {\n        this.nextTickStack.push(callback);\n      };\n      this.watchers = {};\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      Object.entries(Alpine.magicProperties).forEach(_ref7 => {\n        let _ref8 = _slicedToArray(_ref7, 2),\n          name = _ref8[0],\n          callback = _ref8[1];\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      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      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      componentForClone || setTimeout(() => {\n        Alpine.onComponentInitializeds.forEach(callback => callback(this));\n      }, 0);\n    }\n    getUnobservedData() {\n      return unwrap$1(this.membrane, this.$data);\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              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              return comparisonData[part];\n            }, self.unobservedData);\n          });\n        } // Don't react to data changes for cases like the `x-created` hook.\n\n        if (self.pauseReactivity) return;\n        updateDom();\n      });\n    }\n    walkAndSkipNestedComponents(el, callback) {\n      let initializeComponentCallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};\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        return callback(el);\n      });\n    }\n    initializeElements(rootEl) {\n      let extraVars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => {};\n      let componentForClone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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    initializeElement(el, extraVars) {\n      let shouldRegisterListeners = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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      shouldRegisterListeners && this.registerListeners(el, extraVars);\n      this.resolveBoundAttributes(el, true, extraVars);\n    }\n    updateElements(rootEl) {\n      let extraVars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => {};\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    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    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    updateElement(el, extraVars) {\n      this.resolveBoundAttributes(el, false, extraVars);\n    }\n    registerListeners(el, extraVars) {\n      getXAttrs(el, this).forEach(_ref9 => {\n        let type = _ref9.type,\n          value = _ref9.value,\n          modifiers = _ref9.modifiers,\n          expression = _ref9.expression;\n        switch (type) {\n          case 'on':\n            registerListener(this, el, value, modifiers, expression, extraVars);\n            break;\n          case 'model':\n            registerModelListener(this, el, modifiers, expression, extraVars);\n            break;\n        }\n      });\n    }\n    resolveBoundAttributes(el) {\n      let initialUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      let extraVars = arguments.length > 2 ? arguments[2] : undefined;\n      let attrs = getXAttrs(el, this);\n      attrs.forEach(_ref10 => {\n        let type = _ref10.type,\n          value = _ref10.value,\n          modifiers = _ref10.modifiers,\n          expression = _ref10.expression;\n        switch (type) {\n          case 'model':\n            handleAttributeBindingDirective(this, el, 'value', expression, extraVars, type, modifiers);\n            break;\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          case 'text':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleTextDirective(el, output, expression);\n            break;\n          case 'html':\n            handleHtmlDirective(this, el, expression, extraVars);\n            break;\n          case 'show':\n            var output = this.evaluateReturnExpression(el, expression, extraVars);\n            handleShowDirective(this, el, output, modifiers, initialUpdate);\n            break;\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          case 'for':\n            handleForDirective(this, el, expression, initialUpdate, extraVars);\n            break;\n          case 'cloak':\n            el.removeAttribute('x-cloak');\n            break;\n        }\n      });\n    }\n    evaluateReturnExpression(el, expression) {\n      let extraVars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};\n      return saferEval(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n    evaluateCommandExpression(el, expression) {\n      let extraVars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : () => {};\n      return saferEvalNoReturn(el, expression, this.$data, _objectSpread2(_objectSpread2({}, extraVars()), {}, {\n        $dispatch: this.getDispatchFunction(el)\n      }));\n    }\n    getDispatchFunction(el) {\n      return function (event) {\n        let detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        el.dispatchEvent(new CustomEvent(event, {\n          detail,\n          bubbles: true\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          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          if (mutations[i].addedNodes.length > 0) {\n            mutations[i].addedNodes.forEach(node => {\n              if (node.nodeType !== 1 || node.__x_inserted_me) return;\n              if (node.matches('[x-data]') && !node.__x) {\n                node.__x = new Component(node);\n                return;\n              }\n              this.initializeElements(node);\n            });\n          }\n        }\n      });\n      observer.observe(targetNode, observerOptions);\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  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      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) {\n      let el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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        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  if (!isTesting()) {\n    window.Alpine = Alpine;\n    if (window.deferLoadingAlpine) {\n      window.deferLoadingAlpine(function () {\n        window.Alpine.start();\n      });\n    } else {\n      window.Alpine.start();\n    }\n  }\n  return Alpine;\n});","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }"],"names":["Bridge","init","document","body","querySelectorAll","forEach","el","_el$getAttribute","setAttribute","getAttribute","this","configureEventHandlers","setMutationObserverState","state","window","Alpine","version","required","current","requiredArray","split","currentArray","i","length","isValidVersion","Error","pauseMutationObserver","renderCallback","documentElement","hasAttribute","discoverUninitializedComponents","initializeComponent","requestAnimationFrame","beforeRenderCallback","event","data","newBody","detail","_el$getAttribute2","removeAttribute","__x_for_key","__x_inserted_me","remove","beforeCacheCallback","_el$getAttribute3","nextEl","nextElementSibling","currEl","ifEl","addEventListener","callback","console","error","Object","getOwnPropertyDescriptor","NodeList","prototype","defineProperty","Array","readyState","_slicedToArray","arr","isArray","_arrayWithHoles","_i","Symbol","iterator","_s","_e","_x","_r","_arr","_n","_d","call","next","done","push","value","err","return","_iterableToArrayLimit","o","minLen","_arrayLikeToArray","n","toString","slice","constructor","name","from","test","_unsupportedIterableToArray","TypeError","_nonIterableRest","len","arr2","module","exports","_defineProperty","obj","key","enumerable","configurable","writable","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","apply","_objectSpread2","target","arguments","source","getOwnPropertyDescriptors","defineProperties","domReady","Promise","resolve","arrayUnique","array","Set","isTesting","navigator","userAgent","includes","checkedAttrLooseCompare","valueA","valueB","warnIfMalformedTemplate","directive","tagName","toLowerCase","warn","content","childElementCount","kebabCase","subject","replace","camelCase","match","char","toUpperCase","walk","node","firstElementChild","debounce","func","wait","timeout","context","args","later","clearTimeout","setTimeout","handleError","expression","assign","tryCatch","cb","_ref","catch","e","saferEval","dataContext","additionalHelperVariables","undefined","Function","values","saferEvalNoReturn","AsyncFunction","getPrototypeOf","async","methodReference","xAttrRE","isXAttr","attr","replaceAtAndColonWithStandardSyntax","getXAttrs","component","type","directives","attributes","map","parseHtmlAttribute","spreadDirective","spreadObject","$data","concat","entries","_ref2","_ref3","sortDirectives","directiveOrder","sort","a","b","typeA","indexOf","typeB","_ref4","normalizedName","typeMatch","valueMatch","modifiers","isBooleanAttr","attrName","startsWith","convertClassStringToArray","classList","filterFn","Boolean","TRANSITION_TYPE_IN","TRANSITION_TYPE_OUT","TRANSITION_CANCELLED","transitionIn","show","reject","__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","start","during","transitionProperty","trim","transitionDuration","transitionTimingFunction","end","cleanup","transition","ensureStringExpression","evaluateReturnExpression","transitionClasses","find","classesDuring","classesStart","classesEnd","originalClasses","__x_original_classes","add","finish","once","isConnected","nextFrame","Number","getComputedStyle","animationDuration","isNaN","called","handleForDirective","templateEl","initialUpdate","extraVars","iteratorNames","parseForExpression","items","evaluateItemsAndReturnEmptyIfXIfIsPresentAndFalseOnElement","currentEl","item","iterationScopeVariables","getIterationScopeVariables","currentKey","generateKeyForIteration","lookAheadForMatchingKeyedElementAndMoveItIfFound","__x_for","updateElements","addElementInLoopAfterCurrentEl","initializeElements","removeAnyLeftOverElementsFromPreviousUpdate","forIteratorRE","stripParensRE","forAliasRE","inMatch","String","res","iteratorMatch","collection","scopeVariables","bindKeyAttribute","ifAttribute","clone","importNode","parentElement","insertBefore","tmpNextEl","nextElementFromOldLoop","nextElementFromOldLoopImmutable","nextSibling","handleAttributeBindingDirective","attrType","ignoreFocusedForValueBinding","activeElement","isSameNode","checked","val","updateSelect","classNames","className","newClasses","setIfChanged","arrayWrappedValue","options","option","selected","text","handleTextDirective","output","textContent","handleHtmlDirective","innerHTML","handleShowDirective","display","__x_is_shown","removeProperty","handle","showDirectiveLastElement","contains","executeAndClearRemainingShowDirectiveStack","showDirectiveStack","handleIfDirective","expressionResult","elementHasAlreadyBeenAdded","registerListener","passive","handler","listenerTarget","offsetWidth","offsetHeight","runListenerHandler","removeEventListener","isKeyEvent","isListeningForASpecificKeyThatHasntBeenPressed","preventDefault","stopPropagation","then","nextModifier","evaluateCommandExpression","keyModifiers","debounceIndex","splice","keyToModifier","selectedSystemKeyModifiers","modifier","registerModelListener","rightSideOfExpression","generateModelAssignmentFunction","currentValue","CustomEvent","newValue","safeParseNumber","multiple","selectedOptions","number","parseFloat","ObjectDefineProperty","create","isExtensible","getOwnPropertyNames","preventExtensions","hasOwnProperty","_Array$prototype","ArrayConcat","isUndefined","isFunction","isObject","proxyToValueMap","WeakMap","registerProxy","proxy","set","unwrap","replicaOrAny","get","wrapValue","membrane","valueIsObservable","getProxy","unwrapDescriptor","descriptor","lockShadowTarget","shadowTarget","originalTarget","wrapDescriptor","ReactiveProxyHandler","valueObserved","valueMutated","deleteProperty","thisArg","argArray","construct","newTarget","has","shadowIsExtensible","targetIsExtensible","setPrototypeOf","desc","shadowDescriptor","originalDescriptor","wrapReadOnlyValue","getReadOnlyProxy","ReadOnlyHandler","createShadowTarget","ObjectDotPrototype","defaultValueIsObservable","proto","defaultValueObserved","defaultValueMutated","defaultValueDistortion","getValue","unwrapProxy","ReactiveMembrane","valueDistortion","objectGraph","unwrappedValue","distorted","getReactiveState","readOnly","reactive","p","distortedValue","reactiveState","reactiveHandler","Proxy","readOnlyHandler","wrap","mutationCallback","unwrap$1","observable","unwrappedData","copy","Component","componentForClone","$el","dataAttr","dataExpression","initExpression","dataExtras","canonicalComponentElementReference","magicProperties","_ref5","_ref6","unobservedData","getUnobservedData","_this$wrapDataInObser","wrapDataInObservable","initReturnedCallback","$refs","getRefsProxy","nextTickStack","$nextTick","watchers","$watch","property","_ref7","_ref8","onBeforeComponentInitializeds","pauseReactivity","listenForNewElementsToInitialize","onComponentInitializeds","self","updateDom","fullDotNotationKey","dotNotationParts","reduce","comparisonData","part","is","walkAndSkipNestedComponents","initializeComponentCallback","__x","rootEl","initializeElement","executeAndClearNextTickStack","shouldRegisterListeners","registerListeners","resolveBoundAttributes","updateElement","shift","reverse","promiseChain","promise","finishElement","_ref9","_ref10","$dispatch","getDispatchFunction","dispatchEvent","bubbles","targetNode","observerOptions","childList","subtree","MutationObserver","mutations","closestParentComponent","closest","attributeName","xAttr","rawData","addedNodes","nodeType","matches","observe","ref","discoverComponents","listenForNewUninitializedComponentsAtRunTime","rootEls","querySelector","newEl","addMagicProperty","onComponentInitialized","onBeforeComponentInitialized","deferLoadingAlpine","factory","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","getter","__esModule","d","definition","prop"],"sourceRoot":""}