Your IP : 216.73.216.79
//#region node_modules/alpinejs/dist/module.esm.js
var flushPending = false;
var flushing = false;
var queue = [];
var lastFlushedIndex = -1;
var transactionActive = false;
function scheduler(callback) {
queueJob(callback);
}
function startTransaction() {
transactionActive = true;
}
function commitTransaction() {
transactionActive = false;
queueFlush();
}
function queueJob(job) {
if (!queue.includes(job)) queue.push(job);
queueFlush();
}
function dequeueJob(job) {
let index = queue.indexOf(job);
if (index !== -1 && index > lastFlushedIndex) queue.splice(index, 1);
}
function queueFlush() {
if (!flushing && !flushPending) {
if (transactionActive) return;
flushPending = true;
queueMicrotask(flushJobs);
}
}
function flushJobs() {
flushPending = false;
flushing = true;
for (let i = 0; i < queue.length; i++) {
queue[i]();
lastFlushedIndex = i;
}
queue.length = 0;
lastFlushedIndex = -1;
flushing = false;
}
var reactive;
var effect;
var release;
var raw;
var shouldSchedule = true;
function disableEffectScheduling(callback) {
shouldSchedule = false;
callback();
shouldSchedule = true;
}
function setReactivityEngine(engine) {
reactive = engine.reactive;
release = engine.release;
effect = (callback) => engine.effect(callback, { scheduler: (task) => {
if (shouldSchedule) scheduler(task);
else task();
} });
raw = engine.raw;
}
function overrideEffect(override) {
effect = override;
}
function elementBoundEffect(el) {
let cleanup2 = () => {};
let wrappedEffect = (callback) => {
let effectReference = effect(callback);
if (!el._x_effects) {
el._x_effects = /* @__PURE__ */ new Set();
el._x_runEffects = () => {
el._x_effects.forEach((i) => i());
};
}
el._x_effects.add(effectReference);
cleanup2 = () => {
if (effectReference === void 0) return;
el._x_effects.delete(effectReference);
release(effectReference);
};
return effectReference;
};
return [wrappedEffect, () => {
cleanup2();
}];
}
function watch(getter, callback) {
let firstTime = true;
let oldValue;
let oldValueJSON;
let effectReference = effect(() => {
let value = getter();
let newJSON = JSON.stringify(value);
if (!firstTime) {
if (typeof value === "object" || value !== oldValue) {
let previousValue = typeof oldValue === "object" ? JSON.parse(oldValueJSON) : oldValue;
queueMicrotask(() => {
callback(value, previousValue);
});
}
}
oldValue = value;
oldValueJSON = newJSON;
firstTime = false;
});
return () => release(effectReference);
}
async function transaction(callback) {
startTransaction();
try {
await callback();
await Promise.resolve();
} finally {
commitTransaction();
}
}
var onAttributeAddeds = [];
var onElRemoveds = [];
var onElAddeds = [];
function onElAdded(callback) {
onElAddeds.push(callback);
}
function onElRemoved(el, callback) {
if (typeof callback === "function") {
if (!el._x_cleanups) el._x_cleanups = [];
el._x_cleanups.push(callback);
} else {
callback = el;
onElRemoveds.push(callback);
}
}
function onAttributesAdded(callback) {
onAttributeAddeds.push(callback);
}
function onAttributeRemoved(el, name, callback) {
if (!el._x_attributeCleanups) el._x_attributeCleanups = {};
if (!el._x_attributeCleanups[name]) el._x_attributeCleanups[name] = [];
el._x_attributeCleanups[name].push(callback);
}
function cleanupAttributes(el, names) {
if (!el._x_attributeCleanups) return;
Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
if (names === void 0 || names.includes(name)) {
value.forEach((i) => i());
delete el._x_attributeCleanups[name];
}
});
}
function cleanupElement(el) {
el._x_effects?.forEach(dequeueJob);
while (el._x_cleanups?.length) el._x_cleanups.pop()();
}
var observer = new MutationObserver(onMutate);
var currentlyObserving = false;
function startObservingMutations() {
observer.observe(document, {
subtree: true,
childList: true,
attributes: true,
attributeOldValue: true
});
currentlyObserving = true;
}
function stopObservingMutations() {
flushObserver();
observer.disconnect();
currentlyObserving = false;
}
var queuedMutations = [];
function flushObserver() {
let records = observer.takeRecords();
queuedMutations.push(() => records.length > 0 && onMutate(records));
let queueLengthWhenTriggered = queuedMutations.length;
queueMicrotask(() => {
if (queuedMutations.length === queueLengthWhenTriggered) while (queuedMutations.length > 0) queuedMutations.shift()();
});
}
function mutateDom(callback) {
if (!currentlyObserving) return callback();
stopObservingMutations();
let result = callback();
startObservingMutations();
return result;
}
var isCollecting = false;
var deferredMutations = [];
function deferMutations() {
isCollecting = true;
}
function flushAndStopDeferringMutations() {
isCollecting = false;
onMutate(deferredMutations);
deferredMutations = [];
}
function onMutate(mutations) {
if (isCollecting) {
deferredMutations = deferredMutations.concat(mutations);
return;
}
let addedNodes = [];
let removedNodes = /* @__PURE__ */ new Set();
let addedAttributes = /* @__PURE__ */ new Map();
let removedAttributes = /* @__PURE__ */ new Map();
for (let i = 0; i < mutations.length; i++) {
if (mutations[i].target._x_ignoreMutationObserver) continue;
if (mutations[i].type === "childList") {
mutations[i].removedNodes.forEach((node) => {
if (node.nodeType !== 1) return;
if (!node._x_marker) return;
removedNodes.add(node);
});
mutations[i].addedNodes.forEach((node) => {
if (node.nodeType !== 1) return;
if (removedNodes.has(node)) {
removedNodes.delete(node);
return;
}
if (node._x_marker) return;
addedNodes.push(node);
});
}
if (mutations[i].type === "attributes") {
let el = mutations[i].target;
let name = mutations[i].attributeName;
let oldValue = mutations[i].oldValue;
let add2 = () => {
if (!addedAttributes.has(el)) addedAttributes.set(el, []);
addedAttributes.get(el).push({
name,
value: el.getAttribute(name)
});
};
let remove = () => {
if (!removedAttributes.has(el)) removedAttributes.set(el, []);
removedAttributes.get(el).push(name);
};
if (el.hasAttribute(name) && oldValue === null) add2();
else if (el.hasAttribute(name)) {
remove();
add2();
} else remove();
}
}
removedAttributes.forEach((attrs, el) => {
cleanupAttributes(el, attrs);
});
addedAttributes.forEach((attrs, el) => {
onAttributeAddeds.forEach((i) => i(el, attrs));
});
for (let node of removedNodes) {
if (addedNodes.some((i) => i.contains(node))) continue;
onElRemoveds.forEach((i) => i(node));
}
for (let node of addedNodes) {
if (!node.isConnected) continue;
onElAddeds.forEach((i) => i(node));
}
addedNodes = null;
removedNodes = null;
addedAttributes = null;
removedAttributes = null;
}
function scope(node) {
return mergeProxies(closestDataStack(node));
}
function addScopeToNode(node, data2, referenceNode) {
node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
return () => {
node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
};
}
function closestDataStack(node) {
if (node._x_dataStack) return node._x_dataStack;
if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) return closestDataStack(node.host);
if (!node.parentNode) return [];
return closestDataStack(node.parentNode);
}
function mergeProxies(objects) {
return new Proxy({ objects }, mergeProxyTrap);
}
function keyInPrototypeChain(obj, key) {
if (obj === null || obj === Object.prototype) return null;
if (Object.prototype.hasOwnProperty.call(obj, key)) return obj;
return keyInPrototypeChain(Object.getPrototypeOf(obj), key);
}
var mergeProxyTrap = {
ownKeys({ objects }) {
return Array.from(new Set(objects.flatMap((i) => Object.keys(i))));
},
has({ objects }, name) {
if (name == Symbol.unscopables) return false;
return objects.some((obj) => Object.prototype.hasOwnProperty.call(obj, name) || Reflect.has(obj, name));
},
get({ objects }, name, thisProxy) {
if (name == "toJSON") return collapseProxies;
return Reflect.get(objects.find((obj) => Reflect.has(obj, name)) || {}, name, thisProxy);
},
set({ objects }, name, value, thisProxy) {
let target;
for (const obj of objects) {
target = keyInPrototypeChain(obj, name);
if (target) break;
}
if (!target) target = objects[objects.length - 1];
const descriptor = Object.getOwnPropertyDescriptor(target, name);
if (descriptor?.set && descriptor?.get) return descriptor.set.call(thisProxy, value) || true;
return Reflect.set(target, name, value);
}
};
function collapseProxies() {
return Reflect.ownKeys(this).reduce((acc, key) => {
acc[key] = Reflect.get(this, key);
return acc;
}, {});
}
function initInterceptors(data2) {
let isObject3 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
let recurse = (obj, basePath = "") => {
Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {
if (enumerable === false || value === void 0) return;
if (typeof value === "object" && value !== null && value.__v_skip) return;
let path = basePath === "" ? key : `${basePath}.${key}`;
if (typeof value === "object" && value !== null && value._x_interceptor) obj[key] = value.initialize(data2, path, key);
else if (isObject3(value) && value !== obj && !(value instanceof Element)) recurse(value, path);
});
};
return recurse(data2);
}
function interceptor(callback, mutateObj = () => {}) {
let obj = {
initialValue: void 0,
_x_interceptor: true,
initialize(data2, path, key) {
return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
}
};
mutateObj(obj);
return (initialValue) => {
if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
let initialize = obj.initialize.bind(obj);
obj.initialize = (data2, path, key) => {
obj.initialValue = initialValue.initialize(data2, path, key);
return initialize(data2, path, key);
};
} else obj.initialValue = initialValue;
return obj;
};
}
function get(obj, path) {
return path.split(".").reduce((carry, segment) => carry[segment], obj);
}
function set(obj, path, value) {
if (typeof path === "string") path = path.split(".");
if (path.length === 1) obj[path[0]] = value;
else if (path.length === 0) throw error;
else if (obj[path[0]]) return set(obj[path[0]], path.slice(1), value);
else {
obj[path[0]] = {};
return set(obj[path[0]], path.slice(1), value);
}
}
var magics = {};
function magic(name, callback) {
magics[name] = callback;
}
function injectMagics(obj, el) {
let memoizedUtilities = getUtilities(el);
Object.entries(magics).forEach(([name, callback]) => {
Object.defineProperty(obj, `$${name}`, {
get() {
return callback(el, memoizedUtilities);
},
enumerable: false
});
});
return obj;
}
function getUtilities(el) {
let [utilities, cleanup2] = getElementBoundUtilities(el);
let utils = {
interceptor,
...utilities
};
onElRemoved(el, cleanup2);
return utils;
}
function tryCatch(el, expression, callback, ...args) {
try {
return callback(...args);
} catch (e) {
handleError(e, el, expression);
}
}
function handleError(...args) {
return errorHandler(...args);
}
var errorHandler = normalErrorHandler;
function setErrorHandler(handler4) {
errorHandler = handler4;
}
function normalErrorHandler(error2, el, expression = void 0) {
error2 = Object.assign(error2 ?? { message: "No error message given." }, {
el,
expression
});
console.warn(`Alpine Expression Error: ${error2.message}
${expression ? "Expression: \"" + expression + "\"\n\n" : ""}`, el);
setTimeout(() => {
throw error2;
}, 0);
}
var shouldAutoEvaluateFunctions = true;
function dontAutoEvaluateFunctions(callback) {
let cache = shouldAutoEvaluateFunctions;
shouldAutoEvaluateFunctions = false;
let result = callback();
shouldAutoEvaluateFunctions = cache;
return result;
}
function evaluate(el, expression, extras = {}) {
let result;
evaluateLater(el, expression)((value) => result = value, extras);
return result;
}
function evaluateLater(...args) {
return theEvaluatorFunction(...args);
}
var theEvaluatorFunction = () => {};
function setEvaluator(newEvaluator) {
theEvaluatorFunction = newEvaluator;
}
var theRawEvaluatorFunction;
function setRawEvaluator(newEvaluator) {
theRawEvaluatorFunction = newEvaluator;
}
function normalEvaluator(el, expression) {
let overriddenMagics = {};
injectMagics(overriddenMagics, el);
let dataStack = [overriddenMagics, ...closestDataStack(el)];
let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
return tryCatch.bind(null, el, expression, evaluator);
}
function generateEvaluatorFromFunction(dataStack, func) {
return (receiver = () => {}, { scope: scope2 = {}, params = [], context } = {}) => {
if (!shouldAutoEvaluateFunctions) {
runIfTypeOfFunction(receiver, func, mergeProxies([scope2, ...dataStack]), params);
return;
}
runIfTypeOfFunction(receiver, func.apply(mergeProxies([scope2, ...dataStack]), params));
};
}
var evaluatorMemo = {};
function generateFunctionFromString(expression, el) {
if (evaluatorMemo[expression]) return evaluatorMemo[expression];
let AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
const safeAsyncFunction = () => {
try {
let func2 = new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`);
Object.defineProperty(func2, "name", { value: `[Alpine] ${expression}` });
return func2;
} catch (error2) {
handleError(error2, el, expression);
return Promise.resolve();
}
};
let func = safeAsyncFunction();
evaluatorMemo[expression] = func;
return func;
}
function generateEvaluatorFromString(dataStack, expression, el) {
let func = generateFunctionFromString(expression, el);
return (receiver = () => {}, { scope: scope2 = {}, params = [], context } = {}) => {
func.result = void 0;
func.finished = false;
let completeScope = mergeProxies([scope2, ...dataStack]);
if (typeof func === "function") {
let promise = func.call(context, func, completeScope).catch((error2) => handleError(error2, el, expression));
if (func.finished) {
runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
func.result = void 0;
} else promise.then((result) => {
runIfTypeOfFunction(receiver, result, completeScope, params, el);
}).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
}
};
}
function runIfTypeOfFunction(receiver, value, scope2, params, el) {
if (shouldAutoEvaluateFunctions && typeof value === "function") {
let result = value.apply(scope2, params);
if (result instanceof Promise) result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
else receiver(result);
} else if (typeof value === "object" && value instanceof Promise) value.then((i) => receiver(i));
else receiver(value);
}
function evaluateRaw(...args) {
return theRawEvaluatorFunction(...args);
}
function normalRawEvaluator(el, expression, extras = {}) {
let overriddenMagics = {};
injectMagics(overriddenMagics, el);
let dataStack = [overriddenMagics, ...closestDataStack(el)];
let scope2 = mergeProxies([extras.scope ?? {}, ...dataStack]);
let params = extras.params ?? [];
if (expression.includes("await")) {
let AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
return new AsyncFunction(["scope"], `with (scope) { let __result = ${/^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression}; return __result }`).call(extras.context, scope2);
} else {
let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(()=>{ ${expression} })()` : expression;
let result = new Function(["scope"], `with (scope) { let __result = ${rightSideSafeExpression}; return __result }`).call(extras.context, scope2);
if (typeof result === "function" && shouldAutoEvaluateFunctions) return result.apply(scope2, params);
return result;
}
}
var prefixAsString = "x-";
function prefix(subject = "") {
return prefixAsString + subject;
}
function setPrefix(newPrefix) {
prefixAsString = newPrefix;
}
var directiveHandlers = {};
function directive(name, callback) {
directiveHandlers[name] = callback;
return { before(directive2) {
if (!directiveHandlers[directive2]) {
console.warn(String.raw`Cannot find directive \`${directive2}\`. \`${name}\` will use the default order of execution`);
return;
}
const pos = directiveOrder.indexOf(directive2);
directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
} };
}
function directiveExists(name) {
return Object.keys(directiveHandlers).includes(name);
}
function directives(el, attributes, originalAttributeOverride) {
attributes = Array.from(attributes);
if (el._x_virtualDirectives) {
let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({
name,
value
}));
let staticAttributes = attributesOnly(vAttributes);
vAttributes = vAttributes.map((attribute) => {
if (staticAttributes.find((attr) => attr.name === attribute.name)) return {
name: `x-bind:${attribute.name}`,
value: `"${attribute.value}"`
};
return attribute;
});
attributes = attributes.concat(vAttributes);
}
let transformedAttributeMap = {};
return attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority).map((directive2) => {
return getDirectiveHandler(el, directive2);
});
}
function attributesOnly(attributes) {
return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
}
var isDeferringHandlers = false;
var directiveHandlerStacks = /* @__PURE__ */ new Map();
var currentHandlerStackKey = Symbol();
function deferHandlingDirectives(callback) {
isDeferringHandlers = true;
let key = Symbol();
currentHandlerStackKey = key;
directiveHandlerStacks.set(key, []);
let flushHandlers = () => {
while (directiveHandlerStacks.get(key).length) directiveHandlerStacks.get(key).shift()();
directiveHandlerStacks.delete(key);
};
let stopDeferring = () => {
isDeferringHandlers = false;
flushHandlers();
};
callback(flushHandlers);
stopDeferring();
}
function getElementBoundUtilities(el) {
let cleanups = [];
let cleanup2 = (callback) => cleanups.push(callback);
let [effect3, cleanupEffect] = elementBoundEffect(el);
cleanups.push(cleanupEffect);
let utilities = {
Alpine: alpine_default,
effect: effect3,
cleanup: cleanup2,
evaluateLater: evaluateLater.bind(evaluateLater, el),
evaluate: evaluate.bind(evaluate, el)
};
let doCleanup = () => cleanups.forEach((i) => i());
return [utilities, doCleanup];
}
function getDirectiveHandler(el, directive2) {
let noop = () => {};
let handler4 = directiveHandlers[directive2.type] || noop;
let [utilities, cleanup2] = getElementBoundUtilities(el);
onAttributeRemoved(el, directive2.original, cleanup2);
let fullHandler = () => {
if (el._x_ignore || el._x_ignoreSelf) return;
handler4.inline && handler4.inline(el, directive2, utilities);
handler4 = handler4.bind(handler4, el, directive2, utilities);
isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
};
fullHandler.runCleanups = cleanup2;
return fullHandler;
}
var startingWith = (subject, replacement) => ({ name, value }) => {
if (name.startsWith(subject)) name = name.replace(subject, replacement);
return {
name,
value
};
};
var into = (i) => i;
function toTransformedAttributes(callback = () => {}) {
return ({ name, value }) => {
let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
return transform(carry);
}, {
name,
value
});
if (newName !== name) callback(newName, name);
return {
name: newName,
value: newValue
};
};
}
var attributeTransformers = [];
function mapAttributes(callback) {
attributeTransformers.push(callback);
}
function outNonAlpineAttributes({ name }) {
return alpineAttributeRegex().test(name);
}
var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
return ({ name, value }) => {
if (name === value) value = "";
let typeMatch = name.match(alpineAttributeRegex());
let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
let original = originalAttributeOverride || transformedAttributeMap[name] || name;
return {
type: typeMatch ? typeMatch[1] : null,
value: valueMatch ? valueMatch[1] : null,
modifiers: modifiers.map((i) => i.replace(".", "")),
expression: value,
original
};
};
}
var DEFAULT = "DEFAULT";
var directiveOrder = [
"ignore",
"ref",
"data",
"id",
"anchor",
"bind",
"init",
"for",
"model",
"modelable",
"transition",
"show",
"if",
DEFAULT,
"teleport"
];
function byPriority(a, b) {
let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
}
function dispatch(el, name, detail = {}, options = {}) {
return el.dispatchEvent(new CustomEvent(name, {
detail,
bubbles: true,
composed: true,
cancelable: true,
...options
}));
}
function walk(el, callback) {
if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
Array.from(el.children).forEach((el2) => walk(el2, callback));
return;
}
let skip = false;
callback(el, () => skip = true);
if (skip) return;
let node = el.firstElementChild;
while (node) {
walk(node, callback, false);
node = node.nextElementSibling;
}
}
function warn(message, ...args) {
console.warn(`Alpine Warning: ${message}`, ...args);
}
var started = false;
function start() {
if (started) warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
started = true;
if (!document.body) warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
dispatch(document, "alpine:init");
dispatch(document, "alpine:initializing");
startObservingMutations();
onElAdded((el) => initTree(el, walk));
onElRemoved((el) => destroyTree(el));
onAttributesAdded((el, attrs) => {
directives(el, attrs).forEach((handle) => handle());
});
let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
Array.from(document.querySelectorAll(allSelectors().join(","))).filter(outNestedComponents).forEach((el) => {
initTree(el);
});
dispatch(document, "alpine:initialized");
setTimeout(() => {
warnAboutMissingPlugins();
});
}
var rootSelectorCallbacks = [];
var initSelectorCallbacks = [];
function rootSelectors() {
return rootSelectorCallbacks.map((fn) => fn());
}
function allSelectors() {
return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
}
function addRootSelector(selectorCallback) {
rootSelectorCallbacks.push(selectorCallback);
}
function addInitSelector(selectorCallback) {
initSelectorCallbacks.push(selectorCallback);
}
function closestRoot(el, includeInitSelectors = false) {
return findClosest(el, (element) => {
if ((includeInitSelectors ? allSelectors() : rootSelectors()).some((selector) => element.matches(selector))) return true;
});
}
function findClosest(el, callback) {
if (!el) return;
if (callback(el)) return el;
if (el._x_teleportBack) return findClosest(el._x_teleportBack, callback);
if (el.parentNode instanceof ShadowRoot) return findClosest(el.parentNode.host, callback);
if (!el.parentElement) return;
return findClosest(el.parentElement, callback);
}
function isRoot(el) {
return rootSelectors().some((selector) => el.matches(selector));
}
var initInterceptors2 = [];
function interceptInit(callback) {
initInterceptors2.push(callback);
}
var markerDispenser = 1;
function initTree(el, walker = walk, intercept = () => {}) {
if (findClosest(el, (i) => i._x_ignore)) return;
deferHandlingDirectives(() => {
walker(el, (el2, skip) => {
if (el2._x_marker) return;
intercept(el2, skip);
initInterceptors2.forEach((i) => i(el2, skip));
directives(el2, el2.attributes).forEach((handle) => handle());
if (!el2._x_ignore) el2._x_marker = markerDispenser++;
el2._x_ignore && skip();
});
});
}
function destroyTree(root, walker = walk) {
walker(root, (el) => {
cleanupElement(el);
cleanupAttributes(el);
delete el._x_marker;
});
}
function warnAboutMissingPlugins() {
[
[
"ui",
"dialog",
["[x-dialog], [x-popover]"]
],
[
"anchor",
"anchor",
["[x-anchor]"]
],
[
"sort",
"sort",
["[x-sort]"]
]
].forEach(([plugin2, directive2, selectors]) => {
if (directiveExists(directive2)) return;
selectors.some((selector) => {
if (document.querySelector(selector)) {
warn(`found "${selector}", but missing ${plugin2} plugin`);
return true;
}
});
});
}
var tickStack = [];
var isHolding = false;
function nextTick(callback = () => {}) {
queueMicrotask(() => {
isHolding || setTimeout(() => {
releaseNextTicks();
});
});
return new Promise((res) => {
tickStack.push(() => {
callback();
res();
});
});
}
function releaseNextTicks() {
isHolding = false;
while (tickStack.length) tickStack.shift()();
}
function holdNextTicks() {
isHolding = true;
}
function setClasses(el, value) {
if (Array.isArray(value)) return setClassesFromString(el, value.join(" "));
else if (typeof value === "object" && value !== null) return setClassesFromObject(el, value);
else if (typeof value === "function") return setClasses(el, value());
return setClassesFromString(el, value);
}
function splitClasses(classString) {
return classString.split(/\s/).filter(Boolean);
}
function setClassesFromString(el, classString) {
let missingClasses = (classString2) => splitClasses(classString2).filter((i) => !el.classList.contains(i)).filter(Boolean);
let addClassesAndReturnUndo = (classes) => {
el.classList.add(...classes);
return () => {
el.classList.remove(...classes);
};
};
classString = classString === true ? classString = "" : classString || "";
return addClassesAndReturnUndo(missingClasses(classString));
}
function setClassesFromObject(el, classObject) {
let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? splitClasses(classString) : false).filter(Boolean);
let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? splitClasses(classString) : false).filter(Boolean);
let added = [];
let removed = [];
forRemove.forEach((i) => {
if (el.classList.contains(i)) {
el.classList.remove(i);
removed.push(i);
}
});
forAdd.forEach((i) => {
if (!el.classList.contains(i)) {
el.classList.add(i);
added.push(i);
}
});
return () => {
removed.forEach((i) => el.classList.add(i));
added.forEach((i) => el.classList.remove(i));
};
}
function setStyles(el, value) {
if (typeof value === "object" && value !== null) return setStylesFromObject(el, value);
return setStylesFromString(el, value);
}
function setStylesFromObject(el, value) {
let previousStyles = {};
Object.entries(value).forEach(([key, value2]) => {
previousStyles[key] = el.style[key];
if (!key.startsWith("--")) key = kebabCase(key);
el.style.setProperty(key, value2);
});
setTimeout(() => {
if (el.style.length === 0) el.removeAttribute("style");
});
return () => {
setStyles(el, previousStyles);
};
}
function setStylesFromString(el, value) {
let cache = el.getAttribute("style", value);
el.setAttribute("style", value);
return () => {
el.setAttribute("style", cache || "");
};
}
function kebabCase(subject) {
return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
}
function once(callback, fallback = () => {}) {
let called = false;
return function() {
if (!called) {
called = true;
callback.apply(this, arguments);
} else fallback.apply(this, arguments);
};
}
directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate2 }) => {
if (typeof expression === "function") expression = evaluate2(expression);
if (expression === false) return;
if (!expression || typeof expression === "boolean") registerTransitionsFromHelper(el, modifiers, value);
else registerTransitionsFromClassString(el, expression, value);
});
function registerTransitionsFromClassString(el, classString, stage) {
registerTransitionObject(el, setClasses, "");
({
"enter": (classes) => {
el._x_transition.enter.during = classes;
},
"enter-start": (classes) => {
el._x_transition.enter.start = classes;
},
"enter-end": (classes) => {
el._x_transition.enter.end = classes;
},
"leave": (classes) => {
el._x_transition.leave.during = classes;
},
"leave-start": (classes) => {
el._x_transition.leave.start = classes;
},
"leave-end": (classes) => {
el._x_transition.leave.end = classes;
}
})[stage](classString);
}
function registerTransitionsFromHelper(el, modifiers, stage) {
registerTransitionObject(el, setStyles);
let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
if (modifiers.includes("in") && !doesntSpecify) modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
if (modifiers.includes("out") && !doesntSpecify) modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
let wantsOpacity = wantsAll || modifiers.includes("opacity");
let wantsScale = wantsAll || modifiers.includes("scale");
let opacityValue = wantsOpacity ? 0 : 1;
let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
let delay = modifierValue(modifiers, "delay", 0) / 1e3;
let origin = modifierValue(modifiers, "origin", "center");
let property = "opacity, transform";
let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
if (transitioningIn) {
el._x_transition.enter.during = {
transformOrigin: origin,
transitionDelay: `${delay}s`,
transitionProperty: property,
transitionDuration: `${durationIn}s`,
transitionTimingFunction: easing
};
el._x_transition.enter.start = {
opacity: opacityValue,
transform: `scale(${scaleValue})`
};
el._x_transition.enter.end = {
opacity: 1,
transform: `scale(1)`
};
}
if (transitioningOut) {
el._x_transition.leave.during = {
transformOrigin: origin,
transitionDelay: `${delay}s`,
transitionProperty: property,
transitionDuration: `${durationOut}s`,
transitionTimingFunction: easing
};
el._x_transition.leave.start = {
opacity: 1,
transform: `scale(1)`
};
el._x_transition.leave.end = {
opacity: opacityValue,
transform: `scale(${scaleValue})`
};
}
}
function registerTransitionObject(el, setFunction, defaultValue = {}) {
if (!el._x_transition) el._x_transition = {
enter: {
during: defaultValue,
start: defaultValue,
end: defaultValue
},
leave: {
during: defaultValue,
start: defaultValue,
end: defaultValue
},
in(before = () => {}, after = () => {}) {
transition(el, setFunction, {
during: this.enter.during,
start: this.enter.start,
end: this.enter.end
}, before, after);
},
out(before = () => {}, after = () => {}) {
transition(el, setFunction, {
during: this.leave.during,
start: this.leave.start,
end: this.leave.end
}, before, after);
}
};
}
window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
let clickAwayCompatibleShow = () => nextTick2(show);
if (value) {
if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) el._x_transition.enter && (Object.entries(el._x_transition.enter.during).length || Object.entries(el._x_transition.enter.start).length || Object.entries(el._x_transition.enter.end).length) ? el._x_transition.in(show) : clickAwayCompatibleShow();
else el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
return;
}
el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
el._x_transition.out(() => {}, () => resolve(hide));
el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
}) : Promise.resolve(hide);
queueMicrotask(() => {
let closest = closestHide(el);
if (closest) {
if (!closest._x_hideChildren) closest._x_hideChildren = [];
closest._x_hideChildren.push(el);
} else nextTick2(() => {
let hideAfterChildren = (el2) => {
let carry = Promise.all([el2._x_hidePromise, ...(el2._x_hideChildren || []).map(hideAfterChildren)]).then(([i]) => i?.());
delete el2._x_hidePromise;
delete el2._x_hideChildren;
return carry;
};
hideAfterChildren(el).catch((e) => {
if (!e.isFromCancelledTransition) throw e;
});
});
});
};
function closestHide(el) {
let parent = el.parentNode;
if (!parent) return;
return parent._x_hidePromise ? parent : closestHide(parent);
}
function transition(el, setFunction, { during, start: start2, end } = {}, before = () => {}, after = () => {}) {
if (el._x_transitioning) el._x_transitioning.cancel();
if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) {
before();
after();
return;
}
let undoStart, undoDuring, undoEnd;
performTransition(el, {
start() {
undoStart = setFunction(el, start2);
},
during() {
undoDuring = setFunction(el, during);
},
before,
end() {
undoStart();
undoEnd = setFunction(el, end);
},
after,
cleanup() {
undoDuring();
undoEnd();
}
});
}
function performTransition(el, stages) {
let interrupted, reachedBefore, reachedEnd;
let finish = once(() => {
mutateDom(() => {
interrupted = true;
if (!reachedBefore) stages.before();
if (!reachedEnd) {
stages.end();
releaseNextTicks();
}
stages.after();
if (el.isConnected) stages.cleanup();
delete el._x_transitioning;
});
});
el._x_transitioning = {
beforeCancels: [],
beforeCancel(callback) {
this.beforeCancels.push(callback);
},
cancel: once(function() {
while (this.beforeCancels.length) this.beforeCancels.shift()();
finish();
}),
finish
};
mutateDom(() => {
stages.start();
stages.during();
});
holdNextTicks();
requestAnimationFrame(() => {
if (interrupted) return;
let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
if (duration === 0) duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
mutateDom(() => {
stages.before();
});
reachedBefore = true;
requestAnimationFrame(() => {
if (interrupted) return;
mutateDom(() => {
stages.end();
});
releaseNextTicks();
setTimeout(el._x_transitioning.finish, duration + delay);
reachedEnd = true;
});
});
}
function modifierValue(modifiers, key, fallback) {
if (modifiers.indexOf(key) === -1) return fallback;
const rawValue = modifiers[modifiers.indexOf(key) + 1];
if (!rawValue) return fallback;
if (key === "scale") {
if (isNaN(rawValue)) return fallback;
}
if (key === "duration" || key === "delay") {
let match = rawValue.match(/([0-9]+)ms/);
if (match) return match[1];
}
if (key === "origin") {
if ([
"top",
"right",
"left",
"center",
"bottom"
].includes(modifiers[modifiers.indexOf(key) + 2])) return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
}
return rawValue;
}
var isCloning = false;
function skipDuringClone(callback, fallback = () => {}) {
return (...args) => isCloning ? fallback(...args) : callback(...args);
}
function onlyDuringClone(callback) {
return (...args) => isCloning && callback(...args);
}
var interceptors = [];
function interceptClone(callback) {
interceptors.push(callback);
}
function cloneNode(from, to) {
interceptors.forEach((i) => i(from, to));
isCloning = true;
dontRegisterReactiveSideEffects(() => {
initTree(to, (el, callback) => {
callback(el, () => {});
});
});
isCloning = false;
}
var isCloningLegacy = false;
function clone(oldEl, newEl) {
if (!newEl._x_dataStack) newEl._x_dataStack = oldEl._x_dataStack;
isCloning = true;
isCloningLegacy = true;
dontRegisterReactiveSideEffects(() => {
cloneTree(newEl);
});
isCloning = false;
isCloningLegacy = false;
}
function cloneTree(el) {
let hasRunThroughFirstEl = false;
let shallowWalker = (el2, callback) => {
walk(el2, (el3, skip) => {
if (hasRunThroughFirstEl && isRoot(el3)) return skip();
hasRunThroughFirstEl = true;
callback(el3, skip);
});
};
initTree(el, shallowWalker);
}
function dontRegisterReactiveSideEffects(callback) {
let cache = effect;
overrideEffect((callback2, el) => {
let storedEffect = cache(callback2);
release(storedEffect);
return () => {};
});
callback();
overrideEffect(cache);
}
function bind(el, name, value, modifiers = []) {
if (!el._x_bindings) el._x_bindings = reactive({});
el._x_bindings[name] = value;
name = modifiers.includes("camel") ? camelCase(name) : name;
switch (name) {
case "value":
bindInputValue(el, value);
break;
case "style":
bindStyles(el, value);
break;
case "class":
bindClasses(el, value);
break;
case "selected":
case "checked":
bindAttributeAndProperty(el, name, value);
break;
default:
bindAttribute(el, name, value);
break;
}
}
function bindInputValue(el, value) {
if (isRadio(el)) {
if (el.attributes.value === void 0) el.value = value;
} else if (isCheckbox(el)) if (Number.isInteger(value)) el.value = value;
else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) el.value = String(value);
else if (Array.isArray(value)) el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
else el.checked = !!value;
else if (el.tagName === "SELECT") updateSelect(el, value);
else {
if (el.value === value) return;
el.value = value === void 0 ? "" : value;
}
}
function bindClasses(el, value) {
if (el._x_undoAddedClasses) el._x_undoAddedClasses();
el._x_undoAddedClasses = setClasses(el, value);
}
function bindStyles(el, value) {
if (el._x_undoAddedStyles) el._x_undoAddedStyles();
el._x_undoAddedStyles = setStyles(el, value);
}
function bindAttributeAndProperty(el, name, value) {
bindAttribute(el, name, value);
setPropertyIfChanged(el, name, value);
}
function bindAttribute(el, name, value) {
if ([
null,
void 0,
false
].includes(value) && attributeShouldntBePreservedIfFalsy(name)) el.removeAttribute(name);
else {
if (isBooleanAttr(name)) value = name;
setIfChanged(el, name, value);
}
}
function setIfChanged(el, attrName, value) {
if (el.getAttribute(attrName) != value) el.setAttribute(attrName, value);
}
function setPropertyIfChanged(el, propName, value) {
if (el[propName] !== value) el[propName] = value;
}
function updateSelect(el, value) {
const arrayWrappedValue = [].concat(value).map((value2) => {
return value2 + "";
});
Array.from(el.options).forEach((option) => {
option.selected = arrayWrappedValue.includes(option.value);
});
}
function camelCase(subject) {
return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
}
function checkedAttrLooseCompare(valueA, valueB) {
return valueA == valueB;
}
function safeParseBoolean(rawValue) {
if ([
1,
"1",
"true",
"on",
"yes",
true
].includes(rawValue)) return true;
if ([
0,
"0",
"false",
"off",
"no",
false
].includes(rawValue)) return false;
return rawValue ? Boolean(rawValue) : null;
}
var booleanAttributes = /* @__PURE__ */ new Set([
"allowfullscreen",
"async",
"autofocus",
"autoplay",
"checked",
"controls",
"default",
"defer",
"disabled",
"formnovalidate",
"inert",
"ismap",
"itemscope",
"loop",
"multiple",
"muted",
"nomodule",
"novalidate",
"open",
"playsinline",
"readonly",
"required",
"reversed",
"selected",
"shadowrootclonable",
"shadowrootdelegatesfocus",
"shadowrootserializable"
]);
function isBooleanAttr(attrName) {
return booleanAttributes.has(attrName);
}
function attributeShouldntBePreservedIfFalsy(name) {
return ![
"aria-pressed",
"aria-checked",
"aria-expanded",
"aria-selected"
].includes(name);
}
function getBinding(el, name, fallback) {
if (el._x_bindings && el._x_bindings[name] !== void 0) return el._x_bindings[name];
return getAttributeBinding(el, name, fallback);
}
function extractProp(el, name, fallback, extract = true) {
if (el._x_bindings && el._x_bindings[name] !== void 0) return el._x_bindings[name];
if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
let binding = el._x_inlineBindings[name];
binding.extract = extract;
return dontAutoEvaluateFunctions(() => {
return evaluate(el, binding.expression);
});
}
return getAttributeBinding(el, name, fallback);
}
function getAttributeBinding(el, name, fallback) {
let attr = el.getAttribute(name);
if (attr === null) return typeof fallback === "function" ? fallback() : fallback;
if (attr === "") return true;
if (isBooleanAttr(name)) return !![name, "true"].includes(attr);
return attr;
}
function isCheckbox(el) {
return el.type === "checkbox" || el.localName === "ui-checkbox" || el.localName === "ui-switch";
}
function isRadio(el) {
return el.type === "radio" || el.localName === "ui-radio";
}
function debounce(func, wait) {
let timeout;
return function() {
const context = this, args = arguments;
const later = function() {
timeout = null;
func.apply(context, args);
};
clearTimeout(timeout);
timeout = setTimeout(later, wait);
};
}
function throttle(func, limit) {
let inThrottle;
return function() {
let context = this, args = arguments;
if (!inThrottle) {
func.apply(context, args);
inThrottle = true;
setTimeout(() => inThrottle = false, limit);
}
};
}
function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
let firstRun = true;
let outerHash;
let reference = effect(() => {
let outer = outerGet();
let inner = innerGet();
if (firstRun) {
innerSet(cloneIfObject(outer));
firstRun = false;
} else {
let outerHashLatest = JSON.stringify(outer);
let innerHashLatest = JSON.stringify(inner);
if (outerHashLatest !== outerHash) innerSet(cloneIfObject(outer));
else if (outerHashLatest !== innerHashLatest) outerSet(cloneIfObject(inner));
}
outerHash = JSON.stringify(outerGet());
JSON.stringify(innerGet());
});
return () => {
release(reference);
};
}
function cloneIfObject(value) {
return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
}
function plugin(callback) {
(Array.isArray(callback) ? callback : [callback]).forEach((i) => i(alpine_default));
}
var stores = {};
var isReactive = false;
function store(name, value) {
if (!isReactive) {
stores = reactive(stores);
isReactive = true;
}
if (value === void 0) return stores[name];
stores[name] = value;
initInterceptors(stores[name]);
if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") stores[name].init();
}
function getStores() {
return stores;
}
var binds = {};
function bind2(name, bindings) {
let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
if (name instanceof Element) return applyBindingsObject(name, getBindings());
else binds[name] = getBindings;
return () => {};
}
function injectBindingProviders(obj) {
Object.entries(binds).forEach(([name, callback]) => {
Object.defineProperty(obj, name, { get() {
return (...args) => {
return callback(...args);
};
} });
});
return obj;
}
function applyBindingsObject(el, obj, original) {
let cleanupRunners = [];
while (cleanupRunners.length) cleanupRunners.pop()();
let attributes = Object.entries(obj).map(([name, value]) => ({
name,
value
}));
let staticAttributes = attributesOnly(attributes);
attributes = attributes.map((attribute) => {
if (staticAttributes.find((attr) => attr.name === attribute.name)) return {
name: `x-bind:${attribute.name}`,
value: `"${attribute.value}"`
};
return attribute;
});
directives(el, attributes, original).map((handle) => {
cleanupRunners.push(handle.runCleanups);
handle();
});
return () => {
while (cleanupRunners.length) cleanupRunners.pop()();
};
}
var datas = {};
function data(name, callback) {
datas[name] = callback;
}
function injectDataProviders(obj, context) {
Object.entries(datas).forEach(([name, callback]) => {
Object.defineProperty(obj, name, {
get() {
return (...args) => {
return callback.bind(context)(...args);
};
},
enumerable: false
});
});
return obj;
}
var alpine_default = {
get reactive() {
return reactive;
},
get release() {
return release;
},
get effect() {
return effect;
},
get raw() {
return raw;
},
get transaction() {
return transaction;
},
version: "3.15.11",
flushAndStopDeferringMutations,
dontAutoEvaluateFunctions,
disableEffectScheduling,
startObservingMutations,
stopObservingMutations,
setReactivityEngine,
onAttributeRemoved,
onAttributesAdded,
closestDataStack,
skipDuringClone,
onlyDuringClone,
addRootSelector,
addInitSelector,
setErrorHandler,
interceptClone,
addScopeToNode,
deferMutations,
mapAttributes,
evaluateLater,
interceptInit,
initInterceptors,
injectMagics,
setEvaluator,
setRawEvaluator,
mergeProxies,
extractProp,
findClosest,
onElRemoved,
closestRoot,
destroyTree,
interceptor,
transition,
setStyles,
mutateDom,
directive,
entangle,
throttle,
debounce,
evaluate,
evaluateRaw,
initTree,
nextTick,
prefixed: prefix,
prefix: setPrefix,
plugin,
magic,
store,
start,
clone,
cloneNode,
bound: getBinding,
$data: scope,
watch,
walk,
data,
bind: bind2
};
function makeMap(str, expectsLowerCase) {
const map = /* @__PURE__ */ Object.create(null);
const list = str.split(",");
for (let i = 0; i < list.length; i++) map[list[i]] = true;
return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
}
var EMPTY_OBJ = Object.freeze({});
Object.freeze([]);
var hasOwnProperty = Object.prototype.hasOwnProperty;
var hasOwn = (val, key) => hasOwnProperty.call(val, key);
var isArray = Array.isArray;
var isMap = (val) => toTypeString(val) === "[object Map]";
var isString = (val) => typeof val === "string";
var isSymbol = (val) => typeof val === "symbol";
var isObject = (val) => val !== null && typeof val === "object";
var objectToString = Object.prototype.toString;
var toTypeString = (value) => objectToString.call(value);
var toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
var cacheStringFunction = (fn) => {
const cache = /* @__PURE__ */ Object.create(null);
return (str) => {
return cache[str] || (cache[str] = fn(str));
};
};
var camelizeRE = /-(\w)/g;
cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
});
var hyphenateRE = /\B([A-Z])/g;
cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
var targetMap = /* @__PURE__ */ new WeakMap();
var effectStack = [];
var activeEffect;
var ITERATE_KEY = Symbol("iterate");
var MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
function isEffect(fn) {
return fn && fn._isEffect === true;
}
function effect2(fn, options = EMPTY_OBJ) {
if (isEffect(fn)) fn = fn.raw;
const effect3 = createReactiveEffect(fn, options);
if (!options.lazy) effect3();
return effect3;
}
function stop(effect3) {
if (effect3.active) {
cleanup(effect3);
if (effect3.options.onStop) effect3.options.onStop();
effect3.active = false;
}
}
var uid = 0;
function createReactiveEffect(fn, options) {
const effect3 = function reactiveEffect() {
if (!effect3.active) return fn();
if (!effectStack.includes(effect3)) {
cleanup(effect3);
try {
enableTracking();
effectStack.push(effect3);
activeEffect = effect3;
return fn();
} finally {
effectStack.pop();
resetTracking();
activeEffect = effectStack[effectStack.length - 1];
}
}
};
effect3.id = uid++;
effect3.allowRecurse = !!options.allowRecurse;
effect3._isEffect = true;
effect3.active = true;
effect3.raw = fn;
effect3.deps = [];
effect3.options = options;
return effect3;
}
function cleanup(effect3) {
const { deps } = effect3;
if (deps.length) {
for (let i = 0; i < deps.length; i++) deps[i].delete(effect3);
deps.length = 0;
}
}
var shouldTrack = true;
var trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function enableTracking() {
trackStack.push(shouldTrack);
shouldTrack = true;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === void 0 ? true : last;
}
function track(target, type, key) {
if (!shouldTrack || activeEffect === void 0) return;
let depsMap = targetMap.get(target);
if (!depsMap) targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
let dep = depsMap.get(key);
if (!dep) depsMap.set(key, dep = /* @__PURE__ */ new Set());
if (!dep.has(activeEffect)) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
if (activeEffect.options.onTrack) activeEffect.options.onTrack({
effect: activeEffect,
target,
type,
key
});
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) return;
const effects = /* @__PURE__ */ new Set();
const add2 = (effectsToAdd) => {
if (effectsToAdd) effectsToAdd.forEach((effect3) => {
if (effect3 !== activeEffect || effect3.allowRecurse) effects.add(effect3);
});
};
if (type === "clear") depsMap.forEach(add2);
else if (key === "length" && isArray(target)) depsMap.forEach((dep, key2) => {
if (key2 === "length" || key2 >= newValue) add2(dep);
});
else {
if (key !== void 0) add2(depsMap.get(key));
switch (type) {
case "add":
if (!isArray(target)) {
add2(depsMap.get(ITERATE_KEY));
if (isMap(target)) add2(depsMap.get(MAP_KEY_ITERATE_KEY));
} else if (isIntegerKey(key)) add2(depsMap.get("length"));
break;
case "delete":
if (!isArray(target)) {
add2(depsMap.get(ITERATE_KEY));
if (isMap(target)) add2(depsMap.get(MAP_KEY_ITERATE_KEY));
}
break;
case "set":
if (isMap(target)) add2(depsMap.get(ITERATE_KEY));
break;
}
}
const run = (effect3) => {
if (effect3.options.onTrigger) effect3.options.onTrigger({
effect: effect3,
target,
key,
type,
newValue,
oldValue,
oldTarget
});
if (effect3.options.scheduler) effect3.options.scheduler(effect3);
else effect3();
};
effects.forEach(run);
}
var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
var get2 = /* @__PURE__ */ createGetter();
var readonlyGet = /* @__PURE__ */ createGetter(true);
var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
function createArrayInstrumentations() {
const instrumentations = {};
[
"includes",
"indexOf",
"lastIndexOf"
].forEach((key) => {
instrumentations[key] = function(...args) {
const arr = toRaw(this);
for (let i = 0, l = this.length; i < l; i++) track(arr, "get", i + "");
const res = arr[key](...args);
if (res === -1 || res === false) return arr[key](...args.map(toRaw));
else return res;
};
});
[
"push",
"pop",
"shift",
"unshift",
"splice"
].forEach((key) => {
instrumentations[key] = function(...args) {
pauseTracking();
const res = toRaw(this)[key].apply(this, args);
resetTracking();
return res;
};
});
return instrumentations;
}
function createGetter(isReadonly = false, shallow = false) {
return function get3(target, key, receiver) {
if (key === "__v_isReactive") return !isReadonly;
else if (key === "__v_isReadonly") return isReadonly;
else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) return target;
const targetIsArray = isArray(target);
if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) return Reflect.get(arrayInstrumentations, key, receiver);
const res = Reflect.get(target, key, receiver);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) return res;
if (!isReadonly) track(target, "get", key);
if (shallow) return res;
if (isRef(res)) return !targetIsArray || !isIntegerKey(key) ? res.value : res;
if (isObject(res)) return isReadonly ? readonly(res) : reactive2(res);
return res;
};
}
var set2 = /* @__PURE__ */ createSetter();
function createSetter(shallow = false) {
return function set3(target, key, value, receiver) {
let oldValue = target[key];
if (!shallow) {
value = toRaw(value);
oldValue = toRaw(oldValue);
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
}
const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);
if (target === toRaw(receiver)) {
if (!hadKey) trigger(target, "add", key, value);
else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
}
return result;
};
}
function deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
const oldValue = target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) trigger(target, "delete", key, void 0, oldValue);
return result;
}
function has(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) track(target, "has", key);
return result;
}
function ownKeys(target) {
track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
return Reflect.ownKeys(target);
}
var mutableHandlers = {
get: get2,
set: set2,
deleteProperty,
has,
ownKeys
};
var readonlyHandlers = {
get: readonlyGet,
set(target, key) {
console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
return true;
},
deleteProperty(target, key) {
console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
return true;
}
};
var toReactive = (value) => isObject(value) ? reactive2(value) : value;
var toReadonly = (value) => isObject(value) ? readonly(value) : value;
var toShallow = (value) => value;
var getProto = (v) => Reflect.getPrototypeOf(v);
function get$1(target, key, isReadonly = false, isShallow = false) {
target = target["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) !isReadonly && track(rawTarget, "get", key);
!isReadonly && track(rawTarget, "get", rawKey);
const { has: has2 } = getProto(rawTarget);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
if (has2.call(rawTarget, key)) return wrap(target.get(key));
else if (has2.call(rawTarget, rawKey)) return wrap(target.get(rawKey));
else if (target !== rawTarget) target.get(key);
}
function has$1(key, isReadonly = false) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) !isReadonly && track(rawTarget, "has", key);
!isReadonly && track(rawTarget, "has", rawKey);
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly = false) {
target = target["__v_raw"];
!isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
return Reflect.get(target, "size", target);
}
function add(value) {
value = toRaw(value);
const target = toRaw(this);
if (!getProto(target).has.call(target, value)) {
target.add(value);
trigger(target, "add", value, value);
}
return this;
}
function set$1(key, value) {
value = toRaw(value);
const target = toRaw(this);
const { has: has2, get: get3 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
} else checkIdentityKeys(target, has2, key);
const oldValue = get3.call(target, key);
target.set(key, value);
if (!hadKey) trigger(target, "add", key, value);
else if (hasChanged(value, oldValue)) trigger(target, "set", key, value, oldValue);
return this;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has: has2, get: get3 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
} else checkIdentityKeys(target, has2, key);
const oldValue = get3 ? get3.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) trigger(target, "delete", key, void 0, oldValue);
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const oldTarget = isMap(target) ? new Map(target) : new Set(target);
const result = target.clear();
if (hadItems) trigger(target, "clear", void 0, void 0, oldTarget);
return result;
}
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw"];
const rawTarget = toRaw(target);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
!isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly, isShallow) {
return function(...args) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
const isKeyOnly = method === "keys" && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
!isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
return {
next() {
const { value, done } = innerIterator.next();
return done ? {
value,
done
} : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
{
const key = args[0] ? `on key "${args[0]}" ` : ``;
console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
}
return type === "delete" ? false : this;
};
}
function createInstrumentations() {
const mutableInstrumentations2 = {
get(key) {
return get$1(this, key);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations2 = {
get(key) {
return get$1(this, key, false, true);
},
get size() {
return size(this);
},
has: has$1,
add,
set: set$1,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations2 = {
get(key) {
return get$1(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, false)
};
const shallowReadonlyInstrumentations2 = {
get(key) {
return get$1(this, key, true, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, true)
};
[
"keys",
"values",
"entries",
Symbol.iterator
].forEach((method) => {
mutableInstrumentations2[method] = createIterableMethod(method, false, false);
readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
shallowInstrumentations2[method] = createIterableMethod(method, false, true);
shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
});
return [
mutableInstrumentations2,
readonlyInstrumentations2,
shallowInstrumentations2,
shallowReadonlyInstrumentations2
];
}
var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive") return !isReadonly;
else if (key === "__v_isReadonly") return isReadonly;
else if (key === "__v_raw") return target;
return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
};
}
var mutableCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(false, false) };
var readonlyCollectionHandlers = { get: /* @__PURE__ */ createInstrumentationGetter(true, false) };
function checkIdentityKeys(target, has2, key) {
const rawKey = toRaw(key);
if (rawKey !== key && has2.call(target, rawKey)) {
const type = toRawType(target);
console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
}
}
var reactiveMap = /* @__PURE__ */ new WeakMap();
var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
var readonlyMap = /* @__PURE__ */ new WeakMap();
var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array": return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet": return 2;
default: return 0;
}
}
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
}
function reactive2(target) {
if (target && target["__v_isReadonly"]) return target;
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
}
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
}
function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
if (!isObject(target)) {
console.warn(`value cannot be made reactive: ${String(target)}`);
return target;
}
if (target["__v_raw"] && !(isReadonly && target["__v_isReactive"])) return target;
const existingProxy = proxyMap.get(target);
if (existingProxy) return existingProxy;
const targetType = getTargetType(target);
if (targetType === 0) return target;
const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function toRaw(observed) {
return observed && toRaw(observed["__v_raw"]) || observed;
}
function isRef(r) {
return Boolean(r && r.__v_isRef === true);
}
magic("nextTick", () => nextTick);
magic("dispatch", (el) => dispatch.bind(dispatch, el));
magic("watch", (el, { evaluateLater: evaluateLater2, cleanup: cleanup2 }) => (key, callback) => {
let evaluate2 = evaluateLater2(key);
let getter = () => {
let value;
evaluate2((i) => value = i);
return value;
};
cleanup2(watch(getter, callback));
});
magic("store", getStores);
magic("data", (el) => scope(el));
magic("root", (el) => closestRoot(el));
magic("refs", (el) => {
if (el._x_refs_proxy) return el._x_refs_proxy;
el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
return el._x_refs_proxy;
});
function getArrayOfRefObject(el) {
let refObjects = [];
findClosest(el, (i) => {
if (i._x_refs) refObjects.push(i._x_refs);
});
return refObjects;
}
var globalIdMemo = {};
function findAndIncrementId(name) {
if (!globalIdMemo[name]) globalIdMemo[name] = 0;
return ++globalIdMemo[name];
}
function closestIdRoot(el, name) {
return findClosest(el, (element) => {
if (element._x_ids && element._x_ids[name]) return true;
});
}
function setIdRoot(el, name) {
if (!el._x_ids) el._x_ids = {};
if (!el._x_ids[name]) el._x_ids[name] = findAndIncrementId(name);
}
magic("id", (el, { cleanup: cleanup2 }) => (name, key = null) => {
return cacheIdByNameOnElement(el, `${name}${key ? `-${key}` : ""}`, cleanup2, () => {
let root = closestIdRoot(el, name);
let id = root ? root._x_ids[name] : findAndIncrementId(name);
return key ? `${name}-${id}-${key}` : `${name}-${id}`;
});
});
interceptClone((from, to) => {
if (from._x_id) to._x_id = from._x_id;
});
function cacheIdByNameOnElement(el, cacheKey, cleanup2, callback) {
if (!el._x_id) el._x_id = {};
if (el._x_id[cacheKey]) return el._x_id[cacheKey];
let output = callback();
el._x_id[cacheKey] = output;
cleanup2(() => {
delete el._x_id[cacheKey];
});
return output;
}
magic("el", (el) => el);
warnMissingPluginMagic("Focus", "focus", "focus");
warnMissingPluginMagic("Persist", "persist", "persist");
function warnMissingPluginMagic(name, magicName, slug) {
magic(magicName, (el) => warn(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
}
directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
let func = evaluateLater2(expression);
let innerGet = () => {
let result;
func((i) => result = i);
return result;
};
let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
let innerSet = (val) => evaluateInnerSet(() => {}, { scope: { "__placeholder": val } });
innerSet(innerGet());
queueMicrotask(() => {
if (!el._x_model) return;
el._x_removeModelListeners["default"]();
let outerGet = el._x_model.get;
let outerSet = el._x_model.setWithModifiers;
cleanup2(entangle({
get() {
return outerGet();
},
set(value) {
outerSet(value);
}
}, {
get() {
return innerGet();
},
set(value) {
innerSet(value);
}
}));
});
});
directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
if (el.tagName.toLowerCase() !== "template") warn("x-teleport can only be used on a <template> tag", el);
let target = getTarget(expression);
let clone2 = el.content.cloneNode(true).firstElementChild;
el._x_teleport = clone2;
clone2._x_teleportBack = el;
el.setAttribute("data-teleport-template", true);
clone2.setAttribute("data-teleport-target", true);
if (el._x_forwardEvents) el._x_forwardEvents.forEach((eventName) => {
clone2.addEventListener(eventName, (e) => {
e.stopPropagation();
el.dispatchEvent(new e.constructor(e.type, e));
});
});
addScopeToNode(clone2, {}, el);
let placeInDom = (clone3, target2, modifiers2) => {
if (modifiers2.includes("prepend")) target2.parentNode.insertBefore(clone3, target2);
else if (modifiers2.includes("append")) target2.parentNode.insertBefore(clone3, target2.nextSibling);
else target2.appendChild(clone3);
};
mutateDom(() => {
placeInDom(clone2, target, modifiers);
skipDuringClone(() => {
initTree(clone2);
})();
});
el._x_teleportPutBack = () => {
let target2 = getTarget(expression);
mutateDom(() => {
placeInDom(el._x_teleport, target2, modifiers);
});
};
cleanup2(() => mutateDom(() => {
clone2.remove();
destroyTree(clone2);
}));
});
var teleportContainerDuringClone = document.createElement("div");
function getTarget(expression) {
let target = skipDuringClone(() => {
return document.querySelector(expression);
}, () => {
return teleportContainerDuringClone;
})();
if (!target) warn(`Cannot find x-teleport element for selector: "${expression}"`);
return target;
}
var handler = () => {};
handler.inline = (el, { modifiers }, { cleanup: cleanup2 }) => {
modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
cleanup2(() => {
modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
});
};
directive("ignore", handler);
directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
effect3(evaluateLater(el, expression));
}));
function on(el, event, modifiers, callback) {
let listenerTarget = el;
let handler4 = (e) => callback(e);
let options = {};
let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
if (modifiers.includes("dot")) event = dotSyntax(event);
if (modifiers.includes("camel")) event = camelCase2(event);
if (modifiers.includes("capture")) options.capture = true;
if (modifiers.includes("window")) listenerTarget = window;
if (modifiers.includes("document")) listenerTarget = document;
if (modifiers.includes("passive")) options.passive = modifiers[modifiers.indexOf("passive") + 1] !== "false";
handler4 = addDebounceOrThrottle(modifiers, handler4);
if (modifiers.includes("prevent")) handler4 = wrapHandler(handler4, (next, e) => {
e.preventDefault();
next(e);
});
if (modifiers.includes("stop")) handler4 = wrapHandler(handler4, (next, e) => {
e.stopPropagation();
next(e);
});
if (modifiers.includes("once")) handler4 = wrapHandler(handler4, (next, e) => {
next(e);
listenerTarget.removeEventListener(event, handler4, options);
});
if (modifiers.includes("away") || modifiers.includes("outside")) {
listenerTarget = document;
handler4 = wrapHandler(handler4, (next, e) => {
if (el.contains(e.target)) return;
if (e.target.isConnected === false) return;
if (el.offsetWidth < 1 && el.offsetHeight < 1) return;
if (el._x_isShown === false) return;
next(e);
});
}
if (modifiers.includes("self")) handler4 = wrapHandler(handler4, (next, e) => {
e.target === el && next(e);
});
if (event === "submit") handler4 = wrapHandler(handler4, (next, e) => {
if (e.target._x_pendingModelUpdates) e.target._x_pendingModelUpdates.forEach((fn) => fn());
next(e);
});
if (isKeyEvent(event) || isClickEvent(event)) handler4 = wrapHandler(handler4, (next, e) => {
if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) return;
next(e);
});
listenerTarget.addEventListener(event, handler4, options);
return () => {
listenerTarget.removeEventListener(event, handler4, options);
};
}
function addDebounceOrThrottle(modifiers, handler4) {
if (modifiers.includes("debounce")) {
let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
handler4 = debounce(handler4, wait);
}
if (modifiers.includes("throttle")) {
let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
handler4 = throttle(handler4, wait);
}
return handler4;
}
function dotSyntax(subject) {
return subject.replace(/-/g, ".");
}
function camelCase2(subject) {
return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
}
function isNumeric(subject) {
return !Array.isArray(subject) && !isNaN(subject);
}
function kebabCase2(subject) {
if ([" ", "_"].includes(subject)) return subject;
return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
}
function isKeyEvent(event) {
return ["keydown", "keyup"].includes(event);
}
function isClickEvent(event) {
return [
"contextmenu",
"click",
"mouse"
].some((i) => event.includes(i));
}
function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
let keyModifiers = modifiers.filter((i) => {
return ![
"window",
"document",
"prevent",
"stop",
"once",
"capture",
"self",
"away",
"outside",
"passive",
"preserve-scroll",
"blur",
"change",
"lazy"
].includes(i);
});
if (keyModifiers.includes("debounce")) {
let debounceIndex = keyModifiers.indexOf("debounce");
keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
}
if (keyModifiers.includes("throttle")) {
let debounceIndex = keyModifiers.indexOf("throttle");
keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
}
if (keyModifiers.length === 0) return false;
if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0])) return false;
const selectedSystemKeyModifiers = [
"ctrl",
"shift",
"alt",
"meta",
"cmd",
"super"
].filter((modifier) => keyModifiers.includes(modifier));
keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
if (selectedSystemKeyModifiers.length > 0) {
if (selectedSystemKeyModifiers.filter((modifier) => {
if (modifier === "cmd" || modifier === "super") modifier = "meta";
return e[`${modifier}Key`];
}).length === selectedSystemKeyModifiers.length) {
if (isClickEvent(e.type)) return false;
if (keyToModifiers(e.key).includes(keyModifiers[0])) return false;
}
}
return true;
}
function keyToModifiers(key) {
if (!key) return [];
key = kebabCase2(key);
let modifierToKeyMap = {
"ctrl": "control",
"slash": "/",
"space": " ",
"spacebar": " ",
"cmd": "meta",
"esc": "escape",
"up": "arrow-up",
"down": "arrow-down",
"left": "arrow-left",
"right": "arrow-right",
"period": ".",
"comma": ",",
"equal": "=",
"minus": "-",
"underscore": "_"
};
modifierToKeyMap[key] = key;
return Object.keys(modifierToKeyMap).map((modifier) => {
if (modifierToKeyMap[modifier] === key) return modifier;
}).filter((modifier) => modifier);
}
directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup: cleanup2 }) => {
let scopeTarget = el;
if (modifiers.includes("parent")) scopeTarget = findClosest(el, (element) => element !== el);
let evaluateGet = evaluateLater(scopeTarget, expression);
let evaluateSet;
if (typeof expression === "string") evaluateSet = evaluateLater(scopeTarget, `${expression} = __placeholder`);
else if (typeof expression === "function" && typeof expression() === "string") evaluateSet = evaluateLater(scopeTarget, `${expression()} = __placeholder`);
else evaluateSet = () => {};
let getValue = () => {
let result;
evaluateGet((value) => result = value);
return isGetterSetter(result) ? result.get() : result;
};
let setValue = (value) => {
let result;
evaluateGet((value2) => result = value2);
if (isGetterSetter(result)) result.set(value);
else evaluateSet(() => {}, { scope: { "__placeholder": value } });
};
if (typeof expression === "string" && el.type === "radio") mutateDom(() => {
if (!el.hasAttribute("name")) el.setAttribute("name", expression);
});
let hasChangeModifier = modifiers.includes("change") || modifiers.includes("lazy");
let hasBlurModifier = modifiers.includes("blur");
let hasEnterModifier = modifiers.includes("enter");
let hasExplicitEventModifiers = hasChangeModifier || hasBlurModifier || hasEnterModifier;
let removeListener;
if (isCloning) removeListener = () => {};
else if (hasExplicitEventModifiers) {
let listeners = [];
let syncValue = (e) => setValue(getInputValue(el, modifiers, e, getValue()));
if (hasChangeModifier) listeners.push(on(el, "change", modifiers, syncValue));
if (hasBlurModifier) {
listeners.push(on(el, "blur", modifiers, syncValue));
if (el.form) {
let form = el.form;
let syncCallback = () => syncValue({ target: el });
if (!form._x_pendingModelUpdates) form._x_pendingModelUpdates = [];
form._x_pendingModelUpdates.push(syncCallback);
cleanup2(() => {
if (form._x_pendingModelUpdates) form._x_pendingModelUpdates.splice(form._x_pendingModelUpdates.indexOf(syncCallback), 1);
});
}
}
if (hasEnterModifier) listeners.push(on(el, "keydown", modifiers, (e) => {
if (e.key === "Enter") syncValue(e);
}));
removeListener = () => listeners.forEach((remove) => remove());
} else removeListener = on(el, el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) ? "change" : "input", modifiers, (e) => {
setValue(getInputValue(el, modifiers, e, getValue()));
});
if (modifiers.includes("fill")) {
if ([
void 0,
null,
""
].includes(getValue()) || isCheckbox(el) && Array.isArray(getValue()) || el.tagName.toLowerCase() === "select" && el.multiple) setValue(getInputValue(el, modifiers, { target: el }, getValue()));
}
if (!el._x_removeModelListeners) el._x_removeModelListeners = {};
el._x_removeModelListeners["default"] = removeListener;
cleanup2(() => el._x_removeModelListeners["default"]());
if (el.form) {
let removeResetListener = on(el.form, "reset", [], (e) => {
nextTick(() => el._x_model && el._x_model.set(getInputValue(el, modifiers, { target: el }, getValue())));
});
cleanup2(() => removeResetListener());
}
el._x_model = {
get() {
return getValue();
},
set(value) {
setValue(value);
},
setWithModifiers: addDebounceOrThrottle(modifiers, setValue)
};
el._x_forceModelUpdate = (value) => {
if (value === void 0 && typeof expression === "string" && expression.match(/\./)) value = "";
mutateDom(() => {
if (isCheckbox(el)) if (Array.isArray(value)) el.checked = value.some((val) => val == el.value);
else el.checked = !!value;
else if (isRadio(el)) if (typeof value === "boolean") el.checked = safeParseBoolean(el.value) === value;
else el.checked = el.value == value;
else bind(el, "value", value);
});
};
effect3(() => {
let value = getValue();
if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el)) return;
el._x_forceModelUpdate(value);
});
});
function getInputValue(el, modifiers, event, currentValue) {
return mutateDom(() => {
if (event instanceof CustomEvent && event.detail !== void 0) return event.detail !== null && event.detail !== void 0 ? event.detail : event.target.value;
else if (isCheckbox(el)) if (Array.isArray(currentValue)) {
let newValue = null;
if (modifiers.includes("number")) newValue = safeParseNumber(event.target.value);
else if (modifiers.includes("boolean")) newValue = safeParseBoolean(event.target.value);
else newValue = event.target.value;
return event.target.checked ? currentValue.includes(newValue) ? currentValue : currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
} else return event.target.checked;
else if (el.tagName.toLowerCase() === "select" && el.multiple) {
if (modifiers.includes("number")) return Array.from(event.target.selectedOptions).map((option) => {
return safeParseNumber(option.value || option.text);
});
else if (modifiers.includes("boolean")) return Array.from(event.target.selectedOptions).map((option) => {
return safeParseBoolean(option.value || option.text);
});
return Array.from(event.target.selectedOptions).map((option) => {
return option.value || option.text;
});
} else {
let newValue;
if (isRadio(el)) if (event.target.checked) newValue = event.target.value;
else newValue = currentValue;
else newValue = event.target.value;
if (modifiers.includes("number")) return safeParseNumber(newValue);
else if (modifiers.includes("boolean")) return safeParseBoolean(newValue);
else if (modifiers.includes("trim")) return newValue.trim();
else return newValue;
}
});
}
function safeParseNumber(rawValue) {
let number = rawValue ? parseFloat(rawValue) : null;
return isNumeric2(number) ? number : rawValue;
}
function checkedAttrLooseCompare2(valueA, valueB) {
return valueA == valueB;
}
function isNumeric2(subject) {
return !Array.isArray(subject) && !isNaN(subject);
}
function isGetterSetter(value) {
return value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.set === "function";
}
directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
addInitSelector(() => `[${prefix("init")}]`);
directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate2 }) => {
if (typeof expression === "string") return !!expression.trim() && evaluate2(expression, {}, false);
return evaluate2(expression, {}, false);
}));
directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
let evaluate2 = evaluateLater2(expression);
effect3(() => {
evaluate2((value) => {
mutateDom(() => {
el.textContent = value;
});
});
});
});
directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
let evaluate2 = evaluateLater2(expression);
effect3(() => {
evaluate2((value) => {
mutateDom(() => {
el.innerHTML = value ?? "";
el._x_ignoreSelf = true;
initTree(el);
delete el._x_ignoreSelf;
});
});
});
});
mapAttributes(startingWith(":", into(prefix("bind:"))));
var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3, cleanup: cleanup2 }) => {
if (!value) {
let bindingProviders = {};
injectBindingProviders(bindingProviders);
evaluateLater(el, expression)((bindings) => {
applyBindingsObject(el, bindings, original);
}, { scope: bindingProviders });
return;
}
if (value === "key") return storeKeyForXFor(el, expression);
if (el._x_inlineBindings && el._x_inlineBindings[value] && el._x_inlineBindings[value].extract) return;
let evaluate2 = evaluateLater(el, expression);
effect3(() => evaluate2((result) => {
if (result === void 0 && typeof expression === "string" && expression.match(/\./)) result = "";
mutateDom(() => bind(el, value, result, modifiers));
}));
cleanup2(() => {
el._x_undoAddedClasses && el._x_undoAddedClasses();
el._x_undoAddedStyles && el._x_undoAddedStyles();
});
};
handler2.inline = (el, { value, modifiers, expression }) => {
if (!value) return;
if (!el._x_inlineBindings) el._x_inlineBindings = {};
el._x_inlineBindings[value] = {
expression,
extract: false
};
};
directive("bind", handler2);
function storeKeyForXFor(el, expression) {
el._x_keyExpression = expression;
}
addRootSelector(() => `[${prefix("data")}]`);
directive("data", (el, { expression }, { cleanup: cleanup2 }) => {
if (shouldSkipRegisteringDataDuringClone(el)) return;
expression = expression === "" ? "{}" : expression;
let magicContext = {};
injectMagics(magicContext, el);
let dataProviderContext = {};
injectDataProviders(dataProviderContext, magicContext);
let data2 = evaluate(el, expression, { scope: dataProviderContext });
if (data2 === void 0 || data2 === true) data2 = {};
injectMagics(data2, el);
let reactiveData = reactive(data2);
initInterceptors(reactiveData);
let undo = addScopeToNode(el, reactiveData);
reactiveData["init"] && evaluate(el, reactiveData["init"]);
cleanup2(() => {
reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
undo();
});
});
interceptClone((from, to) => {
if (from._x_dataStack) {
to._x_dataStack = from._x_dataStack;
to.setAttribute("data-has-alpine-state", true);
}
});
function shouldSkipRegisteringDataDuringClone(el) {
if (!isCloning) return false;
if (isCloningLegacy) return true;
return el.hasAttribute("data-has-alpine-state");
}
directive("show", (el, { modifiers, expression }, { effect: effect3 }) => {
let evaluate2 = evaluateLater(el, expression);
if (!el._x_doHide) el._x_doHide = () => {
mutateDom(() => {
el.style.setProperty("display", "none", modifiers.includes("important") ? "important" : void 0);
});
};
if (!el._x_doShow) el._x_doShow = () => {
mutateDom(() => {
if (el.style.length === 1 && el.style.display === "none") el.removeAttribute("style");
else el.style.removeProperty("display");
});
};
let hide = () => {
el._x_doHide();
el._x_isShown = false;
};
let show = () => {
el._x_doShow();
el._x_isShown = true;
};
let clickAwayCompatibleShow = () => setTimeout(show);
let toggle = once((value) => value ? show() : hide(), (value) => {
if (typeof el._x_toggleAndCascadeWithTransitions === "function") el._x_toggleAndCascadeWithTransitions(el, value, show, hide);
else value ? clickAwayCompatibleShow() : hide();
});
let oldValue;
let firstTime = true;
effect3(() => evaluate2((value) => {
if (!firstTime && value === oldValue) return;
if (modifiers.includes("immediate")) value ? clickAwayCompatibleShow() : hide();
toggle(value);
oldValue = value;
firstTime = false;
}));
});
directive("for", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
let iteratorNames = parseForExpression(expression);
let evaluateItems = evaluateLater(el, iteratorNames.items);
let evaluateKey = evaluateLater(el, el._x_keyExpression || "index");
el._x_lookup = /* @__PURE__ */ new Map();
effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey));
cleanup2(() => {
el._x_lookup.forEach((el2) => mutateDom(() => {
destroyTree(el2);
el2.remove();
}));
delete el._x_lookup;
});
});
function refreshScope(scope2) {
return (newScope) => {
Object.entries(newScope).forEach(([key, value]) => {
scope2[key] = value;
});
};
}
function loop(templateEl, iteratorNames, evaluateItems, evaluateKey) {
evaluateItems((items) => {
if (isNumeric3(items)) items = Array.from({ length: items }, (_, i) => i + 1);
if (items === void 0) items = [];
if (items instanceof Set) items = Array.from(items);
if (items instanceof Map) items = Array.from(items);
let oldLookup = templateEl._x_lookup;
let lookup = /* @__PURE__ */ new Map();
templateEl._x_lookup = lookup;
let hasStringKeys = isObject2(items);
let scopeEntries = Object.entries(items).map(([index, item]) => {
if (!hasStringKeys) index = parseInt(index);
let scope2 = getIterationScopeVariables(iteratorNames, item, index, items);
let key;
evaluateKey((innerKey) => {
if (typeof innerKey === "object") warn("x-for key cannot be an object, it must be a string or an integer", templateEl);
if (oldLookup.has(innerKey)) {
lookup.set(innerKey, oldLookup.get(innerKey));
oldLookup.delete(innerKey);
}
key = innerKey;
}, { scope: {
index,
...scope2
} });
return [key, scope2];
});
mutateDom(() => {
oldLookup.forEach((el) => {
destroyTree(el);
el.remove();
});
let added = /* @__PURE__ */ new Set();
let prev = templateEl;
scopeEntries.forEach(([key, scope2]) => {
if (lookup.has(key)) {
let el = lookup.get(key);
el._x_refreshXForScope(scope2);
if (prev.nextElementSibling !== el) {
if (prev.nextElementSibling) el.replaceWith(prev.nextElementSibling);
prev.after(el);
}
prev = el;
if (el._x_currentIfEl) {
if (el.nextElementSibling !== el._x_currentIfEl) prev.after(el._x_currentIfEl);
prev = el._x_currentIfEl;
}
return;
}
if (templateEl.content.children.length > 1) warn("x-for templates require a single root element, additional elements will be ignored.", templateEl);
let clone2 = document.importNode(templateEl.content, true).firstElementChild;
let reactiveScope = reactive(scope2);
addScopeToNode(clone2, reactiveScope, templateEl);
clone2._x_refreshXForScope = refreshScope(reactiveScope);
lookup.set(key, clone2);
added.add(clone2);
prev.after(clone2);
prev = clone2;
});
skipDuringClone(() => added.forEach((clone2) => initTree(clone2)))();
});
});
}
function parseForExpression(expression) {
let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
let stripParensRE = /^\s*\(|\)\s*$/g;
let inMatch = expression.match(/([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/);
if (!inMatch) return;
let res = {};
res.items = inMatch[2].trim();
let item = inMatch[1].replace(stripParensRE, "").trim();
let iteratorMatch = item.match(forIteratorRE);
if (iteratorMatch) {
res.item = item.replace(forIteratorRE, "").trim();
res.index = iteratorMatch[1].trim();
if (iteratorMatch[2]) res.collection = iteratorMatch[2].trim();
} else res.item = item;
return res;
}
function getIterationScopeVariables(iteratorNames, item, index, items) {
let scopeVariables = {};
if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim()).forEach((name, i) => {
scopeVariables[name] = item[i];
});
else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim()).forEach((name) => {
scopeVariables[name] = item[name];
});
else scopeVariables[iteratorNames.item] = item;
if (iteratorNames.index) scopeVariables[iteratorNames.index] = index;
if (iteratorNames.collection) scopeVariables[iteratorNames.collection] = items;
return scopeVariables;
}
function isNumeric3(subject) {
return !Array.isArray(subject) && !isNaN(subject);
}
function isObject2(subject) {
return typeof subject === "object" && !Array.isArray(subject);
}
function handler3() {}
handler3.inline = (el, { expression }, { cleanup: cleanup2 }) => {
let root = closestRoot(el);
if (!root) return;
if (!root._x_refs) root._x_refs = {};
root._x_refs[expression] = el;
cleanup2(() => delete root._x_refs[expression]);
};
directive("ref", handler3);
directive("if", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
if (el.tagName.toLowerCase() !== "template") warn("x-if can only be used on a <template> tag", el);
let evaluate2 = evaluateLater(el, expression);
let show = () => {
if (el._x_currentIfEl) return el._x_currentIfEl;
let clone2 = el.content.cloneNode(true).firstElementChild;
addScopeToNode(clone2, {}, el);
mutateDom(() => {
el.after(clone2);
skipDuringClone(() => initTree(clone2))();
});
el._x_currentIfEl = clone2;
el._x_undoIf = () => {
mutateDom(() => {
destroyTree(clone2);
clone2.remove();
});
delete el._x_currentIfEl;
};
return clone2;
};
let hide = () => {
if (!el._x_undoIf) return;
el._x_undoIf();
delete el._x_undoIf;
};
effect3(() => evaluate2((value) => {
value ? show() : hide();
}));
cleanup2(() => el._x_undoIf && el._x_undoIf());
});
directive("id", (el, { expression }, { evaluate: evaluate2 }) => {
evaluate2(expression).forEach((name) => setIdRoot(el, name));
});
interceptClone((from, to) => {
if (from._x_ids) to._x_ids = from._x_ids;
});
mapAttributes(startingWith("@", into(prefix("on:"))));
directive("on", skipDuringClone((el, { value, modifiers, expression }, { cleanup: cleanup2 }) => {
let evaluate2 = expression ? evaluateLater(el, expression) : () => {};
if (el.tagName.toLowerCase() === "template") {
if (!el._x_forwardEvents) el._x_forwardEvents = [];
if (!el._x_forwardEvents.includes(value)) el._x_forwardEvents.push(value);
}
let removeListener = on(el, value, modifiers, (e) => {
evaluate2(() => {}, {
scope: { "$event": e },
params: [e]
});
});
cleanup2(() => removeListener());
}));
warnMissingPluginDirective("Collapse", "collapse", "collapse");
warnMissingPluginDirective("Intersect", "intersect", "intersect");
warnMissingPluginDirective("Focus", "trap", "focus");
warnMissingPluginDirective("Mask", "mask", "mask");
function warnMissingPluginDirective(name, directiveName, slug) {
directive(directiveName, (el) => warn(`You can't use [x-${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
}
alpine_default.setEvaluator(normalEvaluator);
alpine_default.setRawEvaluator(normalRawEvaluator);
alpine_default.setReactivityEngine({
reactive: reactive2,
effect: effect2,
release: stop,
raw: toRaw
});
var src_default = alpine_default;
var module_default = src_default;
//#endregion
export { src_default as Alpine, module_default as default };
//# sourceMappingURL=alpinejs.js.map