5714 lines
180 KiB
JavaScript
5714 lines
180 KiB
JavaScript
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __commonJS = (cb, mod) => function __require() {
|
|
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
};
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// node_modules/@vue/shared/dist/shared.cjs.js
|
|
var require_shared_cjs = __commonJS({
|
|
"node_modules/@vue/shared/dist/shared.cjs.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
function makeMap(str) {
|
|
const map = /* @__PURE__ */ Object.create(null);
|
|
for (const key of str.split(","))
|
|
map[key] = 1;
|
|
return (val) => val in map;
|
|
}
|
|
var EMPTY_OBJ = Object.freeze({});
|
|
var EMPTY_ARR = Object.freeze([]);
|
|
var NOOP = () => {
|
|
};
|
|
var NO = () => false;
|
|
var isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
|
|
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
|
|
var isModelListener = (key) => key.startsWith("onUpdate:");
|
|
var extend = Object.assign;
|
|
var remove = (arr, el) => {
|
|
const i = arr.indexOf(el);
|
|
if (i > -1) {
|
|
arr.splice(i, 1);
|
|
}
|
|
};
|
|
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 isSet = (val) => toTypeString(val) === "[object Set]";
|
|
var isDate = (val) => toTypeString(val) === "[object Date]";
|
|
var isRegExp = (val) => toTypeString(val) === "[object RegExp]";
|
|
var isFunction = (val) => typeof val === "function";
|
|
var isString = (val) => typeof val === "string";
|
|
var isSymbol = (val) => typeof val === "symbol";
|
|
var isObject2 = (val) => val !== null && typeof val === "object";
|
|
var isPromise = (val) => {
|
|
return (isObject2(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
|
|
};
|
|
var objectToString = Object.prototype.toString;
|
|
var toTypeString = (value) => objectToString.call(value);
|
|
var toRawType = (value) => {
|
|
return toTypeString(value).slice(8, -1);
|
|
};
|
|
var isPlainObject = (val) => toTypeString(val) === "[object Object]";
|
|
var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
|
|
var isReservedProp = /* @__PURE__ */ makeMap(
|
|
// the leading comma is intentional so empty string "" is also included
|
|
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
|
|
);
|
|
var isBuiltInDirective = /* @__PURE__ */ makeMap(
|
|
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
|
|
);
|
|
var cacheStringFunction = (fn) => {
|
|
const cache = /* @__PURE__ */ Object.create(null);
|
|
return (str) => {
|
|
const hit = cache[str];
|
|
return hit || (cache[str] = fn(str));
|
|
};
|
|
};
|
|
var camelizeRE = /-\w/g;
|
|
var camelize = cacheStringFunction(
|
|
(str) => {
|
|
return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
|
|
}
|
|
);
|
|
var hyphenateRE = /\B([A-Z])/g;
|
|
var hyphenate = cacheStringFunction(
|
|
(str) => str.replace(hyphenateRE, "-$1").toLowerCase()
|
|
);
|
|
var capitalize = cacheStringFunction((str) => {
|
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
});
|
|
var toHandlerKey = cacheStringFunction(
|
|
(str) => {
|
|
const s = str ? `on${capitalize(str)}` : ``;
|
|
return s;
|
|
}
|
|
);
|
|
var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
|
|
var invokeArrayFns = (fns, ...arg) => {
|
|
for (let i = 0; i < fns.length; i++) {
|
|
fns[i](...arg);
|
|
}
|
|
};
|
|
var def = (obj, key, value, writable = false) => {
|
|
Object.defineProperty(obj, key, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable,
|
|
value
|
|
});
|
|
};
|
|
var looseToNumber = (val) => {
|
|
const n = parseFloat(val);
|
|
return isNaN(n) ? val : n;
|
|
};
|
|
var toNumber = (val) => {
|
|
const n = isString(val) ? Number(val) : NaN;
|
|
return isNaN(n) ? val : n;
|
|
};
|
|
var _globalThis;
|
|
var getGlobalThis = () => {
|
|
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
|
|
};
|
|
var identRE = /^[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*$/;
|
|
function genPropsAccessExp(name) {
|
|
return identRE.test(name) ? `__props.${name}` : `__props[${JSON.stringify(name)}]`;
|
|
}
|
|
function genCacheKey(source, options) {
|
|
return source + JSON.stringify(
|
|
options,
|
|
(_, val) => typeof val === "function" ? val.toString() : val
|
|
);
|
|
}
|
|
var PatchFlags = {
|
|
"TEXT": 1,
|
|
"1": "TEXT",
|
|
"CLASS": 2,
|
|
"2": "CLASS",
|
|
"STYLE": 4,
|
|
"4": "STYLE",
|
|
"PROPS": 8,
|
|
"8": "PROPS",
|
|
"FULL_PROPS": 16,
|
|
"16": "FULL_PROPS",
|
|
"NEED_HYDRATION": 32,
|
|
"32": "NEED_HYDRATION",
|
|
"STABLE_FRAGMENT": 64,
|
|
"64": "STABLE_FRAGMENT",
|
|
"KEYED_FRAGMENT": 128,
|
|
"128": "KEYED_FRAGMENT",
|
|
"UNKEYED_FRAGMENT": 256,
|
|
"256": "UNKEYED_FRAGMENT",
|
|
"NEED_PATCH": 512,
|
|
"512": "NEED_PATCH",
|
|
"DYNAMIC_SLOTS": 1024,
|
|
"1024": "DYNAMIC_SLOTS",
|
|
"DEV_ROOT_FRAGMENT": 2048,
|
|
"2048": "DEV_ROOT_FRAGMENT",
|
|
"CACHED": -1,
|
|
"-1": "CACHED",
|
|
"BAIL": -2,
|
|
"-2": "BAIL"
|
|
};
|
|
var PatchFlagNames = {
|
|
[1]: `TEXT`,
|
|
[2]: `CLASS`,
|
|
[4]: `STYLE`,
|
|
[8]: `PROPS`,
|
|
[16]: `FULL_PROPS`,
|
|
[32]: `NEED_HYDRATION`,
|
|
[64]: `STABLE_FRAGMENT`,
|
|
[128]: `KEYED_FRAGMENT`,
|
|
[256]: `UNKEYED_FRAGMENT`,
|
|
[512]: `NEED_PATCH`,
|
|
[1024]: `DYNAMIC_SLOTS`,
|
|
[2048]: `DEV_ROOT_FRAGMENT`,
|
|
[-1]: `CACHED`,
|
|
[-2]: `BAIL`
|
|
};
|
|
var ShapeFlags = {
|
|
"ELEMENT": 1,
|
|
"1": "ELEMENT",
|
|
"FUNCTIONAL_COMPONENT": 2,
|
|
"2": "FUNCTIONAL_COMPONENT",
|
|
"STATEFUL_COMPONENT": 4,
|
|
"4": "STATEFUL_COMPONENT",
|
|
"TEXT_CHILDREN": 8,
|
|
"8": "TEXT_CHILDREN",
|
|
"ARRAY_CHILDREN": 16,
|
|
"16": "ARRAY_CHILDREN",
|
|
"SLOTS_CHILDREN": 32,
|
|
"32": "SLOTS_CHILDREN",
|
|
"TELEPORT": 64,
|
|
"64": "TELEPORT",
|
|
"SUSPENSE": 128,
|
|
"128": "SUSPENSE",
|
|
"COMPONENT_SHOULD_KEEP_ALIVE": 256,
|
|
"256": "COMPONENT_SHOULD_KEEP_ALIVE",
|
|
"COMPONENT_KEPT_ALIVE": 512,
|
|
"512": "COMPONENT_KEPT_ALIVE",
|
|
"COMPONENT": 6,
|
|
"6": "COMPONENT"
|
|
};
|
|
var SlotFlags = {
|
|
"STABLE": 1,
|
|
"1": "STABLE",
|
|
"DYNAMIC": 2,
|
|
"2": "DYNAMIC",
|
|
"FORWARDED": 3,
|
|
"3": "FORWARDED"
|
|
};
|
|
var slotFlagsText = {
|
|
[1]: "STABLE",
|
|
[2]: "DYNAMIC",
|
|
[3]: "FORWARDED"
|
|
};
|
|
var GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
|
|
var isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
|
|
var isGloballyWhitelisted = isGloballyAllowed;
|
|
var range = 2;
|
|
function generateCodeFrame(source, start2 = 0, end = source.length) {
|
|
start2 = Math.max(0, Math.min(start2, source.length));
|
|
end = Math.max(0, Math.min(end, source.length));
|
|
if (start2 > end)
|
|
return "";
|
|
let lines = source.split(/(\r?\n)/);
|
|
const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
|
|
lines = lines.filter((_, idx) => idx % 2 === 0);
|
|
let count = 0;
|
|
const res = [];
|
|
for (let i = 0; i < lines.length; i++) {
|
|
count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
|
|
if (count >= start2) {
|
|
for (let j = i - range; j <= i + range || end > count; j++) {
|
|
if (j < 0 || j >= lines.length)
|
|
continue;
|
|
const line = j + 1;
|
|
res.push(
|
|
`${line}${" ".repeat(Math.max(3 - String(line).length, 0))}| ${lines[j]}`
|
|
);
|
|
const lineLength = lines[j].length;
|
|
const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
|
|
if (j === i) {
|
|
const pad = start2 - (count - (lineLength + newLineSeqLength));
|
|
const length = Math.max(
|
|
1,
|
|
end > count ? lineLength - pad : end - start2
|
|
);
|
|
res.push(` | ` + " ".repeat(pad) + "^".repeat(length));
|
|
} else if (j > i) {
|
|
if (end > count) {
|
|
const length = Math.max(Math.min(end - count, lineLength), 1);
|
|
res.push(` | ` + "^".repeat(length));
|
|
}
|
|
count += lineLength + newLineSeqLength;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return res.join("\n");
|
|
}
|
|
function normalizeStyle(value) {
|
|
if (isArray(value)) {
|
|
const res = {};
|
|
for (let i = 0; i < value.length; i++) {
|
|
const item = value[i];
|
|
const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
|
|
if (normalized) {
|
|
for (const key in normalized) {
|
|
res[key] = normalized[key];
|
|
}
|
|
}
|
|
}
|
|
return res;
|
|
} else if (isString(value) || isObject2(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
var listDelimiterRE = /;(?![^(]*\))/g;
|
|
var propertyDelimiterRE = /:([^]+)/;
|
|
var styleCommentRE = /\/\*[^]*?\*\//g;
|
|
function parseStringStyle(cssText) {
|
|
const ret = {};
|
|
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
|
|
if (item) {
|
|
const tmp = item.split(propertyDelimiterRE);
|
|
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function stringifyStyle(styles) {
|
|
if (!styles)
|
|
return "";
|
|
if (isString(styles))
|
|
return styles;
|
|
let ret = "";
|
|
for (const key in styles) {
|
|
const value = styles[key];
|
|
if (isString(value) || typeof value === "number") {
|
|
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
|
|
ret += `${normalizedKey}:${value};`;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
function normalizeClass(value) {
|
|
let res = "";
|
|
if (isString(value)) {
|
|
res = value;
|
|
} else if (isArray(value)) {
|
|
for (let i = 0; i < value.length; i++) {
|
|
const normalized = normalizeClass(value[i]);
|
|
if (normalized) {
|
|
res += normalized + " ";
|
|
}
|
|
}
|
|
} else if (isObject2(value)) {
|
|
for (const name in value) {
|
|
if (value[name]) {
|
|
res += name + " ";
|
|
}
|
|
}
|
|
}
|
|
return res.trim();
|
|
}
|
|
function normalizeProps(props) {
|
|
if (!props)
|
|
return null;
|
|
let { class: klass, style } = props;
|
|
if (klass && !isString(klass)) {
|
|
props.class = normalizeClass(klass);
|
|
}
|
|
if (style) {
|
|
props.style = normalizeStyle(style);
|
|
}
|
|
return props;
|
|
}
|
|
var HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
|
|
var SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
|
|
var MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
|
|
var VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
|
|
var isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
|
|
var isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
|
|
var isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
|
|
var isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
|
|
var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
|
|
var isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
|
|
var isBooleanAttr2 = /* @__PURE__ */ makeMap(
|
|
specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
|
|
);
|
|
function includeBooleanAttr(value) {
|
|
return !!value || value === "";
|
|
}
|
|
var unsafeAttrCharRE = /[>/="'\u0009\u000a\u000c\u0020]/;
|
|
var attrValidationCache = {};
|
|
function isSSRSafeAttrName(name) {
|
|
if (attrValidationCache.hasOwnProperty(name)) {
|
|
return attrValidationCache[name];
|
|
}
|
|
const isUnsafe = unsafeAttrCharRE.test(name);
|
|
if (isUnsafe) {
|
|
console.error(`unsafe attribute name: ${name}`);
|
|
}
|
|
return attrValidationCache[name] = !isUnsafe;
|
|
}
|
|
var propsToAttrMap = {
|
|
acceptCharset: "accept-charset",
|
|
className: "class",
|
|
htmlFor: "for",
|
|
httpEquiv: "http-equiv"
|
|
};
|
|
var isKnownHtmlAttr = /* @__PURE__ */ makeMap(
|
|
`accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
|
|
);
|
|
var isKnownSvgAttr = /* @__PURE__ */ makeMap(
|
|
`xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
|
|
);
|
|
var isKnownMathMLAttr = /* @__PURE__ */ makeMap(
|
|
`accent,accentunder,actiontype,align,alignmentscope,altimg,altimg-height,altimg-valign,altimg-width,alttext,bevelled,close,columnsalign,columnlines,columnspan,denomalign,depth,dir,display,displaystyle,encoding,equalcolumns,equalrows,fence,fontstyle,fontweight,form,frame,framespacing,groupalign,height,href,id,indentalign,indentalignfirst,indentalignlast,indentshift,indentshiftfirst,indentshiftlast,indextype,justify,largetop,largeop,lquote,lspace,mathbackground,mathcolor,mathsize,mathvariant,maxsize,minlabelspacing,mode,other,overflow,position,rowalign,rowlines,rowspan,rquote,rspace,scriptlevel,scriptminsize,scriptsizemultiplier,selection,separator,separators,shift,side,src,stackalign,stretchy,subscriptshift,superscriptshift,symmetric,voffset,width,widths,xlink:href,xlink:show,xlink:type,xmlns`
|
|
);
|
|
function isRenderableAttrValue(value) {
|
|
if (value == null) {
|
|
return false;
|
|
}
|
|
const type = typeof value;
|
|
return type === "string" || type === "number" || type === "boolean";
|
|
}
|
|
var escapeRE = /["'&<>]/;
|
|
function escapeHtml(string) {
|
|
const str = "" + string;
|
|
const match = escapeRE.exec(str);
|
|
if (!match) {
|
|
return str;
|
|
}
|
|
let html = "";
|
|
let escaped;
|
|
let index;
|
|
let lastIndex = 0;
|
|
for (index = match.index; index < str.length; index++) {
|
|
switch (str.charCodeAt(index)) {
|
|
case 34:
|
|
escaped = """;
|
|
break;
|
|
case 38:
|
|
escaped = "&";
|
|
break;
|
|
case 39:
|
|
escaped = "'";
|
|
break;
|
|
case 60:
|
|
escaped = "<";
|
|
break;
|
|
case 62:
|
|
escaped = ">";
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
if (lastIndex !== index) {
|
|
html += str.slice(lastIndex, index);
|
|
}
|
|
lastIndex = index + 1;
|
|
html += escaped;
|
|
}
|
|
return lastIndex !== index ? html + str.slice(lastIndex, index) : html;
|
|
}
|
|
var commentStripRE = /^(?:-?>)+|<!--|-->|--!>|<!-$/g;
|
|
function escapeHtmlComment(src) {
|
|
let prev;
|
|
do {
|
|
prev = src;
|
|
src = src.replace(commentStripRE, "");
|
|
} while (src !== prev);
|
|
return src;
|
|
}
|
|
var cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
|
|
function getEscapedCssVarName(key, doubleEscape) {
|
|
return key.replace(
|
|
cssVarNameEscapeSymbolsRE,
|
|
(s) => doubleEscape ? s === '"' ? '\\\\\\"' : `\\\\${s}` : `\\${s}`
|
|
);
|
|
}
|
|
function looseCompareArrays(a, b) {
|
|
if (a.length !== b.length)
|
|
return false;
|
|
let equal = true;
|
|
for (let i = 0; equal && i < a.length; i++) {
|
|
equal = looseEqual(a[i], b[i]);
|
|
}
|
|
return equal;
|
|
}
|
|
function looseEqual(a, b) {
|
|
if (a === b)
|
|
return true;
|
|
let aValidType = isDate(a);
|
|
let bValidType = isDate(b);
|
|
if (aValidType || bValidType) {
|
|
return aValidType && bValidType ? a.getTime() === b.getTime() : false;
|
|
}
|
|
aValidType = isSymbol(a);
|
|
bValidType = isSymbol(b);
|
|
if (aValidType || bValidType) {
|
|
return a === b;
|
|
}
|
|
aValidType = isArray(a);
|
|
bValidType = isArray(b);
|
|
if (aValidType || bValidType) {
|
|
return aValidType && bValidType ? looseCompareArrays(a, b) : false;
|
|
}
|
|
aValidType = isObject2(a);
|
|
bValidType = isObject2(b);
|
|
if (aValidType || bValidType) {
|
|
if (!aValidType || !bValidType) {
|
|
return false;
|
|
}
|
|
const aKeysCount = Object.keys(a).length;
|
|
const bKeysCount = Object.keys(b).length;
|
|
if (aKeysCount !== bKeysCount) {
|
|
return false;
|
|
}
|
|
for (const key in a) {
|
|
const aHasKey = a.hasOwnProperty(key);
|
|
const bHasKey = b.hasOwnProperty(key);
|
|
if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return String(a) === String(b);
|
|
}
|
|
function looseIndexOf(arr, val) {
|
|
return arr.findIndex((item) => looseEqual(item, val));
|
|
}
|
|
var isRef = (val) => {
|
|
return !!(val && val["__v_isRef"] === true);
|
|
};
|
|
var toDisplayString = (val) => {
|
|
return isString(val) ? val : val == null ? "" : isArray(val) || isObject2(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
|
|
};
|
|
var replacer = (_key, val) => {
|
|
if (isRef(val)) {
|
|
return replacer(_key, val.value);
|
|
} else if (isMap(val)) {
|
|
return {
|
|
[`Map(${val.size})`]: [...val.entries()].reduce(
|
|
(entries, [key, val2], i) => {
|
|
entries[stringifySymbol(key, i) + " =>"] = val2;
|
|
return entries;
|
|
},
|
|
{}
|
|
)
|
|
};
|
|
} else if (isSet(val)) {
|
|
return {
|
|
[`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
|
|
};
|
|
} else if (isSymbol(val)) {
|
|
return stringifySymbol(val);
|
|
} else if (isObject2(val) && !isArray(val) && !isPlainObject(val)) {
|
|
return String(val);
|
|
}
|
|
return val;
|
|
};
|
|
var stringifySymbol = (v, i = "") => {
|
|
var _a;
|
|
return (
|
|
// Symbol.description in es2019+ so we need to cast here to pass
|
|
// the lib: es2016 check
|
|
isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
|
|
);
|
|
};
|
|
function normalizeCssVarValue(value) {
|
|
if (value == null) {
|
|
return "initial";
|
|
}
|
|
if (typeof value === "string") {
|
|
return value === "" ? " " : value;
|
|
}
|
|
if (typeof value !== "number" || !Number.isFinite(value)) {
|
|
{
|
|
console.warn(
|
|
"[Vue warn] Invalid value used for CSS binding. Expected a string or a finite number but received:",
|
|
value
|
|
);
|
|
}
|
|
}
|
|
return String(value);
|
|
}
|
|
exports.EMPTY_ARR = EMPTY_ARR;
|
|
exports.EMPTY_OBJ = EMPTY_OBJ;
|
|
exports.NO = NO;
|
|
exports.NOOP = NOOP;
|
|
exports.PatchFlagNames = PatchFlagNames;
|
|
exports.PatchFlags = PatchFlags;
|
|
exports.ShapeFlags = ShapeFlags;
|
|
exports.SlotFlags = SlotFlags;
|
|
exports.camelize = camelize;
|
|
exports.capitalize = capitalize;
|
|
exports.cssVarNameEscapeSymbolsRE = cssVarNameEscapeSymbolsRE;
|
|
exports.def = def;
|
|
exports.escapeHtml = escapeHtml;
|
|
exports.escapeHtmlComment = escapeHtmlComment;
|
|
exports.extend = extend;
|
|
exports.genCacheKey = genCacheKey;
|
|
exports.genPropsAccessExp = genPropsAccessExp;
|
|
exports.generateCodeFrame = generateCodeFrame;
|
|
exports.getEscapedCssVarName = getEscapedCssVarName;
|
|
exports.getGlobalThis = getGlobalThis;
|
|
exports.hasChanged = hasChanged;
|
|
exports.hasOwn = hasOwn;
|
|
exports.hyphenate = hyphenate;
|
|
exports.includeBooleanAttr = includeBooleanAttr;
|
|
exports.invokeArrayFns = invokeArrayFns;
|
|
exports.isArray = isArray;
|
|
exports.isBooleanAttr = isBooleanAttr2;
|
|
exports.isBuiltInDirective = isBuiltInDirective;
|
|
exports.isDate = isDate;
|
|
exports.isFunction = isFunction;
|
|
exports.isGloballyAllowed = isGloballyAllowed;
|
|
exports.isGloballyWhitelisted = isGloballyWhitelisted;
|
|
exports.isHTMLTag = isHTMLTag;
|
|
exports.isIntegerKey = isIntegerKey;
|
|
exports.isKnownHtmlAttr = isKnownHtmlAttr;
|
|
exports.isKnownMathMLAttr = isKnownMathMLAttr;
|
|
exports.isKnownSvgAttr = isKnownSvgAttr;
|
|
exports.isMap = isMap;
|
|
exports.isMathMLTag = isMathMLTag;
|
|
exports.isModelListener = isModelListener;
|
|
exports.isObject = isObject2;
|
|
exports.isOn = isOn;
|
|
exports.isPlainObject = isPlainObject;
|
|
exports.isPromise = isPromise;
|
|
exports.isRegExp = isRegExp;
|
|
exports.isRenderableAttrValue = isRenderableAttrValue;
|
|
exports.isReservedProp = isReservedProp;
|
|
exports.isSSRSafeAttrName = isSSRSafeAttrName;
|
|
exports.isSVGTag = isSVGTag;
|
|
exports.isSet = isSet;
|
|
exports.isSpecialBooleanAttr = isSpecialBooleanAttr;
|
|
exports.isString = isString;
|
|
exports.isSymbol = isSymbol;
|
|
exports.isVoidTag = isVoidTag;
|
|
exports.looseEqual = looseEqual;
|
|
exports.looseIndexOf = looseIndexOf;
|
|
exports.looseToNumber = looseToNumber;
|
|
exports.makeMap = makeMap;
|
|
exports.normalizeClass = normalizeClass;
|
|
exports.normalizeCssVarValue = normalizeCssVarValue;
|
|
exports.normalizeProps = normalizeProps;
|
|
exports.normalizeStyle = normalizeStyle;
|
|
exports.objectToString = objectToString;
|
|
exports.parseStringStyle = parseStringStyle;
|
|
exports.propsToAttrMap = propsToAttrMap;
|
|
exports.remove = remove;
|
|
exports.slotFlagsText = slotFlagsText;
|
|
exports.stringifyStyle = stringifyStyle;
|
|
exports.toDisplayString = toDisplayString;
|
|
exports.toHandlerKey = toHandlerKey;
|
|
exports.toNumber = toNumber;
|
|
exports.toRawType = toRawType;
|
|
exports.toTypeString = toTypeString;
|
|
}
|
|
});
|
|
|
|
// node_modules/@vue/shared/index.js
|
|
var require_shared = __commonJS({
|
|
"node_modules/@vue/shared/index.js"(exports, module2) {
|
|
"use strict";
|
|
if (false) {
|
|
module2.exports = null;
|
|
} else {
|
|
module2.exports = require_shared_cjs();
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/@vue/reactivity/dist/reactivity.cjs.js
|
|
var require_reactivity_cjs = __commonJS({
|
|
"node_modules/@vue/reactivity/dist/reactivity.cjs.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
var shared = require_shared();
|
|
function warn2(msg, ...args) {
|
|
console.warn(`[Vue warn] ${msg}`, ...args);
|
|
}
|
|
var activeEffectScope;
|
|
var EffectScope = class {
|
|
// TODO isolatedDeclarations "__v_skip"
|
|
constructor(detached = false) {
|
|
this.detached = detached;
|
|
this._active = true;
|
|
this._on = 0;
|
|
this.effects = [];
|
|
this.cleanups = [];
|
|
this._isPaused = false;
|
|
this._warnOnRun = true;
|
|
this.__v_skip = true;
|
|
if (!detached && activeEffectScope) {
|
|
if (activeEffectScope.active) {
|
|
this.parent = activeEffectScope;
|
|
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
|
|
this
|
|
) - 1;
|
|
} else {
|
|
this._active = false;
|
|
this._warnOnRun = false;
|
|
}
|
|
}
|
|
}
|
|
get active() {
|
|
return this._active;
|
|
}
|
|
pause() {
|
|
if (this._active) {
|
|
this._isPaused = true;
|
|
let i, l;
|
|
if (this.scopes) {
|
|
const scopes = this.scopes.slice();
|
|
for (i = 0, l = scopes.length; i < l; i++) {
|
|
scopes[i].pause();
|
|
}
|
|
}
|
|
for (i = 0, l = this.effects.length; i < l; i++) {
|
|
this.effects[i].pause();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Resumes the effect scope, including all child scopes and effects.
|
|
*/
|
|
resume() {
|
|
if (this._active) {
|
|
if (this._isPaused) {
|
|
this._isPaused = false;
|
|
let i, l;
|
|
if (this.scopes) {
|
|
const scopes = this.scopes.slice();
|
|
for (i = 0, l = scopes.length; i < l; i++) {
|
|
scopes[i].resume();
|
|
}
|
|
}
|
|
const effects = this.effects.slice();
|
|
for (i = 0, l = effects.length; i < l; i++) {
|
|
effects[i].resume();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
run(fn) {
|
|
if (this._active) {
|
|
const currentEffectScope = activeEffectScope;
|
|
try {
|
|
activeEffectScope = this;
|
|
return fn();
|
|
} finally {
|
|
activeEffectScope = currentEffectScope;
|
|
}
|
|
} else if (this._warnOnRun) {
|
|
warn2(`cannot run an inactive effect scope.`);
|
|
}
|
|
}
|
|
/**
|
|
* This should only be called on non-detached scopes
|
|
* @internal
|
|
*/
|
|
on() {
|
|
if (++this._on === 1) {
|
|
this.prevScope = activeEffectScope;
|
|
activeEffectScope = this;
|
|
}
|
|
}
|
|
/**
|
|
* This should only be called on non-detached scopes
|
|
* @internal
|
|
*/
|
|
off() {
|
|
if (this._on > 0 && --this._on === 0) {
|
|
if (activeEffectScope === this) {
|
|
activeEffectScope = this.prevScope;
|
|
} else {
|
|
let current = activeEffectScope;
|
|
while (current) {
|
|
if (current.prevScope === this) {
|
|
current.prevScope = this.prevScope;
|
|
break;
|
|
}
|
|
current = current.prevScope;
|
|
}
|
|
}
|
|
this.prevScope = void 0;
|
|
}
|
|
}
|
|
stop(fromParent) {
|
|
if (this._active) {
|
|
this._active = false;
|
|
let i, l;
|
|
for (i = 0, l = this.effects.length; i < l; i++) {
|
|
this.effects[i].stop();
|
|
}
|
|
this.effects.length = 0;
|
|
for (i = 0, l = this.cleanups.length; i < l; i++) {
|
|
this.cleanups[i]();
|
|
}
|
|
this.cleanups.length = 0;
|
|
if (this.scopes) {
|
|
const scopes = this.scopes.slice();
|
|
for (i = 0, l = scopes.length; i < l; i++) {
|
|
scopes[i].stop(true);
|
|
}
|
|
this.scopes.length = 0;
|
|
}
|
|
if (!this.detached && this.parent && !fromParent) {
|
|
const last = this.parent.scopes.pop();
|
|
if (last && last !== this) {
|
|
this.parent.scopes[this.index] = last;
|
|
last.index = this.index;
|
|
}
|
|
}
|
|
this.parent = void 0;
|
|
}
|
|
}
|
|
};
|
|
function effectScope(detached) {
|
|
return new EffectScope(detached);
|
|
}
|
|
function getCurrentScope() {
|
|
return activeEffectScope;
|
|
}
|
|
function onScopeDispose(fn, failSilently = false) {
|
|
if (activeEffectScope) {
|
|
activeEffectScope.cleanups.push(fn);
|
|
} else if (!failSilently) {
|
|
warn2(
|
|
`onScopeDispose() is called when there is no active effect scope to be associated with.`
|
|
);
|
|
}
|
|
}
|
|
var activeSub;
|
|
var EffectFlags = {
|
|
"ACTIVE": 1,
|
|
"1": "ACTIVE",
|
|
"RUNNING": 2,
|
|
"2": "RUNNING",
|
|
"TRACKING": 4,
|
|
"4": "TRACKING",
|
|
"NOTIFIED": 8,
|
|
"8": "NOTIFIED",
|
|
"DIRTY": 16,
|
|
"16": "DIRTY",
|
|
"ALLOW_RECURSE": 32,
|
|
"32": "ALLOW_RECURSE",
|
|
"PAUSED": 64,
|
|
"64": "PAUSED",
|
|
"EVALUATED": 128,
|
|
"128": "EVALUATED"
|
|
};
|
|
var pausedQueueEffects = /* @__PURE__ */ new WeakSet();
|
|
var ReactiveEffect = class {
|
|
constructor(fn) {
|
|
this.fn = fn;
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
this.flags = 1 | 4;
|
|
this.next = void 0;
|
|
this.cleanup = void 0;
|
|
this.scheduler = void 0;
|
|
if (activeEffectScope) {
|
|
if (activeEffectScope.active) {
|
|
activeEffectScope.effects.push(this);
|
|
} else {
|
|
this.flags &= -2;
|
|
}
|
|
}
|
|
}
|
|
pause() {
|
|
this.flags |= 64;
|
|
}
|
|
resume() {
|
|
if (this.flags & 64) {
|
|
this.flags &= -65;
|
|
if (pausedQueueEffects.has(this)) {
|
|
pausedQueueEffects.delete(this);
|
|
this.trigger();
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
notify() {
|
|
if (this.flags & 2 && !(this.flags & 32)) {
|
|
return;
|
|
}
|
|
if (!(this.flags & 8)) {
|
|
batch(this);
|
|
}
|
|
}
|
|
run() {
|
|
if (!(this.flags & 1)) {
|
|
return this.fn();
|
|
}
|
|
this.flags |= 2;
|
|
cleanupEffect(this);
|
|
prepareDeps(this);
|
|
const prevEffect = activeSub;
|
|
const prevShouldTrack = shouldTrack;
|
|
activeSub = this;
|
|
shouldTrack = true;
|
|
try {
|
|
return this.fn();
|
|
} finally {
|
|
if (activeSub !== this) {
|
|
warn2(
|
|
"Active effect was not restored correctly - this is likely a Vue internal bug."
|
|
);
|
|
}
|
|
cleanupDeps(this);
|
|
activeSub = prevEffect;
|
|
shouldTrack = prevShouldTrack;
|
|
this.flags &= -3;
|
|
}
|
|
}
|
|
stop() {
|
|
if (this.flags & 1) {
|
|
for (let link = this.deps; link; link = link.nextDep) {
|
|
removeSub(link);
|
|
}
|
|
this.deps = this.depsTail = void 0;
|
|
cleanupEffect(this);
|
|
this.onStop && this.onStop();
|
|
this.flags &= -2;
|
|
}
|
|
}
|
|
trigger() {
|
|
if (this.flags & 64) {
|
|
pausedQueueEffects.add(this);
|
|
} else if (this.scheduler) {
|
|
this.scheduler();
|
|
} else {
|
|
this.runIfDirty();
|
|
}
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
runIfDirty() {
|
|
if (isDirty(this)) {
|
|
this.run();
|
|
}
|
|
}
|
|
get dirty() {
|
|
return isDirty(this);
|
|
}
|
|
};
|
|
var batchDepth = 0;
|
|
var batchedSub;
|
|
var batchedComputed;
|
|
function batch(sub, isComputed = false) {
|
|
sub.flags |= 8;
|
|
if (isComputed) {
|
|
sub.next = batchedComputed;
|
|
batchedComputed = sub;
|
|
return;
|
|
}
|
|
sub.next = batchedSub;
|
|
batchedSub = sub;
|
|
}
|
|
function startBatch() {
|
|
batchDepth++;
|
|
}
|
|
function endBatch() {
|
|
if (--batchDepth > 0) {
|
|
return;
|
|
}
|
|
if (batchedComputed) {
|
|
let e = batchedComputed;
|
|
batchedComputed = void 0;
|
|
while (e) {
|
|
const next = e.next;
|
|
e.next = void 0;
|
|
e.flags &= -9;
|
|
e = next;
|
|
}
|
|
}
|
|
let error2;
|
|
while (batchedSub) {
|
|
let e = batchedSub;
|
|
batchedSub = void 0;
|
|
while (e) {
|
|
const next = e.next;
|
|
e.next = void 0;
|
|
e.flags &= -9;
|
|
if (e.flags & 1) {
|
|
try {
|
|
;
|
|
e.trigger();
|
|
} catch (err) {
|
|
if (!error2)
|
|
error2 = err;
|
|
}
|
|
}
|
|
e = next;
|
|
}
|
|
}
|
|
if (error2)
|
|
throw error2;
|
|
}
|
|
function prepareDeps(sub) {
|
|
for (let link = sub.deps; link; link = link.nextDep) {
|
|
link.version = -1;
|
|
link.prevActiveLink = link.dep.activeLink;
|
|
link.dep.activeLink = link;
|
|
}
|
|
}
|
|
function cleanupDeps(sub) {
|
|
let head;
|
|
let tail = sub.depsTail;
|
|
let link = tail;
|
|
while (link) {
|
|
const prev = link.prevDep;
|
|
if (link.version === -1) {
|
|
if (link === tail)
|
|
tail = prev;
|
|
removeSub(link);
|
|
removeDep(link);
|
|
} else {
|
|
head = link;
|
|
}
|
|
link.dep.activeLink = link.prevActiveLink;
|
|
link.prevActiveLink = void 0;
|
|
link = prev;
|
|
}
|
|
sub.deps = head;
|
|
sub.depsTail = tail;
|
|
}
|
|
function isDirty(sub) {
|
|
for (let link = sub.deps; link; link = link.nextDep) {
|
|
if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (sub._dirty) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function refreshComputed(computed2) {
|
|
if (computed2.flags & 4 && !(computed2.flags & 16)) {
|
|
return;
|
|
}
|
|
computed2.flags &= -17;
|
|
if (computed2.globalVersion === globalVersion) {
|
|
return;
|
|
}
|
|
computed2.globalVersion = globalVersion;
|
|
if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
|
|
return;
|
|
}
|
|
computed2.flags |= 2;
|
|
const dep = computed2.dep;
|
|
const prevSub = activeSub;
|
|
const prevShouldTrack = shouldTrack;
|
|
activeSub = computed2;
|
|
shouldTrack = true;
|
|
try {
|
|
prepareDeps(computed2);
|
|
const value = computed2.fn(computed2._value);
|
|
if (dep.version === 0 || shared.hasChanged(value, computed2._value)) {
|
|
computed2.flags |= 128;
|
|
computed2._value = value;
|
|
dep.version++;
|
|
}
|
|
} catch (err) {
|
|
dep.version++;
|
|
throw err;
|
|
} finally {
|
|
activeSub = prevSub;
|
|
shouldTrack = prevShouldTrack;
|
|
cleanupDeps(computed2);
|
|
computed2.flags &= -3;
|
|
}
|
|
}
|
|
function removeSub(link, soft = false) {
|
|
const { dep, prevSub, nextSub } = link;
|
|
if (prevSub) {
|
|
prevSub.nextSub = nextSub;
|
|
link.prevSub = void 0;
|
|
}
|
|
if (nextSub) {
|
|
nextSub.prevSub = prevSub;
|
|
link.nextSub = void 0;
|
|
}
|
|
if (dep.subsHead === link) {
|
|
dep.subsHead = nextSub;
|
|
}
|
|
if (dep.subs === link) {
|
|
dep.subs = prevSub;
|
|
if (!prevSub && dep.computed) {
|
|
dep.computed.flags &= -5;
|
|
for (let l = dep.computed.deps; l; l = l.nextDep) {
|
|
removeSub(l, true);
|
|
}
|
|
}
|
|
}
|
|
if (!soft && !--dep.sc && dep.map) {
|
|
dep.map.delete(dep.key);
|
|
}
|
|
}
|
|
function removeDep(link) {
|
|
const { prevDep, nextDep } = link;
|
|
if (prevDep) {
|
|
prevDep.nextDep = nextDep;
|
|
link.prevDep = void 0;
|
|
}
|
|
if (nextDep) {
|
|
nextDep.prevDep = prevDep;
|
|
link.nextDep = void 0;
|
|
}
|
|
}
|
|
function effect3(fn, options) {
|
|
if (fn.effect instanceof ReactiveEffect) {
|
|
fn = fn.effect.fn;
|
|
}
|
|
const e = new ReactiveEffect(fn);
|
|
if (options) {
|
|
shared.extend(e, options);
|
|
}
|
|
try {
|
|
e.run();
|
|
} catch (err) {
|
|
e.stop();
|
|
throw err;
|
|
}
|
|
const runner = e.run.bind(e);
|
|
runner.effect = e;
|
|
return runner;
|
|
}
|
|
function stop2(runner) {
|
|
runner.effect.stop();
|
|
}
|
|
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 onEffectCleanup(fn, failSilently = false) {
|
|
if (activeSub instanceof ReactiveEffect) {
|
|
activeSub.cleanup = fn;
|
|
} else if (!failSilently) {
|
|
warn2(
|
|
`onEffectCleanup() was called when there was no active effect to associate with.`
|
|
);
|
|
}
|
|
}
|
|
function cleanupEffect(e) {
|
|
const { cleanup } = e;
|
|
e.cleanup = void 0;
|
|
if (cleanup) {
|
|
const prevSub = activeSub;
|
|
activeSub = void 0;
|
|
try {
|
|
cleanup();
|
|
} finally {
|
|
activeSub = prevSub;
|
|
}
|
|
}
|
|
}
|
|
var globalVersion = 0;
|
|
var Link = class {
|
|
constructor(sub, dep) {
|
|
this.sub = sub;
|
|
this.dep = dep;
|
|
this.version = dep.version;
|
|
this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
|
|
}
|
|
};
|
|
var Dep = class {
|
|
// TODO isolatedDeclarations "__v_skip"
|
|
constructor(computed2) {
|
|
this.computed = computed2;
|
|
this.version = 0;
|
|
this.activeLink = void 0;
|
|
this.subs = void 0;
|
|
this.map = void 0;
|
|
this.key = void 0;
|
|
this.sc = 0;
|
|
this.__v_skip = true;
|
|
{
|
|
this.subsHead = void 0;
|
|
}
|
|
}
|
|
track(debugInfo) {
|
|
if (!activeSub || !shouldTrack || activeSub === this.computed) {
|
|
return;
|
|
}
|
|
let link = this.activeLink;
|
|
if (link === void 0 || link.sub !== activeSub) {
|
|
link = this.activeLink = new Link(activeSub, this);
|
|
if (!activeSub.deps) {
|
|
activeSub.deps = activeSub.depsTail = link;
|
|
} else {
|
|
link.prevDep = activeSub.depsTail;
|
|
activeSub.depsTail.nextDep = link;
|
|
activeSub.depsTail = link;
|
|
}
|
|
addSub(link);
|
|
} else if (link.version === -1) {
|
|
link.version = this.version;
|
|
if (link.nextDep) {
|
|
const next = link.nextDep;
|
|
next.prevDep = link.prevDep;
|
|
if (link.prevDep) {
|
|
link.prevDep.nextDep = next;
|
|
}
|
|
link.prevDep = activeSub.depsTail;
|
|
link.nextDep = void 0;
|
|
activeSub.depsTail.nextDep = link;
|
|
activeSub.depsTail = link;
|
|
if (activeSub.deps === link) {
|
|
activeSub.deps = next;
|
|
}
|
|
}
|
|
}
|
|
if (activeSub.onTrack) {
|
|
activeSub.onTrack(
|
|
shared.extend(
|
|
{
|
|
effect: activeSub
|
|
},
|
|
debugInfo
|
|
)
|
|
);
|
|
}
|
|
return link;
|
|
}
|
|
trigger(debugInfo) {
|
|
this.version++;
|
|
globalVersion++;
|
|
this.notify(debugInfo);
|
|
}
|
|
notify(debugInfo) {
|
|
startBatch();
|
|
try {
|
|
if (true) {
|
|
for (let head = this.subsHead; head; head = head.nextSub) {
|
|
if (head.sub.onTrigger && !(head.sub.flags & 8)) {
|
|
head.sub.onTrigger(
|
|
shared.extend(
|
|
{
|
|
effect: head.sub
|
|
},
|
|
debugInfo
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
for (let link = this.subs; link; link = link.prevSub) {
|
|
if (link.sub.notify()) {
|
|
;
|
|
link.sub.dep.notify();
|
|
}
|
|
}
|
|
} finally {
|
|
endBatch();
|
|
}
|
|
}
|
|
};
|
|
function addSub(link) {
|
|
link.dep.sc++;
|
|
if (link.sub.flags & 4) {
|
|
const computed2 = link.dep.computed;
|
|
if (computed2 && !link.dep.subs) {
|
|
computed2.flags |= 4 | 16;
|
|
for (let l = computed2.deps; l; l = l.nextDep) {
|
|
addSub(l);
|
|
}
|
|
}
|
|
const currentTail = link.dep.subs;
|
|
if (currentTail !== link) {
|
|
link.prevSub = currentTail;
|
|
if (currentTail)
|
|
currentTail.nextSub = link;
|
|
}
|
|
if (link.dep.subsHead === void 0) {
|
|
link.dep.subsHead = link;
|
|
}
|
|
link.dep.subs = link;
|
|
}
|
|
}
|
|
var targetMap = /* @__PURE__ */ new WeakMap();
|
|
var ITERATE_KEY = /* @__PURE__ */ Symbol(
|
|
"Object iterate"
|
|
);
|
|
var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol(
|
|
"Map keys iterate"
|
|
);
|
|
var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol(
|
|
"Array iterate"
|
|
);
|
|
function track(target, type, key) {
|
|
if (shouldTrack && activeSub) {
|
|
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 = new Dep());
|
|
dep.map = depsMap;
|
|
dep.key = key;
|
|
}
|
|
{
|
|
dep.track({
|
|
target,
|
|
type,
|
|
key
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
|
const depsMap = targetMap.get(target);
|
|
if (!depsMap) {
|
|
globalVersion++;
|
|
return;
|
|
}
|
|
const run = (dep) => {
|
|
if (dep) {
|
|
{
|
|
dep.trigger({
|
|
target,
|
|
type,
|
|
key,
|
|
newValue,
|
|
oldValue,
|
|
oldTarget
|
|
});
|
|
}
|
|
}
|
|
};
|
|
startBatch();
|
|
if (type === "clear") {
|
|
depsMap.forEach(run);
|
|
} else {
|
|
const targetIsArray = shared.isArray(target);
|
|
const isArrayIndex = targetIsArray && shared.isIntegerKey(key);
|
|
if (targetIsArray && key === "length") {
|
|
const newLength = Number(newValue);
|
|
depsMap.forEach((dep, key2) => {
|
|
if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !shared.isSymbol(key2) && key2 >= newLength) {
|
|
run(dep);
|
|
}
|
|
});
|
|
} else {
|
|
if (key !== void 0 || depsMap.has(void 0)) {
|
|
run(depsMap.get(key));
|
|
}
|
|
if (isArrayIndex) {
|
|
run(depsMap.get(ARRAY_ITERATE_KEY));
|
|
}
|
|
switch (type) {
|
|
case "add":
|
|
if (!targetIsArray) {
|
|
run(depsMap.get(ITERATE_KEY));
|
|
if (shared.isMap(target)) {
|
|
run(depsMap.get(MAP_KEY_ITERATE_KEY));
|
|
}
|
|
} else if (isArrayIndex) {
|
|
run(depsMap.get("length"));
|
|
}
|
|
break;
|
|
case "delete":
|
|
if (!targetIsArray) {
|
|
run(depsMap.get(ITERATE_KEY));
|
|
if (shared.isMap(target)) {
|
|
run(depsMap.get(MAP_KEY_ITERATE_KEY));
|
|
}
|
|
}
|
|
break;
|
|
case "set":
|
|
if (shared.isMap(target)) {
|
|
run(depsMap.get(ITERATE_KEY));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
endBatch();
|
|
}
|
|
function getDepFromReactive(object, key) {
|
|
const depMap = targetMap.get(object);
|
|
return depMap && depMap.get(key);
|
|
}
|
|
function reactiveReadArray(array) {
|
|
const raw2 = toRaw2(array);
|
|
if (raw2 === array)
|
|
return raw2;
|
|
track(raw2, "iterate", ARRAY_ITERATE_KEY);
|
|
return isShallow(array) ? raw2 : raw2.map(toReactive);
|
|
}
|
|
function shallowReadArray(arr) {
|
|
track(arr = toRaw2(arr), "iterate", ARRAY_ITERATE_KEY);
|
|
return arr;
|
|
}
|
|
function toWrapped(target, item) {
|
|
if (isReadonly(target)) {
|
|
return isReactive2(target) ? toReadonly(toReactive(item)) : toReadonly(item);
|
|
}
|
|
return toReactive(item);
|
|
}
|
|
var arrayInstrumentations = {
|
|
__proto__: null,
|
|
[Symbol.iterator]() {
|
|
return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
|
|
},
|
|
concat(...args) {
|
|
return reactiveReadArray(this).concat(
|
|
...args.map((x) => shared.isArray(x) ? reactiveReadArray(x) : x)
|
|
);
|
|
},
|
|
entries() {
|
|
return iterator(this, "entries", (value) => {
|
|
value[1] = toWrapped(this, value[1]);
|
|
return value;
|
|
});
|
|
},
|
|
every(fn, thisArg) {
|
|
return apply(this, "every", fn, thisArg, void 0, arguments);
|
|
},
|
|
filter(fn, thisArg) {
|
|
return apply(
|
|
this,
|
|
"filter",
|
|
fn,
|
|
thisArg,
|
|
(v) => v.map((item) => toWrapped(this, item)),
|
|
arguments
|
|
);
|
|
},
|
|
find(fn, thisArg) {
|
|
return apply(
|
|
this,
|
|
"find",
|
|
fn,
|
|
thisArg,
|
|
(item) => toWrapped(this, item),
|
|
arguments
|
|
);
|
|
},
|
|
findIndex(fn, thisArg) {
|
|
return apply(this, "findIndex", fn, thisArg, void 0, arguments);
|
|
},
|
|
findLast(fn, thisArg) {
|
|
return apply(
|
|
this,
|
|
"findLast",
|
|
fn,
|
|
thisArg,
|
|
(item) => toWrapped(this, item),
|
|
arguments
|
|
);
|
|
},
|
|
findLastIndex(fn, thisArg) {
|
|
return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
|
|
},
|
|
// flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
|
|
forEach(fn, thisArg) {
|
|
return apply(this, "forEach", fn, thisArg, void 0, arguments);
|
|
},
|
|
includes(...args) {
|
|
return searchProxy(this, "includes", args);
|
|
},
|
|
indexOf(...args) {
|
|
return searchProxy(this, "indexOf", args);
|
|
},
|
|
join(separator) {
|
|
return reactiveReadArray(this).join(separator);
|
|
},
|
|
// keys() iterator only reads `length`, no optimization required
|
|
lastIndexOf(...args) {
|
|
return searchProxy(this, "lastIndexOf", args);
|
|
},
|
|
map(fn, thisArg) {
|
|
return apply(this, "map", fn, thisArg, void 0, arguments);
|
|
},
|
|
pop() {
|
|
return noTracking(this, "pop");
|
|
},
|
|
push(...args) {
|
|
return noTracking(this, "push", args);
|
|
},
|
|
reduce(fn, ...args) {
|
|
return reduce(this, "reduce", fn, args);
|
|
},
|
|
reduceRight(fn, ...args) {
|
|
return reduce(this, "reduceRight", fn, args);
|
|
},
|
|
shift() {
|
|
return noTracking(this, "shift");
|
|
},
|
|
// slice could use ARRAY_ITERATE but also seems to beg for range tracking
|
|
some(fn, thisArg) {
|
|
return apply(this, "some", fn, thisArg, void 0, arguments);
|
|
},
|
|
splice(...args) {
|
|
return noTracking(this, "splice", args);
|
|
},
|
|
toReversed() {
|
|
return reactiveReadArray(this).toReversed();
|
|
},
|
|
toSorted(comparer) {
|
|
return reactiveReadArray(this).toSorted(comparer);
|
|
},
|
|
toSpliced(...args) {
|
|
return reactiveReadArray(this).toSpliced(...args);
|
|
},
|
|
unshift(...args) {
|
|
return noTracking(this, "unshift", args);
|
|
},
|
|
values() {
|
|
return iterator(this, "values", (item) => toWrapped(this, item));
|
|
}
|
|
};
|
|
function iterator(self2, method, wrapValue) {
|
|
const arr = shallowReadArray(self2);
|
|
const iter = arr[method]();
|
|
if (arr !== self2 && !isShallow(self2)) {
|
|
iter._next = iter.next;
|
|
iter.next = () => {
|
|
const result = iter._next();
|
|
if (!result.done) {
|
|
result.value = wrapValue(result.value);
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
return iter;
|
|
}
|
|
var arrayProto = Array.prototype;
|
|
function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
|
|
const arr = shallowReadArray(self2);
|
|
const needsWrap = arr !== self2 && !isShallow(self2);
|
|
const methodFn = arr[method];
|
|
if (methodFn !== arrayProto[method]) {
|
|
const result2 = methodFn.apply(self2, args);
|
|
return needsWrap ? toReactive(result2) : result2;
|
|
}
|
|
let wrappedFn = fn;
|
|
if (arr !== self2) {
|
|
if (needsWrap) {
|
|
wrappedFn = function(item, index) {
|
|
return fn.call(this, toWrapped(self2, item), index, self2);
|
|
};
|
|
} else if (fn.length > 2) {
|
|
wrappedFn = function(item, index) {
|
|
return fn.call(this, item, index, self2);
|
|
};
|
|
}
|
|
}
|
|
const result = methodFn.call(arr, wrappedFn, thisArg);
|
|
return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
|
|
}
|
|
function reduce(self2, method, fn, args) {
|
|
const arr = shallowReadArray(self2);
|
|
const needsWrap = arr !== self2 && !isShallow(self2);
|
|
let wrappedFn = fn;
|
|
let wrapInitialAccumulator = false;
|
|
if (arr !== self2) {
|
|
if (needsWrap) {
|
|
wrapInitialAccumulator = args.length === 0;
|
|
wrappedFn = function(acc, item, index) {
|
|
if (wrapInitialAccumulator) {
|
|
wrapInitialAccumulator = false;
|
|
acc = toWrapped(self2, acc);
|
|
}
|
|
return fn.call(this, acc, toWrapped(self2, item), index, self2);
|
|
};
|
|
} else if (fn.length > 3) {
|
|
wrappedFn = function(acc, item, index) {
|
|
return fn.call(this, acc, item, index, self2);
|
|
};
|
|
}
|
|
}
|
|
const result = arr[method](wrappedFn, ...args);
|
|
return wrapInitialAccumulator ? toWrapped(self2, result) : result;
|
|
}
|
|
function searchProxy(self2, method, args) {
|
|
const arr = toRaw2(self2);
|
|
track(arr, "iterate", ARRAY_ITERATE_KEY);
|
|
const res = arr[method](...args);
|
|
if ((res === -1 || res === false) && isProxy(args[0])) {
|
|
args[0] = toRaw2(args[0]);
|
|
return arr[method](...args);
|
|
}
|
|
return res;
|
|
}
|
|
function noTracking(self2, method, args = []) {
|
|
pauseTracking();
|
|
startBatch();
|
|
const res = toRaw2(self2)[method].apply(self2, args);
|
|
endBatch();
|
|
resetTracking();
|
|
return res;
|
|
}
|
|
var isNonTrackableKeys = /* @__PURE__ */ shared.makeMap(`__proto__,__v_isRef,__isVue`);
|
|
var builtInSymbols = new Set(
|
|
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(shared.isSymbol)
|
|
);
|
|
function hasOwnProperty(key) {
|
|
if (!shared.isSymbol(key))
|
|
key = String(key);
|
|
const obj = toRaw2(this);
|
|
track(obj, "has", key);
|
|
return obj.hasOwnProperty(key);
|
|
}
|
|
var BaseReactiveHandler = class {
|
|
constructor(_isReadonly = false, _isShallow = false) {
|
|
this._isReadonly = _isReadonly;
|
|
this._isShallow = _isShallow;
|
|
}
|
|
get(target, key, receiver) {
|
|
if (key === "__v_skip")
|
|
return target["__v_skip"];
|
|
const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
|
|
if (key === "__v_isReactive") {
|
|
return !isReadonly2;
|
|
} else if (key === "__v_isReadonly") {
|
|
return isReadonly2;
|
|
} else if (key === "__v_isShallow") {
|
|
return isShallow2;
|
|
} else if (key === "__v_raw") {
|
|
if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
|
|
// this means the receiver is a user proxy of the reactive proxy
|
|
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
|
|
return target;
|
|
}
|
|
return;
|
|
}
|
|
const targetIsArray = shared.isArray(target);
|
|
if (!isReadonly2) {
|
|
let fn;
|
|
if (targetIsArray && (fn = arrayInstrumentations[key])) {
|
|
return fn;
|
|
}
|
|
if (key === "hasOwnProperty") {
|
|
return hasOwnProperty;
|
|
}
|
|
}
|
|
const res = Reflect.get(
|
|
target,
|
|
key,
|
|
// if this is a proxy wrapping a ref, return methods using the raw ref
|
|
// as receiver so that we don't have to call `toRaw` on the ref in all
|
|
// its class methods
|
|
isRef(target) ? target : receiver
|
|
);
|
|
if (shared.isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
|
return res;
|
|
}
|
|
if (!isReadonly2) {
|
|
track(target, "get", key);
|
|
}
|
|
if (isShallow2) {
|
|
return res;
|
|
}
|
|
if (isRef(res)) {
|
|
const value = targetIsArray && shared.isIntegerKey(key) ? res : res.value;
|
|
return isReadonly2 && shared.isObject(value) ? readonly(value) : value;
|
|
}
|
|
if (shared.isObject(res)) {
|
|
return isReadonly2 ? readonly(res) : reactive3(res);
|
|
}
|
|
return res;
|
|
}
|
|
};
|
|
var MutableReactiveHandler = class extends BaseReactiveHandler {
|
|
constructor(isShallow2 = false) {
|
|
super(false, isShallow2);
|
|
}
|
|
set(target, key, value, receiver) {
|
|
let oldValue = target[key];
|
|
const isArrayWithIntegerKey = shared.isArray(target) && shared.isIntegerKey(key);
|
|
if (!this._isShallow) {
|
|
const isOldValueReadonly = isReadonly(oldValue);
|
|
if (!isShallow(value) && !isReadonly(value)) {
|
|
oldValue = toRaw2(oldValue);
|
|
value = toRaw2(value);
|
|
}
|
|
if (!isArrayWithIntegerKey && isRef(oldValue) && !isRef(value)) {
|
|
if (isOldValueReadonly) {
|
|
{
|
|
warn2(
|
|
`Set operation on key "${String(key)}" failed: target is readonly.`,
|
|
target[key]
|
|
);
|
|
}
|
|
return true;
|
|
} else {
|
|
oldValue.value = value;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : shared.hasOwn(target, key);
|
|
const result = Reflect.set(
|
|
target,
|
|
key,
|
|
value,
|
|
isRef(target) ? target : receiver
|
|
);
|
|
if (target === toRaw2(receiver) && result) {
|
|
if (!hadKey) {
|
|
trigger(target, "add", key, value);
|
|
} else if (shared.hasChanged(value, oldValue)) {
|
|
trigger(target, "set", key, value, oldValue);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
deleteProperty(target, key) {
|
|
const hadKey = shared.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;
|
|
}
|
|
has(target, key) {
|
|
const result = Reflect.has(target, key);
|
|
if (!shared.isSymbol(key) || !builtInSymbols.has(key)) {
|
|
track(target, "has", key);
|
|
}
|
|
return result;
|
|
}
|
|
ownKeys(target) {
|
|
track(
|
|
target,
|
|
"iterate",
|
|
shared.isArray(target) ? "length" : ITERATE_KEY
|
|
);
|
|
return Reflect.ownKeys(target);
|
|
}
|
|
};
|
|
var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
|
|
constructor(isShallow2 = false) {
|
|
super(true, isShallow2);
|
|
}
|
|
set(target, key) {
|
|
{
|
|
warn2(
|
|
`Set operation on key "${String(key)}" failed: target is readonly.`,
|
|
target
|
|
);
|
|
}
|
|
return true;
|
|
}
|
|
deleteProperty(target, key) {
|
|
{
|
|
warn2(
|
|
`Delete operation on key "${String(key)}" failed: target is readonly.`,
|
|
target
|
|
);
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
|
|
var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
|
|
var shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
|
|
var shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
|
|
var toShallow = (value) => value;
|
|
var getProto = (v) => Reflect.getPrototypeOf(v);
|
|
function createIterableMethod(method, isReadonly2, isShallow2) {
|
|
return function(...args) {
|
|
const target = this["__v_raw"];
|
|
const rawTarget = toRaw2(target);
|
|
const targetIsMap = shared.isMap(rawTarget);
|
|
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
|
|
const isKeyOnly = method === "keys" && targetIsMap;
|
|
const innerIterator = target[method](...args);
|
|
const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
|
|
!isReadonly2 && track(
|
|
rawTarget,
|
|
"iterate",
|
|
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
|
|
);
|
|
return shared.extend(
|
|
// inheriting all iterator properties
|
|
Object.create(innerIterator),
|
|
{
|
|
// iterator protocol
|
|
next() {
|
|
const { value, done } = innerIterator.next();
|
|
return done ? { value, done } : {
|
|
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
|
|
done
|
|
};
|
|
}
|
|
}
|
|
);
|
|
};
|
|
}
|
|
function createReadonlyMethod(type) {
|
|
return function(...args) {
|
|
{
|
|
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
|
warn2(
|
|
`${shared.capitalize(type)} operation ${key}failed: target is readonly.`,
|
|
toRaw2(this)
|
|
);
|
|
}
|
|
return type === "delete" ? false : type === "clear" ? void 0 : this;
|
|
};
|
|
}
|
|
function createInstrumentations(readonly2, shallow) {
|
|
const instrumentations = {
|
|
get(key) {
|
|
const target = this["__v_raw"];
|
|
const rawTarget = toRaw2(target);
|
|
const rawKey = toRaw2(key);
|
|
if (!readonly2) {
|
|
if (shared.hasChanged(key, rawKey)) {
|
|
track(rawTarget, "get", key);
|
|
}
|
|
track(rawTarget, "get", rawKey);
|
|
}
|
|
const { has } = getProto(rawTarget);
|
|
const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
|
|
if (has.call(rawTarget, key)) {
|
|
return wrap(target.get(key));
|
|
} else if (has.call(rawTarget, rawKey)) {
|
|
return wrap(target.get(rawKey));
|
|
} else if (target !== rawTarget) {
|
|
target.get(key);
|
|
}
|
|
},
|
|
get size() {
|
|
const target = this["__v_raw"];
|
|
!readonly2 && track(toRaw2(target), "iterate", ITERATE_KEY);
|
|
return target.size;
|
|
},
|
|
has(key) {
|
|
const target = this["__v_raw"];
|
|
const rawTarget = toRaw2(target);
|
|
const rawKey = toRaw2(key);
|
|
if (!readonly2) {
|
|
if (shared.hasChanged(key, rawKey)) {
|
|
track(rawTarget, "has", key);
|
|
}
|
|
track(rawTarget, "has", rawKey);
|
|
}
|
|
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
|
|
},
|
|
forEach(callback, thisArg) {
|
|
const observed = this;
|
|
const target = observed["__v_raw"];
|
|
const rawTarget = toRaw2(target);
|
|
const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
|
|
!readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
|
|
return target.forEach((value, key) => {
|
|
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
|
});
|
|
}
|
|
};
|
|
shared.extend(
|
|
instrumentations,
|
|
readonly2 ? {
|
|
add: createReadonlyMethod("add"),
|
|
set: createReadonlyMethod("set"),
|
|
delete: createReadonlyMethod("delete"),
|
|
clear: createReadonlyMethod("clear")
|
|
} : {
|
|
add(value) {
|
|
const target = toRaw2(this);
|
|
const proto = getProto(target);
|
|
const rawValue = toRaw2(value);
|
|
const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
|
|
const hadKey = proto.has.call(target, valueToAdd) || shared.hasChanged(value, valueToAdd) && proto.has.call(target, value) || shared.hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
|
|
if (!hadKey) {
|
|
target.add(valueToAdd);
|
|
trigger(target, "add", valueToAdd, valueToAdd);
|
|
}
|
|
return this;
|
|
},
|
|
set(key, value) {
|
|
if (!shallow && !isShallow(value) && !isReadonly(value)) {
|
|
value = toRaw2(value);
|
|
}
|
|
const target = toRaw2(this);
|
|
const { has, get: get2 } = getProto(target);
|
|
let hadKey = has.call(target, key);
|
|
if (!hadKey) {
|
|
key = toRaw2(key);
|
|
hadKey = has.call(target, key);
|
|
} else {
|
|
checkIdentityKeys(target, has, key);
|
|
}
|
|
const oldValue = get2.call(target, key);
|
|
target.set(key, value);
|
|
if (!hadKey) {
|
|
trigger(target, "add", key, value);
|
|
} else if (shared.hasChanged(value, oldValue)) {
|
|
trigger(target, "set", key, value, oldValue);
|
|
}
|
|
return this;
|
|
},
|
|
delete(key) {
|
|
const target = toRaw2(this);
|
|
const { has, get: get2 } = getProto(target);
|
|
let hadKey = has.call(target, key);
|
|
if (!hadKey) {
|
|
key = toRaw2(key);
|
|
hadKey = has.call(target, key);
|
|
} else {
|
|
checkIdentityKeys(target, has, key);
|
|
}
|
|
const oldValue = get2 ? get2.call(target, key) : void 0;
|
|
const result = target.delete(key);
|
|
if (hadKey) {
|
|
trigger(target, "delete", key, void 0, oldValue);
|
|
}
|
|
return result;
|
|
},
|
|
clear() {
|
|
const target = toRaw2(this);
|
|
const hadItems = target.size !== 0;
|
|
const oldTarget = shared.isMap(target) ? new Map(target) : new Set(target);
|
|
const result = target.clear();
|
|
if (hadItems) {
|
|
trigger(
|
|
target,
|
|
"clear",
|
|
void 0,
|
|
void 0,
|
|
oldTarget
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
);
|
|
const iteratorMethods = [
|
|
"keys",
|
|
"values",
|
|
"entries",
|
|
Symbol.iterator
|
|
];
|
|
iteratorMethods.forEach((method) => {
|
|
instrumentations[method] = createIterableMethod(method, readonly2, shallow);
|
|
});
|
|
return instrumentations;
|
|
}
|
|
function createInstrumentationGetter(isReadonly2, shallow) {
|
|
const instrumentations = createInstrumentations(isReadonly2, shallow);
|
|
return (target, key, receiver) => {
|
|
if (key === "__v_isReactive") {
|
|
return !isReadonly2;
|
|
} else if (key === "__v_isReadonly") {
|
|
return isReadonly2;
|
|
} else if (key === "__v_raw") {
|
|
return target;
|
|
}
|
|
return Reflect.get(
|
|
shared.hasOwn(instrumentations, key) && key in target ? instrumentations : target,
|
|
key,
|
|
receiver
|
|
);
|
|
};
|
|
}
|
|
var mutableCollectionHandlers = {
|
|
get: /* @__PURE__ */ createInstrumentationGetter(false, false)
|
|
};
|
|
var shallowCollectionHandlers = {
|
|
get: /* @__PURE__ */ createInstrumentationGetter(false, true)
|
|
};
|
|
var readonlyCollectionHandlers = {
|
|
get: /* @__PURE__ */ createInstrumentationGetter(true, false)
|
|
};
|
|
var shallowReadonlyCollectionHandlers = {
|
|
get: /* @__PURE__ */ createInstrumentationGetter(true, true)
|
|
};
|
|
function checkIdentityKeys(target, has, key) {
|
|
const rawKey = toRaw2(key);
|
|
if (rawKey !== key && has.call(target, rawKey)) {
|
|
const type = shared.toRawType(target);
|
|
warn2(
|
|
`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 reactive3(target) {
|
|
if (/* @__PURE__ */ isReadonly(target)) {
|
|
return target;
|
|
}
|
|
return createReactiveObject(
|
|
target,
|
|
false,
|
|
mutableHandlers,
|
|
mutableCollectionHandlers,
|
|
reactiveMap
|
|
);
|
|
}
|
|
function shallowReactive(target) {
|
|
return createReactiveObject(
|
|
target,
|
|
false,
|
|
shallowReactiveHandlers,
|
|
shallowCollectionHandlers,
|
|
shallowReactiveMap
|
|
);
|
|
}
|
|
function readonly(target) {
|
|
return createReactiveObject(
|
|
target,
|
|
true,
|
|
readonlyHandlers,
|
|
readonlyCollectionHandlers,
|
|
readonlyMap
|
|
);
|
|
}
|
|
function shallowReadonly(target) {
|
|
return createReactiveObject(
|
|
target,
|
|
true,
|
|
shallowReadonlyHandlers,
|
|
shallowReadonlyCollectionHandlers,
|
|
shallowReadonlyMap
|
|
);
|
|
}
|
|
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
|
|
if (!shared.isObject(target)) {
|
|
{
|
|
warn2(
|
|
`value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
|
|
target
|
|
)}`
|
|
);
|
|
}
|
|
return target;
|
|
}
|
|
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
|
|
return target;
|
|
}
|
|
if (target["__v_skip"] || !Object.isExtensible(target)) {
|
|
return target;
|
|
}
|
|
const existingProxy = proxyMap.get(target);
|
|
if (existingProxy) {
|
|
return existingProxy;
|
|
}
|
|
const targetType = targetTypeMap(shared.toRawType(target));
|
|
if (targetType === 0) {
|
|
return target;
|
|
}
|
|
const proxy = new Proxy(
|
|
target,
|
|
targetType === 2 ? collectionHandlers : baseHandlers
|
|
);
|
|
proxyMap.set(target, proxy);
|
|
return proxy;
|
|
}
|
|
function isReactive2(value) {
|
|
if (/* @__PURE__ */ isReadonly(value)) {
|
|
return /* @__PURE__ */ isReactive2(value["__v_raw"]);
|
|
}
|
|
return !!(value && value["__v_isReactive"]);
|
|
}
|
|
function isReadonly(value) {
|
|
return !!(value && value["__v_isReadonly"]);
|
|
}
|
|
function isShallow(value) {
|
|
return !!(value && value["__v_isShallow"]);
|
|
}
|
|
function isProxy(value) {
|
|
return value ? !!value["__v_raw"] : false;
|
|
}
|
|
function toRaw2(observed) {
|
|
const raw2 = observed && observed["__v_raw"];
|
|
return raw2 ? /* @__PURE__ */ toRaw2(raw2) : observed;
|
|
}
|
|
function markRaw(value) {
|
|
if (!shared.hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
|
|
shared.def(value, "__v_skip", true);
|
|
}
|
|
return value;
|
|
}
|
|
var toReactive = (value) => shared.isObject(value) ? /* @__PURE__ */ reactive3(value) : value;
|
|
var toReadonly = (value) => shared.isObject(value) ? /* @__PURE__ */ readonly(value) : value;
|
|
function isRef(r) {
|
|
return r ? r["__v_isRef"] === true : false;
|
|
}
|
|
function ref(value) {
|
|
return createRef(value, false);
|
|
}
|
|
function shallowRef(value) {
|
|
return createRef(value, true);
|
|
}
|
|
function createRef(rawValue, shallow) {
|
|
if (/* @__PURE__ */ isRef(rawValue)) {
|
|
return rawValue;
|
|
}
|
|
return new RefImpl(rawValue, shallow);
|
|
}
|
|
var RefImpl = class {
|
|
constructor(value, isShallow2) {
|
|
this.dep = new Dep();
|
|
this["__v_isRef"] = true;
|
|
this["__v_isShallow"] = false;
|
|
this._rawValue = isShallow2 ? value : toRaw2(value);
|
|
this._value = isShallow2 ? value : toReactive(value);
|
|
this["__v_isShallow"] = isShallow2;
|
|
}
|
|
get value() {
|
|
{
|
|
this.dep.track({
|
|
target: this,
|
|
type: "get",
|
|
key: "value"
|
|
});
|
|
}
|
|
return this._value;
|
|
}
|
|
set value(newValue) {
|
|
const oldValue = this._rawValue;
|
|
const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
|
|
newValue = useDirectValue ? newValue : toRaw2(newValue);
|
|
if (shared.hasChanged(newValue, oldValue)) {
|
|
this._rawValue = newValue;
|
|
this._value = useDirectValue ? newValue : toReactive(newValue);
|
|
{
|
|
this.dep.trigger({
|
|
target: this,
|
|
type: "set",
|
|
key: "value",
|
|
newValue,
|
|
oldValue
|
|
});
|
|
}
|
|
}
|
|
}
|
|
};
|
|
function triggerRef(ref2) {
|
|
if (ref2.dep) {
|
|
{
|
|
ref2.dep.trigger({
|
|
target: ref2,
|
|
type: "set",
|
|
key: "value",
|
|
newValue: ref2._value
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function unref(ref2) {
|
|
return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
|
|
}
|
|
function toValue(source) {
|
|
return shared.isFunction(source) ? source() : unref(source);
|
|
}
|
|
var shallowUnwrapHandlers = {
|
|
get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
|
|
set: (target, key, value, receiver) => {
|
|
const oldValue = target[key];
|
|
if (/* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
|
|
oldValue.value = value;
|
|
return true;
|
|
} else {
|
|
return Reflect.set(target, key, value, receiver);
|
|
}
|
|
}
|
|
};
|
|
function proxyRefs(objectWithRefs) {
|
|
return isReactive2(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
|
|
}
|
|
var CustomRefImpl = class {
|
|
constructor(factory) {
|
|
this["__v_isRef"] = true;
|
|
this._value = void 0;
|
|
const dep = this.dep = new Dep();
|
|
const { get: get2, set: set2 } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
|
|
this._get = get2;
|
|
this._set = set2;
|
|
}
|
|
get value() {
|
|
return this._value = this._get();
|
|
}
|
|
set value(newVal) {
|
|
this._set(newVal);
|
|
}
|
|
};
|
|
function customRef(factory) {
|
|
return new CustomRefImpl(factory);
|
|
}
|
|
function toRefs(object) {
|
|
if (!isProxy(object)) {
|
|
warn2(`toRefs() expects a reactive object but received a plain one.`);
|
|
}
|
|
const ret = shared.isArray(object) ? new Array(object.length) : {};
|
|
for (const key in object) {
|
|
ret[key] = propertyToRef(object, key);
|
|
}
|
|
return ret;
|
|
}
|
|
var ObjectRefImpl = class {
|
|
constructor(_object, key, _defaultValue) {
|
|
this._object = _object;
|
|
this._defaultValue = _defaultValue;
|
|
this["__v_isRef"] = true;
|
|
this._value = void 0;
|
|
this._key = shared.isSymbol(key) ? key : String(key);
|
|
this._raw = toRaw2(_object);
|
|
let shallow = true;
|
|
let obj = _object;
|
|
if (!shared.isArray(_object) || shared.isSymbol(this._key) || !shared.isIntegerKey(this._key)) {
|
|
do {
|
|
shallow = !isProxy(obj) || isShallow(obj);
|
|
} while (shallow && (obj = obj["__v_raw"]));
|
|
}
|
|
this._shallow = shallow;
|
|
}
|
|
get value() {
|
|
let val = this._object[this._key];
|
|
if (this._shallow) {
|
|
val = unref(val);
|
|
}
|
|
return this._value = val === void 0 ? this._defaultValue : val;
|
|
}
|
|
set value(newVal) {
|
|
if (this._shallow && /* @__PURE__ */ isRef(this._raw[this._key])) {
|
|
const nestedRef = this._object[this._key];
|
|
if (/* @__PURE__ */ isRef(nestedRef)) {
|
|
nestedRef.value = newVal;
|
|
return;
|
|
}
|
|
}
|
|
this._object[this._key] = newVal;
|
|
}
|
|
get dep() {
|
|
return getDepFromReactive(this._raw, this._key);
|
|
}
|
|
};
|
|
var GetterRefImpl = class {
|
|
constructor(_getter) {
|
|
this._getter = _getter;
|
|
this["__v_isRef"] = true;
|
|
this["__v_isReadonly"] = true;
|
|
this._value = void 0;
|
|
}
|
|
get value() {
|
|
return this._value = this._getter();
|
|
}
|
|
};
|
|
function toRef(source, key, defaultValue) {
|
|
if (/* @__PURE__ */ isRef(source)) {
|
|
return source;
|
|
} else if (shared.isFunction(source)) {
|
|
return new GetterRefImpl(source);
|
|
} else if (shared.isObject(source) && arguments.length > 1) {
|
|
return propertyToRef(source, key, defaultValue);
|
|
} else {
|
|
return /* @__PURE__ */ ref(source);
|
|
}
|
|
}
|
|
function propertyToRef(source, key, defaultValue) {
|
|
return new ObjectRefImpl(source, key, defaultValue);
|
|
}
|
|
var ComputedRefImpl = class {
|
|
constructor(fn, setter, isSSR) {
|
|
this.fn = fn;
|
|
this.setter = setter;
|
|
this._value = void 0;
|
|
this.dep = new Dep(this);
|
|
this.__v_isRef = true;
|
|
this.deps = void 0;
|
|
this.depsTail = void 0;
|
|
this.flags = 16;
|
|
this.globalVersion = globalVersion - 1;
|
|
this.next = void 0;
|
|
this.effect = this;
|
|
this["__v_isReadonly"] = !setter;
|
|
this.isSSR = isSSR;
|
|
}
|
|
/**
|
|
* @internal
|
|
*/
|
|
notify() {
|
|
this.flags |= 16;
|
|
if (!(this.flags & 8) && // avoid infinite self recursion
|
|
activeSub !== this) {
|
|
batch(this, true);
|
|
return true;
|
|
}
|
|
}
|
|
get value() {
|
|
const link = this.dep.track({
|
|
target: this,
|
|
type: "get",
|
|
key: "value"
|
|
});
|
|
refreshComputed(this);
|
|
if (link) {
|
|
link.version = this.dep.version;
|
|
}
|
|
return this._value;
|
|
}
|
|
set value(newValue) {
|
|
if (this.setter) {
|
|
this.setter(newValue);
|
|
} else {
|
|
warn2("Write operation failed: computed value is readonly");
|
|
}
|
|
}
|
|
};
|
|
function computed(getterOrOptions, debugOptions, isSSR = false) {
|
|
let getter;
|
|
let setter;
|
|
if (shared.isFunction(getterOrOptions)) {
|
|
getter = getterOrOptions;
|
|
} else {
|
|
getter = getterOrOptions.get;
|
|
setter = getterOrOptions.set;
|
|
}
|
|
const cRef = new ComputedRefImpl(getter, setter, isSSR);
|
|
if (debugOptions && !isSSR) {
|
|
cRef.onTrack = debugOptions.onTrack;
|
|
cRef.onTrigger = debugOptions.onTrigger;
|
|
}
|
|
return cRef;
|
|
}
|
|
var TrackOpTypes = {
|
|
"GET": "get",
|
|
"HAS": "has",
|
|
"ITERATE": "iterate"
|
|
};
|
|
var TriggerOpTypes = {
|
|
"SET": "set",
|
|
"ADD": "add",
|
|
"DELETE": "delete",
|
|
"CLEAR": "clear"
|
|
};
|
|
var ReactiveFlags = {
|
|
"SKIP": "__v_skip",
|
|
"IS_REACTIVE": "__v_isReactive",
|
|
"IS_READONLY": "__v_isReadonly",
|
|
"IS_SHALLOW": "__v_isShallow",
|
|
"RAW": "__v_raw",
|
|
"IS_REF": "__v_isRef"
|
|
};
|
|
var WatchErrorCodes = {
|
|
"WATCH_GETTER": 2,
|
|
"2": "WATCH_GETTER",
|
|
"WATCH_CALLBACK": 3,
|
|
"3": "WATCH_CALLBACK",
|
|
"WATCH_CLEANUP": 4,
|
|
"4": "WATCH_CLEANUP"
|
|
};
|
|
var INITIAL_WATCHER_VALUE = {};
|
|
var cleanupMap = /* @__PURE__ */ new WeakMap();
|
|
var activeWatcher = void 0;
|
|
function getCurrentWatcher() {
|
|
return activeWatcher;
|
|
}
|
|
function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
|
|
if (owner) {
|
|
let cleanups = cleanupMap.get(owner);
|
|
if (!cleanups)
|
|
cleanupMap.set(owner, cleanups = []);
|
|
cleanups.push(cleanupFn);
|
|
} else if (!failSilently) {
|
|
warn2(
|
|
`onWatcherCleanup() was called when there was no active watcher to associate with.`
|
|
);
|
|
}
|
|
}
|
|
function watch2(source, cb, options = shared.EMPTY_OBJ) {
|
|
const { immediate, deep, once: once2, scheduler: scheduler2, augmentJob, call } = options;
|
|
const warnInvalidSource = (s) => {
|
|
(options.onWarn || warn2)(
|
|
`Invalid watch source: `,
|
|
s,
|
|
`A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
|
|
);
|
|
};
|
|
const reactiveGetter = (source2) => {
|
|
if (deep)
|
|
return source2;
|
|
if (isShallow(source2) || deep === false || deep === 0)
|
|
return traverse(source2, 1);
|
|
return traverse(source2);
|
|
};
|
|
let effect4;
|
|
let getter;
|
|
let cleanup;
|
|
let boundCleanup;
|
|
let forceTrigger = false;
|
|
let isMultiSource = false;
|
|
if (isRef(source)) {
|
|
getter = () => source.value;
|
|
forceTrigger = isShallow(source);
|
|
} else if (isReactive2(source)) {
|
|
getter = () => reactiveGetter(source);
|
|
forceTrigger = true;
|
|
} else if (shared.isArray(source)) {
|
|
isMultiSource = true;
|
|
forceTrigger = source.some((s) => isReactive2(s) || isShallow(s));
|
|
getter = () => source.map((s) => {
|
|
if (isRef(s)) {
|
|
return s.value;
|
|
} else if (isReactive2(s)) {
|
|
return reactiveGetter(s);
|
|
} else if (shared.isFunction(s)) {
|
|
return call ? call(s, 2) : s();
|
|
} else {
|
|
warnInvalidSource(s);
|
|
}
|
|
});
|
|
} else if (shared.isFunction(source)) {
|
|
if (cb) {
|
|
getter = call ? () => call(source, 2) : source;
|
|
} else {
|
|
getter = () => {
|
|
if (cleanup) {
|
|
pauseTracking();
|
|
try {
|
|
cleanup();
|
|
} finally {
|
|
resetTracking();
|
|
}
|
|
}
|
|
const currentEffect = activeWatcher;
|
|
activeWatcher = effect4;
|
|
try {
|
|
return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
|
|
} finally {
|
|
activeWatcher = currentEffect;
|
|
}
|
|
};
|
|
}
|
|
} else {
|
|
getter = shared.NOOP;
|
|
warnInvalidSource(source);
|
|
}
|
|
if (cb && deep) {
|
|
const baseGetter = getter;
|
|
const depth = deep === true ? Infinity : deep;
|
|
getter = () => traverse(baseGetter(), depth);
|
|
}
|
|
const scope2 = getCurrentScope();
|
|
const watchHandle = () => {
|
|
effect4.stop();
|
|
if (scope2 && scope2.active) {
|
|
shared.remove(scope2.effects, effect4);
|
|
}
|
|
};
|
|
if (once2 && cb) {
|
|
const _cb = cb;
|
|
cb = (...args) => {
|
|
const res = _cb(...args);
|
|
watchHandle();
|
|
return res;
|
|
};
|
|
}
|
|
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
|
|
const job = (immediateFirstRun) => {
|
|
if (!(effect4.flags & 1) || !effect4.dirty && !immediateFirstRun) {
|
|
return;
|
|
}
|
|
if (cb) {
|
|
const newValue = effect4.run();
|
|
if (immediateFirstRun || deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue))) {
|
|
if (cleanup) {
|
|
cleanup();
|
|
}
|
|
const currentWatcher = activeWatcher;
|
|
activeWatcher = effect4;
|
|
try {
|
|
const args = [
|
|
newValue,
|
|
// pass undefined as the old value when it's changed for the first time
|
|
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
|
|
boundCleanup
|
|
];
|
|
oldValue = newValue;
|
|
call ? call(cb, 3, args) : (
|
|
// @ts-expect-error
|
|
cb(...args)
|
|
);
|
|
} finally {
|
|
activeWatcher = currentWatcher;
|
|
}
|
|
}
|
|
} else {
|
|
effect4.run();
|
|
}
|
|
};
|
|
if (augmentJob) {
|
|
augmentJob(job);
|
|
}
|
|
effect4 = new ReactiveEffect(getter);
|
|
effect4.scheduler = scheduler2 ? () => scheduler2(job, false) : job;
|
|
boundCleanup = (fn) => onWatcherCleanup(fn, false, effect4);
|
|
cleanup = effect4.onStop = () => {
|
|
const cleanups = cleanupMap.get(effect4);
|
|
if (cleanups) {
|
|
if (call) {
|
|
call(cleanups, 4);
|
|
} else {
|
|
for (const cleanup2 of cleanups)
|
|
cleanup2();
|
|
}
|
|
cleanupMap.delete(effect4);
|
|
}
|
|
};
|
|
{
|
|
effect4.onTrack = options.onTrack;
|
|
effect4.onTrigger = options.onTrigger;
|
|
}
|
|
if (cb) {
|
|
if (immediate) {
|
|
job(true);
|
|
} else {
|
|
oldValue = effect4.run();
|
|
}
|
|
} else if (scheduler2) {
|
|
scheduler2(job.bind(null, true), true);
|
|
} else {
|
|
effect4.run();
|
|
}
|
|
watchHandle.pause = effect4.pause.bind(effect4);
|
|
watchHandle.resume = effect4.resume.bind(effect4);
|
|
watchHandle.stop = watchHandle;
|
|
return watchHandle;
|
|
}
|
|
function traverse(value, depth = Infinity, seen) {
|
|
if (depth <= 0 || !shared.isObject(value) || value["__v_skip"]) {
|
|
return value;
|
|
}
|
|
seen = seen || /* @__PURE__ */ new Map();
|
|
if ((seen.get(value) || 0) >= depth) {
|
|
return value;
|
|
}
|
|
seen.set(value, depth);
|
|
depth--;
|
|
if (isRef(value)) {
|
|
traverse(value.value, depth, seen);
|
|
} else if (shared.isArray(value)) {
|
|
for (let i = 0; i < value.length; i++) {
|
|
traverse(value[i], depth, seen);
|
|
}
|
|
} else if (shared.isSet(value) || shared.isMap(value)) {
|
|
value.forEach((v) => {
|
|
traverse(v, depth, seen);
|
|
});
|
|
} else if (shared.isPlainObject(value)) {
|
|
for (const key in value) {
|
|
traverse(value[key], depth, seen);
|
|
}
|
|
for (const key of Object.getOwnPropertySymbols(value)) {
|
|
if (Object.prototype.propertyIsEnumerable.call(value, key)) {
|
|
traverse(value[key], depth, seen);
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
exports.ARRAY_ITERATE_KEY = ARRAY_ITERATE_KEY;
|
|
exports.EffectFlags = EffectFlags;
|
|
exports.EffectScope = EffectScope;
|
|
exports.ITERATE_KEY = ITERATE_KEY;
|
|
exports.MAP_KEY_ITERATE_KEY = MAP_KEY_ITERATE_KEY;
|
|
exports.ReactiveEffect = ReactiveEffect;
|
|
exports.ReactiveFlags = ReactiveFlags;
|
|
exports.TrackOpTypes = TrackOpTypes;
|
|
exports.TriggerOpTypes = TriggerOpTypes;
|
|
exports.WatchErrorCodes = WatchErrorCodes;
|
|
exports.computed = computed;
|
|
exports.customRef = customRef;
|
|
exports.effect = effect3;
|
|
exports.effectScope = effectScope;
|
|
exports.enableTracking = enableTracking;
|
|
exports.getCurrentScope = getCurrentScope;
|
|
exports.getCurrentWatcher = getCurrentWatcher;
|
|
exports.isProxy = isProxy;
|
|
exports.isReactive = isReactive2;
|
|
exports.isReadonly = isReadonly;
|
|
exports.isRef = isRef;
|
|
exports.isShallow = isShallow;
|
|
exports.markRaw = markRaw;
|
|
exports.onEffectCleanup = onEffectCleanup;
|
|
exports.onScopeDispose = onScopeDispose;
|
|
exports.onWatcherCleanup = onWatcherCleanup;
|
|
exports.pauseTracking = pauseTracking;
|
|
exports.proxyRefs = proxyRefs;
|
|
exports.reactive = reactive3;
|
|
exports.reactiveReadArray = reactiveReadArray;
|
|
exports.readonly = readonly;
|
|
exports.ref = ref;
|
|
exports.resetTracking = resetTracking;
|
|
exports.shallowReactive = shallowReactive;
|
|
exports.shallowReadArray = shallowReadArray;
|
|
exports.shallowReadonly = shallowReadonly;
|
|
exports.shallowRef = shallowRef;
|
|
exports.stop = stop2;
|
|
exports.toRaw = toRaw2;
|
|
exports.toReactive = toReactive;
|
|
exports.toReadonly = toReadonly;
|
|
exports.toRef = toRef;
|
|
exports.toRefs = toRefs;
|
|
exports.toValue = toValue;
|
|
exports.track = track;
|
|
exports.traverse = traverse;
|
|
exports.trigger = trigger;
|
|
exports.triggerRef = triggerRef;
|
|
exports.unref = unref;
|
|
exports.watch = watch2;
|
|
}
|
|
});
|
|
|
|
// node_modules/@vue/reactivity/index.js
|
|
var require_reactivity = __commonJS({
|
|
"node_modules/@vue/reactivity/index.js"(exports, module2) {
|
|
"use strict";
|
|
if (false) {
|
|
module2.exports = null;
|
|
} else {
|
|
module2.exports = require_reactivity_cjs();
|
|
}
|
|
}
|
|
});
|
|
|
|
// packages/alpinejs/builds/module.js
|
|
var module_exports = {};
|
|
__export(module_exports, {
|
|
Alpine: () => src_default,
|
|
default: () => module_default
|
|
});
|
|
module.exports = __toCommonJS(module_exports);
|
|
|
|
// packages/alpinejs/src/scheduler.js
|
|
var flushPending = false;
|
|
var flushing = false;
|
|
var queue = [];
|
|
var lastFlushedIndex = -1;
|
|
var queueNeedsSort = false;
|
|
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);
|
|
if (job._x_schedulerPriority !== void 0)
|
|
queueNeedsSort = true;
|
|
}
|
|
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++) {
|
|
if (queueNeedsSort)
|
|
sortPendingJobs(i);
|
|
queue[i]();
|
|
lastFlushedIndex = i;
|
|
}
|
|
queue.length = 0;
|
|
lastFlushedIndex = -1;
|
|
queueNeedsSort = false;
|
|
flushing = false;
|
|
}
|
|
function sortPendingJobs(start2) {
|
|
let depths = /* @__PURE__ */ new Map();
|
|
let sorted = queue.slice(start2).sort((a, b) => compareJobs(a, b, depths));
|
|
for (let i = 0; i < sorted.length; i++) {
|
|
queue[start2 + i] = sorted[i];
|
|
}
|
|
queueNeedsSort = false;
|
|
}
|
|
function compareJobs(a, b, depths) {
|
|
if (!isStructural(a))
|
|
return isStructural(b) ? 1 : 0;
|
|
if (!isStructural(b))
|
|
return -1;
|
|
let depthDifference = getElementDepth(a._x_schedulerPriority.el, depths) - getElementDepth(b._x_schedulerPriority.el, depths);
|
|
return depthDifference || a._x_schedulerPriority.order - b._x_schedulerPriority.order;
|
|
}
|
|
function isStructural(job) {
|
|
return job._x_schedulerPriority !== void 0;
|
|
}
|
|
function getElementDepth(el, depths) {
|
|
if (depths.has(el))
|
|
return depths.get(el);
|
|
let depth = 0;
|
|
let owner = el;
|
|
while (el) {
|
|
depth++;
|
|
if (el._x_teleportBack) {
|
|
el = el._x_teleportBack;
|
|
} else if (typeof ShadowRoot === "function" && el.parentNode instanceof ShadowRoot) {
|
|
el = el.parentNode.host;
|
|
} else {
|
|
el = el.parentElement;
|
|
}
|
|
}
|
|
depths.set(owner, depth);
|
|
return depth;
|
|
}
|
|
|
|
// packages/alpinejs/src/reactivity.js
|
|
var reactive;
|
|
var effect;
|
|
var release;
|
|
var raw;
|
|
var nextStructuralEffectOrder = 0;
|
|
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 cleanup = () => {
|
|
};
|
|
let wrappedEffect = (callback, options) => {
|
|
let priority = (options == null ? void 0 : options.priority) === "structural" ? nextStructuralEffectOrder++ : void 0;
|
|
let effectReference = effect(callback);
|
|
if (priority !== void 0 && effectReference !== void 0) {
|
|
effectReference._x_schedulerPriority = { el, order: priority };
|
|
}
|
|
if (!el._x_effects) {
|
|
el._x_effects = /* @__PURE__ */ new Set();
|
|
el._x_runEffects = () => {
|
|
el._x_effects.forEach((i) => i());
|
|
};
|
|
}
|
|
el._x_effects.add(effectReference);
|
|
cleanup = () => {
|
|
if (effectReference === void 0)
|
|
return;
|
|
el._x_effects.delete(effectReference);
|
|
release(effectReference);
|
|
};
|
|
return effectReference;
|
|
};
|
|
return [wrappedEffect, () => {
|
|
cleanup();
|
|
}];
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
// packages/alpinejs/src/mutation.js
|
|
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) {
|
|
var _a, _b;
|
|
(_a = el._x_effects) == null ? void 0 : _a.forEach(dequeueJob);
|
|
while ((_b = el._x_cleanups) == null ? void 0 : _b.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 flushPendingMutations() {
|
|
while (queuedMutations.length > 0)
|
|
queuedMutations.shift()();
|
|
let records = observer.takeRecords();
|
|
if (records.length > 0)
|
|
onMutate(records);
|
|
}
|
|
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 add = () => {
|
|
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) {
|
|
add();
|
|
} else if (el.hasAttribute(name)) {
|
|
remove();
|
|
add();
|
|
} 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;
|
|
}
|
|
|
|
// packages/alpinejs/src/scope.js
|
|
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 == null ? void 0 : descriptor.set) && (descriptor == null ? void 0 : descriptor.get))
|
|
return descriptor.set.call(thisProxy, value) || true;
|
|
return Reflect.set(target, name, value);
|
|
}
|
|
};
|
|
function collapseProxies() {
|
|
let keys = Reflect.ownKeys(this);
|
|
return keys.reduce((acc, key) => {
|
|
acc[key] = Reflect.get(this, key);
|
|
return acc;
|
|
}, {});
|
|
}
|
|
|
|
// packages/alpinejs/src/interceptor.js
|
|
function initInterceptors(data2, cleanup = () => {
|
|
}) {
|
|
let isObject2 = (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, cleanup);
|
|
} else {
|
|
if (isObject2(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, cleanup) {
|
|
return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key, cleanup);
|
|
}
|
|
};
|
|
mutateObj(obj);
|
|
return (initialValue) => {
|
|
if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
|
|
let initialize = obj.initialize.bind(obj);
|
|
obj.initialize = (data2, path, key, cleanup) => {
|
|
let innerValue = initialValue.initialize(data2, path, key, cleanup);
|
|
obj.initialValue = innerValue;
|
|
return initialize(data2, path, key, cleanup);
|
|
};
|
|
} 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
// packages/alpinejs/src/magics.js
|
|
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, cleanup] = getElementBoundUtilities(el);
|
|
let utils = { interceptor, ...utilities };
|
|
onElRemoved(el, cleanup);
|
|
return utils;
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/error.js
|
|
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 != null ? 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);
|
|
}
|
|
|
|
// packages/alpinejs/src/evaluator.js
|
|
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;
|
|
}
|
|
let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
|
|
runIfTypeOfFunction(receiver, result);
|
|
};
|
|
}
|
|
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 = {}) {
|
|
var _a, _b;
|
|
let overriddenMagics = {};
|
|
injectMagics(overriddenMagics, el);
|
|
let dataStack = [overriddenMagics, ...closestDataStack(el)];
|
|
let scope2 = mergeProxies([(_a = extras.scope) != null ? _a : {}, ...dataStack]);
|
|
let params = (_b = extras.params) != null ? _b : [];
|
|
if (expression.includes("await")) {
|
|
let AsyncFunction = Object.getPrototypeOf(async function() {
|
|
}).constructor;
|
|
let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
|
|
let func = new AsyncFunction(
|
|
["scope"],
|
|
`with (scope) { let __result = ${rightSideSafeExpression}; return __result }`
|
|
);
|
|
let result = func.call(extras.context, scope2);
|
|
return result;
|
|
} else {
|
|
let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(()=>{ ${expression} })()` : expression;
|
|
let func = new Function(
|
|
["scope"],
|
|
`with (scope) { let __result = ${rightSideSafeExpression}; return __result }`
|
|
);
|
|
let result = func.call(extras.context, scope2);
|
|
if (typeof result === "function" && shouldAutoEvaluateFunctions) {
|
|
return result.apply(scope2, params);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// packages/alpinejs/src/directives.js
|
|
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 = {};
|
|
let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
|
|
return directives2.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 cleanup = (callback) => cleanups.push(callback);
|
|
let [effect3, cleanupEffect] = elementBoundEffect(el);
|
|
cleanups.push(cleanupEffect);
|
|
let utilities = {
|
|
Alpine: alpine_default,
|
|
effect: effect3,
|
|
cleanup,
|
|
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, cleanup] = getElementBoundUtilities(el);
|
|
onAttributeRemoved(el, directive2.original, cleanup);
|
|
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 = cleanup;
|
|
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",
|
|
"id",
|
|
"data",
|
|
"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);
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/walk.js
|
|
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;
|
|
}
|
|
}
|
|
|
|
// packages/alpinejs/src/clone.js
|
|
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);
|
|
}
|
|
|
|
// packages/alpinejs/src/deferInit.js
|
|
var activeDefers = 0;
|
|
function deferInit(el, promise) {
|
|
let record = el._x_deferInit;
|
|
if (!record) {
|
|
record = el._x_deferInit = {
|
|
pending: 0,
|
|
ownsIgnore: !el._x_ignore,
|
|
queuedAttributes: /* @__PURE__ */ new Map()
|
|
};
|
|
if (record.ownsIgnore)
|
|
el._x_ignore = true;
|
|
activeDefers++;
|
|
}
|
|
record.pending++;
|
|
Promise.resolve(promise).catch((error2) => {
|
|
try {
|
|
handleError(error2, el);
|
|
} catch (error3) {
|
|
setTimeout(() => {
|
|
throw error3;
|
|
}, 0);
|
|
}
|
|
}).then(() => settle(el, record));
|
|
}
|
|
function settle(el, record) {
|
|
record.pending--;
|
|
if (record.pending > 0)
|
|
return;
|
|
flushPendingMutations();
|
|
if (record.pending > 0)
|
|
return;
|
|
if (el._x_deferInit !== record)
|
|
return;
|
|
delete el._x_deferInit;
|
|
if (record.ownsIgnore)
|
|
delete el._x_ignore;
|
|
activeDefers--;
|
|
if (!el.isConnected)
|
|
return;
|
|
replayQueuedAttributes(record);
|
|
initTree(el);
|
|
}
|
|
function queueAttributesForDeferredTree(el, attrs) {
|
|
if (activeDefers === 0)
|
|
return false;
|
|
let root = findClosest(el, (i) => i._x_deferInit);
|
|
if (!root)
|
|
return false;
|
|
queueInto(root._x_deferInit, el, attrs.map(({ name }) => name));
|
|
return true;
|
|
}
|
|
function queueInto(record, el, names) {
|
|
let entry = record.queuedAttributes.get(el);
|
|
if (!entry || entry.marker !== el._x_marker) {
|
|
entry = { marker: el._x_marker, names: /* @__PURE__ */ new Set() };
|
|
record.queuedAttributes.set(el, entry);
|
|
}
|
|
names.forEach((name) => entry.names.add(name));
|
|
}
|
|
function replayQueuedAttributes(record) {
|
|
record.queuedAttributes.forEach((entry, el) => {
|
|
if (!el.isConnected)
|
|
return;
|
|
if (!el._x_marker)
|
|
return;
|
|
if (el._x_marker !== entry.marker)
|
|
return;
|
|
let suspendedAncestor = findClosest(el, (i) => i._x_deferInit);
|
|
if (suspendedAncestor) {
|
|
queueInto(suspendedAncestor._x_deferInit, el, Array.from(entry.names));
|
|
return;
|
|
}
|
|
let attrs = Array.from(entry.names).filter((name) => el.hasAttribute(name)).map((name) => ({ name, value: el.getAttribute(name) }));
|
|
if (attrs.length === 0)
|
|
return;
|
|
directives(el, attrs).forEach((handle) => handle());
|
|
});
|
|
}
|
|
interceptClone((from, to) => {
|
|
if (activeDefers === 0)
|
|
return;
|
|
if (!from || from.nodeType !== 1 || !to || to.nodeType !== 1)
|
|
return;
|
|
if (findClosest(from, (i) => i._x_deferInit))
|
|
to._x_ignore = true;
|
|
});
|
|
|
|
// packages/alpinejs/src/utils/dispatch.js
|
|
function dispatch(el, name, detail = {}, options = {}) {
|
|
return el.dispatchEvent(
|
|
new CustomEvent(name, {
|
|
detail,
|
|
bubbles: true,
|
|
// Allows events to pass the shadow DOM barrier.
|
|
composed: true,
|
|
cancelable: true,
|
|
// Allows overriding the default event options.
|
|
...options
|
|
})
|
|
);
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/warn.js
|
|
function warn(message, ...args) {
|
|
console.warn(`Alpine Warning: ${message}`, ...args);
|
|
}
|
|
|
|
// packages/alpinejs/src/lifecycle.js
|
|
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) => {
|
|
if (queueAttributesForDeferredTree(el, attrs))
|
|
return;
|
|
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) => {
|
|
const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
|
|
if (selectors.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() {
|
|
let pluginDirectives = [
|
|
["ui", "dialog", ["[x-dialog], [x-popover]"]],
|
|
["anchor", "anchor", ["[x-anchor]"]],
|
|
["sort", "sort", ["[x-sort]"]]
|
|
];
|
|
pluginDirectives.forEach(([plugin2, directive2, selectors]) => {
|
|
if (directiveExists(directive2))
|
|
return;
|
|
selectors.some((selector) => {
|
|
if (document.querySelector(selector)) {
|
|
warn(`found "${selector}", but missing ${plugin2} plugin`);
|
|
return true;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
// packages/alpinejs/src/nextTick.js
|
|
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;
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/classes.js
|
|
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));
|
|
};
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/styles.js
|
|
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();
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/once.js
|
|
function once(callback, fallback = () => {
|
|
}) {
|
|
let called = false;
|
|
return function() {
|
|
if (!called) {
|
|
called = true;
|
|
callback.apply(this, arguments);
|
|
} else {
|
|
fallback.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-transition.js
|
|
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, "");
|
|
let directiveStorageMap = {
|
|
"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;
|
|
}
|
|
};
|
|
directiveStorageMap[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 == null ? void 0 : 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;
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/bind.js
|
|
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.tagName === "OPTION") {
|
|
bindAttribute(el, "value", value);
|
|
} else {
|
|
if (el.value === value && (typeof value !== "object" || value === null))
|
|
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;
|
|
if (isObjectAttr(value))
|
|
value = JSON.stringify(value);
|
|
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 isObjectAttr(value) {
|
|
return typeof value === "object" && value !== null;
|
|
}
|
|
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";
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/debounce.js
|
|
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);
|
|
};
|
|
}
|
|
|
|
// packages/alpinejs/src/utils/throttle.js
|
|
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);
|
|
}
|
|
};
|
|
}
|
|
|
|
// packages/alpinejs/src/entangle.js
|
|
function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
|
|
let firstRun = true;
|
|
let outerHash;
|
|
let innerHash;
|
|
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));
|
|
} else {
|
|
}
|
|
}
|
|
outerHash = JSON.stringify(outerGet());
|
|
innerHash = JSON.stringify(innerGet());
|
|
});
|
|
return () => {
|
|
release(reference);
|
|
};
|
|
}
|
|
function cloneIfObject(value) {
|
|
return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
|
|
}
|
|
|
|
// packages/alpinejs/src/plugin.js
|
|
function plugin(callback) {
|
|
let callbacks = Array.isArray(callback) ? callback : [callback];
|
|
callbacks.forEach((i) => i(alpine_default));
|
|
}
|
|
|
|
// packages/alpinejs/src/store.js
|
|
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;
|
|
if (typeof value === "object" && value !== null && value._x_interceptor) {
|
|
stores[name] = value.initialize(stores, name, name, () => {
|
|
});
|
|
} else {
|
|
initInterceptors(stores[name]);
|
|
}
|
|
if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
|
|
stores[name].init();
|
|
}
|
|
}
|
|
function getStores() {
|
|
return stores;
|
|
}
|
|
|
|
// packages/alpinejs/src/binds.js
|
|
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()();
|
|
};
|
|
}
|
|
|
|
// packages/alpinejs/src/datas.js
|
|
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;
|
|
}
|
|
|
|
// packages/alpinejs/src/alpine.js
|
|
var Alpine = {
|
|
get reactive() {
|
|
return reactive;
|
|
},
|
|
get release() {
|
|
return release;
|
|
},
|
|
get effect() {
|
|
return effect;
|
|
},
|
|
get raw() {
|
|
return raw;
|
|
},
|
|
get transaction() {
|
|
return transaction;
|
|
},
|
|
version: "3.17.2",
|
|
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,
|
|
// INTERNAL: not public API and is subject to change without major release.
|
|
transition,
|
|
// INTERNAL
|
|
setStyles,
|
|
// INTERNAL
|
|
mutateDom,
|
|
deferInit,
|
|
directive,
|
|
entangle,
|
|
throttle,
|
|
debounce,
|
|
evaluate,
|
|
evaluateRaw,
|
|
initTree,
|
|
nextTick,
|
|
prefixed: prefix,
|
|
prefix: setPrefix,
|
|
plugin,
|
|
magic,
|
|
store,
|
|
start,
|
|
clone,
|
|
// INTERNAL
|
|
cloneNode,
|
|
// INTERNAL
|
|
bound: getBinding,
|
|
$data: scope,
|
|
watch,
|
|
walk,
|
|
data,
|
|
bind: bind2
|
|
};
|
|
var alpine_default = Alpine;
|
|
|
|
// packages/alpinejs/src/index.js
|
|
var import_reactivity10 = __toESM(require_reactivity());
|
|
|
|
// packages/alpinejs/src/magics/$nextTick.js
|
|
magic("nextTick", () => nextTick);
|
|
|
|
// packages/alpinejs/src/magics/$dispatch.js
|
|
magic("dispatch", (el) => dispatch.bind(dispatch, el));
|
|
|
|
// packages/alpinejs/src/magics/$watch.js
|
|
magic("watch", (el, { evaluateLater: evaluateLater2, cleanup }) => (key, callback) => {
|
|
let evaluate2 = evaluateLater2(key);
|
|
let getter = () => {
|
|
let value;
|
|
evaluate2((i) => value = i);
|
|
return value;
|
|
};
|
|
let unwatch = watch(getter, callback);
|
|
cleanup(unwatch);
|
|
});
|
|
|
|
// packages/alpinejs/src/magics/$store.js
|
|
magic("store", getStores);
|
|
|
|
// packages/alpinejs/src/magics/$data.js
|
|
magic("data", (el) => scope(el));
|
|
|
|
// packages/alpinejs/src/magics/$root.js
|
|
magic("root", (el) => closestRoot(el));
|
|
|
|
// packages/alpinejs/src/magics/$refs.js
|
|
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;
|
|
}
|
|
|
|
// packages/alpinejs/src/ids.js
|
|
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);
|
|
}
|
|
|
|
// packages/alpinejs/src/magics/$id.js
|
|
magic("id", (el, { cleanup }) => (name, key = null) => {
|
|
let cacheKey = `${name}${key ? `-${key}` : ""}`;
|
|
return cacheIdByNameOnElement(el, cacheKey, cleanup, () => {
|
|
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, cleanup, 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;
|
|
cleanup(() => {
|
|
delete el._x_id[cacheKey];
|
|
});
|
|
return output;
|
|
}
|
|
|
|
// packages/alpinejs/src/magics/$el.js
|
|
magic("el", (el) => el);
|
|
|
|
// packages/alpinejs/src/magics/index.js
|
|
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));
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-modelable.js
|
|
directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup }) => {
|
|
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 } });
|
|
let initialValue = innerGet();
|
|
innerSet(initialValue);
|
|
queueMicrotask(() => {
|
|
if (!el._x_model)
|
|
return;
|
|
el._x_removeModelListeners["default"]();
|
|
let outerGet = el._x_model.get;
|
|
let outerSet = el._x_model.setWithModifiers;
|
|
let releaseEntanglement = entangle(
|
|
{
|
|
get() {
|
|
return outerGet();
|
|
},
|
|
set(value) {
|
|
outerSet(value);
|
|
}
|
|
},
|
|
{
|
|
get() {
|
|
return innerGet();
|
|
},
|
|
set(value) {
|
|
innerSet(value);
|
|
}
|
|
}
|
|
);
|
|
cleanup(releaseEntanglement);
|
|
});
|
|
});
|
|
|
|
// packages/alpinejs/src/directives/x-teleport.js
|
|
directive("teleport", (el, { modifiers, expression }, { cleanup }) => {
|
|
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(() => {
|
|
skipDuringClone(() => {
|
|
placeInDom(clone2, target, modifiers);
|
|
initTree(clone2);
|
|
})();
|
|
});
|
|
el._x_teleportPutBack = () => {
|
|
let target2 = getTarget(expression);
|
|
mutateDom(() => {
|
|
placeInDom(el._x_teleport, target2, modifiers);
|
|
});
|
|
};
|
|
cleanup(
|
|
() => 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;
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-ignore.js
|
|
var handler = () => {
|
|
};
|
|
handler.inline = (el, { modifiers }, { cleanup }) => {
|
|
modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
|
|
cleanup(() => {
|
|
modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
|
|
});
|
|
};
|
|
directive("ignore", handler);
|
|
|
|
// packages/alpinejs/src/directives/x-effect.js
|
|
directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
|
|
effect3(evaluateLater(el, expression));
|
|
}));
|
|
|
|
// packages/alpinejs/src/utils/on.js
|
|
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 systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
|
|
const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
|
|
keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
|
|
if (selectedSystemKeyModifiers.length > 0) {
|
|
const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
|
|
if (modifier === "cmd" || modifier === "super")
|
|
modifier = "meta";
|
|
return e[`${modifier}Key`];
|
|
});
|
|
if (activelyPressedKeyModifiers.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);
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-model.js
|
|
directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup }) => {
|
|
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);
|
|
cleanup(() => {
|
|
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 {
|
|
let event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) ? "change" : "input";
|
|
removeListener = on(el, event, 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;
|
|
cleanup(() => 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())));
|
|
});
|
|
cleanup(() => 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);
|
|
}
|
|
});
|
|
};
|
|
if (el.tagName === "SELECT") {
|
|
let observer2 = new MutationObserver(() => {
|
|
el._x_forceModelUpdate(getValue());
|
|
});
|
|
observer2.observe(el, { childList: true });
|
|
cleanup(() => observer2.disconnect());
|
|
}
|
|
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) => {
|
|
let rawValue = option.value || option.text;
|
|
return safeParseNumber(rawValue);
|
|
});
|
|
} else if (modifiers.includes("boolean")) {
|
|
return Array.from(event.target.selectedOptions).map((option) => {
|
|
let rawValue = option.value || option.text;
|
|
return safeParseBoolean(rawValue);
|
|
});
|
|
}
|
|
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";
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-cloak.js
|
|
directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
|
|
|
|
// packages/alpinejs/src/directives/x-init.js
|
|
addInitSelector(() => `[${prefix("init")}]`);
|
|
directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate2 }) => {
|
|
if (typeof expression === "string") {
|
|
return !!expression.trim() && evaluate2(expression, {}, false);
|
|
}
|
|
return evaluate2(expression, {}, false);
|
|
}));
|
|
|
|
// packages/alpinejs/src/directives/x-text.js
|
|
directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
|
|
let evaluate2 = evaluateLater2(expression);
|
|
effect3(() => {
|
|
evaluate2((value) => {
|
|
mutateDom(() => {
|
|
el.textContent = value;
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
// packages/alpinejs/src/directives/x-html.js
|
|
directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
|
|
let evaluate2 = evaluateLater2(expression);
|
|
effect3(() => {
|
|
evaluate2((value) => {
|
|
mutateDom(() => {
|
|
Array.from(el.children).forEach((child) => destroyTree(child));
|
|
el.innerHTML = value != null ? value : "";
|
|
el._x_ignoreSelf = true;
|
|
initTree(el);
|
|
delete el._x_ignoreSelf;
|
|
});
|
|
});
|
|
}, { priority: "structural" });
|
|
});
|
|
|
|
// packages/alpinejs/src/directives/x-bind.js
|
|
mapAttributes(startingWith(":", into(prefix("bind:"))));
|
|
var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3, cleanup }) => {
|
|
if (!value) {
|
|
let bindingProviders = {};
|
|
injectBindingProviders(bindingProviders);
|
|
let getBindings = evaluateLater(el, expression);
|
|
getBindings((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));
|
|
}));
|
|
cleanup(() => {
|
|
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;
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-data.js
|
|
addRootSelector(() => `[${prefix("data")}]`);
|
|
var dataForReconciliation = Symbol();
|
|
directive("data", (el, { expression }, { cleanup }) => {
|
|
if (shouldSkipRegisteringDataDuringClone(el))
|
|
return;
|
|
let dataToReconcile = el[dataForReconciliation];
|
|
if ((dataToReconcile == null ? void 0 : dataToReconcile.expression) === expression)
|
|
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;
|
|
if (dataToReconcile == null ? void 0 : dataToReconcile.reactiveData) {
|
|
reactiveData = dataToReconcile.reactiveData;
|
|
reconcileData(reactiveData, data2);
|
|
let initialized = { expression };
|
|
el[dataForReconciliation] = initialized;
|
|
queueMicrotask(() => {
|
|
if (el[dataForReconciliation] === initialized) {
|
|
delete el[dataForReconciliation];
|
|
}
|
|
});
|
|
} else {
|
|
reactiveData = reactive(data2);
|
|
}
|
|
initInterceptors(reactiveData, cleanup);
|
|
let undo = addScopeToNode(el, reactiveData);
|
|
reactiveData["init"] && evaluate(el, reactiveData["init"]);
|
|
cleanup(() => {
|
|
reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
|
|
undo();
|
|
let removed = { reactiveData };
|
|
el[dataForReconciliation] = removed;
|
|
queueMicrotask(() => {
|
|
if (el[dataForReconciliation] === removed) {
|
|
delete el[dataForReconciliation];
|
|
}
|
|
});
|
|
});
|
|
});
|
|
function reconcileData(target, source) {
|
|
Object.keys(source).forEach((key) => {
|
|
let descriptor = Object.getOwnPropertyDescriptor(source, key);
|
|
let existingDescriptor = Object.getOwnPropertyDescriptor(target, key);
|
|
if (descriptor.get || descriptor.set || (existingDescriptor == null ? void 0 : existingDescriptor.get) || (existingDescriptor == null ? void 0 : existingDescriptor.set)) {
|
|
if (existingDescriptor)
|
|
delete target[key];
|
|
if (!existingDescriptor)
|
|
target[key] = void 0;
|
|
descriptor.get || descriptor.set ? Object.defineProperty(target, key, descriptor) : target[key] = source[key];
|
|
} else {
|
|
target[key] = source[key];
|
|
}
|
|
});
|
|
Object.keys(target).filter((key) => !Object.prototype.hasOwnProperty.call(source, key)).forEach((key) => delete target[key]);
|
|
}
|
|
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");
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-show.js
|
|
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;
|
|
}));
|
|
});
|
|
|
|
// packages/alpinejs/src/directives/x-for.js
|
|
directive("for", skipDuringClone((el, { expression }, { effect: effect3, cleanup }) => {
|
|
let iteratorNames = parseForExpression(expression);
|
|
let evaluateItems = evaluateLater(el, iteratorNames.items);
|
|
let evaluateKey = evaluateLater(
|
|
el,
|
|
// the x-bind:key expression is stored for our use instead of evaluated.
|
|
el._x_keyExpression || "index"
|
|
);
|
|
el._x_lookup = /* @__PURE__ */ new Map();
|
|
effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey), { priority: "structural" });
|
|
cleanup(() => {
|
|
el._x_lookup.forEach(
|
|
(el2) => mutateDom(() => {
|
|
destroyTree(el2);
|
|
el2.remove();
|
|
})
|
|
);
|
|
delete el._x_lookup;
|
|
delete el._x_lastRenderedEl;
|
|
});
|
|
}));
|
|
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 === null)
|
|
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 = isObject(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;
|
|
});
|
|
added.forEach((clone2) => initTree(clone2));
|
|
if (prev !== templateEl) {
|
|
templateEl._x_lastRenderedEl = prev;
|
|
} else {
|
|
delete templateEl._x_lastRenderedEl;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
function parseForExpression(expression) {
|
|
let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
|
|
let stripParensRE = /^\s*\(|\)\s*$/g;
|
|
let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
|
|
let inMatch = expression.match(forAliasRE);
|
|
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)) {
|
|
let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
|
|
names.forEach((name, i) => {
|
|
scopeVariables[name] = item[i];
|
|
});
|
|
} else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") {
|
|
let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim());
|
|
names.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 typeof subject !== "object" && !isNaN(subject);
|
|
}
|
|
function isObject(subject) {
|
|
return typeof subject === "object" && !Array.isArray(subject);
|
|
}
|
|
|
|
// packages/alpinejs/src/directives/x-ref.js
|
|
function handler3() {
|
|
}
|
|
handler3.inline = (el, { expression }, { cleanup }) => {
|
|
let root = closestRoot(el);
|
|
if (!root)
|
|
return;
|
|
if (!root._x_refs)
|
|
root._x_refs = {};
|
|
root._x_refs[expression] = el;
|
|
cleanup(() => delete root._x_refs[expression]);
|
|
};
|
|
directive("ref", handler3);
|
|
|
|
// packages/alpinejs/src/directives/x-if.js
|
|
directive("if", skipDuringClone((el, { expression }, { effect: effect3, cleanup }) => {
|
|
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);
|
|
initTree(clone2);
|
|
});
|
|
el._x_currentIfEl = clone2;
|
|
el._x_lastRenderedEl = clone2;
|
|
el._x_undoIf = () => {
|
|
mutateDom(() => {
|
|
destroyTree(clone2);
|
|
clone2.remove();
|
|
});
|
|
delete el._x_currentIfEl;
|
|
delete el._x_lastRenderedEl;
|
|
};
|
|
return clone2;
|
|
};
|
|
let hide = () => {
|
|
if (!el._x_undoIf)
|
|
return;
|
|
el._x_undoIf();
|
|
delete el._x_undoIf;
|
|
};
|
|
effect3(() => evaluate2((value) => {
|
|
value ? show() : hide();
|
|
}), { priority: "structural" });
|
|
cleanup(() => el._x_undoIf && el._x_undoIf());
|
|
}));
|
|
|
|
// packages/alpinejs/src/directives/x-id.js
|
|
directive("id", (el, { expression }, { evaluate: evaluate2 }) => {
|
|
let names = evaluate2(expression);
|
|
names.forEach((name) => setIdRoot(el, name));
|
|
});
|
|
interceptClone((from, to) => {
|
|
if (from._x_ids) {
|
|
to._x_ids = from._x_ids;
|
|
}
|
|
});
|
|
|
|
// packages/alpinejs/src/directives/x-on.js
|
|
mapAttributes(startingWith("@", into(prefix("on:"))));
|
|
directive("on", skipDuringClone((el, { value, modifiers, expression }, { cleanup }) => {
|
|
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] });
|
|
});
|
|
cleanup(() => removeListener());
|
|
}));
|
|
|
|
// packages/alpinejs/src/directives/index.js
|
|
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));
|
|
}
|
|
|
|
// packages/alpinejs/src/index.js
|
|
alpine_default.setEvaluator(normalEvaluator);
|
|
alpine_default.setRawEvaluator(normalRawEvaluator);
|
|
alpine_default.setReactivityEngine({
|
|
reactive: import_reactivity10.reactive,
|
|
// Since Vue 3.2, the scheduler is called with no arguments, so we wrap
|
|
// the effect to hand Alpine's scheduler the runner it expects to queue.
|
|
effect: (callback, options = {}) => {
|
|
let runner;
|
|
runner = (0, import_reactivity10.effect)(callback, {
|
|
scheduler: () => {
|
|
if (!runner)
|
|
return;
|
|
options.scheduler ? options.scheduler(runner) : runner();
|
|
}
|
|
});
|
|
return runner;
|
|
},
|
|
release: import_reactivity10.stop,
|
|
raw: import_reactivity10.toRaw
|
|
});
|
|
var src_default = alpine_default;
|
|
|
|
// packages/alpinejs/builds/module.js
|
|
var module_default = src_default;
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
Alpine
|
|
});
|
|
/*! Bundled license information:
|
|
|
|
@vue/shared/dist/shared.cjs.js:
|
|
(**
|
|
* @vue/shared v3.5.41
|
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
|
* @license MIT
|
|
**)
|
|
|
|
@vue/reactivity/dist/reactivity.cjs.js:
|
|
(**
|
|
* @vue/reactivity v3.5.41
|
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
|
* @license MIT
|
|
**)
|
|
*/
|