vendor: 14 bytes, lines 1-2
1(() => { 2 //
2packages/alpinejs/src/scheduler.js 3 var flushPending = false; 4 var flushing = false; 5 var queue = []; 6 function scheduler(callback) { 7 queueJob(callback); 8 } 9 function queueJob(job) { 10 if (!queue.includes(job)) 11 queue.push(job); 12 queueFlush(); 13 } 14 function queueFlush() { 15 if (!flushing && !flushPending) { 16 flushPending = true; 17 queueMicrotask(flushJobs); 18 } 19 } 20 function flushJobs() { 21 flushPending = false; 22 flushing = true; 23 for (let i = 0; i < queue.length; i++) { 24 queue[i](); 25 } 26 queue.length = 0; 27 flushing = false; 28 } 29 30
vendor: 1,224 bytes, lines 30-80
30// packages/alpinejs/src/reactivity.js 31 var reactive; 32 var effect; 33 var release; 34 var raw; 35 var shouldSchedule = true; 36 function disableEffectScheduling(callback) { 37 shouldSchedule = false; 38 callback(); 39 shouldSchedule = true; 40 } 41 function setReactivityEngine(engine) { 42 reactive = engine.reactive; 43 release = engine.release; 44 effect = (callback) => engine.effect(callback, {scheduler: (task) => { 45 if (shouldSchedule) { 46 scheduler(task); 47 } else { 48 task(); 49 } 50 }}); 51 raw = engine.raw; 52 } 53 function overrideEffect(override) { 54 effect = override; 55 } 56 function elementBoundEffect(el) { 57 let cleanup2 = () => { 58 }; 59 let wrappedEffect = (callback) => { 60 let effectReference = effect(callback); 61 if (!el._x_effects) { 62 el._x_effects = new Set(); 63 el._x_runEffects = () => { 64 el._x_effects.forEach((i) => i()); 65 }; 66 } 67 el._x_effects.add(effectReference); 68 cleanup2 = () => { 69 if (effectReference === void 0) 70 return; 71 el._x_effects.delete(effectReference); 72 release(effectReference); 73 }; 74 }; 75 return [wrappedEffect, () => { 76 cleanup2(); 77 }]; 78 } 79 80
80// packages/alpinejs/src/mutation.js 81 var onAttributeAddeds = []; 82 var onElRemoveds = []; 83 var onElAddeds = []; 84 function onElAdded(callback) { 85 onElAddeds.push(callback); 86 } 87 function onElRemoved(callback) { 88 onElRemoveds.push(callback); 89 } 90 function onAttributesAdded(callback) { 91 onAttributeAddeds.push(callback); 92 } 93 function onAttributeRemoved(el, name, callback) { 94 if (!el._x_attributeCleanups) 95 el._x_attributeCleanups = {}; 96 if (!el._x_attributeCleanups[name]) 97 el._x_attributeCleanups[name] = []; 98 el._x_attributeCleanups[name].push(callback); 99 } 100 function cleanupAttributes(el, names) { 101 if (!el._x_attributeCleanups) 102 return; 103 Object.entries(el._x_attributeCleanups).forEach(([name, value]) => { 104 (names === void 0 || names.includes(name)) && value.forEach((i) => i()); 105 delete el._x_attributeCleanups[name]; 106 }); 107 } 108 var observer = new MutationObserver(onMutate); 109 var currentlyObserving = false; 110 function startObservingMutations() { 111 observer.observe(document, {subtree: true, childList: true, attributes: true, attributeOldValue: true}); 112 currentlyObserving = true; 113 } 114 function stopObservingMutations() { 115 observer.disconnect(); 116 currentlyObserving = false; 117 } 118 var recordQueue = []; 119 var willProcessRecordQueue = false; 120 function flushObserver() { 121 recordQueue = recordQueue.concat(observer.takeRecords()); 122 if (recordQueue.length && !willProcessRecordQueue) { 123 willProcessRecordQueue = true; 124 queueMicrotask(() => { 125 processRecordQueue(); 126 willProcessRecordQueue = false; 127 }); 128 } 129 } 130 function processRecordQueue() { 131 onMutate(recordQueue); 132 recordQueue.length = 0; 133 } 134 function mutateDom(callback) { 135 if (!currentlyObserving) 136 return callback(); 137 flushObserver(); 138 stopObservingMutations(); 139 let result = callback(); 140 startObservingMutations(); 141 return result; 142 } 143 function onMutate(mutations) { 144 let addedNodes = []; 145 let removedNodes = []; 146 let addedAttributes = new Map(); 147 let removedAttributes = new Map(); 148 for (let i = 0; i < mutations.length; i++) { 149 if (mutations[i].target._x_ignoreMutationObserver) 150 continue; 151 if (mutations[i].type === "childList") { 152 mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.push(node)); 153 mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.push(node)); 154 } 155 if (mutations[i].type === "attributes") { 156 let el = mutations[i].target; 157 let name = mutations[i].attributeName; 158 let oldValue = mutations[i].oldValue; 159 let add2 = () => { 160 if (!addedAttributes.has(el)) 161 addedAttributes.set(el, []); 162 addedAttributes.get(el).push({name, value: el.getAttribute(name)}); 163 }; 164 let remove = () => { 165 if (!removedAttributes.has(el)) 166 removedAttributes.set(el, []); 167 removedAttributes.get(el).push(name); 168 }; 169 if (el.hasAttribute(name) && oldValue === null) { 170 add2(); 171 } else if (el.hasAttribute(name)) { 172 remove(); 173 add2(); 174 } else { 175 remove(); 176 } 177 } 178 } 179 removedAttributes.forEach((attrs, el) => { 180 cleanupAttributes(el, attrs); 181 }); 182 addedAttributes.forEach((attrs, el) => { 183 onAttributeAddeds.forEach((i) => i(el, attrs)); 184 }); 185 for (let node of addedNodes) { 186 if (removedNodes.includes(node)) 187 continue; 188 onElAddeds.forEach((i) => i(node)); 189 } 190 for (let node of removedNodes) { 191 if (addedNodes.includes(node)) 192 continue; 193 onElRemoveds.forEach((i) => i(node)); 194 } 195 addedNodes = null; 196 removedNodes = null; 197 addedAttributes = null; 198 removedAttributes = null; 199 } 200 201
201// packages/alpinejs/src/scope.js 202 function addScopeToNode(node, data2, referenceNode) { 203 node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)]; 204 return () => { 205 node._x_dataStack = node._x_dataStack.filter((i) => i !== data2); 206 }; 207 } 208 function refreshScope(element, scope) { 209 let existingScope = element._x_dataStack[0]; 210 Object.entries(scope).forEach(([key, value]) => { 211 existingScope[key] = value; 212 }); 213 } 214 function closestDataStack(node) { 215 if (node._x_dataStack) 216 return node._x_dataStack; 217 if (node instanceof ShadowRoot) { 218 return closestDataStack(node.host); 219 } 220 if (!node.parentNode) { 221 return []; 222 } 223 return closestDataStack(node.parentNode); 224 } 225 function mergeProxies(objects) { 226 return new Proxy({}, { 227 ownKeys: () => { 228 return Array.from(new Set(objects.flatMap((i) => Object.keys(i)))); 229 }, 230 has: (target, name) => { 231 return objects.some((obj) => obj.hasOwnProperty(name)); 232 }, 233 get: (target, name) => { 234 return (objects.find((obj) => obj.hasOwnProperty(name)) || {})[name]; 235 }, 236 set: (target, name, value) => { 237 let closestObjectWithKey = objects.find((obj) => obj.hasOwnProperty(name)); 238 if (closestObjectWithKey) { 239 closestObjectWithKey[name] = value; 240 } else { 241 objects[objects.length - 1][name] = value; 242 } 243 return true; 244 } 245 }); 246 } 247 248
vendor: 2,011 bytes, lines 248-309
248// packages/alpinejs/src/interceptor.js 249 function initInterceptors(data2) { 250 let isObject2 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null; 251 let recurse = (obj, basePath = "") => { 252 Object.entries(obj).forEach(([key, value]) => { 253 let path = basePath === "" ? key : `${basePath}.${key}`; 254 if (typeof value === "object" && value !== null && value._x_interceptor) { 255 obj[key] = value.initialize(data2, path, key); 256 } else { 257 if (isObject2(value) && value !== obj && !(value instanceof Element)) { 258 recurse(value, path); 259 } 260 } 261 }); 262 }; 263 return recurse(data2); 264 } 265 function interceptor(callback, mutateObj = () => { 266 }) { 267 let obj = { 268 initialValue: void 0, 269 _x_interceptor: true, 270 initialize(data2, path, key) { 271 return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key); 272 } 273 }; 274 mutateObj(obj); 275 return (initialValue) => { 276 if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) { 277 let initialize = obj.initialize.bind(obj); 278 obj.initialize = (data2, path, key) => { 279 let innerValue = initialValue.initialize(data2, path, key); 280 obj.initialValue = innerValue; 281 return initialize(data2, path, key); 282 }; 283 } else { 284 obj.initialValue = initialValue; 285 } 286 return obj; 287 }; 288 } 289 function get(obj, path) { 290 return path.split(".").reduce((carry, segment) => carry[segment], obj); 291 } 292 function set(obj, path, value) { 293 if (typeof path === "string") 294 path = path.split("."); 295 if (path.length === 1) 296 obj[path[0]] = value; 297 else if (path.length === 0) 298 throw error; 299 else { 300 if (obj[path[0]]) 301 return set(obj[path[0]], path.slice(1), value); 302 else { 303 obj[path[0]] = {}; 304 return set(obj[path[0]], path.slice(1), value); 305 } 306 } 307 } 308 309
309// packages/alpinejs/src/magics.js 310 var magics = {}; 311 function magic(name, callback) { 312 magics[name] = callback; 313 } 314 function injectMagics(obj, el) { 315 Object.entries(magics).forEach(([name, callback]) => { 316 Object.defineProperty(obj, `$${name}`, { 317 get() { 318 return callback(el, {Alpine: alpine_default, interceptor}); 319 }, 320 enumerable: false 321 }); 322 }); 323 return obj; 324 } 325 326
326// packages/alpinejs/src/evaluator.js 327 function evaluate(el, expression, extras = {}) { 328 let result; 329 evaluateLater(el, expression)((value) => result = value, extras); 330 return result; 331 } 332 function evaluateLater(...args) { 333 return theEvaluatorFunction(...args); 334 } 335 var theEvaluatorFunction = normalEvaluator; 336 function setEvaluator(newEvaluator) { 337 theEvaluatorFunction = newEvaluator; 338 } 339 function normalEvaluator(el, expression) { 340 let overriddenMagics = {}; 341 injectMagics(overriddenMagics, el); 342 let dataStack = [overriddenMagics, ...closestDataStack(el)]; 343 if (typeof expression === "function") { 344 return generateEvaluatorFromFunction(dataStack, expression); 345 } 346 let evaluator = generateEvaluatorFromString(dataStack, expression); 347 return tryCatch.bind(null, el, expression, evaluator); 348 } 349 function generateEvaluatorFromFunction(dataStack, func) { 350 return (receiver = () => { 351 }, {scope = {}, params = []} = {}) => { 352 let result = func.apply(mergeProxies([scope, ...dataStack]), params); 353 runIfTypeOfFunction(receiver, result); 354 }; 355 } 356 var evaluatorMemo = {}; 357 function generateFunctionFromString(expression) { 358 if (evaluatorMemo[expression]) { 359 return evaluatorMemo[expression]; 360 } 361 let AsyncFunction = Object.getPrototypeOf(async function() { 362 }).constructor; 363 let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression) || /^(let|const)/.test(expression) ? `(() => { ${expression} })()` : expression; 364 let func = new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`); 365 evaluatorMemo[expression] = func; 366 return func; 367 } 368 function generateEvaluatorFromString(dataStack, expression) { 369 let func = generateFunctionFromString(expression); 370 return (receiver = () => { 371 }, {scope = {}, params = []} = {}) => { 372 func.result = void 0; 373 func.finished = false; 374 let completeScope = mergeProxies([scope, ...dataStack]); 375 let promise = func(func, completeScope); 376 if (func.finished) { 377 runIfTypeOfFunction(receiver, func.result, completeScope, params); 378 } else { 379 promise.then((result) => { 380 runIfTypeOfFunction(receiver, result, completeScope, params); 381 }); 382 } 383 }; 384 } 385 function runIfTypeOfFunction(receiver, value, scope, params) { 386 if (typeof value === "function") { 387 let result = value.apply(scope, params); 388 if (result instanceof Promise) { 389 result.then((i) => runIfTypeOfFunction(receiver, i, scope, params)); 390 } else { 391 receiver(result); 392 } 393 } else { 394 receiver(value); 395 } 396 } 397 function tryCatch(el, expression, callback, ...args) { 398 try { 399 return callback(...args); 400 } catch (e) { 401 console.warn(`Alpine Expression Error: ${e.message} 402 403Expression: "${expression}" 404 405`, el); 406 throw e; 407 } 408 } 409 410
vendor: 4,603 bytes, lines 410-540
410// packages/alpinejs/src/directives.js 411 var prefixAsString = "x-"; 412 function prefix(subject = "") { 413 return prefixAsString + subject; 414 } 415 function setPrefix(newPrefix) { 416 prefixAsString = newPrefix; 417 } 418 var directiveHandlers = {}; 419 function directive(name, callback) { 420 directiveHandlers[name] = callback; 421 } 422 function directives(el, attributes, originalAttributeOverride) { 423 let transformedAttributeMap = {}; 424 let directives2 = Array.from(attributes).map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority); 425 return directives2.map((directive2) => { 426 return getDirectiveHandler(el, directive2); 427 }); 428 } 429 function attributesOnly(attributes) { 430 return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr)); 431 } 432 var isDeferringHandlers = false; 433 var directiveHandlerStacks = new Map(); 434 var currentHandlerStackKey = Symbol(); 435 function deferHandlingDirectives(callback) { 436 isDeferringHandlers = true; 437 let key = Symbol(); 438 currentHandlerStackKey = key; 439 directiveHandlerStacks.set(key, []); 440 let flushHandlers = () => { 441 while (directiveHandlerStacks.get(key).length) 442 directiveHandlerStacks.get(key).shift()(); 443 directiveHandlerStacks.delete(key); 444 }; 445 let stopDeferring = () => { 446 isDeferringHandlers = false; 447 flushHandlers(); 448 }; 449 callback(flushHandlers); 450 stopDeferring(); 451 } 452 function getDirectiveHandler(el, directive2) { 453 let noop = () => { 454 }; 455 let handler3 = directiveHandlers[directive2.type] || noop; 456 let cleanups = []; 457 let cleanup2 = (callback) => cleanups.push(callback); 458 let [effect3, cleanupEffect] = elementBoundEffect(el); 459 cleanups.push(cleanupEffect); 460 let utilities = { 461 Alpine: alpine_default, 462 effect: effect3, 463 cleanup: cleanup2, 464 evaluateLater: evaluateLater.bind(evaluateLater, el), 465 evaluate: evaluate.bind(evaluate, el) 466 }; 467 let doCleanup = () => cleanups.forEach((i) => i()); 468 onAttributeRemoved(el, directive2.original, doCleanup); 469 let fullHandler = () => { 470 if (el._x_ignore || el._x_ignoreSelf) 471 return; 472 handler3.inline && handler3.inline(el, directive2, utilities); 473 handler3 = handler3.bind(handler3, el, directive2, utilities); 474 isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler3) : handler3(); 475 }; 476 fullHandler.runCleanups = doCleanup; 477 return fullHandler; 478 } 479 var startingWith = (subject, replacement) => ({name, value}) => { 480 if (name.startsWith(subject)) 481 name = name.replace(subject, replacement); 482 return {name, value}; 483 }; 484 var into = (i) => i; 485 function toTransformedAttributes(callback = () => { 486 }) { 487 return ({name, value}) => { 488 let {name: newName, value: newValue} = attributeTransformers.reduce((carry, transform) => { 489 return transform(carry); 490 }, {name, value}); 491 if (newName !== name) 492 callback(newName, name); 493 return {name: newName, value: newValue}; 494 }; 495 } 496 var attributeTransformers = []; 497 function mapAttributes(callback) { 498 attributeTransformers.push(callback); 499 } 500 function outNonAlpineAttributes({name}) { 501 return alpineAttributeRegex().test(name); 502 } 503 var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`); 504 function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) { 505 return ({name, value}) => { 506 let typeMatch = name.match(alpineAttributeRegex()); 507 let valueMatch = name.match(/:([a-zA-Z0-9\-:]+)/); 508 let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || []; 509 let original = originalAttributeOverride || transformedAttributeMap[name] || name; 510 return { 511 type: typeMatch ? typeMatch[1] : null, 512 value: valueMatch ? valueMatch[1] : null, 513 modifiers: modifiers.map((i) => i.replace(".", "")), 514 expression: value, 515 original 516 }; 517 }; 518 } 519 var DEFAULT = "DEFAULT"; 520 var directiveOrder = [ 521 "ignore", 522 "ref", 523 "data", 524 "bind", 525 "init", 526 "for", 527 "model", 528 "transition", 529 "show", 530 "if", 531 DEFAULT, 532 "element" 533 ]; 534 function byPriority(a, b) { 535 let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type; 536 let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type; 537 return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB); 538 } 539 540
540// packages/alpinejs/src/utils/dispatch.js 541 function dispatch(el, name, detail = {}) { 542 el.dispatchEvent(new CustomEvent(name, { 543 detail, 544 bubbles: true, 545 composed: true, 546 cancelable: true 547 })); 548 } 549 550
550// packages/alpinejs/src/nextTick.js 551 var tickStack = []; 552 var isHolding = false; 553 function nextTick(callback) { 554 tickStack.push(callback); 555 queueMicrotask(() => { 556 isHolding || setTimeout(() => { 557 releaseNextTicks(); 558 }); 559 }); 560 } 561 function releaseNextTicks() { 562 isHolding = false; 563 while (tickStack.length) 564 tickStack.shift()(); 565 } 566 function holdNextTicks() { 567 isHolding = true; 568 } 569 570
570// packages/alpinejs/src/utils/walk.js 571 function walk(el, callback) { 572 if (el instanceof ShadowRoot) { 573 Array.from(el.children).forEach((el2) => walk(el2, callback)); 574 return; 575 } 576 let skip = false; 577 callback(el, () => skip = true); 578 if (skip) 579 return; 580 let node = el.firstElementChild; 581 while (node) { 582 walk(node, callback, false); 583 node = node.nextElementSibling; 584 }
vendor: 187 bytes, lines 584-593
584 585 } 586 587 // packages/alpinejs/src/utils/warn.js 588 function warn(message, ...args) { 589 console.warn(`Alpine Warning: ${message}`, ...args); 590 } 591 592 // packages/alpinejs/src/lifecycle.js 593
593function start() { 594 if (!document.body) 595 warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?"); 596 dispatch(document, "alpine:init"); 597 dispatch(document, "alpine:initializing"); 598 startObservingMutations(); 599 onElAdded((el) => initTree(el, walk)); 600 onElRemoved((el) => nextTick(() => destroyTree(el))); 601 onAttributesAdded((el, attrs) => { 602 directives(el, attrs).forEach((handle) => handle()); 603 }); 604 let outNestedComponents = (el) => !closestRoot(el.parentElement); 605 Array.from(document.querySelectorAll(allSelectors())).filter(outNestedComponents).forEach((el) => { 606 initTree(el); 607 }); 608 dispatch(document, "alpine:initialized"); 609 } 610 var rootSelectorCallbacks = []; 611 var initSelectorCallbacks = []; 612 function rootSelectors() { 613 return rootSelectorCallbacks.map((fn) => fn()); 614 } 615 function allSelectors() { 616 return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn()); 617 } 618 function addRootSelector(selectorCallback) { 619 rootSelectorCallbacks.push(selectorCallback); 620 } 621 function addInitSelector(selectorCallback) { 622 initSelectorCallbacks.push(selectorCallback); 623 } 624 function closestRoot(el) { 625 if (!el) 626 return; 627 if (rootSelectors().some((selector) => el.matches(selector))) 628 return el; 629 if (!el.parentElement) 630 return; 631 return closestRoot(el.parentElement); 632 } 633 function isRoot(el) { 634 return rootSelectors().some((selector) => el.matches(selector)); 635 } 636 function initTree(el, walker = walk) { 637 deferHandlingDirectives(() => { 638 walker(el, (el2, skip) => { 639 directives(el2, el2.attributes).forEach((handle) => handle()); 640 el2._x_ignore && skip(); 641 }); 642 }); 643 } 644 function destroyTree(root) { 645 walk(root, (el) => cleanupAttributes(el)); 646 } 647 648
648// packages/alpinejs/src/utils/debounce.js 649 function debounce(func, wait) { 650 var timeout; 651 return function() { 652 var context = this, args = arguments; 653 var
vendor: 527 bytes, lines 653-675
653 later = function() { 654 timeout = null; 655 func.apply(context, args); 656 }; 657 clearTimeout(timeout); 658 timeout = setTimeout(later, wait); 659 }; 660 } 661 662 // packages/alpinejs/src/utils/throttle.js 663 function throttle(func, limit) { 664 let inThrottle; 665 return function() { 666 let context = this, args = arguments; 667 if (!inThrottle) { 668 func.apply(context, args); 669 inThrottle = true; 670 setTimeout(() => inThrottle = false, limit); 671 } 672 }; 673 } 674 675 // packages/alpinejs/src/
675plugin.js 676 function plugin(callback) { 677 callback(alpine_default); 678 } 679 680
680// packages/alpinejs/src/store.js 681 var stores = {}; 682 var isReactive = false; 683 function store(name, value) { 684 if (!isReactive) { 685 stores = reactive(stores); 686 isReactive = true; 687 } 688 if (value === void 0) { 689 return stores[name]; 690 } 691 stores[name] = value; 692 if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") { 693 stores[name].init(); 694 } 695 } 696 function getStores() { 697 return stores; 698 } 699 700
vendor: 968 bytes, lines 700-734
700// packages/alpinejs/src/clone.js 701 var isCloning = false; 702 function skipDuringClone(callback) { 703 return (...args) => isCloning || callback(...args); 704 } 705 function clone(oldEl, newEl) { 706 newEl._x_dataStack = oldEl._x_dataStack; 707 isCloning = true; 708 dontRegisterReactiveSideEffects(() => { 709 cloneTree(newEl); 710 }); 711 isCloning = false; 712 } 713 function cloneTree(el) { 714 let hasRunThroughFirstEl = false; 715 let shallowWalker = (el2, callback) => { 716 walk(el2, (el3, skip) => { 717 if (hasRunThroughFirstEl && isRoot(el3)) 718 return skip(); 719 hasRunThroughFirstEl = true; 720 callback(el3, skip); 721 }); 722 }; 723 initTree(el, shallowWalker); 724 } 725 function dontRegisterReactiveSideEffects(callback) { 726 let cache = effect; 727 overrideEffect((callback2, el) => { 728 let storedEffect = cache(callback2); 729 release(storedEffect); 730 return () => { 731 }; 732 }); 733 callback(); 734 overrideEffect(cache)
vendor: 708 bytes, lines 734-770
734; 735 } 736 737 // packages/alpinejs/src/datas.js 738 var datas = {}; 739 function data(name, callback) { 740 datas[name] = callback; 741 } 742 function injectDataProviders(obj, context) { 743 Object.entries(datas).forEach(([name, callback]) => { 744 Object.defineProperty(obj, name, { 745 get() { 746 return (...args) => { 747 return callback.bind(context)(...args); 748 }; 749 }, 750 enumerable: false 751 }); 752 }); 753 return obj; 754 } 755 756 // packages/alpinejs/src/alpine.js 757 var Alpine = { 758 get reactive() { 759 return reactive; 760 }, 761 get release() { 762 return release; 763 }, 764 get effect() { 765 return effect; 766 }, 767 get raw() { 768 return raw; 769 }, 770
770version: "3.3.2", 771 disableEffectScheduling, 772 setReactivityEngine, 773 addRootSelector, 774 mapAttributes, 775 evaluateLater, 776 setEvaluator, 777 closestRoot, 778 interceptor, 779 mutateDom, 780 directive, 781 throttle, 782 debounce, 783 evaluate, 784 initTree, 785 nextTick, 786 prefix: setPrefix, 787 plugin, 788 magic, 789 store, 790 start, 791 clone, 792 data 793 }; 794 var alpine_default = Alpine; 795 796
vendor: 2,680 bytes, lines 796-861
796// node_modules/@vue/shared/dist/shared.esm-bundler.js 797 function makeMap(str, expectsLowerCase) { 798 const map = Object.create(null); 799 const list = str.split(","); 800 for (let i = 0; i < list.length; i++) { 801 map[list[i]] = true; 802 } 803 return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val]; 804 } 805 var PatchFlagNames = { 806 [1]: `TEXT`, 807 [2]: `CLASS`, 808 [4]: `STYLE`, 809 [8]: `PROPS`, 810 [16]: `FULL_PROPS`, 811 [32]: `HYDRATE_EVENTS`, 812 [64]: `STABLE_FRAGMENT`, 813 [128]: `KEYED_FRAGMENT`, 814 [256]: `UNKEYED_FRAGMENT`, 815 [512]: `NEED_PATCH`, 816 [1024]: `DYNAMIC_SLOTS`, 817 [2048]: `DEV_ROOT_FRAGMENT`, 818 [-1]: `HOISTED`, 819 [-2]: `BAIL` 820 }; 821 var slotFlagsText = { 822 [1]: "STABLE", 823 [2]: "DYNAMIC", 824 [3]: "FORWARDED" 825 }; 826 var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; 827 var isBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`); 828 var EMPTY_OBJ = true ? Object.freeze({}) : {}; 829 var EMPTY_ARR = true ? Object.freeze([]) : []; 830 var extend = Object.assign; 831 var hasOwnProperty = Object.prototype.hasOwnProperty; 832 var hasOwn = (val, key) => hasOwnProperty.call(val, key); 833 var isArray = Array.isArray; 834 var isMap = (val) => toTypeString(val) === "[object Map]"; 835 var isString = (val) => typeof val === "string"; 836 var isSymbol = (val) => typeof val === "symbol"; 837 var isObject = (val) => val !== null && typeof val === "object"; 838 var objectToString = Object.prototype.toString; 839 var toTypeString = (value) => objectToString.call(value); 840 var toRawType = (value) => { 841 return toTypeString(value).slice(8, -1); 842 }; 843 var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; 844 var cacheStringFunction = (fn) => { 845 const cache = Object.create(null); 846 return (str) => { 847 const hit = cache[str]; 848 return hit || (cache[str] = fn(str)); 849 }; 850 }; 851 var camelizeRE = /-(\w)/g; 852 var camelize = cacheStringFunction((str) => { 853 return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); 854 }); 855 var hyphenateRE = /\B([A-Z])/g; 856 var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); 857 var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); 858 var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``); 859 var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); 860 861
vendor: 20,251 bytes, lines 861-1513
861// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js 862 var targetMap = new WeakMap(); 863 var effectStack = []; 864 var activeEffect; 865 var ITERATE_KEY = Symbol(true ? "iterate" : ""); 866 var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : ""); 867 function isEffect(fn) { 868 return fn && fn._isEffect === true; 869 } 870 function effect2(fn, options = EMPTY_OBJ) { 871 if (isEffect(fn)) { 872 fn = fn.raw; 873 } 874 const effect3 = createReactiveEffect(fn, options); 875 if (!options.lazy) { 876 effect3(); 877 } 878 return effect3; 879 } 880 function stop(effect3) { 881 if (effect3.active) { 882 cleanup(effect3); 883 if (effect3.options.onStop) { 884 effect3.options.onStop(); 885 } 886 effect3.active = false; 887 } 888 } 889 var uid = 0; 890 function createReactiveEffect(fn, options) { 891 const effect3 = function reactiveEffect() { 892 if (!effect3.active) { 893 return fn(); 894 } 895 if (!effectStack.includes(effect3)) { 896 cleanup(effect3); 897 try { 898 enableTracking(); 899 effectStack.push(effect3); 900 activeEffect = effect3; 901 return fn(); 902 } finally { 903 effectStack.pop(); 904 resetTracking(); 905 activeEffect = effectStack[effectStack.length - 1]; 906 } 907 } 908 }; 909 effect3.id = uid++; 910 effect3.allowRecurse = !!options.allowRecurse; 911 effect3._isEffect = true; 912 effect3.active = true; 913 effect3.raw = fn; 914 effect3.deps = []; 915 effect3.options = options; 916 return effect3; 917 } 918 function cleanup(effect3) { 919 const {deps} = effect3; 920 if (deps.length) { 921 for (let i = 0; i < deps.length; i++) { 922 deps[i].delete(effect3); 923 } 924 deps.length = 0; 925 } 926 } 927 var shouldTrack = true; 928 var trackStack = []; 929 function pauseTracking() { 930 trackStack.push(shouldTrack); 931 shouldTrack = false; 932 } 933 function enableTracking() { 934 trackStack.push(shouldTrack); 935 shouldTrack = true; 936 } 937 function resetTracking() { 938 const last = trackStack.pop(); 939 shouldTrack = last === void 0 ? true : last; 940 } 941 function track(target, type, key) { 942 if (!shouldTrack || activeEffect === void 0) { 943 return; 944 } 945 let depsMap = targetMap.get(target); 946 if (!depsMap) { 947 targetMap.set(target, depsMap = new Map()); 948 } 949 let dep = depsMap.get(key); 950 if (!dep) { 951 depsMap.set(key, dep = new Set()); 952 } 953 if (!dep.has(activeEffect)) { 954 dep.add(activeEffect); 955 activeEffect.deps.push(dep); 956 if (activeEffect.options.onTrack) { 957 activeEffect.options.onTrack({ 958 effect: activeEffect, 959 target, 960 type, 961 key 962 }); 963 } 964 } 965 } 966 function trigger(target, type, key, newValue, oldValue, oldTarget) { 967 const depsMap = targetMap.get(target); 968 if (!depsMap) { 969 return; 970 } 971 const effects = new Set(); 972 const add2 = (effectsToAdd) => { 973 if (effectsToAdd) { 974 effectsToAdd.forEach((effect3) => { 975 if (effect3 !== activeEffect || effect3.allowRecurse) { 976 effects.add(effect3); 977 } 978 }); 979 } 980 }; 981 if (type === "clear") { 982 depsMap.forEach(add2); 983 } else if (key === "length" && isArray(target)) { 984 depsMap.forEach((dep, key2) => { 985 if (key2 === "length" || key2 >= newValue) { 986 add2(dep); 987 } 988 }); 989 } else { 990 if (key !== void 0) { 991 add2(depsMap.get(key)); 992 } 993 switch (type) { 994 case "add": 995 if (!isArray(target)) { 996 add2(depsMap.get(ITERATE_KEY)); 997 if (isMap(target)) { 998 add2(depsMap.get(MAP_KEY_ITERATE_KEY)); 999 } 1000 } else if (isIntegerKey(key)) { 1001 add2(depsMap.get("length")); 1002 } 1003 break; 1004 case "delete": 1005 if (!isArray(target)) { 1006 add2(depsMap.get(ITERATE_KEY)); 1007 if (isMap(target)) { 1008 add2(depsMap.get(MAP_KEY_ITERATE_KEY)); 1009 } 1010 } 1011 break; 1012 case "set": 1013 if (isMap(target)) { 1014 add2(depsMap.get(ITERATE_KEY)); 1015 } 1016 break; 1017 } 1018 } 1019 const run = (effect3) => { 1020 if (effect3.options.onTrigger) { 1021 effect3.options.onTrigger({ 1022 effect: effect3, 1023 target, 1024 key, 1025 type, 1026 newValue, 1027 oldValue, 1028 oldTarget 1029 }); 1030 } 1031 if (effect3.options.scheduler) { 1032 effect3.options.scheduler(effect3); 1033 } else { 1034 effect3(); 1035 } 1036 }; 1037 effects.forEach(run); 1038 } 1039 var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); 1040 var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol)); 1041 var get2 = /* @__PURE__ */ createGetter(); 1042 var shallowGet = /* @__PURE__ */ createGetter(false, true); 1043 var readonlyGet = /* @__PURE__ */ createGetter(true); 1044 var shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); 1045 var arrayInstrumentations = {}; 1046 ["includes", "indexOf", "lastIndexOf"].forEach((key) => { 1047 const method = Array.prototype[key]; 1048 arrayInstrumentations[key] = function(...args) { 1049 const arr = toRaw(this); 1050 for (let i = 0, l = this.length; i < l; i++) { 1051 track(arr, "get", i + ""); 1052 } 1053 const res = method.apply(arr, args); 1054 if (res === -1 || res === false) { 1055 return method.apply(arr, args.map(toRaw)); 1056 } else { 1057 return res; 1058 } 1059 }; 1060 }); 1061 ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { 1062 const method = Array.prototype[key]; 1063 arrayInstrumentations[key] = function(...args) { 1064 pauseTracking(); 1065 const res = method.apply(this, args); 1066 resetTracking(); 1067 return res; 1068 }; 1069 }); 1070 function createGetter(isReadonly = false, shallow = false) { 1071 return function get3(target, key, receiver) { 1072 if (key === "__v_isReactive") { 1073 return !isReadonly; 1074 } else if (key === "__v_isReadonly") { 1075 return isReadonly; 1076 } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { 1077 return target; 1078 } 1079 const targetIsArray = isArray(target); 1080 if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { 1081 return Reflect.get(arrayInstrumentations, key, receiver); 1082 } 1083 const res = Reflect.get(target, key, receiver); 1084 if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { 1085 return res; 1086 } 1087 if (!isReadonly) { 1088 track(target, "get", key); 1089 } 1090 if (shallow) { 1091 return res; 1092 } 1093 if (isRef(res)) { 1094 const shouldUnwrap = !targetIsArray || !isIntegerKey(key); 1095 return shouldUnwrap ? res.value : res; 1096 } 1097 if (isObject(res)) { 1098 return isReadonly ? readonly(res) : reactive2(res); 1099 } 1100 return res; 1101 }; 1102 } 1103 var set2 = /* @__PURE__ */ createSetter(); 1104 var shallowSet = /* @__PURE__ */ createSetter(true); 1105 function createSetter(shallow = false) { 1106 return function set3(target, key, value, receiver) { 1107 let oldValue = target[key]; 1108 if (!shallow) { 1109 value = toRaw(value); 1110 oldValue = toRaw(oldValue); 1111 if (!isArray(target) && isRef(oldValue) && !isRef(value)) { 1112 oldValue.value = value; 1113 return true; 1114 } 1115 } 1116 const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key); 1117 const result = Reflect.set(target, key, value, receiver); 1118 if (target === toRaw(receiver)) { 1119 if (!hadKey) { 1120 trigger(target, "add", key, value); 1121 } else if (hasChanged(value, oldValue)) { 1122 trigger(target, "set", key, value, oldValue); 1123 } 1124 } 1125 return result; 1126 }; 1127 } 1128 function deleteProperty(target, key) { 1129 const hadKey = hasOwn(target, key); 1130 const oldValue = target[key]; 1131 const result = Reflect.deleteProperty(target, key); 1132 if (result && hadKey) { 1133 trigger(target, "delete", key, void 0, oldValue); 1134 } 1135 return result; 1136 } 1137 function has(target, key) { 1138 const result = Reflect.has(target, key); 1139 if (!isSymbol(key) || !builtInSymbols.has(key)) { 1140 track(target, "has", key); 1141 } 1142 return result; 1143 } 1144 function ownKeys(target) { 1145 track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY); 1146 return Reflect.ownKeys(target); 1147 } 1148 var mutableHandlers = { 1149 get: get2, 1150 set: set2, 1151 deleteProperty, 1152 has, 1153 ownKeys 1154 }; 1155 var readonlyHandlers = { 1156 get: readonlyGet, 1157 set(target, key) { 1158 if (true) { 1159 console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); 1160 } 1161 return true; 1162 }, 1163 deleteProperty(target, key) { 1164 if (true) { 1165 console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); 1166 } 1167 return true; 1168 } 1169 }; 1170 var shallowReactiveHandlers = extend({}, mutableHandlers, { 1171 get: shallowGet, 1172 set: shallowSet 1173 }); 1174 var shallowReadonlyHandlers = extend({}, readonlyHandlers, { 1175 get: shallowReadonlyGet 1176 }); 1177 var toReactive = (value) => isObject(value) ? reactive2(value) : value; 1178 var toReadonly = (value) => isObject(value) ? readonly(value) : value; 1179 var toShallow = (value) => value; 1180 var getProto = (v) => Reflect.getPrototypeOf(v); 1181 function get$1(target, key, isReadonly = false, isShallow = false) { 1182 target = target["__v_raw"]; 1183 const rawTarget = toRaw(target); 1184 const rawKey = toRaw(key); 1185 if (key !== rawKey) { 1186 !isReadonly && track(rawTarget, "get", key); 1187 } 1188 !isReadonly && track(rawTarget, "get", rawKey); 1189 const {has: has2} = getProto(rawTarget); 1190 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 1191 if (has2.call(rawTarget, key)) { 1192 return wrap(target.get(key)); 1193 } else if (has2.call(rawTarget, rawKey)) { 1194 return wrap(target.get(rawKey)); 1195 } else if (target !== rawTarget) { 1196 target.get(key); 1197 } 1198 } 1199 function has$1(key, isReadonly = false) { 1200 const target = this["__v_raw"]; 1201 const rawTarget = toRaw(target); 1202 const rawKey = toRaw(key); 1203 if (key !== rawKey) { 1204 !isReadonly && track(rawTarget, "has", key); 1205 } 1206 !isReadonly && track(rawTarget, "has", rawKey); 1207 return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); 1208 } 1209 function size(target, isReadonly = false) { 1210 target = target["__v_raw"]; 1211 !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY); 1212 return Reflect.get(target, "size", target); 1213 } 1214 function add(value) { 1215 value = toRaw(value); 1216 const target = toRaw(this); 1217 const proto = getProto(target); 1218 const hadKey = proto.has.call(target, value); 1219 if (!hadKey) { 1220 target.add(value); 1221 trigger(target, "add", value, value); 1222 } 1223 return this; 1224 } 1225 function set$1(key, value) { 1226 value = toRaw(value); 1227 const target = toRaw(this); 1228 const {has: has2, get: get3} = getProto(target); 1229 let hadKey = has2.call(target, key); 1230 if (!hadKey) { 1231 key = toRaw(key); 1232 hadKey = has2.call(target, key); 1233 } else if (true) { 1234 checkIdentityKeys(target, has2, key); 1235 } 1236 const oldValue = get3.call(target, key); 1237 target.set(key, value); 1238 if (!hadKey) { 1239 trigger(target, "add", key, value); 1240 } else if (hasChanged(value, oldValue)) { 1241 trigger(target, "set", key, value, oldValue); 1242 } 1243 return this; 1244 } 1245 function deleteEntry(key) { 1246 const target = toRaw(this); 1247 const {has: has2, get: get3} = getProto(target); 1248 let hadKey = has2.call(target, key); 1249 if (!hadKey) { 1250 key = toRaw(key); 1251 hadKey = has2.call(target, key); 1252 } else if (true) { 1253 checkIdentityKeys(target, has2, key); 1254 } 1255 const oldValue = get3 ? get3.call(target, key) : void 0; 1256 const result = target.delete(key); 1257 if (hadKey) { 1258 trigger(target, "delete", key, void 0, oldValue); 1259 } 1260 return result; 1261 } 1262 function clear() { 1263 const target = toRaw(this); 1264 const hadItems = target.size !== 0; 1265 const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0; 1266 const result = target.clear(); 1267 if (hadItems) { 1268 trigger(target, "clear", void 0, void 0, oldTarget); 1269 } 1270 return result; 1271 } 1272 function createForEach(isReadonly, isShallow) { 1273 return function forEach(callback, thisArg) { 1274 const observed = this; 1275 const target = observed["__v_raw"]; 1276 const rawTarget = toRaw(target); 1277 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 1278 !isReadonly && track(rawTarget, "iterate", ITERATE_KEY); 1279 return target.forEach((value, key) => { 1280 return callback.call(thisArg, wrap(value), wrap(key), observed); 1281 }); 1282 }; 1283 } 1284 function createIterableMethod(method, isReadonly, isShallow) { 1285 return function(...args) { 1286 const target = this["__v_raw"]; 1287 const rawTarget = toRaw(target); 1288 const targetIsMap = isMap(rawTarget); 1289 const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; 1290 const isKeyOnly = method === "keys" && targetIsMap; 1291 const innerIterator = target[method](...args); 1292 const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; 1293 !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); 1294 return { 1295 next() { 1296 const {value, done} = innerIterator.next(); 1297 return done ? {value, done} : { 1298 value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), 1299 done 1300 }; 1301 }, 1302 [Symbol.iterator]() { 1303 return this; 1304 } 1305 }; 1306 }; 1307 } 1308 function createReadonlyMethod(type) { 1309 return function(...args) { 1310 if (true) { 1311 const key = args[0] ? `on key "${args[0]}" ` : ``; 1312 console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); 1313 } 1314 return type === "delete" ? false : this; 1315 }; 1316 } 1317 var mutableInstrumentations = { 1318 get(key) { 1319 return get$1(this, key); 1320 }, 1321 get size() { 1322 return size(this); 1323 }, 1324 has: has$1, 1325 add, 1326 set: set$1, 1327 delete: deleteEntry, 1328 clear, 1329 forEach: createForEach(false, false) 1330 }; 1331 var shallowInstrumentations = { 1332 get(key) { 1333 return get$1(this, key, false, true); 1334 }, 1335 get size() { 1336 return size(this); 1337 }, 1338 has: has$1, 1339 add, 1340 set: set$1, 1341 delete: deleteEntry, 1342 clear, 1343 forEach: createForEach(false, true) 1344 }; 1345 var readonlyInstrumentations = { 1346 get(key) { 1347 return get$1(this, key, true); 1348 }, 1349 get size() { 1350 return size(this, true); 1351 }, 1352 has(key) { 1353 return has$1.call(this, key, true); 1354 }, 1355 add: createReadonlyMethod("add"), 1356 set: createReadonlyMethod("set"), 1357 delete: createReadonlyMethod("delete"), 1358 clear: createReadonlyMethod("clear"), 1359 forEach: createForEach(true, false) 1360 }; 1361 var shallowReadonlyInstrumentations = { 1362 get(key) { 1363 return get$1(this, key, true, true); 1364 }, 1365 get size() { 1366 return size(this, true); 1367 }, 1368 has(key) { 1369 return has$1.call(this, key, true); 1370 }, 1371 add: createReadonlyMethod("add"), 1372 set: createReadonlyMethod("set"), 1373 delete: createReadonlyMethod("delete"), 1374 clear: createReadonlyMethod("clear"), 1375 forEach: createForEach(true, true) 1376 }; 1377 var iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; 1378 iteratorMethods.forEach((method) => { 1379 mutableInstrumentations[method] = createIterableMethod(method, false, false); 1380 readonlyInstrumentations[method] = createIterableMethod(method, true, false); 1381 shallowInstrumentations[method] = createIterableMethod(method, false, true); 1382 shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); 1383 }); 1384 function createInstrumentationGetter(isReadonly, shallow) { 1385 const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations; 1386 return (target, key, receiver) => { 1387 if (key === "__v_isReactive") { 1388 return !isReadonly; 1389 } else if (key === "__v_isReadonly") { 1390 return isReadonly; 1391 } else if (key === "__v_raw") { 1392 return target; 1393 } 1394 return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver); 1395 }; 1396 } 1397 var mutableCollectionHandlers = { 1398 get: createInstrumentationGetter(false, false) 1399 }; 1400 var shallowCollectionHandlers = { 1401 get: createInstrumentationGetter(false, true) 1402 }; 1403 var readonlyCollectionHandlers = { 1404 get: createInstrumentationGetter(true, false) 1405 }; 1406 var shallowReadonlyCollectionHandlers = { 1407 get: createInstrumentationGetter(true, true) 1408 }; 1409 function checkIdentityKeys(target, has2, key) { 1410 const rawKey = toRaw(key); 1411 if (rawKey !== key && has2.call(target, rawKey)) { 1412 const type = toRawType(target); 1413 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.`); 1414 } 1415 } 1416 var reactiveMap = new WeakMap(); 1417 var shallowReactiveMap = new WeakMap(); 1418 var readonlyMap = new WeakMap(); 1419 var shallowReadonlyMap = new WeakMap(); 1420 function targetTypeMap(rawType) { 1421 switch (rawType) { 1422 case "Object": 1423 case "Array": 1424 return 1; 1425 case "Map": 1426 case "Set": 1427 case "WeakMap": 1428 case "WeakSet": 1429 return 2; 1430 default: 1431 return 0; 1432 } 1433 } 1434 function getTargetType(value) { 1435 return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value)); 1436 } 1437 function reactive2(target) { 1438 if (target && target["__v_isReadonly"]) { 1439 return target; 1440 } 1441 return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); 1442 } 1443 function readonly(target) { 1444 return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); 1445 } 1446 function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { 1447 if (!isObject(target)) { 1448 if (true) { 1449 console.warn(`value cannot be made reactive: ${String(target)}`); 1450 } 1451 return target; 1452 } 1453 if (target["__v_raw"] && !(isReadonly && target["__v_isReactive"])) { 1454 return target; 1455 } 1456 const existingProxy = proxyMap.get(target); 1457 if (existingProxy) { 1458 return existingProxy; 1459 } 1460 const targetType = getTargetType(target); 1461 if (targetType === 0) { 1462 return target; 1463 } 1464 const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers); 1465 proxyMap.set(target, proxy); 1466 return proxy; 1467 } 1468 function toRaw(observed) { 1469 return observed && toRaw(observed["__v_raw"]) || observed; 1470 } 1471 function isRef(r) { 1472 return Boolean(r && r.__v_isRef === true); 1473 } 1474 1475 // packages/alpinejs/src/magics/$nextTick.js 1476 magic("nextTick", () => nextTick); 1477 1478 // packages/alpinejs/src/magics/$dispatch.js 1479 magic("dispatch", (el) => dispatch.bind(dispatch, el)); 1480 1481 // packages/alpinejs/src/magics/$watch.js 1482 magic("watch", (el) => (key, callback) => { 1483 let evaluate2 = evaluateLater(el, key); 1484 let firstTime = true; 1485 let oldValue; 1486 effect(() => evaluate2((value) => { 1487 let div = document.createElement("div"); 1488 div.dataset.throwAway = value; 1489 if (!firstTime) { 1490 queueMicrotask(() => { 1491 callback(value, oldValue); 1492 oldValue = value; 1493 }); 1494 } else { 1495 oldValue = value; 1496 } 1497 firstTime = false; 1498 })); 1499 }); 1500 1501 // packages/alpinejs/src/magics/$store.js 1502 magic("store", getStores); 1503 1504 // packages/alpinejs/src/magics/$root.js 1505 magic("root", (el) => closestRoot(el)); 1506 1507 // packages/alpinejs/src/magics/$refs.js 1508 magic("refs", (el) => closestRoot(el)._x_refs || {}); 1509 1510 // packages/alpinejs/src/magics/$el.js 1511 magic("el", (el) => el); 1512 1513
vendor: 1,174 bytes, lines 1513-1538
1513// packages/alpinejs/src/utils/classes.js 1514 function setClasses(el, value) { 1515 if (Array.isArray(value)) { 1516 return setClassesFromString(el, value.join(" ")); 1517 } else if (typeof value === "object" && value !== null) { 1518 return setClassesFromObject(el, value); 1519 } else if (typeof value === "function") { 1520 return setClasses(el, value()); 1521 } 1522 return setClassesFromString(el, value); 1523 } 1524 function setClassesFromString(el, classString) { 1525 let split = (classString2) => classString2.split(" ").filter(Boolean); 1526 let missingClasses = (classString2) => classString2.split(" ").filter((i) => !el.classList.contains(i)).filter(Boolean); 1527 let addClassesAndReturnUndo = (classes) => { 1528 el.classList.add(...classes); 1529 return () => { 1530 el.classList.remove(...classes); 1531 }; 1532 }; 1533 classString = classString === true ? classString = "" : classString || ""; 1534 return addClassesAndReturnUndo(missingClasses(classString)); 1535 } 1536 function setClassesFromObject(el, classObject) { 1537 let split = (classString) => classString.split(" ").filter(Boolean); 1538 let forAdd = Object.entries(classObject).flatMap(([classString, bool]) =>
1538 bool ? split(classString) : false).filter(Boolean); 1539 let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean); 1540 let added = []; 1541 let removed = []; 1542 forRemove.forEach((i) => { 1543 if (el.classList.contains(i)) { 1544 el.classList.remove(i); 1545 removed.push(i); 1546 } 1547 }); 1548 forAdd.forEach((i) => { 1549 if (!el.classList.contains(i)) { 1550 el.classList.add(i); 1551 added.push(i); 1552 } 1553 }); 1554 return () => { 1555 removed.forEach((i) => el.classList.add(i)); 1556 added.forEach((i) => el.classList.remove(i)); 1557 }; 1558 } 1559 1560
vendor: 822 bytes, lines 1560-1586
1560// packages/alpinejs/src/utils/styles.js 1561 function setStyles(el, value) { 1562 if (typeof value === "object" && value !== null) { 1563 return setStylesFromObject(el, value); 1564 } 1565 return setStylesFromString(el, value); 1566 } 1567 function setStylesFromObject(el, value) { 1568 let previousStyles = {}; 1569 Object.entries(value).forEach(([key, value2]) => { 1570 previousStyles[key] = el.style[key]; 1571 el.style.setProperty(kebabCase(key), value2); 1572 }); 1573 setTimeout(() => { 1574 if (el.style.length === 0) { 1575 el.removeAttribute("style"); 1576 } 1577 }); 1578 return () => { 1579 setStyles(el, previousStyles); 1580 }; 1581 } 1582 function setStylesFromString(el, value) { 1583 let cache = el.getAttribute("style", value); 1584 el.setAttribute("style", value); 1585 return () => { 1586 el.setAttribute("style", cache
vendor: 509 bytes, lines 1586-1608
1586); 1587 }; 1588 } 1589 function kebabCase(subject) { 1590 return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(); 1591 } 1592 1593 // packages/alpinejs/src/utils/once.js 1594 function once(callback, fallback = () => { 1595 }) { 1596 let called = false; 1597 return function() { 1598 if (!called) { 1599 called = true; 1600 callback.apply(this, arguments); 1601 } else { 1602 fallback.apply(this, arguments); 1603 } 1604 }; 1605 } 1606 1607 // packages/alpinejs/src/directives/x-transition.js 1608 directive("transition", (el, {
vendor: 8,871 bytes, lines 1608-1880
1608value, modifiers, expression}, {evaluate: evaluate2}) => { 1609 if (typeof expression === "function") 1610 expression = evaluate2(expression); 1611 if (!expression) { 1612 registerTransitionsFromHelper(el, modifiers, value); 1613 } else { 1614 registerTransitionsFromClassString(el, expression, value); 1615 } 1616 }); 1617 function registerTransitionsFromClassString(el, classString, stage) { 1618 registerTransitionObject(el, setClasses, ""); 1619 let directiveStorageMap = { 1620 enter: (classes) => { 1621 el._x_transition.enter.during = classes; 1622 }, 1623 "enter-start": (classes) => { 1624 el._x_transition.enter.start = classes; 1625 }, 1626 "enter-end": (classes) => { 1627 el._x_transition.enter.end = classes; 1628 }, 1629 leave: (classes) => { 1630 el._x_transition.leave.during = classes; 1631 }, 1632 "leave-start": (classes) => { 1633 el._x_transition.leave.start = classes; 1634 }, 1635 "leave-end": (classes) => { 1636 el._x_transition.leave.end = classes; 1637 } 1638 }; 1639 directiveStorageMap[stage](classString); 1640 } 1641 function registerTransitionsFromHelper(el, modifiers, stage) { 1642 registerTransitionObject(el, setStyles); 1643 let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage; 1644 let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage); 1645 let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage); 1646 if (modifiers.includes("in") && !doesntSpecify) { 1647 modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out")); 1648 } 1649 if (modifiers.includes("out") && !doesntSpecify) { 1650 modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out")); 1651 } 1652 let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale"); 1653 let wantsOpacity = wantsAll || modifiers.includes("opacity"); 1654 let wantsScale = wantsAll || modifiers.includes("scale"); 1655 let opacityValue = wantsOpacity ? 0 : 1; 1656 let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1; 1657 let delay = modifierValue(modifiers, "delay", 0); 1658 let origin = modifierValue(modifiers, "origin", "center"); 1659 let property = "opacity, transform"; 1660 let durationIn = modifierValue(modifiers, "duration", 150) / 1e3; 1661 let durationOut = modifierValue(modifiers, "duration", 75) / 1e3; 1662 let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`; 1663 if (transitioningIn) { 1664 el._x_transition.enter.during = { 1665 transformOrigin: origin, 1666 transitionDelay: delay, 1667 transitionProperty: property, 1668 transitionDuration: `${durationIn}s`, 1669 transitionTimingFunction: easing 1670 }; 1671 el._x_transition.enter.start = { 1672 opacity: opacityValue, 1673 transform: `scale(${scaleValue})` 1674 }; 1675 el._x_transition.enter.end = { 1676 opacity: 1, 1677 transform: `scale(1)` 1678 }; 1679 } 1680 if (transitioningOut) { 1681 el._x_transition.leave.during = { 1682 transformOrigin: origin, 1683 transitionDelay: delay, 1684 transitionProperty: property, 1685 transitionDuration: `${durationOut}s`, 1686 transitionTimingFunction: easing 1687 }; 1688 el._x_transition.leave.start = { 1689 opacity: 1, 1690 transform: `scale(1)` 1691 }; 1692 el._x_transition.leave.end = { 1693 opacity: opacityValue, 1694 transform: `scale(${scaleValue})` 1695 }; 1696 } 1697 } 1698 function registerTransitionObject(el, setFunction, defaultValue = {}) { 1699 if (!el._x_transition) 1700 el._x_transition = { 1701 enter: {during: defaultValue, start: defaultValue, end: defaultValue}, 1702 leave: {during: defaultValue, start: defaultValue, end: defaultValue}, 1703 in(before = () => { 1704 }, after = () => { 1705 }) { 1706 transition(el, setFunction, { 1707 during: this.enter.during, 1708 start: this.enter.start, 1709 end: this.enter.end, 1710 entering: true 1711 }, before, after); 1712 }, 1713 out(before = () => { 1714 }, after = () => { 1715 }) { 1716 transition(el, setFunction, { 1717 during: this.leave.during, 1718 start: this.leave.start, 1719 end: this.leave.end, 1720 entering: false 1721 }, before, after); 1722 } 1723 }; 1724 } 1725 window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) { 1726 let clickAwayCompatibleShow = () => requestAnimationFrame(show); 1727 if (value) { 1728 el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow(); 1729 return; 1730 } 1731 el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => { 1732 el._x_transition.out(() => { 1733 }, () => resolve(hide)); 1734 el._x_transitioning.beforeCancel(() => reject({isFromCancelledTransition: true})); 1735 }) : Promise.resolve(hide); 1736 queueMicrotask(() => { 1737 let closest = closestHide(el); 1738 if (closest) { 1739 if (!closest._x_hideChildren) 1740 closest._x_hideChildren = []; 1741 closest._x_hideChildren.push(el); 1742 } else { 1743 queueMicrotask(() => { 1744 let hideAfterChildren = (el2) => { 1745 let carry = Promise.all([ 1746 el2._x_hidePromise, 1747 ...(el2._x_hideChildren || []).map(hideAfterChildren) 1748 ]).then(([i]) => i()); 1749 delete el2._x_hidePromise; 1750 delete el2._x_hideChildren; 1751 return carry; 1752 }; 1753 hideAfterChildren(el).catch((e) => { 1754 if (!e.isFromCancelledTransition) 1755 throw e; 1756 }); 1757 }); 1758 } 1759 }); 1760 }; 1761 function closestHide(el) { 1762 let parent = el.parentNode; 1763 if (!parent) 1764 return; 1765 return parent._x_hidePromise ? parent : closestHide(parent); 1766 } 1767 function transition(el, setFunction, {during, start: start2, end, entering} = {}, before = () => { 1768 }, after = () => { 1769 }) { 1770 if (el._x_transitioning) 1771 el._x_transitioning.cancel(); 1772 if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) { 1773 before(); 1774 after(); 1775 return; 1776 } 1777 let undoStart, undoDuring, undoEnd; 1778 performTransition(el, { 1779 start() { 1780 undoStart = setFunction(el, start2); 1781 }, 1782 during() { 1783 undoDuring = setFunction(el, during); 1784 }, 1785 before, 1786 end() { 1787 undoStart(); 1788 undoEnd = setFunction(el, end); 1789 }, 1790 after, 1791 cleanup() { 1792 undoDuring(); 1793 undoEnd(); 1794 } 1795 }, entering); 1796 } 1797 function performTransition(el, stages, entering) { 1798 let interrupted, reachedBefore, reachedEnd; 1799 let finish = once(() => { 1800 mutateDom(() => { 1801 interrupted = true; 1802 if (!reachedBefore) 1803 stages.before(); 1804 if (!reachedEnd) { 1805 stages.end(); 1806 releaseNextTicks(); 1807 } 1808 stages.after(); 1809 if (el.isConnected) 1810 stages.cleanup(); 1811 delete el._x_transitioning; 1812 }); 1813 }); 1814 el._x_transitioning = { 1815 beforeCancels: [], 1816 beforeCancel(callback) { 1817 this.beforeCancels.push(callback); 1818 }, 1819 cancel: once(function() { 1820 while (this.beforeCancels.length) { 1821 this.beforeCancels.shift()(); 1822 } 1823 ; 1824 finish(); 1825 }), 1826 finish, 1827 entering 1828 }; 1829 mutateDom(() => { 1830 stages.start(); 1831 stages.during(); 1832 }); 1833 holdNextTicks(); 1834 requestAnimationFrame(() => { 1835 if (interrupted) 1836 return; 1837 let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3; 1838 let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3; 1839 if (duration === 0) 1840 duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3; 1841 mutateDom(() => { 1842 stages.before(); 1843 }); 1844 reachedBefore = true; 1845 requestAnimationFrame(() => { 1846 if (interrupted) 1847 return; 1848 mutateDom(() => { 1849 stages.end(); 1850 }); 1851 releaseNextTicks(); 1852 setTimeout(el._x_transitioning.finish, duration + delay); 1853 reachedEnd = true; 1854 }); 1855 }); 1856 } 1857 function modifierValue(modifiers, key, fallback) { 1858 if (modifiers.indexOf(key) === -1) 1859 return fallback; 1860 const rawValue = modifiers[modifiers.indexOf(key) + 1]; 1861 if (!rawValue) 1862 return fallback; 1863 if (key === "scale") { 1864 if (isNaN(rawValue)) 1865 return fallback; 1866 } 1867 if (key === "duration") { 1868 let match = rawValue.match(/([0-9]+)ms/); 1869 if (match) 1870 return match[1]; 1871 } 1872 if (key === "origin") { 1873 if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) { 1874 return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" "); 1875 } 1876 } 1877 return rawValue; 1878 } 1879 1880
1880// packages/alpinejs/src/directives/x-ignore.js 1881 var handler = () => { 1882 }; 1883 handler.inline = (el, {modifiers}, {cleanup: cleanup2}) => { 1884 modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true; 1885 cleanup2(() => { 1886 modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore; 1887 }); 1888 }; 1889 directive("ignore", handler); 1890 1891
1891// packages/alpinejs/src/directives/x-effect.js 1892 directive("effect", (el, {expression}, {effect: effect3}) => effect3(evaluateLater(el, expression))); 1893 1894
vendor: 1,042 bytes, lines 1894-1926
1894// packages/alpinejs/src/utils/bind.js 1895 function bind(el, name, value, modifiers = []) { 1896 if (!el._x_bindings) 1897 el._x_bindings = reactive({}); 1898 el._x_bindings[name] = value; 1899 name = modifiers.includes("camel") ? camelCase(name) : name; 1900 switch (name) { 1901 case "value": 1902 bindInputValue(el, value); 1903 break; 1904 case "style": 1905 bindStyles(el, value); 1906 break; 1907 case "class": 1908 bindClasses(el, value); 1909 break; 1910 default: 1911 bindAttribute(el, name, value); 1912 break; 1913 } 1914 } 1915 function bindInputValue(el, value) { 1916 if (el.type === "radio") { 1917 if (el.attributes.value === void 0) { 1918 el.value = value; 1919 } 1920 if (window.fromModel) { 1921 el.checked = checkedAttrLooseCompare(el.value, value); 1922 } 1923 } else if (el.type === "checkbox") { 1924 if (Number.isInteger(value)) { 1925 el.value = value; 1926 } else if (!Number.isInteger(value) && !Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {
vendor: 2,319 bytes, lines 1927-2015
1927 el.value = String(value); 1928 } else { 1929 if (Array.isArray(value)) { 1930 el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value)); 1931 } else { 1932 el.checked = !!value; 1933 } 1934 } 1935 } else if (el.tagName === "SELECT") { 1936 updateSelect(el, value); 1937 } else { 1938 if (el.value === value) 1939 return; 1940 el.value = value; 1941 } 1942 } 1943 function bindClasses(el, value) { 1944 if (el._x_undoAddedClasses) 1945 el._x_undoAddedClasses(); 1946 el._x_undoAddedClasses = setClasses(el, value); 1947 } 1948 function bindStyles(el, value) { 1949 if (el._x_undoAddedStyles) 1950 el._x_undoAddedStyles(); 1951 el._x_undoAddedStyles = setStyles(el, value); 1952 } 1953 function bindAttribute(el, name, value) { 1954 if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) { 1955 el.removeAttribute(name); 1956 } else { 1957 if (isBooleanAttr2(name)) 1958 value = name; 1959 setIfChanged(el, name, value); 1960 } 1961 } 1962 function setIfChanged(el, attrName, value) { 1963 if (el.getAttribute(attrName) != value) { 1964 el.setAttribute(attrName, value); 1965 } 1966 } 1967 function updateSelect(el, value) { 1968 const arrayWrappedValue = [].concat(value).map((value2) => { 1969 return value2 + ""; 1970 }); 1971 Array.from(el.options).forEach((option) => { 1972 option.selected = arrayWrappedValue.includes(option.value); 1973 }); 1974 } 1975 function camelCase(subject) { 1976 return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase()); 1977 } 1978 function checkedAttrLooseCompare(valueA, valueB) { 1979 return valueA == valueB; 1980 } 1981 function isBooleanAttr2(attrName) { 1982 const booleanAttributes = [ 1983 "disabled", 1984 "checked", 1985 "required", 1986 "readonly", 1987 "hidden", 1988 "open", 1989 "selected", 1990 "autofocus", 1991 "itemscope", 1992 "multiple", 1993 "novalidate", 1994 "allowfullscreen", 1995 "allowpaymentrequest", 1996 "formnovalidate", 1997 "autoplay", 1998 "controls", 1999 "loop", 2000 "muted", 2001 "playsinline", 2002 "default", 2003 "ismap", 2004 "reversed", 2005 "async", 2006 "defer", 2007 "nomodule" 2008 ]; 2009 return booleanAttributes.includes(attrName); 2010 } 2011 function attributeShouldntBePreservedIfFalsy(name) { 2012 return !["aria-pressed", "aria-checked"].includes(name); 2013 } 2014 2015
vendor: 4,321 bytes, lines 2015-2122
2015// packages/alpinejs/src/utils/on.js 2016 function on(el, event, modifiers, callback) { 2017 let listenerTarget = el; 2018 let handler3 = (e) => callback(e); 2019 let options = {}; 2020 let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e); 2021 if (modifiers.includes("dot")) 2022 event = dotSyntax(event); 2023 if (modifiers.includes("camel")) 2024 event = camelCase2(event); 2025 if (modifiers.includes("passive")) 2026 options.passive = true; 2027 if (modifiers.includes("window")) 2028 listenerTarget = window; 2029 if (modifiers.includes("document")) 2030 listenerTarget = document; 2031 if (modifiers.includes("prevent")) 2032 handler3 = wrapHandler(handler3, (next, e) => { 2033 e.preventDefault(); 2034 next(e); 2035 }); 2036 if (modifiers.includes("stop")) 2037 handler3 = wrapHandler(handler3, (next, e) => { 2038 e.stopPropagation(); 2039 next(e); 2040 }); 2041 if (modifiers.includes("self")) 2042 handler3 = wrapHandler(handler3, (next, e) => { 2043 e.target === el && next(e); 2044 }); 2045 if (modifiers.includes("away") || modifiers.includes("outside")) { 2046 listenerTarget = document; 2047 handler3 = wrapHandler(handler3, (next, e) => { 2048 if (el.contains(e.target)) 2049 return; 2050 if (el.offsetWidth < 1 && el.offsetHeight < 1) 2051 return; 2052 next(e); 2053 }); 2054 } 2055 handler3 = wrapHandler(handler3, (next, e) => { 2056 if (isKeyEvent(event)) { 2057 if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) { 2058 return; 2059 } 2060 } 2061 next(e); 2062 }); 2063 if (modifiers.includes("debounce")) { 2064 let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait"; 2065 let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250; 2066 handler3 = debounce(handler3, wait); 2067 } 2068 if (modifiers.includes("throttle")) { 2069 let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait"; 2070 let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250; 2071 handler3 = throttle(handler3, wait); 2072 } 2073 if (modifiers.includes("once")) { 2074 handler3 = wrapHandler(handler3, (next, e) => { 2075 next(e); 2076 listenerTarget.removeEventListener(event, handler3, options); 2077 }); 2078 } 2079 listenerTarget.addEventListener(event, handler3, options); 2080 return () => { 2081 listenerTarget.removeEventListener(event, handler3, options); 2082 }; 2083 } 2084 function dotSyntax(subject) { 2085 return subject.replace(/-/g, "."); 2086 } 2087 function camelCase2(subject) { 2088 return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase()); 2089 } 2090 function isNumeric(subject) { 2091 return !Array.isArray(subject) && !isNaN(subject); 2092 } 2093 function kebabCase2(subject) { 2094 return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase(); 2095 } 2096 function isKeyEvent(event) { 2097 return ["keydown", "keyup"].includes(event); 2098 } 2099 function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) { 2100 let keyModifiers = modifiers.filter((i) => { 2101 return !["window", "document", "prevent", "stop", "once"].includes(i); 2102 }); 2103 if (keyModifiers.includes("debounce")) { 2104 let debounceIndex = keyModifiers.indexOf("debounce"); 2105 keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1); 2106 } 2107 if (keyModifiers.length === 0) 2108 return false; 2109 if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0])) 2110 return false; 2111 const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"]; 2112 const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier)); 2113 keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i)); 2114 if (selectedSystemKeyModifiers.length > 0) { 2115 const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => { 2116 if (modifier === "cmd" || modifier === "super") 2117 modifier = "meta"; 2118 return e[`${modifier}Key`]; 2119 }); 2120 if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) { 2121 if (keyToModifiers(e.key).includes(keyModifiers[0])) 2122 return false;
2123 } 2124 } 2125 return true; 2126 } 2127 function keyToModifiers(key) { 2128 if (!key) 2129 return []; 2130 key = kebabCase2(key); 2131 let modifierToKeyMap = { 2132 ctrl: "control", 2133 slash: "/", 2134 space: "-", 2135 spacebar: "-", 2136 cmd: "meta", 2137 esc: "escape", 2138 up: "arrow-up", 2139 down: "arrow-down", 2140 left: "arrow-left", 2141 right: "arrow-right", 2142 period: ".", 2143 equal: "=" 2144 }; 2145 modifierToKeyMap[key] = key; 2146 return Object.keys(modifierToKeyMap).map((modifier) => { 2147 if (modifierToKeyMap[modifier] === key) 2148 return modifier; 2149 }).filter((modifier) => modifier); 2150 } 2151 2152
2152// packages/alpinejs/src/directives/x-model.js 2153 directive("model", (el, {modifiers, expression}, {effect: effect3, cleanup: cleanup2}) => { 2154 let evaluate2 = evaluateLater(el, expression); 2155 let assignmentExpression = `${expression} = rightSideOfExpression($event, ${expression})`; 2156 let evaluateAssignment = evaluateLater(el, assignmentExpression); 2157 var event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) || modifiers.includes("lazy") ? "change" : "input"; 2158 let assigmentFunction = generateAssignmentFunction(el, modifiers, expression); 2159 let removeListener = on(el, event, modifiers, (e) => { 2160 evaluateAssignment(() => { 2161 }, {scope: { 2162 $event: e, 2163 rightSideOfExpression: assigmentFunction 2164 }}); 2165 }); 2166 cleanup2(() => removeListener()); 2167 el._x_forceModelUpdate = () => { 2168 evaluate2((value) => { 2169 if (value === void 0 && expression.match(/\./)) 2170 value = ""; 2171 window.fromModel = true; 2172 mutateDom(() => bind(el, "value", value)); 2173 delete window.fromModel; 2174 }); 2175 }; 2176 effect3(() => { 2177 if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el)) 2178 return; 2179 el._x_forceModelUpdate(); 2180 }); 2181 }); 2182 function generateAssignmentFunction(el, modifiers, expression) { 2183 if (el.type === "radio") { 2184 mutateDom(() => { 2185 if (!el.hasAttribute("name")) 2186 el.setAttribute("name", expression); 2187 }); 2188 } 2189 return (event, currentValue) => { 2190 return mutateDom(() => { 2191 if (event instanceof CustomEvent && event.detail !== void 0) { 2192 return event.detail || event.target.value; 2193 } else if (el.type === "checkbox") { 2194 if (Array.isArray(currentValue)) { 2195 let newValue = modifiers.includes("number") ? safeParseNumber(event.target.value) : event.target.value; 2196 return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue)); 2197 } else { 2198 return event.target.checked; 2199 } 2200 } else if (el.tagName.toLowerCase() === "select" && el.multiple) { 2201 return modifiers.includes("number") ? Array.from(event.target.selectedOptions).map((option) => { 2202 let rawValue = option.value || option.text; 2203 return safeParseNumber(rawValue); 2204 }) : Array.from(event.target.selectedOptions).map((option) => { 2205 return option.value || option.text; 2206 }); 2207 } else { 2208 let rawValue = event.target.value; 2209 return modifiers.includes("number") ? safeParseNumber(rawValue) : modifiers.includes("trim") ? rawValue.trim() : rawValue; 2210 } 2211 }); 2212 }; 2213 } 2214 function safeParseNumber(rawValue) { 2215 let number = rawValue ? parseFloat(rawValue) : null; 2216 return isNumeric2(number) ? number : rawValue; 2217 } 2218 function checkedAttrLooseCompare2(valueA, valueB) { 2219 return valueA == valueB; 2220 } 2221 function isNumeric2(subject) { 2222 return !Array.isArray(subject) && !isNaN(subject)
vendor: 301 bytes, lines 2222-2230
2222; 2223 } 2224 2225 // packages/alpinejs/src/directives/x-cloak.js 2226 directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak"))))); 2227 2228 // packages/alpinejs/src/directives/x-init.js 2229 addInitSelector(() => `[${prefix("init")}]`); 2230 directive("init", skipDuringClone((el, {
2230expression}) => !!expression.trim() && evaluate(el, expression, {}, false))); 2231 2232
2232// packages/alpinejs/src/directives/x-text.js 2233 directive("text", (el, {expression}, {effect: effect3, evaluateLater: evaluateLater2}) => { 2234 let evaluate2 = evaluateLater2(expression); 2235 effect3(() => { 2236 evaluate2((value) => { 2237 mutateDom(() => { 2238 el.textContent = value; 2239 }); 2240 }); 2241 }); 2242 }); 2243 2244
2244// packages/alpinejs/src/directives/x-html.js 2245 directive("html", (el, {expression}, {effect: effect3, evaluateLater: evaluateLater2}) => { 2246 let evaluate2 = evaluateLater2(expression); 2247 effect3(() => { 2248 evaluate2((value) => { 2249 el.innerHTML = value; 2250 }); 2251 }); 2252 }); 2253 2254
2254// packages/alpinejs/src/directives/x-bind.js 2255 mapAttributes(startingWith(":", into(prefix("bind:")))); 2256 directive("bind", (el, {value, modifiers, expression, original}, {effect: effect3}) => { 2257 if (!value) 2258 return applyBindingsObject(el, expression, original, effect3); 2259 if (value === "key") 2260 return storeKeyForXFor(el, expression); 2261 let evaluate2 = evaluateLater(el, expression); 2262 effect3(() => evaluate2((result) => { 2263 if (result === void 0 && expression.match(/\./)) 2264 result = ""; 2265 mutateDom(() => bind(el, value, result, modifiers)); 2266 })); 2267 }); 2268 function applyBindingsObject(el, expression, original, effect3) { 2269 let getBindings = evaluateLater(el, expression); 2270 let cleanupRunners = []; 2271 effect3(() => { 2272 while (cleanupRunners.length) 2273 cleanupRunners.pop()(); 2274 getBindings((bindings) => { 2275 let attributes = Object.entries(bindings).map(([name, value]) => ({name, value})); 2276 attributesOnly(attributes).forEach(({name, value}, index) => { 2277 attributes[index] = { 2278 name: `x-bind:${name}`, 2279 value: `"${value}"` 2280 }; 2281 }); 2282 directives(el, attributes, original).map((handle) => { 2283 cleanupRunners.push(handle.runCleanups); 2284 handle(); 2285 }); 2286 }); 2287 }); 2288 } 2289 function storeKeyForXFor(el, expression) { 2290 el._x_keyExpression = expression; 2291 } 2292 2293
2293// packages/alpinejs/src/directives/x-data.js 2294 addRootSelector(() => `[${prefix("data")}]`); 2295 directive("data", skipDuringClone((el, {expression}, {cleanup: cleanup2}) => { 2296 expression = expression === "" ? "{}" : expression; 2297 let magicContext = {}; 2298 injectMagics(magicContext, el); 2299 let dataProviderContext = {}; 2300 injectDataProviders(dataProviderContext, magicContext); 2301 let data2 = evaluate(el, expression, {scope: dataProviderContext}); 2302 injectMagics(data2, el); 2303 let reactiveData = reactive(data2); 2304 initInterceptors(reactiveData); 2305 let undo = addScopeToNode(el, reactiveData); 2306 reactiveData["init"] && evaluate(el, reactiveData["init"]); 2307 cleanup2(() => { 2308 undo(); 2309 reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]); 2310 }); 2311 })); 2312 2313
2313// packages/alpinejs/src/directives/x-show.js 2314 directive("show", (el, {modifiers, expression}, {effect: effect3}) => { 2315 let evaluate2 = evaluateLater(el, expression); 2316 let hide = () => mutateDom(() => { 2317 el.style.display = "none"; 2318 el._x_isShown = false; 2319 }); 2320 let show = () => mutateDom(() => { 2321 if (el.style.length === 1 && el.style.display === "none") { 2322 el.removeAttribute("style"); 2323 } else { 2324 el.style.removeProperty("display"); 2325 } 2326 el._x_isShown = true; 2327 }); 2328 let clickAwayCompatibleShow = () => setTimeout(show); 2329 let toggle = once((value) => value ? show() : hide(), (value) => { 2330 if (typeof el._x_toggleAndCascadeWithTransitions === "function") { 2331 el._x_toggleAndCascadeWithTransitions(el, value, show, hide); 2332 } else { 2333 value ? clickAwayCompatibleShow() : hide(); 2334 } 2335 }); 2336 let oldValue; 2337 let firstTime = true; 2338 effect3(() => evaluate2((value) => { 2339 if (!firstTime && value === oldValue) 2340 return; 2341 if (modifiers.includes("immediate")) 2342 value ? clickAwayCompatibleShow() : hide(); 2343 toggle(value); 2344 oldValue = value; 2345 firstTime = false; 2346 })); 2347 }); 2348 2349
2349// packages/alpinejs/src/directives/x-for.js 2350 directive("for", (el, {expression}, {effect: effect3, cleanup: cleanup2}) => { 2351 let iteratorNames = parseForExpression(expression); 2352 let evaluateItems = evaluateLater(el, iteratorNames.items); 2353 let evaluateKey = evaluateLater(el, el._x_keyExpression || "index"); 2354 el._x_prevKeys = []; 2355 el._x_lookup = {}; 2356 effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey)); 2357 cleanup2(() => { 2358 Object.values(el._x_lookup).forEach((el2) => el2.remove()); 2359 delete el._x_prevKeys; 2360 delete el._x_lookup; 2361 }); 2362 }); 2363 function loop(el, iteratorNames, evaluateItems, evaluateKey) { 2364 let isObject2 = (i) => typeof i === "object" && !Array.isArray(i); 2365 let templateEl = el; 2366 evaluateItems((items) => { 2367 if (isNumeric3(items) && items >= 0) { 2368 items = Array.from(Array(items).keys(), (i) => i + 1); 2369 } 2370 if (items === void 0) 2371 items = []; 2372 let lookup = el._x_lookup; 2373 let prevKeys = el._x_prevKeys; 2374 let scopes = []; 2375 let keys = []; 2376 if (isObject2(items)) { 2377 items = Object.entries(items).map(([key, value]) => { 2378 let scope = getIterationScopeVariables(iteratorNames, value, key, items); 2379 evaluateKey((value2) => keys.push(value2), {scope: {index: key, ...scope}}); 2380 scopes.push(scope); 2381 }); 2382 } else { 2383 for (let i = 0; i < items.length; i++) { 2384 let scope = getIterationScopeVariables(iteratorNames, items[i], i, items); 2385 evaluateKey((value) => keys.push(value), {scope: {index: i, ...scope}}); 2386 scopes.push(scope); 2387 } 2388 } 2389 let adds = []; 2390 let moves = []; 2391 let removes = []; 2392 let sames = []; 2393 for (let i = 0; i < prevKeys.length; i++) { 2394 let key = prevKeys[i]; 2395 if (keys.indexOf(key) === -1) 2396 removes.push(key); 2397 } 2398 prevKeys = prevKeys.filter((key) => !removes.includes(key)); 2399 let lastKey = "template"; 2400 for (let i = 0; i < keys.length; i++) { 2401 let key = keys[i]; 2402 let prevIndex = prevKeys.indexOf(key); 2403 if (prevIndex === -1) { 2404 prevKeys.splice(i, 0, key); 2405 adds.push([lastKey, i]); 2406 } else if (prevIndex !== i) { 2407 let keyInSpot = prevKeys.splice(i, 1)[0]; 2408 let keyForSpot = prevKeys.splice(prevIndex - 1, 1)[0]; 2409 prevKeys.splice(i, 0, keyForSpot); 2410 prevKeys.splice(prevIndex, 0, keyInSpot); 2411 moves.push([keyInSpot, keyForSpot]); 2412 } else { 2413 sames.push(key); 2414 } 2415 lastKey = key; 2416 } 2417 for (let i = 0; i < removes.length; i++) { 2418 let key = removes[i]; 2419 lookup[key].remove(); 2420 lookup[key] = null; 2421 delete lookup[key]; 2422 } 2423 for (let i = 0; i < moves.length; i++) { 2424 let [keyInSpot, keyForSpot] = moves[i]; 2425 let elInSpot = lookup[keyInSpot]; 2426 let elForSpot = lookup[keyForSpot]; 2427 let marker = document.createElement("div"); 2428 mutateDom(() => { 2429 elForSpot.after(marker); 2430 elInSpot.after(elForSpot); 2431 marker.before(elInSpot); 2432 marker.remove(); 2433 }); 2434 refreshScope(elForSpot, scopes[keys.indexOf(keyForSpot)]); 2435 } 2436 for (let i = 0; i < adds.length; i++) { 2437 let [lastKey2, index] = adds[i]; 2438 let lastEl = lastKey2 === "template" ? templateEl : lookup[lastKey2]; 2439 let scope = scopes[index]; 2440 let key = keys[index]; 2441 let clone2 = document.importNode(templateEl.content, true).firstElementChild; 2442 addScopeToNode(clone2, reactive(scope), templateEl); 2443 mutateDom(() => { 2444 lastEl.after(clone2); 2445 initTree(clone2); 2446 }); 2447 if (typeof key === "object") { 2448 warn("x-for key cannot be an object, it must be a string or an integer", templateEl); 2449 } 2450 lookup[key] = clone2; 2451 } 2452 for (let i = 0; i < sames.length; i++) { 2453 refreshScope(lookup[sames[i]], scopes[keys.indexOf(sames[i])]); 2454 } 2455 templateEl._x_prevKeys = keys; 2456 }); 2457 } 2458 function parseForExpression(expression) { 2459 let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/; 2460 let stripParensRE = /^\s*\(|\)\s*$/g; 2461 let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/; 2462 let inMatch = expression.match(forAliasRE); 2463 if (!inMatch) 2464 return; 2465 let res = {}; 2466 res.items = inMatch[2].trim(); 2467 let item = inMatch[1].replace(stripParensRE, "").trim(); 2468 let iteratorMatch = item.match(forIteratorRE); 2469 if (iteratorMatch) { 2470 res.item = item.replace(forIteratorRE, "").trim(); 2471 res.index = iteratorMatch[1].trim(); 2472 if (iteratorMatch[2]) { 2473 res.collection = iteratorMatch[2].trim(); 2474 } 2475 } else { 2476 res.item = item; 2477 } 2478 return res; 2479 } 2480 function getIterationScopeVariables(iteratorNames, item, index, items) { 2481 let scopeVariables = {}; 2482 if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) { 2483 let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
vendor: 744 bytes, lines 2484-2505
2484 names.forEach((name, i) => { 2485 scopeVariables[name] = item[i]; 2486 }); 2487 } else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") { 2488 let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim()); 2489 names.forEach((name) => { 2490 scopeVariables[name] = item[name]; 2491 }); 2492 } else { 2493 scopeVariables[iteratorNames.item] = item; 2494 } 2495 if (iteratorNames.index) 2496 scopeVariables[iteratorNames.index] = index; 2497 if (iteratorNames.collection) 2498 scopeVariables[iteratorNames.collection] = items; 2499 return scopeVariables; 2500 } 2501 function isNumeric3(subject) { 2502 return !Array.isArray(subject) && !isNaN(subject); 2503 } 2504 2505
2505// packages/alpinejs/src/directives/x-ref.js 2506 function handler2() { 2507 } 2508 handler2.inline = (el, {expression}, {cleanup: cleanup2}) => { 2509 let root = closestRoot(el); 2510 if (!root._x_refs) 2511 root._x_refs = {}; 2512 root._x_refs[expression] = el; 2513 cleanup2(() => delete root._x_refs[expression]); 2514 }; 2515 directive("ref", handler2); 2516 2517
vendor: 871 bytes, lines 2517-2548
2517// packages/alpinejs/src/directives/x-if.js 2518 directive("if", (el, {expression}, {effect: effect3, cleanup: cleanup2}) => { 2519 let evaluate2 = evaluateLater(el, expression); 2520 let show = () => { 2521 if (el._x_currentIfEl) 2522 return el._x_currentIfEl; 2523 let clone2 = el.content.cloneNode(true).firstElementChild; 2524 addScopeToNode(clone2, {}, el); 2525 mutateDom(() => { 2526 el.after(clone2); 2527 initTree(clone2); 2528 }); 2529 el._x_currentIfEl = clone2; 2530 el._x_undoIf = () => { 2531 clone2.remove(); 2532 delete el._x_currentIfEl; 2533 }; 2534 return clone2; 2535 }; 2536 let hide = () => { 2537 if (!el._x_undoIf) 2538 return; 2539 el._x_undoIf(); 2540 delete el._x_undoIf; 2541 }; 2542 effect3(() => evaluate2((value) => { 2543 value ? show() : hide(); 2544 })); 2545 cleanup2(() => el._x_undoIf && el._x_undoIf()); 2546 }); 2547 2548
2548// packages/alpinejs/src/directives/x-on.js 2549 mapAttributes(startingWith("@", into(prefix("on:")))); 2550 directive("on", skipDuringClone((el, {value, modifiers, expression}, {cleanup: cleanup2}) => { 2551 let evaluate2 = expression ? evaluateLater(el, expression) : () => { 2552 }; 2553 let removeListener = on(el, value, modifiers, (e) => { 2554 evaluate2(() => { 2555 }, {scope: {$event: e}, params: [e]}); 2556 }); 2557 cleanup2(() => removeListener()); 2558 })); 2559 2560
2560// packages/alpinejs/src/index.js 2561 alpine_default.setEvaluator(normalEvaluator); 2562 alpine_default.setReactivityEngine({reactive: reactive2, effect: effect2, release: stop, raw: toRaw}); 2563 var src_default = alpine_default; 2564 2565
2565// packages/alpinejs/builds/cdn.js 2566 window.Alpine = src_default; 2567 queueMicrotask(() => { 2568 src_default.start(); 2569 }); 2570})();
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.