{ "version": 3, "sources": ["../src/scheduler.js", "../src/reactivity.js", "../src/mutation.js", "../src/scope.js", "../src/interceptor.js", "../src/magics.js", "../src/utils/error.js", "../src/evaluator.js", "../src/directives.js", "../src/utils/dispatch.js", "../src/utils/walk.js", "../src/utils/warn.js", "../src/lifecycle.js", "../src/nextTick.js", "../src/utils/classes.js", "../src/utils/styles.js", "../src/utils/once.js", "../src/directives/x-transition.js", "../src/clone.js", "../src/utils/bind.js", "../src/utils/debounce.js", "../src/utils/throttle.js", "../src/entangle.js", "../src/plugin.js", "../src/store.js", "../src/binds.js", "../src/datas.js", "../src/alpine.js", "../../../node_modules/@vue/shared/dist/shared.esm-bundler.js", "../../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js", "../src/magics/$nextTick.js", "../src/magics/$dispatch.js", "../src/magics/$watch.js", "../src/magics/$store.js", "../src/magics/$data.js", "../src/magics/$root.js", "../src/magics/$refs.js", "../src/ids.js", "../src/magics/$id.js", "../src/magics/$el.js", "../src/magics/index.js", "../src/directives/x-modelable.js", "../src/directives/x-teleport.js", "../src/directives/x-ignore.js", "../src/directives/x-effect.js", "../src/utils/on.js", "../src/directives/x-model.js", "../src/directives/x-cloak.js", "../src/directives/x-init.js", "../src/directives/x-text.js", "../src/directives/x-html.js", "../src/directives/x-bind.js", "../src/directives/x-data.js", "../src/directives/x-show.js", "../src/directives/x-for.js", "../src/directives/x-ref.js", "../src/directives/x-if.js", "../src/directives/x-id.js", "../src/directives/x-on.js", "../src/directives/index.js", "../src/index.js", "../builds/cdn.js"], "sourcesContent": ["\nlet flushPending = false\nlet flushing = false\nlet queue = []\nlet lastFlushedIndex = -1\n\nexport function scheduler (callback) { queueJob(callback) }\n\nfunction queueJob(job) {\n if (! queue.includes(job)) queue.push(job)\n\n queueFlush()\n}\nexport function dequeueJob(job) {\n let index = queue.indexOf(job)\n\n if (index !== -1 && index > lastFlushedIndex) queue.splice(index, 1)\n}\n\nfunction queueFlush() {\n if (! flushing && ! flushPending) {\n flushPending = true\n\n queueMicrotask(flushJobs)\n }\n}\n\nexport function flushJobs() {\n flushPending = false\n flushing = true\n\n for (let i = 0; i < queue.length; i++) {\n queue[i]()\n lastFlushedIndex = i\n }\n\n queue.length = 0\n lastFlushedIndex = -1\n\n flushing = false\n}\n", "\nimport { scheduler } from './scheduler'\n\nlet reactive, effect, release, raw\n\nlet shouldSchedule = true\nexport function disableEffectScheduling(callback) {\n shouldSchedule = false\n\n callback()\n\n shouldSchedule = true\n}\n\nexport function setReactivityEngine(engine) {\n reactive = engine.reactive\n release = engine.release\n effect = (callback) => engine.effect(callback, { scheduler: task => {\n if (shouldSchedule) {\n scheduler(task)\n } else {\n task()\n }\n } })\n raw = engine.raw\n}\n\nexport function overrideEffect(override) { effect = override }\n\nexport function elementBoundEffect(el) {\n let cleanup = () => {}\n\n let wrappedEffect = (callback) => {\n let effectReference = effect(callback)\n\n if (! el._x_effects) {\n el._x_effects = new Set\n\n // Livewire depends on el._x_runEffects.\n el._x_runEffects = () => { el._x_effects.forEach(i => i()) }\n }\n\n el._x_effects.add(effectReference)\n\n cleanup = () => {\n if (effectReference === undefined) return\n\n el._x_effects.delete(effectReference)\n\n release(effectReference)\n }\n\n return effectReference\n }\n\n return [wrappedEffect, () => { cleanup() }]\n}\n\nexport function watch(getter, callback) {\n let firstTime = true\n\n let oldValue\n\n let effectReference = effect(() => {\n let value = getter()\n\n // JSON.stringify touches every single property at any level enabling deep watching\n JSON.stringify(value)\n\n if (! firstTime) {\n // We have to queue this watcher as a microtask so that\n // the watcher doesn't pick up its own dependencies.\n queueMicrotask(() => {\n callback(value, oldValue)\n\n oldValue = value\n })\n } else {\n oldValue = value\n }\n\n firstTime = false\n })\n\n return () => release(effectReference)\n}\n\nexport {\n release,\n reactive,\n effect,\n raw,\n}\n", "import { dequeueJob } from \"./scheduler\";\nlet onAttributeAddeds = []\nlet onElRemoveds = []\nlet onElAddeds = []\n\nexport function onElAdded(callback) {\n onElAddeds.push(callback)\n}\n\nexport function onElRemoved(el, callback) {\n if (typeof callback === 'function') {\n if (! el._x_cleanups) el._x_cleanups = []\n el._x_cleanups.push(callback)\n } else {\n callback = el\n onElRemoveds.push(callback)\n }\n}\n\nexport function onAttributesAdded(callback) {\n onAttributeAddeds.push(callback)\n}\n\nexport function onAttributeRemoved(el, name, callback) {\n if (! el._x_attributeCleanups) el._x_attributeCleanups = {}\n if (! el._x_attributeCleanups[name]) el._x_attributeCleanups[name] = []\n\n el._x_attributeCleanups[name].push(callback)\n}\n\nexport function cleanupAttributes(el, names) {\n if (! el._x_attributeCleanups) return\n\n Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {\n if (names === undefined || names.includes(name)) {\n value.forEach(i => i())\n\n delete el._x_attributeCleanups[name]\n }\n })\n}\n\nexport function cleanupElement(el) {\n el._x_effects?.forEach(dequeueJob)\n\n while (el._x_cleanups?.length) el._x_cleanups.pop()()\n}\n\nlet observer = new MutationObserver(onMutate)\n\nlet currentlyObserving = false\n\nexport function startObservingMutations() {\n observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true })\n\n currentlyObserving = true\n}\n\nexport function stopObservingMutations() {\n flushObserver()\n\n observer.disconnect()\n\n currentlyObserving = false\n}\n\nlet queuedMutations = []\n\nexport function flushObserver() {\n let records = observer.takeRecords()\n\n queuedMutations.push(() => records.length > 0 && onMutate(records))\n\n let queueLengthWhenTriggered = queuedMutations.length\n\n queueMicrotask(() => {\n // If these two lengths match, then we KNOW that this is the LAST\n // flush in the current event loop. This way, we can process\n // all mutations in one batch at the end of everything...\n if (queuedMutations.length === queueLengthWhenTriggered) {\n // Now Alpine can process all the mutations...\n while (queuedMutations.length > 0) queuedMutations.shift()()\n }\n })\n}\n\nexport function mutateDom(callback) {\n if (! currentlyObserving) return callback()\n\n stopObservingMutations()\n\n let result = callback()\n\n startObservingMutations()\n\n return result\n}\n\nlet isCollecting = false\nlet deferredMutations = []\n\nexport function deferMutations() {\n isCollecting = true\n}\n\nexport function flushAndStopDeferringMutations() {\n isCollecting = false\n\n onMutate(deferredMutations)\n\n deferredMutations = []\n}\n\nfunction onMutate(mutations) {\n if (isCollecting) {\n deferredMutations = deferredMutations.concat(mutations)\n\n return\n }\n\n let addedNodes = []\n let removedNodes = new Set\n let addedAttributes = new Map\n let removedAttributes = new Map\n\n for (let i = 0; i < mutations.length; i++) {\n if (mutations[i].target._x_ignoreMutationObserver) continue\n\n if (mutations[i].type === 'childList') {\n mutations[i].removedNodes.forEach(node => {\n if (node.nodeType !== 1) return\n\n // No need to process removed nodes that haven't been initialized by Alpine...\n if (! node._x_marker) return\n\n removedNodes.add(node)\n })\n\n mutations[i].addedNodes.forEach(node => {\n if (node.nodeType !== 1) return\n\n // If the node is a removal as well, that means it's a \"move\" operation and we'll leave it alone...\n if (removedNodes.has(node)) {\n removedNodes.delete(node)\n\n return\n }\n\n // If the node has already been initialized, we'll leave it alone...\n if (node._x_marker) return;\n\n addedNodes.push(node)\n })\n }\n\n if (mutations[i].type === 'attributes') {\n let el = mutations[i].target\n let name = mutations[i].attributeName\n let oldValue = mutations[i].oldValue\n\n let add = () => {\n if (! addedAttributes.has(el)) addedAttributes.set(el, [])\n\n addedAttributes.get(el).push({ name, value: el.getAttribute(name) })\n }\n\n let remove = () => {\n if (! removedAttributes.has(el)) removedAttributes.set(el, [])\n\n removedAttributes.get(el).push(name)\n }\n\n // New attribute.\n if (el.hasAttribute(name) && oldValue === null) {\n add()\n // Changed attribute.\n } else if (el.hasAttribute(name)) {\n remove()\n add()\n // Removed attribute.\n } else {\n remove()\n }\n }\n }\n\n removedAttributes.forEach((attrs, el) => {\n cleanupAttributes(el, attrs)\n })\n\n addedAttributes.forEach((attrs, el) => {\n onAttributeAddeds.forEach(i => i(el, attrs))\n })\n\n // There are two special scenarios we need to account for when using the mutation\n // observer to init and destroy elements. First, when a node is \"moved\" on the page,\n // it's registered as both an \"add\" and a \"remove\", so we want to skip those.\n // (This is handled above by the ._x_marker conditionals...)\n // Second, when a node is \"wrapped\", it gets registered as a \"removal\" and the wrapper\n // as an \"addition\". We don't want to remove, then re-initialize the node, so we look\n // and see if it's inside any added nodes (wrappers) and skip it.\n // (This is handled below by the .contains conditional...)\n\n for (let node of removedNodes) {\n if (addedNodes.some(i => i.contains(node))) continue\n\n onElRemoveds.forEach(i => i(node))\n }\n\n for (let node of addedNodes) {\n if (! node.isConnected) continue\n\n onElAddeds.forEach(i => i(node))\n }\n\n addedNodes = null\n removedNodes = null\n addedAttributes = null\n removedAttributes = null\n}\n", "\nexport function scope(node) {\n return mergeProxies(closestDataStack(node))\n}\n\nexport function addScopeToNode(node, data, referenceNode) {\n node._x_dataStack = [data, ...closestDataStack(referenceNode || node)]\n\n return () => {\n node._x_dataStack = node._x_dataStack.filter(i => i !== data)\n }\n}\n\nexport function hasScope(node) {\n return !! node._x_dataStack\n}\n\nexport function closestDataStack(node) {\n if (node._x_dataStack) return node._x_dataStack\n\n if (typeof ShadowRoot === 'function' && node instanceof ShadowRoot) {\n return closestDataStack(node.host)\n }\n\n if (! node.parentNode) {\n return []\n }\n\n return closestDataStack(node.parentNode)\n}\n\nexport function closestDataProxy(el) {\n return mergeProxies(closestDataStack(el))\n}\n\nexport function mergeProxies (objects) {\n return new Proxy({ objects }, mergeProxyTrap);\n}\n\nlet mergeProxyTrap = {\n ownKeys({ objects }) {\n return Array.from(\n new Set(objects.flatMap((i) => Object.keys(i)))\n )\n },\n\n has({ objects }, name) {\n if (name == Symbol.unscopables) return false;\n\n return objects.some((obj) =>\n Object.prototype.hasOwnProperty.call(obj, name) ||\n Reflect.has(obj, name)\n );\n },\n\n get({ objects }, name, thisProxy) {\n if (name == \"toJSON\") return collapseProxies\n\n return Reflect.get(\n objects.find((obj) =>\n Reflect.has(obj, name)\n ) || {},\n name,\n thisProxy\n )\n },\n\n set({ objects }, name, value, thisProxy) {\n const target =\n objects.find((obj) =>\n Object.prototype.hasOwnProperty.call(obj, name)\n ) || objects[objects.length - 1];\n const descriptor = Object.getOwnPropertyDescriptor(target, name);\n if (descriptor?.set && descriptor?.get)\n // Can't use Reflect.set here due to [upstream bug](https://github.com/vuejs/core/blob/31abdc8adad569d83b476c340e678c4daa901545/packages/reactivity/src/baseHandlers.ts#L148) in @vue/reactivity\n return descriptor.set.call(thisProxy, value) || true;\n return Reflect.set(target, name, value);\n },\n}\n\nfunction collapseProxies() {\n let keys = Reflect.ownKeys(this)\n\n return keys.reduce((acc, key) => {\n acc[key] = Reflect.get(this, key)\n\n return acc;\n }, {})\n}\n", "// Warning: The concept of \"interceptors\" in Alpine is not public API and is subject to change\n// without tagging a major release.\n\nexport function initInterceptors(data) {\n let isObject = val => typeof val === 'object' && !Array.isArray(val) && val !== null\n\n let recurse = (obj, basePath = '') => {\n Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {\n // Skip getters.\n if (enumerable === false || value === undefined) return\n if (typeof value === 'object' && value !== null && value.__v_skip) return\n\n let path = basePath === '' ? key : `${basePath}.${key}`\n\n if (typeof value === 'object' && value !== null && value._x_interceptor) {\n obj[key] = value.initialize(data, path, key)\n } else {\n if (isObject(value) && value !== obj && ! (value instanceof Element)) {\n recurse(value, path)\n }\n }\n })\n }\n\n return recurse(data)\n}\n\nexport function interceptor(callback, mutateObj = () => {}) {\n let obj = {\n initialValue: undefined,\n\n _x_interceptor: true,\n\n initialize(data, path, key) {\n return callback(this.initialValue, () => get(data, path), (value) => set(data, path, value), path, key)\n }\n }\n\n mutateObj(obj)\n\n return initialValue => {\n if (typeof initialValue === 'object' && initialValue !== null && initialValue._x_interceptor) {\n // Support nesting interceptors.\n let initialize = obj.initialize.bind(obj)\n\n obj.initialize = (data, path, key) => {\n let innerValue = initialValue.initialize(data, path, key)\n\n obj.initialValue = innerValue\n\n return initialize(data, path, key)\n }\n } else {\n obj.initialValue = initialValue\n }\n\n return obj\n }\n}\n\nfunction get(obj, path) {\n return path.split('.').reduce((carry, segment) => carry[segment], obj)\n}\n\nfunction set(obj, path, value) {\n if (typeof path === 'string') path = path.split('.')\n\n if (path.length === 1) obj[path[0]] = value;\n else if (path.length === 0) throw error;\n else {\n if (obj[path[0]])\n return set(obj[path[0]], path.slice(1), value);\n else {\n obj[path[0]] = {};\n return set(obj[path[0]], path.slice(1), value);\n }\n }\n}\n", "import { getElementBoundUtilities } from './directives'\nimport { interceptor } from './interceptor'\nimport { onElRemoved } from './mutation'\n\nlet magics = {}\n\nexport function magic(name, callback) {\n magics[name] = callback\n}\n\nexport function injectMagics(obj, el) {\n let memoizedUtilities = getUtilities(el)\n\n Object.entries(magics).forEach(([name, callback]) => {\n Object.defineProperty(obj, `$${name}`, {\n get() {\n return callback(el, memoizedUtilities);\n },\n enumerable: false,\n })\n })\n\n return obj\n}\n\nexport function getUtilities(el) {\n let [utilities, cleanup] = getElementBoundUtilities(el)\n\n let utils = { interceptor, ...utilities }\n\n onElRemoved(el, cleanup)\n\n return utils;\n}\n", "export function tryCatch(el, expression, callback, ...args) {\n try {\n return callback(...args)\n } catch (e) {\n handleError( e, el, expression )\n }\n}\n\nexport function handleError(error , el, expression = undefined) {\n error = Object.assign( \n error ?? { message: 'No error message given.' }, \n { el, expression } )\n\n console.warn(`Alpine Expression Error: ${error.message}\\n\\n${ expression ? 'Expression: \\\"' + expression + '\\\"\\n\\n' : '' }`, el)\n\n setTimeout( () => { throw error }, 0 )\n}\n", "import { closestDataStack, mergeProxies } from './scope'\nimport { injectMagics } from './magics'\nimport { tryCatch, handleError } from './utils/error'\n\nlet shouldAutoEvaluateFunctions = true\n\nexport function dontAutoEvaluateFunctions(callback) {\n let cache = shouldAutoEvaluateFunctions\n\n shouldAutoEvaluateFunctions = false\n\n let result = callback()\n\n shouldAutoEvaluateFunctions = cache\n\n return result\n}\n\nexport function evaluate(el, expression, extras = {}) {\n let result\n\n evaluateLater(el, expression)(value => result = value, extras)\n\n return result\n}\n\nexport function evaluateLater(...args) {\n return theEvaluatorFunction(...args)\n}\n\nlet theEvaluatorFunction = normalEvaluator\n\nexport function setEvaluator(newEvaluator) {\n theEvaluatorFunction = newEvaluator\n}\n\nexport function normalEvaluator(el, expression) {\n let overriddenMagics = {}\n\n injectMagics(overriddenMagics, el)\n\n let dataStack = [overriddenMagics, ...closestDataStack(el)]\n\n let evaluator = (typeof expression === 'function')\n ? generateEvaluatorFromFunction(dataStack, expression)\n : generateEvaluatorFromString(dataStack, expression, el)\n\n return tryCatch.bind(null, el, expression, evaluator)\n}\n\nexport function generateEvaluatorFromFunction(dataStack, func) {\n return (receiver = () => {}, { scope = {}, params = [] } = {}) => {\n let result = func.apply(mergeProxies([scope, ...dataStack]), params)\n\n runIfTypeOfFunction(receiver, result)\n }\n}\n\nlet evaluatorMemo = {}\n\nfunction generateFunctionFromString(expression, el) {\n if (evaluatorMemo[expression]) {\n return evaluatorMemo[expression]\n }\n\n let AsyncFunction = Object.getPrototypeOf(async function(){}).constructor\n\n // Some expressions that are useful in Alpine are not valid as the right side of an expression.\n // Here we'll detect if the expression isn't valid for an assignment and wrap it in a self-\n // calling function so that we don't throw an error AND a \"return\" statement can b e used.\n let rightSideSafeExpression = 0\n // Support expressions starting with \"if\" statements like: \"if (...) doSomething()\"\n || /^[\\n\\s]*if.*\\(.*\\)/.test(expression.trim())\n // Support expressions starting with \"let/const\" like: \"let foo = 'bar'\"\n || /^(let|const)\\s/.test(expression.trim())\n ? `(async()=>{ ${expression} })()`\n : expression\n\n const safeAsyncFunction = () => {\n try {\n let func = new AsyncFunction(\n [\"__self\", \"scope\"],\n `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`\n )\n \n Object.defineProperty(func, \"name\", {\n value: `[Alpine] ${expression}`,\n })\n \n return func\n } catch ( error ) {\n handleError( error, el, expression )\n return Promise.resolve()\n }\n }\n let func = safeAsyncFunction()\n\n evaluatorMemo[expression] = func\n\n return func\n}\n\nfunction generateEvaluatorFromString(dataStack, expression, el) {\n let func = generateFunctionFromString(expression, el)\n\n return (receiver = () => {}, { scope = {}, params = [] } = {}) => {\n func.result = undefined\n func.finished = false\n\n // Run the function.\n\n let completeScope = mergeProxies([ scope, ...dataStack ])\n\n if (typeof func === 'function' ) {\n let promise = func(func, completeScope).catch((error) => handleError(error, el, expression))\n\n // Check if the function ran synchronously,\n if (func.finished) {\n // Return the immediate result.\n runIfTypeOfFunction(receiver, func.result, completeScope, params, el)\n // Once the function has run, we clear func.result so we don't create\n // memory leaks. func is stored in the evaluatorMemo and every time\n // it runs, it assigns the evaluated expression to result which could\n // potentially store a reference to the DOM element that will be removed later on.\n func.result = undefined\n } else {\n // If not, return the result when the promise resolves.\n promise.then(result => {\n runIfTypeOfFunction(receiver, result, completeScope, params, el)\n }).catch( error => handleError( error, el, expression ) )\n .finally( () => func.result = undefined )\n }\n }\n }\n}\n\nexport function runIfTypeOfFunction(receiver, value, scope, params, el) {\n if (shouldAutoEvaluateFunctions && typeof value === 'function') {\n let result = value.apply(scope, params)\n\n if (result instanceof Promise) {\n result.then(i => runIfTypeOfFunction(receiver, i, scope, params)).catch( error => handleError( error, el, value ) )\n } else {\n receiver(result)\n }\n } else if (typeof value === 'object' && value instanceof Promise) {\n value.then(i => receiver(i))\n } else {\n receiver(value)\n }\n}\n", "import { onAttributeRemoved, onElRemoved } from './mutation'\nimport { evaluate, evaluateLater } from './evaluator'\nimport { elementBoundEffect } from './reactivity'\nimport Alpine from './alpine'\n\nlet prefixAsString = 'x-'\n\nexport function prefix(subject = '') {\n return prefixAsString + subject\n}\n\nexport function setPrefix(newPrefix) {\n prefixAsString = newPrefix\n}\n\nlet directiveHandlers = {}\n\nexport function directive(name, callback) {\n directiveHandlers[name] = callback\n\n return {\n before(directive) {\n if (!directiveHandlers[directive]) {\n console.warn(String.raw`Cannot find directive \\`${directive}\\`. \\`${name}\\` will use the default order of execution`);\n return;\n }\n const pos = directiveOrder.indexOf(directive);\n directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf('DEFAULT'), 0, name);\n }\n }\n}\n\nexport function directiveExists(name) {\n return Object.keys(directiveHandlers).includes(name)\n}\n\nexport function directives(el, attributes, originalAttributeOverride) {\n attributes = Array.from(attributes)\n\n if (el._x_virtualDirectives) {\n let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }))\n\n let staticAttributes = attributesOnly(vAttributes)\n\n // Handle binding normal HTML attributes (non-Alpine directives).\n vAttributes = vAttributes.map(attribute => {\n if (staticAttributes.find(attr => attr.name === attribute.name)) {\n return {\n name: `x-bind:${attribute.name}`,\n value: `\"${attribute.value}\"`,\n }\n }\n\n return attribute\n })\n\n attributes = attributes.concat(vAttributes)\n }\n\n let transformedAttributeMap = {}\n\n let directives = attributes\n .map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName))\n .filter(outNonAlpineAttributes)\n .map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride))\n .sort(byPriority)\n\n return directives.map(directive => {\n return getDirectiveHandler(el, directive)\n })\n}\n\nexport function attributesOnly(attributes) {\n return Array.from(attributes)\n .map(toTransformedAttributes())\n .filter(attr => ! outNonAlpineAttributes(attr))\n}\n\nlet isDeferringHandlers = false\nlet directiveHandlerStacks = new Map\nlet currentHandlerStackKey = Symbol()\n\nexport function deferHandlingDirectives(callback) {\n isDeferringHandlers = true\n\n let key = Symbol()\n\n currentHandlerStackKey = key\n\n directiveHandlerStacks.set(key, [])\n\n let flushHandlers = () => {\n while (directiveHandlerStacks.get(key).length) directiveHandlerStacks.get(key).shift()()\n\n directiveHandlerStacks.delete(key)\n }\n\n let stopDeferring = () => { isDeferringHandlers = false; flushHandlers() }\n\n callback(flushHandlers)\n\n stopDeferring()\n}\n\nexport function getElementBoundUtilities(el) {\n let cleanups = []\n\n let cleanup = callback => cleanups.push(callback)\n\n let [effect, cleanupEffect] = elementBoundEffect(el)\n\n cleanups.push(cleanupEffect)\n\n let utilities = {\n Alpine,\n effect,\n cleanup,\n evaluateLater: evaluateLater.bind(evaluateLater, el),\n evaluate: evaluate.bind(evaluate, el),\n }\n\n let doCleanup = () => cleanups.forEach(i => i())\n\n return [utilities, doCleanup]\n}\n\nexport function getDirectiveHandler(el, directive) {\n let noop = () => {}\n\n let handler = directiveHandlers[directive.type] || noop\n\n let [utilities, cleanup] = getElementBoundUtilities(el)\n\n onAttributeRemoved(el, directive.original, cleanup)\n\n let fullHandler = () => {\n if (el._x_ignore || el._x_ignoreSelf) return\n\n handler.inline && handler.inline(el, directive, utilities)\n\n handler = handler.bind(handler, el, directive, utilities)\n\n isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler) : handler()\n }\n\n fullHandler.runCleanups = cleanup\n\n return fullHandler\n}\n\nexport let startingWith = (subject, replacement) => ({ name, value }) => {\n if (name.startsWith(subject)) name = name.replace(subject, replacement)\n\n return { name, value }\n}\n\nexport let into = i => i\n\nfunction toTransformedAttributes(callback = () => {}) {\n return ({ name, value }) => {\n let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {\n return transform(carry)\n }, { name, value })\n\n if (newName !== name) callback(newName, name)\n\n return { name: newName, value: newValue }\n }\n}\n\nlet attributeTransformers = []\n\nexport function mapAttributes(callback) {\n attributeTransformers.push(callback)\n}\n\nfunction outNonAlpineAttributes({ name }) {\n return alpineAttributeRegex().test(name)\n}\n\nlet alpineAttributeRegex = () => (new RegExp(`^${prefixAsString}([^:^.]+)\\\\b`))\n\nfunction toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {\n return ({ name, value }) => {\n let typeMatch = name.match(alpineAttributeRegex())\n let valueMatch = name.match(/:([a-zA-Z0-9\\-_:]+)/)\n let modifiers = name.match(/\\.[^.\\]]+(?=[^\\]]*$)/g) || []\n let original = originalAttributeOverride || transformedAttributeMap[name] || name\n\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 original,\n }\n }\n}\n\nconst DEFAULT = 'DEFAULT'\n\nlet directiveOrder = [\n 'ignore',\n 'ref',\n 'data',\n 'id',\n 'anchor',\n 'bind',\n 'init',\n 'for',\n 'model',\n 'modelable',\n 'transition',\n 'show',\n 'if',\n DEFAULT,\n 'teleport',\n]\n\nfunction byPriority(a, b) {\n let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type\n let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type\n\n return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB)\n}\n", "\nexport function dispatch(el, name, detail = {}) {\n el.dispatchEvent(\n new CustomEvent(name, {\n detail,\n bubbles: true,\n // Allows events to pass the shadow DOM barrier.\n composed: true,\n cancelable: true,\n })\n )\n}\n", "export function walk(el, callback) {\n if (typeof ShadowRoot === 'function' && el instanceof ShadowRoot) {\n Array.from(el.children).forEach(el => walk(el, callback))\n\n return\n }\n\n let skip = false\n\n callback(el, () => skip = true)\n\n if (skip) return\n\n let node = el.firstElementChild\n\n while (node) {\n walk(node, callback, false)\n\n node = node.nextElementSibling\n }\n}\n", "\nexport function warn(message, ...args) {\n console.warn(`Alpine Warning: ${message}`, ...args)\n}\n", "import { startObservingMutations, onAttributesAdded, onElAdded, onElRemoved, cleanupAttributes, cleanupElement } from \"./mutation\"\nimport { deferHandlingDirectives, directiveExists, directives } from \"./directives\"\nimport { dispatch } from './utils/dispatch'\nimport { walk } from \"./utils/walk\"\nimport { warn } from './utils/warn'\n\nlet started = false\n\nexport function start() {\n if (started) warn('Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.')\n\n started = true\n\n if (! document.body) warn('Unable to initialize. Trying to load Alpine before `
` is available. Did you forget to add `defer` in Alpine\\'s `