File: //home/arjun/projects/buyercall/node_modules/@vue/compat/dist/vue.cjs.prod.js
'use strict';
var parser = require('@babel/parser');
var estreeWalker = require('estree-walker');
var sourceMapJs = require('source-map-js');
function makeMap(str, expectsLowerCase) {
const map = /* @__PURE__ */ Object.create(null);
const list = str.split(",");
for (let i = 0; i < list.length; i++) {
map[list[i]] = true;
}
return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
}
const EMPTY_OBJ = {};
const EMPTY_ARR = [];
const NOOP = () => {
};
const NO = () => false;
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
const isModelListener = (key) => key.startsWith("onUpdate:");
const extend = Object.assign;
const remove = (arr, el) => {
const i = arr.indexOf(el);
if (i > -1) {
arr.splice(i, 1);
}
};
const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
const isArray = Array.isArray;
const isMap = (val) => toTypeString(val) === "[object Map]";
const isSet = (val) => toTypeString(val) === "[object Set]";
const isDate = (val) => toTypeString(val) === "[object Date]";
const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
const isFunction = (val) => typeof val === "function";
const isString = (val) => typeof val === "string";
const isSymbol = (val) => typeof val === "symbol";
const isObject = (val) => val !== null && typeof val === "object";
const isPromise = (val) => {
return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
};
const objectToString = Object.prototype.toString;
const toTypeString = (value) => objectToString.call(value);
const toRawType = (value) => {
return toTypeString(value).slice(8, -1);
};
const isPlainObject = (val) => toTypeString(val) === "[object Object]";
const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
const 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"
);
const isBuiltInDirective = /* @__PURE__ */ makeMap(
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
);
const cacheStringFunction = (fn) => {
const cache = /* @__PURE__ */ Object.create(null);
return (str) => {
const hit = cache[str];
return hit || (cache[str] = fn(str));
};
};
const camelizeRE = /-(\w)/g;
const camelize = cacheStringFunction((str) => {
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
});
const hyphenateRE = /\B([A-Z])/g;
const hyphenate = cacheStringFunction(
(str) => str.replace(hyphenateRE, "-$1").toLowerCase()
);
const capitalize = cacheStringFunction((str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
});
const toHandlerKey = cacheStringFunction((str) => {
const s = str ? `on${capitalize(str)}` : ``;
return s;
});
const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
const invokeArrayFns = (fns, arg) => {
for (let i = 0; i < fns.length; i++) {
fns[i](arg);
}
};
const def = (obj, key, value) => {
Object.defineProperty(obj, key, {
configurable: true,
enumerable: false,
value
});
};
const looseToNumber = (val) => {
const n = parseFloat(val);
return isNaN(n) ? val : n;
};
const toNumber = (val) => {
const n = isString(val) ? Number(val) : NaN;
return isNaN(n) ? val : n;
};
let _globalThis;
const getGlobalThis = () => {
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
};
const 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)}]`;
}
const 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";
const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
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) || isObject(value)) {
return value;
}
}
const listDelimiterRE = /;(?![^(]*\))/g;
const propertyDelimiterRE = /:([^]+)/;
const 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) {
let ret = "";
if (!styles || isString(styles)) {
return ret;
}
for (const key in styles) {
const value = styles[key];
const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
if (isString(value) || typeof value === "number") {
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 (isObject(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;
}
const 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";
const 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";
const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
const isBooleanAttr = /* @__PURE__ */ makeMap(
specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
);
function includeBooleanAttr(value) {
return !!value || value === "";
}
const 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`
);
const 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`
);
const 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;
}
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 = isObject(a);
bValidType = isObject(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));
}
const toDisplayString = (val) => {
return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
};
const replacer = (_key, val) => {
if (val && val.__v_isRef) {
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 (isObject(val) && !isArray(val) && !isPlainObject(val)) {
return String(val);
}
return val;
};
const stringifySymbol = (v, i = "") => {
var _a;
return isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v;
};
let activeEffectScope;
class EffectScope {
constructor(detached = false) {
this.detached = detached;
/**
* @internal
*/
this._active = true;
/**
* @internal
*/
this.effects = [];
/**
* @internal
*/
this.cleanups = [];
this.parent = activeEffectScope;
if (!detached && activeEffectScope) {
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
this
) - 1;
}
}
get active() {
return this._active;
}
run(fn) {
if (this._active) {
const currentEffectScope = activeEffectScope;
try {
activeEffectScope = this;
return fn();
} finally {
activeEffectScope = currentEffectScope;
}
}
}
/**
* This should only be called on non-detached scopes
* @internal
*/
on() {
activeEffectScope = this;
}
/**
* This should only be called on non-detached scopes
* @internal
*/
off() {
activeEffectScope = this.parent;
}
stop(fromParent) {
if (this._active) {
let i, l;
for (i = 0, l = this.effects.length; i < l; i++) {
this.effects[i].stop();
}
for (i = 0, l = this.cleanups.length; i < l; i++) {
this.cleanups[i]();
}
if (this.scopes) {
for (i = 0, l = this.scopes.length; i < l; i++) {
this.scopes[i].stop(true);
}
}
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;
this._active = false;
}
}
}
function effectScope(detached) {
return new EffectScope(detached);
}
function recordEffectScope(effect, scope = activeEffectScope) {
if (scope && scope.active) {
scope.effects.push(effect);
}
}
function getCurrentScope() {
return activeEffectScope;
}
function onScopeDispose(fn) {
if (activeEffectScope) {
activeEffectScope.cleanups.push(fn);
}
}
const createDep = (effects) => {
const dep = new Set(effects);
dep.w = 0;
dep.n = 0;
return dep;
};
const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
const newTracked = (dep) => (dep.n & trackOpBit) > 0;
const initDepMarkers = ({ deps }) => {
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].w |= trackOpBit;
}
}
};
const finalizeDepMarkers = (effect) => {
const { deps } = effect;
if (deps.length) {
let ptr = 0;
for (let i = 0; i < deps.length; i++) {
const dep = deps[i];
if (wasTracked(dep) && !newTracked(dep)) {
dep.delete(effect);
} else {
deps[ptr++] = dep;
}
dep.w &= ~trackOpBit;
dep.n &= ~trackOpBit;
}
deps.length = ptr;
}
};
const targetMap = /* @__PURE__ */ new WeakMap();
let effectTrackDepth = 0;
let trackOpBit = 1;
const maxMarkerBits = 30;
let activeEffect;
const ITERATE_KEY = Symbol("");
const MAP_KEY_ITERATE_KEY = Symbol("");
class ReactiveEffect {
constructor(fn, scheduler = null, scope) {
this.fn = fn;
this.scheduler = scheduler;
this.active = true;
this.deps = [];
this.parent = void 0;
recordEffectScope(this, scope);
}
run() {
if (!this.active) {
return this.fn();
}
let parent = activeEffect;
let lastShouldTrack = shouldTrack;
while (parent) {
if (parent === this) {
return;
}
parent = parent.parent;
}
try {
this.parent = activeEffect;
activeEffect = this;
shouldTrack = true;
trackOpBit = 1 << ++effectTrackDepth;
if (effectTrackDepth <= maxMarkerBits) {
initDepMarkers(this);
} else {
cleanupEffect(this);
}
return this.fn();
} finally {
if (effectTrackDepth <= maxMarkerBits) {
finalizeDepMarkers(this);
}
trackOpBit = 1 << --effectTrackDepth;
activeEffect = this.parent;
shouldTrack = lastShouldTrack;
this.parent = void 0;
if (this.deferStop) {
this.stop();
}
}
}
stop() {
if (activeEffect === this) {
this.deferStop = true;
} else if (this.active) {
cleanupEffect(this);
if (this.onStop) {
this.onStop();
}
this.active = false;
}
}
}
function cleanupEffect(effect2) {
const { deps } = effect2;
if (deps.length) {
for (let i = 0; i < deps.length; i++) {
deps[i].delete(effect2);
}
deps.length = 0;
}
}
function effect(fn, options) {
if (fn.effect instanceof ReactiveEffect) {
fn = fn.effect.fn;
}
const _effect = new ReactiveEffect(fn);
if (options) {
extend(_effect, options);
if (options.scope)
recordEffectScope(_effect, options.scope);
}
if (!options || !options.lazy) {
_effect.run();
}
const runner = _effect.run.bind(_effect);
runner.effect = _effect;
return runner;
}
function stop(runner) {
runner.effect.stop();
}
let shouldTrack = true;
const trackStack = [];
function pauseTracking() {
trackStack.push(shouldTrack);
shouldTrack = false;
}
function resetTracking() {
const last = trackStack.pop();
shouldTrack = last === void 0 ? true : last;
}
function track(target, type, key) {
if (shouldTrack && activeEffect) {
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 = createDep());
}
trackEffects(dep);
}
}
function trackEffects(dep, debuggerEventExtraInfo) {
let shouldTrack2 = false;
if (effectTrackDepth <= maxMarkerBits) {
if (!newTracked(dep)) {
dep.n |= trackOpBit;
shouldTrack2 = !wasTracked(dep);
}
} else {
shouldTrack2 = !dep.has(activeEffect);
}
if (shouldTrack2) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
return;
}
let deps = [];
if (type === "clear") {
deps = [...depsMap.values()];
} else if (key === "length" && isArray(target)) {
const newLength = Number(newValue);
depsMap.forEach((dep, key2) => {
if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
deps.push(dep);
}
});
} else {
if (key !== void 0) {
deps.push(depsMap.get(key));
}
switch (type) {
case "add":
if (!isArray(target)) {
deps.push(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
}
} else if (isIntegerKey(key)) {
deps.push(depsMap.get("length"));
}
break;
case "delete":
if (!isArray(target)) {
deps.push(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set":
if (isMap(target)) {
deps.push(depsMap.get(ITERATE_KEY));
}
break;
}
}
if (deps.length === 1) {
if (deps[0]) {
{
triggerEffects(deps[0]);
}
}
} else {
const effects = [];
for (const dep of deps) {
if (dep) {
effects.push(...dep);
}
}
{
triggerEffects(createDep(effects));
}
}
}
function triggerEffects(dep, debuggerEventExtraInfo) {
const effects = isArray(dep) ? dep : [...dep];
for (const effect2 of effects) {
if (effect2.computed) {
triggerEffect(effect2);
}
}
for (const effect2 of effects) {
if (!effect2.computed) {
triggerEffect(effect2);
}
}
}
function triggerEffect(effect2, debuggerEventExtraInfo) {
if (effect2 !== activeEffect || effect2.allowRecurse) {
if (effect2.scheduler) {
effect2.scheduler();
} else {
effect2.run();
}
}
}
function getDepFromReactive(object, key) {
var _a;
return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
}
const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
const builtInSymbols = new Set(
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
);
const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
function createArrayInstrumentations() {
const instrumentations = {};
["includes", "indexOf", "lastIndexOf"].forEach((key) => {
instrumentations[key] = function(...args) {
const arr = toRaw(this);
for (let i = 0, l = this.length; i < l; i++) {
track(arr, "get", i + "");
}
const res = arr[key](...args);
if (res === -1 || res === false) {
return arr[key](...args.map(toRaw));
} else {
return res;
}
};
});
["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
instrumentations[key] = function(...args) {
pauseTracking();
const res = toRaw(this)[key].apply(this, args);
resetTracking();
return res;
};
});
return instrumentations;
}
function hasOwnProperty(key) {
const obj = toRaw(this);
track(obj, "has", key);
return obj.hasOwnProperty(key);
}
class BaseReactiveHandler {
constructor(_isReadonly = false, _shallow = false) {
this._isReadonly = _isReadonly;
this._shallow = _shallow;
}
get(target, key, receiver) {
const isReadonly2 = this._isReadonly, shallow = this._shallow;
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_isShallow") {
return shallow;
} else if (key === "__v_raw") {
if (receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
// this means the reciever is a user proxy of the reactive proxy
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
return target;
}
return;
}
const targetIsArray = isArray(target);
if (!isReadonly2) {
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
if (key === "hasOwnProperty") {
return hasOwnProperty;
}
}
const res = Reflect.get(target, key, receiver);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
return res;
}
if (!isReadonly2) {
track(target, "get", key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
return targetIsArray && isIntegerKey(key) ? res : res.value;
}
if (isObject(res)) {
return isReadonly2 ? readonly(res) : reactive(res);
}
return res;
}
}
class MutableReactiveHandler extends BaseReactiveHandler {
constructor(shallow = false) {
super(false, shallow);
}
set(target, key, value, receiver) {
let oldValue = target[key];
if (!this._shallow) {
const isOldValueReadonly = isReadonly(oldValue);
if (!isShallow(value) && !isReadonly(value)) {
oldValue = toRaw(oldValue);
value = toRaw(value);
}
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
if (isOldValueReadonly) {
return false;
} else {
oldValue.value = value;
return true;
}
}
}
const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
const result = Reflect.set(target, key, value, receiver);
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
}
return result;
}
deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
has(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has", key);
}
return result;
}
ownKeys(target) {
track(
target,
"iterate",
isArray(target) ? "length" : ITERATE_KEY
);
return Reflect.ownKeys(target);
}
}
class ReadonlyReactiveHandler extends BaseReactiveHandler {
constructor(shallow = false) {
super(true, shallow);
}
set(target, key) {
return true;
}
deleteProperty(target, key) {
return true;
}
}
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
true
);
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get(target, key, isReadonly = false, isShallow = false) {
target = target["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly) {
if (hasChanged(key, rawKey)) {
track(rawTarget, "get", key);
}
track(rawTarget, "get", rawKey);
}
const { has: has2 } = getProto(rawTarget);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
if (has2.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has2.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
} else if (target !== rawTarget) {
target.get(key);
}
}
function has(key, isReadonly = false) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (!isReadonly) {
if (hasChanged(key, rawKey)) {
track(rawTarget, "has", key);
}
track(rawTarget, "has", rawKey);
}
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly = false) {
target = target["__v_raw"];
!isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
return Reflect.get(target, "size", target);
}
function add(value) {
value = toRaw(value);
const target = toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
if (!hadKey) {
target.add(value);
trigger(target, "add", value, value);
}
return this;
}
function set(key, value) {
value = toRaw(value);
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
const oldValue = get2.call(target, key);
target.set(key, value);
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
return this;
}
function deleteEntry(key) {
const target = toRaw(this);
const { has: has2, get: get2 } = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
get2 ? get2.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const result = target.clear();
if (hadItems) {
trigger(target, "clear", void 0, void 0);
}
return result;
}
function createForEach(isReadonly, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw"];
const rawTarget = toRaw(target);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
!isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly, isShallow) {
return function(...args) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
const isKeyOnly = method === "keys" && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
!isReadonly && track(
rawTarget,
"iterate",
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
);
return {
// iterator protocol
next() {
const { value, done } = innerIterator.next();
return done ? { value, done } : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
// iterable protocol
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
return type === "delete" ? false : type === "clear" ? void 0 : this;
};
}
function createInstrumentations() {
const mutableInstrumentations2 = {
get(key) {
return get(this, key);
},
get size() {
return size(this);
},
has,
add,
set,
delete: deleteEntry,
clear,
forEach: createForEach(false, false)
};
const shallowInstrumentations2 = {
get(key) {
return get(this, key, false, true);
},
get size() {
return size(this);
},
has,
add,
set,
delete: deleteEntry,
clear,
forEach: createForEach(false, true)
};
const readonlyInstrumentations2 = {
get(key) {
return get(this, key, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, false)
};
const shallowReadonlyInstrumentations2 = {
get(key) {
return get(this, key, true, true);
},
get size() {
return size(this, true);
},
has(key) {
return has.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, true)
};
const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
iteratorMethods.forEach((method) => {
mutableInstrumentations2[method] = createIterableMethod(
method,
false,
false
);
readonlyInstrumentations2[method] = createIterableMethod(
method,
true,
false
);
shallowInstrumentations2[method] = createIterableMethod(
method,
false,
true
);
shallowReadonlyInstrumentations2[method] = createIterableMethod(
method,
true,
true
);
});
return [
mutableInstrumentations2,
readonlyInstrumentations2,
shallowInstrumentations2,
shallowReadonlyInstrumentations2
];
}
const [
mutableInstrumentations,
readonlyInstrumentations,
shallowInstrumentations,
shallowReadonlyInstrumentations
] = /* @__PURE__ */ createInstrumentations();
function createInstrumentationGetter(isReadonly, shallow) {
const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive") {
return !isReadonly;
} else if (key === "__v_isReadonly") {
return isReadonly;
} else if (key === "__v_raw") {
return target;
}
return Reflect.get(
hasOwn(instrumentations, key) && key in target ? instrumentations : target,
key,
receiver
);
};
}
const mutableCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(false, false)
};
const shallowCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(true, false)
};
const shallowReadonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(true, true)
};
const reactiveMap = /* @__PURE__ */ new WeakMap();
const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
const readonlyMap = /* @__PURE__ */ new WeakMap();
const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array":
return 1 /* COMMON */;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2 /* COLLECTION */;
default:
return 0 /* INVALID */;
}
}
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
}
function reactive(target) {
if (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 (!isObject(target)) {
return target;
}
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
return target;
}
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
const targetType = getTargetType(target);
if (targetType === 0 /* INVALID */) {
return target;
}
const proxy = new Proxy(
target,
targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(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 isReactive(value) || isReadonly(value);
}
function toRaw(observed) {
const raw = observed && observed["__v_raw"];
return raw ? toRaw(raw) : observed;
}
function markRaw(value) {
def(value, "__v_skip", true);
return value;
}
const toReactive = (value) => isObject(value) ? reactive(value) : value;
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
function trackRefValue(ref2) {
if (shouldTrack && activeEffect) {
ref2 = toRaw(ref2);
{
trackEffects(ref2.dep || (ref2.dep = createDep()));
}
}
}
function triggerRefValue(ref2, newVal) {
ref2 = toRaw(ref2);
const dep = ref2.dep;
if (dep) {
{
triggerEffects(dep);
}
}
}
function isRef(r) {
return !!(r && r.__v_isRef === true);
}
function ref(value) {
return createRef(value, false);
}
function shallowRef(value) {
return createRef(value, true);
}
function createRef(rawValue, shallow) {
if (isRef(rawValue)) {
return rawValue;
}
return new RefImpl(rawValue, shallow);
}
class RefImpl {
constructor(value, __v_isShallow) {
this.__v_isShallow = __v_isShallow;
this.dep = void 0;
this.__v_isRef = true;
this._rawValue = __v_isShallow ? value : toRaw(value);
this._value = __v_isShallow ? value : toReactive(value);
}
get value() {
trackRefValue(this);
return this._value;
}
set value(newVal) {
const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
newVal = useDirectValue ? newVal : toRaw(newVal);
if (hasChanged(newVal, this._rawValue)) {
this._rawValue = newVal;
this._value = useDirectValue ? newVal : toReactive(newVal);
triggerRefValue(this);
}
}
}
function triggerRef(ref2) {
triggerRefValue(ref2);
}
function unref(ref2) {
return isRef(ref2) ? ref2.value : ref2;
}
function toValue(source) {
return isFunction(source) ? source() : unref(source);
}
const shallowUnwrapHandlers = {
get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
if (isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
} else {
return Reflect.set(target, key, value, receiver);
}
}
};
function proxyRefs(objectWithRefs) {
return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
}
class CustomRefImpl {
constructor(factory) {
this.dep = void 0;
this.__v_isRef = true;
const { get, set } = factory(
() => trackRefValue(this),
() => triggerRefValue(this)
);
this._get = get;
this._set = set;
}
get value() {
return this._get();
}
set value(newVal) {
this._set(newVal);
}
}
function customRef(factory) {
return new CustomRefImpl(factory);
}
function toRefs(object) {
const ret = isArray(object) ? new Array(object.length) : {};
for (const key in object) {
ret[key] = propertyToRef(object, key);
}
return ret;
}
class ObjectRefImpl {
constructor(_object, _key, _defaultValue) {
this._object = _object;
this._key = _key;
this._defaultValue = _defaultValue;
this.__v_isRef = true;
}
get value() {
const val = this._object[this._key];
return val === void 0 ? this._defaultValue : val;
}
set value(newVal) {
this._object[this._key] = newVal;
}
get dep() {
return getDepFromReactive(toRaw(this._object), this._key);
}
}
class GetterRefImpl {
constructor(_getter) {
this._getter = _getter;
this.__v_isRef = true;
this.__v_isReadonly = true;
}
get value() {
return this._getter();
}
}
function toRef(source, key, defaultValue) {
if (isRef(source)) {
return source;
} else if (isFunction(source)) {
return new GetterRefImpl(source);
} else if (isObject(source) && arguments.length > 1) {
return propertyToRef(source, key, defaultValue);
} else {
return ref(source);
}
}
function propertyToRef(source, key, defaultValue) {
const val = source[key];
return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
}
class ComputedRefImpl {
constructor(getter, _setter, isReadonly, isSSR) {
this._setter = _setter;
this.dep = void 0;
this.__v_isRef = true;
this["__v_isReadonly"] = false;
this._dirty = true;
this.effect = new ReactiveEffect(getter, () => {
if (!this._dirty) {
this._dirty = true;
triggerRefValue(this);
}
});
this.effect.computed = this;
this.effect.active = this._cacheable = !isSSR;
this["__v_isReadonly"] = isReadonly;
}
get value() {
const self = toRaw(this);
trackRefValue(self);
if (self._dirty || !self._cacheable) {
self._dirty = false;
self._value = self.effect.run();
}
return self._value;
}
set value(newValue) {
this._setter(newValue);
}
}
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
const onlyGetter = isFunction(getterOrOptions);
if (onlyGetter) {
getter = getterOrOptions;
setter = NOOP;
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
return cRef;
}
function warn$1(msg, ...args) {
return;
}
function assertNumber(val, type) {
return;
}
function callWithErrorHandling(fn, instance, type, args) {
let res;
try {
res = args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
return res;
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && isPromise(res)) {
res.catch((err) => {
handleError(err, instance, type);
});
}
return res;
}
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
}
function handleError(err, instance, type, throwInDev = true) {
const contextVNode = instance ? instance.vnode : null;
if (instance) {
let cur = instance.parent;
const exposedInstance = instance.proxy;
const errorInfo = type;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
return;
}
}
}
cur = cur.parent;
}
const appErrorHandler = instance.appContext.config.errorHandler;
if (appErrorHandler) {
callWithErrorHandling(
appErrorHandler,
null,
10,
[err, exposedInstance, errorInfo]
);
return;
}
}
logError(err, type, contextVNode, throwInDev);
}
function logError(err, type, contextVNode, throwInDev = true) {
{
console.error(err);
}
}
let isFlushing = false;
let isFlushPending = false;
const queue = [];
let flushIndex = 0;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = null;
function nextTick(fn) {
const p = currentFlushPromise || resolvedPromise;
return fn ? p.then(this ? fn.bind(this) : fn) : p;
}
function findInsertionIndex(id) {
let start = flushIndex + 1;
let end = queue.length;
while (start < end) {
const middle = start + end >>> 1;
const middleJob = queue[middle];
const middleJobId = getId(middleJob);
if (middleJobId < id || middleJobId === id && middleJob.pre) {
start = middle + 1;
} else {
end = middle;
}
}
return start;
}
function queueJob(job) {
if (!queue.length || !queue.includes(
job,
isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
)) {
if (job.id == null) {
queue.push(job);
} else {
queue.splice(findInsertionIndex(job.id), 0, job);
}
queueFlush();
}
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function invalidateJob(job) {
const i = queue.indexOf(job);
if (i > flushIndex) {
queue.splice(i, 1);
}
}
function queuePostFlushCb(cb) {
if (!isArray(cb)) {
if (!activePostFlushCbs || !activePostFlushCbs.includes(
cb,
cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
)) {
pendingPostFlushCbs.push(cb);
}
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.pre) {
if (instance && cb.id !== instance.uid) {
continue;
}
queue.splice(i, 1);
i--;
cb();
}
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)];
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
activePostFlushCbs[postFlushIndex]();
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? Infinity : job.id;
const comparator = (a, b) => {
const diff = getId(a) - getId(b);
if (diff === 0) {
if (a.pre && !b.pre)
return -1;
if (b.pre && !a.pre)
return 1;
}
return diff;
};
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
queue.sort(comparator);
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && job.active !== false) {
if (false) ;
callWithErrorHandling(job, null, 14);
}
}
} finally {
flushIndex = 0;
queue.length = 0;
flushPostFlushCbs();
isFlushing = false;
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs();
}
}
}
let devtools;
let buffer = [];
function setDevtoolsHook(hook, target) {
var _a, _b;
devtools = hook;
if (devtools) {
devtools.enabled = true;
buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
buffer = [];
} else if (
// handle late devtools injection - only do this if we are in an actual
// browser environment to avoid the timer handle stalling test runner exit
// (#4815)
typeof window !== "undefined" && // some envs mock window but not fully
window.HTMLElement && // also exclude jsdom
!((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
) {
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
replay.push((newHook) => {
setDevtoolsHook(newHook, target);
});
setTimeout(() => {
if (!devtools) {
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
buffer = [];
}
}, 3e3);
} else {
buffer = [];
}
}
function warnDeprecation(key, instance, ...args) {
{
return;
}
}
const globalCompatConfig = {
MODE: 2
};
function configureCompat(config) {
extend(globalCompatConfig, config);
}
function getCompatConfigForKey(key, instance) {
const instanceConfig = instance && instance.type.compatConfig;
if (instanceConfig && key in instanceConfig) {
return instanceConfig[key];
}
return globalCompatConfig[key];
}
function isCompatEnabled$1(key, instance, enableForBuiltIn = false) {
if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) {
return false;
}
const rawMode = getCompatConfigForKey("MODE", instance) || 2;
const val = getCompatConfigForKey(key, instance);
const mode = isFunction(rawMode) ? rawMode(instance && instance.type) : rawMode;
if (mode === 2) {
return val !== false;
} else {
return val === true || val === "suppress-warning";
}
}
function assertCompatEnabled(key, instance, ...args) {
if (!isCompatEnabled$1(key, instance)) {
throw new Error(`${key} compat has been disabled.`);
}
}
function softAssertCompatEnabled(key, instance, ...args) {
return isCompatEnabled$1(key, instance);
}
function checkCompatEnabled$1(key, instance, ...args) {
const enabled = isCompatEnabled$1(key, instance);
return enabled;
}
const eventRegistryMap = /* @__PURE__ */ new WeakMap();
function getRegistry(instance) {
let events = eventRegistryMap.get(instance);
if (!events) {
eventRegistryMap.set(instance, events = /* @__PURE__ */ Object.create(null));
}
return events;
}
function on(instance, event, fn) {
if (isArray(event)) {
event.forEach((e) => on(instance, e, fn));
} else {
if (event.startsWith("hook:")) {
assertCompatEnabled(
"INSTANCE_EVENT_HOOKS",
instance,
event
);
} else {
assertCompatEnabled("INSTANCE_EVENT_EMITTER", instance);
}
const events = getRegistry(instance);
(events[event] || (events[event] = [])).push(fn);
}
return instance.proxy;
}
function once(instance, event, fn) {
const wrapped = (...args) => {
off(instance, event, wrapped);
fn.call(instance.proxy, ...args);
};
wrapped.fn = fn;
on(instance, event, wrapped);
return instance.proxy;
}
function off(instance, event, fn) {
assertCompatEnabled("INSTANCE_EVENT_EMITTER", instance);
const vm = instance.proxy;
if (!event) {
eventRegistryMap.set(instance, /* @__PURE__ */ Object.create(null));
return vm;
}
if (isArray(event)) {
event.forEach((e) => off(instance, e, fn));
return vm;
}
const events = getRegistry(instance);
const cbs = events[event];
if (!cbs) {
return vm;
}
if (!fn) {
events[event] = void 0;
return vm;
}
events[event] = cbs.filter((cb) => !(cb === fn || cb.fn === fn));
return vm;
}
function emit$1(instance, event, args) {
const cbs = getRegistry(instance)[event];
if (cbs) {
callWithAsyncErrorHandling(
cbs.map((cb) => cb.bind(instance.proxy)),
instance,
6,
args
);
}
return instance.proxy;
}
const compatModelEventPrefix = `onModelCompat:`;
function convertLegacyVModelProps(vnode) {
const { type, shapeFlag, props, dynamicProps } = vnode;
const comp = type;
if (shapeFlag & 6 && props && "modelValue" in props) {
if (!isCompatEnabled$1(
"COMPONENT_V_MODEL",
// this is a special case where we want to use the vnode component's
// compat config instead of the current rendering instance (which is the
// parent of the component that exposes v-model)
{ type }
)) {
return;
}
const model = comp.model || {};
applyModelFromMixins(model, comp.mixins);
const { prop = "value", event = "input" } = model;
if (prop !== "modelValue") {
props[prop] = props.modelValue;
delete props.modelValue;
}
if (dynamicProps) {
dynamicProps[dynamicProps.indexOf("modelValue")] = prop;
}
props[compatModelEventPrefix + event] = props["onUpdate:modelValue"];
delete props["onUpdate:modelValue"];
}
}
function applyModelFromMixins(model, mixins) {
if (mixins) {
mixins.forEach((m) => {
if (m.model)
extend(model, m.model);
if (m.mixins)
applyModelFromMixins(model, m.mixins);
});
}
}
function compatModelEmit(instance, event, args) {
if (!isCompatEnabled$1("COMPONENT_V_MODEL", instance)) {
return;
}
const props = instance.vnode.props;
const modelHandler = props && props[compatModelEventPrefix + event];
if (modelHandler) {
callWithErrorHandling(
modelHandler,
instance,
6,
args
);
}
}
function emit(instance, event, ...rawArgs) {
if (instance.isUnmounted)
return;
const props = instance.vnode.props || EMPTY_OBJ;
let args = rawArgs;
const isModelListener = event.startsWith("update:");
const modelArg = isModelListener && event.slice(7);
if (modelArg && modelArg in props) {
const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
if (trim) {
args = rawArgs.map((a) => isString(a) ? a.trim() : a);
}
if (number) {
args = rawArgs.map(looseToNumber);
}
}
let handlerName;
let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
props[handlerName = toHandlerKey(camelize(event))];
if (!handler && isModelListener) {
handler = props[handlerName = toHandlerKey(hyphenate(event))];
}
if (handler) {
callWithAsyncErrorHandling(
handler,
instance,
6,
args
);
}
const onceHandler = props[handlerName + `Once`];
if (onceHandler) {
if (!instance.emitted) {
instance.emitted = {};
} else if (instance.emitted[handlerName]) {
return;
}
instance.emitted[handlerName] = true;
callWithAsyncErrorHandling(
onceHandler,
instance,
6,
args
);
}
{
compatModelEmit(instance, event, args);
return emit$1(instance, event, args);
}
}
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
const cache = appContext.emitsCache;
const cached = cache.get(comp);
if (cached !== void 0) {
return cached;
}
const raw = comp.emits;
let normalized = {};
let hasExtends = false;
if (!isFunction(comp)) {
const extendEmits = (raw2) => {
const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
if (normalizedFromExtend) {
hasExtends = true;
extend(normalized, normalizedFromExtend);
}
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendEmits);
}
if (comp.extends) {
extendEmits(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendEmits);
}
}
if (!raw && !hasExtends) {
if (isObject(comp)) {
cache.set(comp, null);
}
return null;
}
if (isArray(raw)) {
raw.forEach((key) => normalized[key] = null);
} else {
extend(normalized, raw);
}
if (isObject(comp)) {
cache.set(comp, normalized);
}
return normalized;
}
function isEmitListener(options, key) {
if (!options || !isOn(key)) {
return false;
}
if (key.startsWith(compatModelEventPrefix)) {
return true;
}
key = key.slice(2).replace(/Once$/, "");
return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
}
let currentRenderingInstance = null;
let currentScopeId = null;
function setCurrentRenderingInstance(instance) {
const prev = currentRenderingInstance;
currentRenderingInstance = instance;
currentScopeId = instance && instance.type.__scopeId || null;
if (!currentScopeId) {
currentScopeId = instance && instance.type._scopeId || null;
}
return prev;
}
function pushScopeId(id) {
currentScopeId = id;
}
function popScopeId() {
currentScopeId = null;
}
const withScopeId = (_id) => withCtx;
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
if (!ctx)
return fn;
if (fn._n) {
return fn;
}
const renderFnWithContext = (...args) => {
if (renderFnWithContext._d) {
setBlockTracking(-1);
}
const prevInstance = setCurrentRenderingInstance(ctx);
let res;
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
if (isNonScopedSlot) {
renderFnWithContext._ns = true;
}
return renderFnWithContext;
}
function markAttrsAccessed() {
}
function renderComponentRoot(instance) {
const {
type: Component,
vnode,
proxy,
withProxy,
props,
propsOptions: [propsOptions],
slots,
attrs,
emit,
render,
renderCache,
data,
setupState,
ctx,
inheritAttrs
} = instance;
let result;
let fallthroughAttrs;
const prev = setCurrentRenderingInstance(instance);
try {
if (vnode.shapeFlag & 4) {
const proxyToUse = withProxy || proxy;
const thisProxy = false ? new Proxy(proxyToUse, {
get(target, key, receiver) {
warn(
`Property '${String(
key
)}' was accessed via 'this'. Avoid using 'this' in templates.`
);
return Reflect.get(target, key, receiver);
}
}) : proxyToUse;
result = normalizeVNode(
render.call(
thisProxy,
proxyToUse,
renderCache,
props,
setupState,
data,
ctx
)
);
fallthroughAttrs = attrs;
} else {
const render2 = Component;
if (false) ;
result = normalizeVNode(
render2.length > 1 ? render2(
props,
false ? {
get attrs() {
markAttrsAccessed();
return attrs;
},
slots,
emit
} : { attrs, slots, emit }
) : render2(
props,
null
/* we know it doesn't need it */
)
);
fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
}
} catch (err) {
blockStack.length = 0;
handleError(err, instance, 1);
result = createVNode(Comment);
}
let root = result;
if (fallthroughAttrs && inheritAttrs !== false) {
const keys = Object.keys(fallthroughAttrs);
const { shapeFlag } = root;
if (keys.length) {
if (shapeFlag & (1 | 6)) {
if (propsOptions && keys.some(isModelListener)) {
fallthroughAttrs = filterModelListeners(
fallthroughAttrs,
propsOptions
);
}
root = cloneVNode(root, fallthroughAttrs);
}
}
}
if (isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance) && vnode.shapeFlag & 4 && root.shapeFlag & (1 | 6)) {
const { class: cls, style } = vnode.props || {};
if (cls || style) {
root = cloneVNode(root, {
class: cls,
style
});
}
}
if (vnode.dirs) {
root = cloneVNode(root);
root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
}
if (vnode.transition) {
root.transition = vnode.transition;
}
{
result = root;
}
setCurrentRenderingInstance(prev);
return result;
}
function filterSingleRoot(children) {
let singleRoot;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isVNode(child)) {
if (child.type !== Comment || child.children === "v-if") {
if (singleRoot) {
return;
} else {
singleRoot = child;
}
}
} else {
return;
}
}
return singleRoot;
}
const getFunctionalFallthrough = (attrs) => {
let res;
for (const key in attrs) {
if (key === "class" || key === "style" || isOn(key)) {
(res || (res = {}))[key] = attrs[key];
}
}
return res;
};
const filterModelListeners = (attrs, props) => {
const res = {};
for (const key in attrs) {
if (!isModelListener(key) || !(key.slice(9) in props)) {
res[key] = attrs[key];
}
}
return res;
};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const { props: prevProps, children: prevChildren, component } = prevVNode;
const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
const emits = component.emitsOptions;
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag >= 0) {
if (patchFlag & 1024) {
return true;
}
if (patchFlag & 16) {
if (!prevProps) {
return !!nextProps;
}
return hasPropsChanged(prevProps, nextProps, emits);
} else if (patchFlag & 8) {
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
return true;
}
}
}
} else {
if (prevChildren || nextChildren) {
if (!nextChildren || !nextChildren.$stable) {
return true;
}
}
if (prevProps === nextProps) {
return false;
}
if (!prevProps) {
return !!nextProps;
}
if (!nextProps) {
return true;
}
return hasPropsChanged(prevProps, nextProps, emits);
}
return false;
}
function hasPropsChanged(prevProps, nextProps, emitsOptions) {
const nextKeys = Object.keys(nextProps);
if (nextKeys.length !== Object.keys(prevProps).length) {
return true;
}
for (let i = 0; i < nextKeys.length; i++) {
const key = nextKeys[i];
if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
return true;
}
}
return false;
}
function updateHOCHostEl({ vnode, parent }, el) {
while (parent && parent.subTree === vnode) {
(vnode = parent.vnode).el = el;
parent = parent.parent;
}
}
const COMPONENTS = "components";
const DIRECTIVES = "directives";
const FILTERS = "filters";
function resolveComponent(name, maybeSelfReference) {
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
function resolveDynamicComponent(component) {
if (isString(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
} else {
return component || NULL_DYNAMIC_COMPONENT;
}
}
function resolveDirective(name) {
return resolveAsset(DIRECTIVES, name);
}
function resolveFilter$1(name) {
return resolveAsset(FILTERS, name);
}
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
const instance = currentRenderingInstance || currentInstance;
if (instance) {
const Component = instance.type;
if (type === COMPONENTS) {
const selfName = getComponentName(
Component,
false
/* do not include inferred name to avoid breaking existing code */
);
if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
return Component;
}
}
const res = (
// local registration
// check instance[type] first which is resolved for options API
resolve(instance[type] || Component[type], name) || // global registration
resolve(instance.appContext[type], name)
);
if (!res && maybeSelfReference) {
return Component;
}
return res;
}
}
function resolve(registry, name) {
return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
}
const isSuspense = (type) => type.__isSuspense;
const SuspenseImpl = {
name: "Suspense",
// In order to make Suspense tree-shakable, we need to avoid importing it
// directly in the renderer. The renderer checks for the __isSuspense flag
// on a vnode's type and calls the `process` method, passing in renderer
// internals.
__isSuspense: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
if (n1 == null) {
mountSuspense(
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized,
rendererInternals
);
} else {
patchSuspense(
n1,
n2,
container,
anchor,
parentComponent,
isSVG,
slotScopeIds,
optimized,
rendererInternals
);
}
},
hydrate: hydrateSuspense,
create: createSuspenseBoundary,
normalize: normalizeSuspenseChildren
};
const Suspense = SuspenseImpl ;
function triggerEvent(vnode, name) {
const eventListener = vnode.props && vnode.props[name];
if (isFunction(eventListener)) {
eventListener();
}
}
function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) {
const {
p: patch,
o: { createElement }
} = rendererInternals;
const hiddenContainer = createElement("div");
const suspense = vnode.suspense = createSuspenseBoundary(
vnode,
parentSuspense,
parentComponent,
container,
hiddenContainer,
anchor,
isSVG,
slotScopeIds,
optimized,
rendererInternals
);
patch(
null,
suspense.pendingBranch = vnode.ssContent,
hiddenContainer,
null,
parentComponent,
suspense,
isSVG,
slotScopeIds
);
if (suspense.deps > 0) {
triggerEvent(vnode, "onPending");
triggerEvent(vnode, "onFallback");
patch(
null,
vnode.ssFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds
);
setActiveBranch(suspense, vnode.ssFallback);
} else {
suspense.resolve(false, true);
}
}
function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
const suspense = n2.suspense = n1.suspense;
suspense.vnode = n2;
n2.el = n1.el;
const newBranch = n2.ssContent;
const newFallback = n2.ssFallback;
const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
if (pendingBranch) {
suspense.pendingBranch = newBranch;
if (isSameVNodeType(newBranch, pendingBranch)) {
patch(
pendingBranch,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else if (isInFallback) {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
} else {
suspense.pendingId++;
if (isHydrating) {
suspense.isHydrating = false;
suspense.activeBranch = pendingBranch;
} else {
unmount(pendingBranch, parentComponent, suspense);
}
suspense.deps = 0;
suspense.effects.length = 0;
suspense.hiddenContainer = createElement("div");
if (isInFallback) {
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
patch(
activeBranch,
newFallback,
container,
anchor,
parentComponent,
null,
// fallback tree will not have suspense context
isSVG,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newFallback);
}
} else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(
activeBranch,
newBranch,
container,
anchor,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
suspense.resolve(true);
} else {
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
}
}
}
} else {
if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
patch(
activeBranch,
newBranch,
container,
anchor,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
setActiveBranch(suspense, newBranch);
} else {
triggerEvent(n2, "onPending");
suspense.pendingBranch = newBranch;
suspense.pendingId++;
patch(
null,
newBranch,
suspense.hiddenContainer,
null,
parentComponent,
suspense,
isSVG,
slotScopeIds,
optimized
);
if (suspense.deps <= 0) {
suspense.resolve();
} else {
const { timeout, pendingId } = suspense;
if (timeout > 0) {
setTimeout(() => {
if (suspense.pendingId === pendingId) {
suspense.fallback(newFallback);
}
}, timeout);
} else if (timeout === 0) {
suspense.fallback(newFallback);
}
}
}
}
}
function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
const {
p: patch,
m: move,
um: unmount,
n: next,
o: { parentNode, remove }
} = rendererInternals;
let parentSuspenseId;
const isSuspensible = isVNodeSuspensible(vnode);
if (isSuspensible) {
if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
parentSuspenseId = parentSuspense.pendingId;
parentSuspense.deps++;
}
}
const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
const suspense = {
vnode,
parent: parentSuspense,
parentComponent,
isSVG,
container,
hiddenContainer,
anchor,
deps: 0,
pendingId: 0,
timeout: typeof timeout === "number" ? timeout : -1,
activeBranch: null,
pendingBranch: null,
isInFallback: !isHydrating,
isHydrating,
isUnmounted: false,
effects: [],
resolve(resume = false, sync = false) {
const {
vnode: vnode2,
activeBranch,
pendingBranch,
pendingId,
effects,
parentComponent: parentComponent2,
container: container2
} = suspense;
let delayEnter = false;
if (suspense.isHydrating) {
suspense.isHydrating = false;
} else if (!resume) {
delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = () => {
if (pendingId === suspense.pendingId) {
move(
pendingBranch,
container2,
next(activeBranch),
0
);
queuePostFlushCb(effects);
}
};
}
let { anchor: anchor2 } = suspense;
if (activeBranch) {
anchor2 = next(activeBranch);
unmount(activeBranch, parentComponent2, suspense, true);
}
if (!delayEnter) {
move(pendingBranch, container2, anchor2, 0);
}
}
setActiveBranch(suspense, pendingBranch);
suspense.pendingBranch = null;
suspense.isInFallback = false;
let parent = suspense.parent;
let hasUnresolvedAncestor = false;
while (parent) {
if (parent.pendingBranch) {
parent.effects.push(...effects);
hasUnresolvedAncestor = true;
break;
}
parent = parent.parent;
}
if (!hasUnresolvedAncestor && !delayEnter) {
queuePostFlushCb(effects);
}
suspense.effects = [];
if (isSuspensible) {
if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
parentSuspense.deps--;
if (parentSuspense.deps === 0 && !sync) {
parentSuspense.resolve();
}
}
}
triggerEvent(vnode2, "onResolve");
},
fallback(fallbackVNode) {
if (!suspense.pendingBranch) {
return;
}
const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, isSVG: isSVG2 } = suspense;
triggerEvent(vnode2, "onFallback");
const anchor2 = next(activeBranch);
const mountFallback = () => {
if (!suspense.isInFallback) {
return;
}
patch(
null,
fallbackVNode,
container2,
anchor2,
parentComponent2,
null,
// fallback tree will not have suspense context
isSVG2,
slotScopeIds,
optimized
);
setActiveBranch(suspense, fallbackVNode);
};
const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
if (delayEnter) {
activeBranch.transition.afterLeave = mountFallback;
}
suspense.isInFallback = true;
unmount(
activeBranch,
parentComponent2,
null,
// no suspense so unmount hooks fire now
true
// shouldRemove
);
if (!delayEnter) {
mountFallback();
}
},
move(container2, anchor2, type) {
suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
suspense.container = container2;
},
next() {
return suspense.activeBranch && next(suspense.activeBranch);
},
registerDep(instance, setupRenderEffect) {
const isInPendingSuspense = !!suspense.pendingBranch;
if (isInPendingSuspense) {
suspense.deps++;
}
const hydratedEl = instance.vnode.el;
instance.asyncDep.catch((err) => {
handleError(err, instance, 0);
}).then((asyncSetupResult) => {
if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
return;
}
instance.asyncResolved = true;
const { vnode: vnode2 } = instance;
handleSetupResult(instance, asyncSetupResult, false);
if (hydratedEl) {
vnode2.el = hydratedEl;
}
const placeholder = !hydratedEl && instance.subTree.el;
setupRenderEffect(
instance,
vnode2,
// component may have been moved before resolve.
// if this is not a hydration, instance.subTree will be the comment
// placeholder.
parentNode(hydratedEl || instance.subTree.el),
// anchor will not be used if this is hydration, so only need to
// consider the comment placeholder case.
hydratedEl ? null : next(instance.subTree),
suspense,
isSVG,
optimized
);
if (placeholder) {
remove(placeholder);
}
updateHOCHostEl(instance, vnode2.el);
if (isInPendingSuspense && --suspense.deps === 0) {
suspense.resolve();
}
});
},
unmount(parentSuspense2, doRemove) {
suspense.isUnmounted = true;
if (suspense.activeBranch) {
unmount(
suspense.activeBranch,
parentComponent,
parentSuspense2,
doRemove
);
}
if (suspense.pendingBranch) {
unmount(
suspense.pendingBranch,
parentComponent,
parentSuspense2,
doRemove
);
}
}
};
return suspense;
}
function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) {
const suspense = vnode.suspense = createSuspenseBoundary(
vnode,
parentSuspense,
parentComponent,
node.parentNode,
document.createElement("div"),
null,
isSVG,
slotScopeIds,
optimized,
rendererInternals,
true
/* hydrating */
);
const result = hydrateNode(
node,
suspense.pendingBranch = vnode.ssContent,
parentComponent,
suspense,
slotScopeIds,
optimized
);
if (suspense.deps === 0) {
suspense.resolve(false, true);
}
return result;
}
function normalizeSuspenseChildren(vnode) {
const { shapeFlag, children } = vnode;
const isSlotChildren = shapeFlag & 32;
vnode.ssContent = normalizeSuspenseSlot(
isSlotChildren ? children.default : children
);
vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
}
function normalizeSuspenseSlot(s) {
let block;
if (isFunction(s)) {
const trackBlock = isBlockTreeEnabled && s._c;
if (trackBlock) {
s._d = false;
openBlock();
}
s = s();
if (trackBlock) {
s._d = true;
block = currentBlock;
closeBlock();
}
}
if (isArray(s)) {
const singleChild = filterSingleRoot(s);
s = singleChild;
}
s = normalizeVNode(s);
if (block && !s.dynamicChildren) {
s.dynamicChildren = block.filter((c) => c !== s);
}
return s;
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && suspense.pendingBranch) {
if (isArray(fn)) {
suspense.effects.push(...fn);
} else {
suspense.effects.push(fn);
}
} else {
queuePostFlushCb(fn);
}
}
function setActiveBranch(suspense, branch) {
suspense.activeBranch = branch;
const { vnode, parentComponent } = suspense;
const el = vnode.el = branch.el;
if (parentComponent && parentComponent.subTree === vnode) {
parentComponent.vnode.el = el;
updateHOCHostEl(parentComponent, el);
}
}
function isVNodeSuspensible(vnode) {
var _a;
return ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
}
const legacyDirectiveHookMap = {
beforeMount: "bind",
mounted: "inserted",
updated: ["update", "componentUpdated"],
unmounted: "unbind"
};
function mapCompatDirectiveHook(name, dir, instance) {
const mappedName = legacyDirectiveHookMap[name];
if (mappedName) {
if (isArray(mappedName)) {
const hook = [];
mappedName.forEach((mapped) => {
const mappedHook = dir[mapped];
if (mappedHook) {
softAssertCompatEnabled(
"CUSTOM_DIR",
instance,
mapped,
name
);
hook.push(mappedHook);
}
});
return hook.length ? hook : void 0;
} else {
if (dir[mappedName]) {
softAssertCompatEnabled(
"CUSTOM_DIR",
instance,
mappedName,
name
);
}
return dir[mappedName];
}
}
}
function watchEffect(effect, options) {
return doWatch(effect, null, options);
}
function watchPostEffect(effect, options) {
return doWatch(
effect,
null,
{ flush: "post" }
);
}
function watchSyncEffect(effect, options) {
return doWatch(
effect,
null,
{ flush: "sync" }
);
}
const INITIAL_WATCHER_VALUE = {};
function watch(source, cb, options) {
return doWatch(source, cb, options);
}
function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
var _a;
const instance = getCurrentScope() === ((_a = currentInstance) == null ? void 0 : _a.scope) ? currentInstance : null;
let getter;
let forceTrigger = false;
let isMultiSource = false;
if (isRef(source)) {
getter = () => source.value;
forceTrigger = isShallow(source);
} else if (isReactive(source)) {
getter = () => source;
deep = true;
} else if (isArray(source)) {
isMultiSource = true;
forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
getter = () => source.map((s) => {
if (isRef(s)) {
return s.value;
} else if (isReactive(s)) {
return traverse(s);
} else if (isFunction(s)) {
return callWithErrorHandling(s, instance, 2);
} else ;
});
} else if (isFunction(source)) {
if (cb) {
getter = () => callWithErrorHandling(source, instance, 2);
} else {
getter = () => {
if (instance && instance.isUnmounted) {
return;
}
if (cleanup) {
cleanup();
}
return callWithAsyncErrorHandling(
source,
instance,
3,
[onCleanup]
);
};
}
} else {
getter = NOOP;
}
if (cb && !deep) {
const baseGetter = getter;
getter = () => {
const val = baseGetter();
if (isArray(val) && checkCompatEnabled$1("WATCH_ARRAY", instance)) {
traverse(val);
}
return val;
};
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup;
let onCleanup = (fn) => {
cleanup = effect.onStop = () => {
callWithErrorHandling(fn, instance, 4);
cleanup = effect.onStop = void 0;
};
};
let ssrCleanup;
if (isInSSRComponentSetup) {
onCleanup = NOOP;
if (!cb) {
getter();
} else if (immediate) {
callWithAsyncErrorHandling(cb, instance, 3, [
getter(),
isMultiSource ? [] : void 0,
onCleanup
]);
}
if (flush === "sync") {
const ctx = useSSRContext();
ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
} else {
return NOOP;
}
}
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
const job = () => {
if (!effect.active) {
return;
}
if (cb) {
const newValue = effect.run();
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || isArray(newValue) && isCompatEnabled$1("WATCH_ARRAY", instance)) {
if (cleanup) {
cleanup();
}
callWithAsyncErrorHandling(cb, instance, 3, [
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,
onCleanup
]);
oldValue = newValue;
}
} else {
effect.run();
}
};
job.allowRecurse = !!cb;
let scheduler;
if (flush === "sync") {
scheduler = job;
} else if (flush === "post") {
scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
} else {
job.pre = true;
if (instance)
job.id = instance.uid;
scheduler = () => queueJob(job);
}
const effect = new ReactiveEffect(getter, scheduler);
if (cb) {
if (immediate) {
job();
} else {
oldValue = effect.run();
}
} else if (flush === "post") {
queuePostRenderEffect(
effect.run.bind(effect),
instance && instance.suspense
);
} else {
effect.run();
}
const unwatch = () => {
effect.stop();
if (instance && instance.scope) {
remove(instance.scope.effects, effect);
}
};
if (ssrCleanup)
ssrCleanup.push(unwatch);
return unwatch;
}
function instanceWatch(source, value, options) {
const publicThis = this.proxy;
const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
let cb;
if (isFunction(value)) {
cb = value;
} else {
cb = value.handler;
options = value;
}
const cur = currentInstance;
setCurrentInstance(this);
const res = doWatch(getter, cb.bind(publicThis), options);
if (cur) {
setCurrentInstance(cur);
} else {
unsetCurrentInstance();
}
return res;
}
function createPathGetter(ctx, path) {
const segments = path.split(".");
return () => {
let cur = ctx;
for (let i = 0; i < segments.length && cur; i++) {
cur = cur[segments[i]];
}
return cur;
};
}
function traverse(value, seen) {
if (!isObject(value) || value["__v_skip"]) {
return value;
}
seen = seen || /* @__PURE__ */ new Set();
if (seen.has(value)) {
return value;
}
seen.add(value);
if (isRef(value)) {
traverse(value.value, seen);
} else if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], seen);
}
} else if (isSet(value) || isMap(value)) {
value.forEach((v) => {
traverse(v, seen);
});
} else if (isPlainObject(value)) {
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
function withDirectives(vnode, directives) {
const internalInstance = currentRenderingInstance;
if (internalInstance === null) {
return vnode;
}
const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
if (dir) {
if (isFunction(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
if (dir.deep) {
traverse(value);
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
let hook = binding.dir[name];
if (!hook) {
hook = mapCompatDirectiveHook(name, binding.dir, instance);
}
if (hook) {
pauseTracking();
callWithAsyncErrorHandling(hook, instance, 8, [
vnode.el,
binding,
vnode,
prevVNode
]);
resetTracking();
}
}
}
const leaveCbKey = Symbol("_leaveCb");
const enterCbKey$1 = Symbol("_enterCb");
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: /* @__PURE__ */ new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionPropsValidators = {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
};
const BaseTransitionImpl = {
name: `BaseTransition`,
props: BaseTransitionPropsValidators,
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
let prevTransitionKey;
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
let child = children[0];
if (children.length > 1) {
for (const c of children) {
if (c.type !== Comment) {
child = c;
break;
}
}
}
const rawProps = toRaw(props);
const { mode } = rawProps;
if (state.isLeaving) {
return emptyPlaceholder(child);
}
const innerChild = getKeepAliveChild(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
const enterHooks = resolveTransitionHooks(
innerChild,
rawProps,
state,
instance
);
setTransitionHooks(innerChild, enterHooks);
const oldChild = instance.subTree;
const oldInnerChild = oldChild && getKeepAliveChild(oldChild);
let transitionKeyChanged = false;
const { getTransitionKey } = innerChild.type;
if (getTransitionKey) {
const key = getTransitionKey();
if (prevTransitionKey === void 0) {
prevTransitionKey = key;
} else if (key !== prevTransitionKey) {
prevTransitionKey = key;
transitionKeyChanged = true;
}
}
if (oldInnerChild && oldInnerChild.type !== Comment && (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) {
const leavingHooks = resolveTransitionHooks(
oldInnerChild,
rawProps,
state,
instance
);
setTransitionHooks(oldInnerChild, leavingHooks);
if (mode === "out-in") {
state.isLeaving = true;
leavingHooks.afterLeave = () => {
state.isLeaving = false;
if (instance.update.active !== false) {
instance.update();
}
};
return emptyPlaceholder(child);
} else if (mode === "in-out" && innerChild.type !== Comment) {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(
state,
oldInnerChild
);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
el[leaveCbKey] = () => {
earlyRemove();
el[leaveCbKey] = void 0;
delete enterHooks.delayedLeave;
};
enterHooks.delayedLeave = delayedLeave;
};
}
}
return child;
};
}
};
{
BaseTransitionImpl.__isBuiltIn = true;
}
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = /* @__PURE__ */ Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance) {
const {
appear,
mode,
persisted = false,
onBeforeEnter,
onEnter,
onAfterEnter,
onEnterCancelled,
onBeforeLeave,
onLeave,
onAfterLeave,
onLeaveCancelled,
onBeforeAppear,
onAppear,
onAfterAppear,
onAppearCancelled
} = props;
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook = (hook, args) => {
hook && callWithAsyncErrorHandling(
hook,
instance,
9,
args
);
};
const callAsyncHook = (hook, args) => {
const done = args[1];
callHook(hook, args);
if (isArray(hook)) {
if (hook.every((hook2) => hook2.length <= 1))
done();
} else if (hook.length <= 1) {
done();
}
};
const hooks = {
mode,
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
} else {
return;
}
}
if (el[leaveCbKey]) {
el[leaveCbKey](
true
/* cancelled */
);
}
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
leavingVNode.el[leaveCbKey]();
}
callHook(hook, [el]);
},
enter(el) {
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
} else {
return;
}
}
let called = false;
const done = el[enterCbKey$1] = (cancelled) => {
if (called)
return;
called = true;
if (cancelled) {
callHook(cancelHook, [el]);
} else {
callHook(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el[enterCbKey$1] = void 0;
};
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
done();
}
},
leave(el, remove) {
const key2 = String(vnode.key);
if (el[enterCbKey$1]) {
el[enterCbKey$1](
true
/* cancelled */
);
}
if (state.isUnmounting) {
return remove();
}
callHook(onBeforeLeave, [el]);
let called = false;
const done = el[leaveCbKey] = (cancelled) => {
if (called)
return;
called = true;
remove();
if (cancelled) {
callHook(onLeaveCancelled, [el]);
} else {
callHook(onAfterLeave, [el]);
}
el[leaveCbKey] = void 0;
if (leavingVNodesCache[key2] === vnode) {
delete leavingVNodesCache[key2];
}
};
leavingVNodesCache[key2] = vnode;
if (onLeave) {
callAsyncHook(onLeave, [el, done]);
} else {
done();
}
},
clone(vnode2) {
return resolveTransitionHooks(vnode2, props, state, instance);
}
};
return hooks;
}
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getKeepAliveChild(vnode) {
return isKeepAlive(vnode) ? (
// #7121 ensure get the child component subtree in case
// it's been replaced during HMR
vnode.children ? vnode.children[0] : void 0
) : vnode;
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 && vnode.component) {
setTransitionHooks(vnode.component.subTree, hooks);
} else if (vnode.shapeFlag & 128) {
vnode.ssContent.transition = hooks.clone(vnode.ssContent);
vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
} else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
let child = children[i];
const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
if (child.type === Fragment) {
if (child.patchFlag & 128)
keyedFragmentCount++;
ret = ret.concat(
getTransitionRawChildren(child.children, keepComment, key)
);
} else if (keepComment || child.type !== Comment) {
ret.push(key != null ? cloneVNode(child, { key }) : child);
}
}
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2;
}
}
return ret;
}
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineComponent(options, extraOptions) {
return isFunction(options) ? (
// #8326: extend call and options.name access are considered side-effects
// by Rollup, so we have to wrap it in a pure-annotated IIFE.
/* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
) : options;
}
const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineAsyncComponent(source) {
if (isFunction(source)) {
source = { loader: source };
}
const {
loader,
loadingComponent,
errorComponent,
delay = 200,
timeout,
// undefined = never times out
suspensible = true,
onError: userOnError
} = source;
let pendingRequest = null;
let resolvedComp;
let retries = 0;
const retry = () => {
retries++;
pendingRequest = null;
return load();
};
const load = () => {
let thisRequest;
return pendingRequest || (thisRequest = pendingRequest = loader().catch((err) => {
err = err instanceof Error ? err : new Error(String(err));
if (userOnError) {
return new Promise((resolve, reject) => {
const userRetry = () => resolve(retry());
const userFail = () => reject(err);
userOnError(err, userRetry, userFail, retries + 1);
});
} else {
throw err;
}
}).then((comp) => {
if (thisRequest !== pendingRequest && pendingRequest) {
return pendingRequest;
}
if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
comp = comp.default;
}
resolvedComp = comp;
return comp;
}));
};
return defineComponent({
name: "AsyncComponentWrapper",
__asyncLoader: load,
get __asyncResolved() {
return resolvedComp;
},
setup() {
const instance = currentInstance;
if (resolvedComp) {
return () => createInnerComp(resolvedComp, instance);
}
const onError = (err) => {
pendingRequest = null;
handleError(
err,
instance,
13,
!errorComponent
/* do not throw in dev if user provided error component */
);
};
if (suspensible && instance.suspense || isInSSRComponentSetup) {
return load().then((comp) => {
return () => createInnerComp(comp, instance);
}).catch((err) => {
onError(err);
return () => errorComponent ? createVNode(errorComponent, {
error: err
}) : null;
});
}
const loaded = ref(false);
const error = ref();
const delayed = ref(!!delay);
if (delay) {
setTimeout(() => {
delayed.value = false;
}, delay);
}
if (timeout != null) {
setTimeout(() => {
if (!loaded.value && !error.value) {
const err = new Error(
`Async component timed out after ${timeout}ms.`
);
onError(err);
error.value = err;
}
}, timeout);
}
load().then(() => {
loaded.value = true;
if (instance.parent && isKeepAlive(instance.parent.vnode)) {
queueJob(instance.parent.update);
}
}).catch((err) => {
onError(err);
error.value = err;
});
return () => {
if (loaded.value && resolvedComp) {
return createInnerComp(resolvedComp, instance);
} else if (error.value && errorComponent) {
return createVNode(errorComponent, {
error: error.value
});
} else if (loadingComponent && !delayed.value) {
return createVNode(loadingComponent);
}
};
}
});
}
function createInnerComp(comp, parent) {
const { ref: ref2, props, children, ce } = parent.vnode;
const vnode = createVNode(comp, props, children);
vnode.ref = ref2;
vnode.ce = ce;
delete parent.vnode.ce;
return vnode;
}
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
const KeepAliveImpl = {
name: `KeepAlive`,
// Marker for special handling inside the renderer. We are not using a ===
// check directly on KeepAlive in the renderer, because importing it directly
// would prevent it from being tree-shaken.
__isKeepAlive: true,
props: {
include: [String, RegExp, Array],
exclude: [String, RegExp, Array],
max: [String, Number]
},
setup(props, { slots }) {
const instance = getCurrentInstance();
const sharedContext = instance.ctx;
if (!sharedContext.renderer) {
return () => {
const children = slots.default && slots.default();
return children && children.length === 1 ? children[0] : children;
};
}
const cache = /* @__PURE__ */ new Map();
const keys = /* @__PURE__ */ new Set();
let current = null;
const parentSuspense = instance.suspense;
const {
renderer: {
p: patch,
m: move,
um: _unmount,
o: { createElement }
}
} = sharedContext;
const storageContainer = createElement("div");
sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
const instance2 = vnode.component;
move(vnode, container, anchor, 0, parentSuspense);
patch(
instance2.vnode,
vnode,
container,
anchor,
instance2,
parentSuspense,
isSVG,
vnode.slotScopeIds,
optimized
);
queuePostRenderEffect(() => {
instance2.isDeactivated = false;
if (instance2.a) {
invokeArrayFns(instance2.a);
}
const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
}, parentSuspense);
};
sharedContext.deactivate = (vnode) => {
const instance2 = vnode.component;
move(vnode, storageContainer, null, 1, parentSuspense);
queuePostRenderEffect(() => {
if (instance2.da) {
invokeArrayFns(instance2.da);
}
const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
if (vnodeHook) {
invokeVNodeHook(vnodeHook, instance2.parent, vnode);
}
instance2.isDeactivated = true;
}, parentSuspense);
};
function unmount(vnode) {
resetShapeFlag(vnode);
_unmount(vnode, instance, parentSuspense, true);
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
const name = getComponentName(vnode.type);
if (name && (!filter || !filter(name))) {
pruneCacheEntry(key);
}
});
}
function pruneCacheEntry(key) {
const cached = cache.get(key);
if (!current || !isSameVNodeType(cached, current)) {
unmount(cached);
} else if (current) {
resetShapeFlag(current);
}
cache.delete(key);
keys.delete(key);
}
watch(
() => [props.include, props.exclude],
([include, exclude]) => {
include && pruneCache((name) => matches(include, name));
exclude && pruneCache((name) => !matches(exclude, name));
},
// prune post-render after `current` has been updated
{ flush: "post", deep: true }
);
let pendingCacheKey = null;
const cacheSubtree = () => {
if (pendingCacheKey != null) {
cache.set(pendingCacheKey, getInnerChild(instance.subTree));
}
};
onMounted(cacheSubtree);
onUpdated(cacheSubtree);
onBeforeUnmount(() => {
cache.forEach((cached) => {
const { subTree, suspense } = instance;
const vnode = getInnerChild(subTree);
if (cached.type === vnode.type && cached.key === vnode.key) {
resetShapeFlag(vnode);
const da = vnode.component.da;
da && queuePostRenderEffect(da, suspense);
return;
}
unmount(cached);
});
});
return () => {
pendingCacheKey = null;
if (!slots.default) {
return null;
}
const children = slots.default();
const rawVNode = children[0];
if (children.length > 1) {
current = null;
return children;
} else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
current = null;
return rawVNode;
}
let vnode = getInnerChild(rawVNode);
const comp = vnode.type;
const name = getComponentName(
isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
);
const { include, exclude, max } = props;
if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
current = vnode;
return rawVNode;
}
const key = vnode.key == null ? comp : vnode.key;
const cachedVNode = cache.get(key);
if (vnode.el) {
vnode = cloneVNode(vnode);
if (rawVNode.shapeFlag & 128) {
rawVNode.ssContent = vnode;
}
}
pendingCacheKey = key;
if (cachedVNode) {
vnode.el = cachedVNode.el;
vnode.component = cachedVNode.component;
if (vnode.transition) {
setTransitionHooks(vnode, vnode.transition);
}
vnode.shapeFlag |= 512;
keys.delete(key);
keys.add(key);
} else {
keys.add(key);
if (max && keys.size > parseInt(max, 10)) {
pruneCacheEntry(keys.values().next().value);
}
}
vnode.shapeFlag |= 256;
current = vnode;
return isSuspense(rawVNode.type) ? rawVNode : vnode;
};
}
};
{
KeepAliveImpl.__isBuildIn = true;
}
const KeepAlive = KeepAliveImpl;
function matches(pattern, name) {
if (isArray(pattern)) {
return pattern.some((p) => matches(p, name));
} else if (isString(pattern)) {
return pattern.split(",").includes(name);
} else if (isRegExp(pattern)) {
return pattern.test(name);
}
return false;
}
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a", target);
}
function onDeactivated(hook, target) {
registerKeepAliveHook(hook, "da", target);
}
function registerKeepAliveHook(hook, type, target = currentInstance) {
const wrappedHook = hook.__wdc || (hook.__wdc = () => {
let current = target;
while (current) {
if (current.isDeactivated) {
return;
}
current = current.parent;
}
return hook();
});
injectHook(type, wrappedHook, target);
if (target) {
let current = target.parent;
while (current && current.parent) {
if (isKeepAlive(current.parent.vnode)) {
injectToKeepAliveRoot(wrappedHook, type, target, current);
}
current = current.parent;
}
}
}
function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
const injected = injectHook(
type,
hook,
keepAliveRoot,
true
/* prepend */
);
onUnmounted(() => {
remove(keepAliveRoot[type], injected);
}, target);
}
function resetShapeFlag(vnode) {
vnode.shapeFlag &= ~256;
vnode.shapeFlag &= ~512;
}
function getInnerChild(vnode) {
return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
if (target.isUnmounted) {
return;
}
pauseTracking();
setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
unsetCurrentInstance();
resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) => (
// post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
(!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
);
const onBeforeMount = createHook("bm");
const onMounted = createHook("m");
const onBeforeUpdate = createHook("bu");
const onUpdated = createHook("u");
const onBeforeUnmount = createHook("bum");
const onUnmounted = createHook("um");
const onServerPrefetch = createHook("sp");
const onRenderTriggered = createHook(
"rtg"
);
const onRenderTracked = createHook(
"rtc"
);
function onErrorCaptured(hook, target = currentInstance) {
injectHook("ec", hook, target);
}
function getCompatChildren(instance) {
assertCompatEnabled("INSTANCE_CHILDREN", instance);
const root = instance.subTree;
const children = [];
if (root) {
walk$1(root, children);
}
return children;
}
function walk$1(vnode, children) {
if (vnode.component) {
children.push(vnode.component.proxy);
} else if (vnode.shapeFlag & 16) {
const vnodes = vnode.children;
for (let i = 0; i < vnodes.length; i++) {
walk$1(vnodes[i], children);
}
}
}
function getCompatListeners(instance) {
assertCompatEnabled("INSTANCE_LISTENERS", instance);
const listeners = {};
const rawProps = instance.vnode.props;
if (!rawProps) {
return listeners;
}
for (const key in rawProps) {
if (isOn(key)) {
listeners[key[2].toLowerCase() + key.slice(3)] = rawProps[key];
}
}
return listeners;
}
function convertLegacyRenderFn(instance) {
const Component2 = instance.type;
const render = Component2.render;
if (!render || render._rc || render._compatChecked || render._compatWrapped) {
return;
}
if (render.length >= 2) {
render._compatChecked = true;
return;
}
if (checkCompatEnabled$1("RENDER_FUNCTION", instance)) {
const wrapped = Component2.render = function compatRender() {
return render.call(this, compatH);
};
wrapped._compatWrapped = true;
}
}
function compatH(type, propsOrChildren, children) {
if (!type) {
type = Comment;
}
if (typeof type === "string") {
const t = hyphenate(type);
if (t === "transition" || t === "transition-group" || t === "keep-alive") {
type = `__compat__${t}`;
}
type = resolveDynamicComponent(type);
}
const l = arguments.length;
const is2ndArgArrayChildren = isArray(propsOrChildren);
if (l === 2 || is2ndArgArrayChildren) {
if (isObject(propsOrChildren) && !is2ndArgArrayChildren) {
if (isVNode(propsOrChildren)) {
return convertLegacySlots(createVNode(type, null, [propsOrChildren]));
}
return convertLegacySlots(
convertLegacyDirectives(
createVNode(type, convertLegacyProps(propsOrChildren, type)),
propsOrChildren
)
);
} else {
return convertLegacySlots(createVNode(type, null, propsOrChildren));
}
} else {
if (isVNode(children)) {
children = [children];
}
return convertLegacySlots(
convertLegacyDirectives(
createVNode(type, convertLegacyProps(propsOrChildren, type), children),
propsOrChildren
)
);
}
}
const skipLegacyRootLevelProps = /* @__PURE__ */ makeMap(
"staticStyle,staticClass,directives,model,hook"
);
function convertLegacyProps(legacyProps, type) {
if (!legacyProps) {
return null;
}
const converted = {};
for (const key in legacyProps) {
if (key === "attrs" || key === "domProps" || key === "props") {
extend(converted, legacyProps[key]);
} else if (key === "on" || key === "nativeOn") {
const listeners = legacyProps[key];
for (const event in listeners) {
let handlerKey = convertLegacyEventKey(event);
if (key === "nativeOn")
handlerKey += `Native`;
const existing = converted[handlerKey];
const incoming = listeners[event];
if (existing !== incoming) {
if (existing) {
converted[handlerKey] = [].concat(existing, incoming);
} else {
converted[handlerKey] = incoming;
}
}
}
} else if (!skipLegacyRootLevelProps(key)) {
converted[key] = legacyProps[key];
}
}
if (legacyProps.staticClass) {
converted.class = normalizeClass([legacyProps.staticClass, converted.class]);
}
if (legacyProps.staticStyle) {
converted.style = normalizeStyle([legacyProps.staticStyle, converted.style]);
}
if (legacyProps.model && isObject(type)) {
const { prop = "value", event = "input" } = type.model || {};
converted[prop] = legacyProps.model.value;
converted[compatModelEventPrefix + event] = legacyProps.model.callback;
}
return converted;
}
function convertLegacyEventKey(event) {
if (event[0] === "&") {
event = event.slice(1) + "Passive";
}
if (event[0] === "~") {
event = event.slice(1) + "Once";
}
if (event[0] === "!") {
event = event.slice(1) + "Capture";
}
return toHandlerKey(event);
}
function convertLegacyDirectives(vnode, props) {
if (props && props.directives) {
return withDirectives(
vnode,
props.directives.map(({ name, value, arg, modifiers }) => {
return [
resolveDirective(name),
value,
arg,
modifiers
];
})
);
}
return vnode;
}
function convertLegacySlots(vnode) {
const { props, children } = vnode;
let slots;
if (vnode.shapeFlag & 6 && isArray(children)) {
slots = {};
for (let i = 0; i < children.length; i++) {
const child = children[i];
const slotName = isVNode(child) && child.props && child.props.slot || "default";
const slot = slots[slotName] || (slots[slotName] = []);
if (isVNode(child) && child.type === "template") {
slot.push(child.children);
} else {
slot.push(child);
}
}
if (slots) {
for (const key in slots) {
const slotChildren = slots[key];
slots[key] = () => slotChildren;
slots[key]._ns = true;
}
}
}
const scopedSlots = props && props.scopedSlots;
if (scopedSlots) {
delete props.scopedSlots;
if (slots) {
extend(slots, scopedSlots);
} else {
slots = scopedSlots;
}
}
if (slots) {
normalizeChildren(vnode, slots);
}
return vnode;
}
function defineLegacyVNodeProperties(vnode) {
if (isCompatEnabled$1(
"RENDER_FUNCTION",
currentRenderingInstance,
true
/* enable for built-ins */
) && isCompatEnabled$1(
"PRIVATE_APIS",
currentRenderingInstance,
true
/* enable for built-ins */
)) {
const context = currentRenderingInstance;
const getInstance = () => vnode.component && vnode.component.proxy;
let componentOptions;
Object.defineProperties(vnode, {
tag: { get: () => vnode.type },
data: { get: () => vnode.props || {}, set: (p) => vnode.props = p },
elm: { get: () => vnode.el },
componentInstance: { get: getInstance },
child: { get: getInstance },
text: { get: () => isString(vnode.children) ? vnode.children : null },
context: { get: () => context && context.proxy },
componentOptions: {
get: () => {
if (vnode.shapeFlag & 4) {
if (componentOptions) {
return componentOptions;
}
return componentOptions = {
Ctor: vnode.type,
propsData: vnode.props,
children: vnode.children
};
}
}
}
});
}
}
const normalizedFunctionalComponentMap = /* @__PURE__ */ new WeakMap();
const legacySlotProxyHandlers = {
get(target, key) {
const slot = target[key];
return slot && slot();
}
};
function convertLegacyFunctionalComponent(comp) {
if (normalizedFunctionalComponentMap.has(comp)) {
return normalizedFunctionalComponentMap.get(comp);
}
const legacyFn = comp.render;
const Func = (props, ctx) => {
const instance = getCurrentInstance();
const legacyCtx = {
props,
children: instance.vnode.children || [],
data: instance.vnode.props || {},
scopedSlots: ctx.slots,
parent: instance.parent && instance.parent.proxy,
slots() {
return new Proxy(ctx.slots, legacySlotProxyHandlers);
},
get listeners() {
return getCompatListeners(instance);
},
get injections() {
if (comp.inject) {
const injections = {};
resolveInjections(comp.inject, injections);
return injections;
}
return {};
}
};
return legacyFn(compatH, legacyCtx);
};
Func.props = comp.props;
Func.displayName = comp.name;
Func.compatConfig = comp.compatConfig;
Func.inheritAttrs = false;
normalizedFunctionalComponentMap.set(comp, Func);
return Func;
}
function renderList(source, renderItem, cache, index) {
let ret;
const cached = cache && cache[index];
if (isArray(source) || isString(source)) {
ret = new Array(source.length);
for (let i = 0, l = source.length; i < l; i++) {
ret[i] = renderItem(source[i], i, void 0, cached && cached[i]);
}
} else if (typeof source === "number") {
ret = new Array(source);
for (let i = 0; i < source; i++) {
ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
}
} else if (isObject(source)) {
if (source[Symbol.iterator]) {
ret = Array.from(
source,
(item, i) => renderItem(item, i, void 0, cached && cached[i])
);
} else {
const keys = Object.keys(source);
ret = new Array(keys.length);
for (let i = 0, l = keys.length; i < l; i++) {
const key = keys[i];
ret[i] = renderItem(source[key], key, i, cached && cached[i]);
}
}
} else {
ret = [];
}
if (cache) {
cache[index] = ret;
}
return ret;
}
function createSlots(slots, dynamicSlots) {
for (let i = 0; i < dynamicSlots.length; i++) {
const slot = dynamicSlots[i];
if (isArray(slot)) {
for (let j = 0; j < slot.length; j++) {
slots[slot[j].name] = slot[j].fn;
}
} else if (slot) {
slots[slot.name] = slot.key ? (...args) => {
const res = slot.fn(...args);
if (res)
res.key = slot.key;
return res;
} : slot.fn;
}
}
return slots;
}
function renderSlot(slots, name, props = {}, fallback, noSlotted) {
if (currentRenderingInstance.isCE || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.isCE) {
if (name !== "default")
props.name = name;
return createVNode("slot", props, fallback && fallback());
}
let slot = slots[name];
if (slot && slot._c) {
slot._d = false;
}
openBlock();
const validSlotContent = slot && ensureValidVNode(slot(props));
const rendered = createBlock(
Fragment,
{
key: props.key || // slot content array of a dynamic conditional slot may have a branch
// key attached in the `createSlots` helper, respect that
validSlotContent && validSlotContent.key || `_${name}`
},
validSlotContent || (fallback ? fallback() : []),
validSlotContent && slots._ === 1 ? 64 : -2
);
if (!noSlotted && rendered.scopeId) {
rendered.slotScopeIds = [rendered.scopeId + "-s"];
}
if (slot && slot._c) {
slot._d = true;
}
return rendered;
}
function ensureValidVNode(vnodes) {
return vnodes.some((child) => {
if (!isVNode(child))
return true;
if (child.type === Comment)
return false;
if (child.type === Fragment && !ensureValidVNode(child.children))
return false;
return true;
}) ? vnodes : null;
}
function toHandlers(obj, preserveCaseIfNecessary) {
const ret = {};
for (const key in obj) {
ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
}
return ret;
}
function toObject(arr) {
const res = {};
for (let i = 0; i < arr.length; i++) {
if (arr[i]) {
extend(res, arr[i]);
}
}
return res;
}
function legacyBindObjectProps(data, _tag, value, _asProp, isSync) {
if (value && isObject(value)) {
if (isArray(value)) {
value = toObject(value);
}
for (const key in value) {
if (isReservedProp(key)) {
data[key] = value[key];
} else if (key === "class") {
data.class = normalizeClass([data.class, value.class]);
} else if (key === "style") {
data.style = normalizeClass([data.style, value.style]);
} else {
const attrs = data.attrs || (data.attrs = {});
const camelizedKey = camelize(key);
const hyphenatedKey = hyphenate(key);
if (!(camelizedKey in attrs) && !(hyphenatedKey in attrs)) {
attrs[key] = value[key];
if (isSync) {
const on = data.on || (data.on = {});
on[`update:${key}`] = function($event) {
value[key] = $event;
};
}
}
}
}
}
return data;
}
function legacyBindObjectListeners(props, listeners) {
return mergeProps(props, toHandlers(listeners));
}
function legacyRenderSlot(instance, name, fallback, props, bindObject) {
if (bindObject) {
props = mergeProps(props, bindObject);
}
return renderSlot(instance.slots, name, props, fallback && (() => fallback));
}
function legacyresolveScopedSlots(fns, raw, hasDynamicKeys) {
return createSlots(
raw || { $stable: !hasDynamicKeys },
mapKeyToName(fns)
);
}
function mapKeyToName(slots) {
for (let i = 0; i < slots.length; i++) {
const fn = slots[i];
if (fn) {
if (isArray(fn)) {
mapKeyToName(fn);
} else {
fn.name = fn.key || "default";
}
}
}
return slots;
}
const staticCacheMap = /* @__PURE__ */ new WeakMap();
function legacyRenderStatic(instance, index) {
let cache = staticCacheMap.get(instance);
if (!cache) {
staticCacheMap.set(instance, cache = []);
}
if (cache[index]) {
return cache[index];
}
const fn = instance.type.staticRenderFns[index];
const ctx = instance.proxy;
return cache[index] = fn.call(ctx, null, ctx);
}
function legacyCheckKeyCodes(instance, eventKeyCode, key, builtInKeyCode, eventKeyName, builtInKeyName) {
const config = instance.appContext.config;
const configKeyCodes = config.keyCodes || {};
const mappedKeyCode = configKeyCodes[key] || builtInKeyCode;
if (builtInKeyName && eventKeyName && !configKeyCodes[key]) {
return isKeyNotMatch(builtInKeyName, eventKeyName);
} else if (mappedKeyCode) {
return isKeyNotMatch(mappedKeyCode, eventKeyCode);
} else if (eventKeyName) {
return hyphenate(eventKeyName) !== key;
}
}
function isKeyNotMatch(expect, actual) {
if (isArray(expect)) {
return !expect.includes(actual);
} else {
return expect !== actual;
}
}
function legacyMarkOnce(tree) {
return tree;
}
function legacyBindDynamicKeys(props, values) {
for (let i = 0; i < values.length; i += 2) {
const key = values[i];
if (typeof key === "string" && key) {
props[values[i]] = values[i + 1];
}
}
return props;
}
function legacyPrependModifier(value, symbol) {
return typeof value === "string" ? symbol + value : value;
}
function installCompatInstanceProperties(map) {
const set = (target, key, val) => {
target[key] = val;
return target[key];
};
const del = (target, key) => {
delete target[key];
};
extend(map, {
$set: (i) => {
assertCompatEnabled("INSTANCE_SET", i);
return set;
},
$delete: (i) => {
assertCompatEnabled("INSTANCE_DELETE", i);
return del;
},
$mount: (i) => {
assertCompatEnabled(
"GLOBAL_MOUNT",
null
/* this warning is global */
);
return i.ctx._compat_mount || NOOP;
},
$destroy: (i) => {
assertCompatEnabled("INSTANCE_DESTROY", i);
return i.ctx._compat_destroy || NOOP;
},
// overrides existing accessor
$slots: (i) => {
if (isCompatEnabled$1("RENDER_FUNCTION", i) && i.render && i.render._compatWrapped) {
return new Proxy(i.slots, legacySlotProxyHandlers);
}
return i.slots;
},
$scopedSlots: (i) => {
assertCompatEnabled("INSTANCE_SCOPED_SLOTS", i);
const res = {};
for (const key in i.slots) {
const fn = i.slots[key];
if (!fn._ns) {
res[key] = fn;
}
}
return res;
},
$on: (i) => on.bind(null, i),
$once: (i) => once.bind(null, i),
$off: (i) => off.bind(null, i),
$children: getCompatChildren,
$listeners: getCompatListeners
});
if (isCompatEnabled$1("PRIVATE_APIS", null)) {
extend(map, {
// needed by many libs / render fns
$vnode: (i) => i.vnode,
// inject additional properties into $options for compat
// e.g. vuex needs this.$options.parent
$options: (i) => {
const res = extend({}, resolveMergedOptions(i));
res.parent = i.proxy.$parent;
res.propsData = i.vnode.props;
return res;
},
// some private properties that are likely accessed...
_self: (i) => i.proxy,
_uid: (i) => i.uid,
_data: (i) => i.data,
_isMounted: (i) => i.isMounted,
_isDestroyed: (i) => i.isUnmounted,
// v2 render helpers
$createElement: () => compatH,
_c: () => compatH,
_o: () => legacyMarkOnce,
_n: () => looseToNumber,
_s: () => toDisplayString,
_l: () => renderList,
_t: (i) => legacyRenderSlot.bind(null, i),
_q: () => looseEqual,
_i: () => looseIndexOf,
_m: (i) => legacyRenderStatic.bind(null, i),
_f: () => resolveFilter$1,
_k: (i) => legacyCheckKeyCodes.bind(null, i),
_b: () => legacyBindObjectProps,
_v: () => createTextVNode,
_e: () => createCommentVNode,
_u: () => legacyresolveScopedSlots,
_g: () => legacyBindObjectListeners,
_d: () => legacyBindDynamicKeys,
_p: () => legacyPrependModifier
});
}
}
const getPublicInstance = (i) => {
if (!i)
return null;
if (isStatefulComponent(i))
return getExposeProxy(i) || i.proxy;
return getPublicInstance(i.parent);
};
const publicPropertiesMap = (
// Move PURE marker to new line to workaround compiler discarding it
// due to type annotation
/* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
$: (i) => i,
$el: (i) => i.vnode.el,
$data: (i) => i.data,
$props: (i) => i.props,
$attrs: (i) => i.attrs,
$slots: (i) => i.slots,
$refs: (i) => i.refs,
$parent: (i) => getPublicInstance(i.parent),
$root: (i) => getPublicInstance(i.root),
$emit: (i) => i.emit,
$options: (i) => resolveMergedOptions(i) ,
$forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
$nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
$watch: (i) => instanceWatch.bind(i)
})
);
{
installCompatInstanceProperties(publicPropertiesMap);
}
const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
const PublicInstanceProxyHandlers = {
get({ _: instance }, key) {
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 1 /* SETUP */:
return setupState[key];
case 2 /* DATA */:
return data[key];
case 4 /* CONTEXT */:
return ctx[key];
case 3 /* PROPS */:
return props[key];
}
} else if (hasSetupBinding(setupState, key)) {
accessCache[key] = 1 /* SETUP */;
return setupState[key];
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
accessCache[key] = 2 /* DATA */;
return data[key];
} else if (
// only cache other properties when instance has declared (thus stable)
// props
(normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
) {
accessCache[key] = 3 /* PROPS */;
return props[key];
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4 /* CONTEXT */;
return ctx[key];
} else if (shouldCacheAccess) {
accessCache[key] = 0 /* OTHER */;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
track(instance, "get", key);
}
return publicGetter(instance);
} else if (
// css module (injected by vue-loader)
(cssModule = type.__cssModules) && (cssModule = cssModule[key])
) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4 /* CONTEXT */;
return ctx[key];
} else if (
// global properties
globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
) {
{
const desc = Object.getOwnPropertyDescriptor(globalProperties, key);
if (desc.get) {
return desc.get.call(instance.proxy);
} else {
const val = globalProperties[key];
return isFunction(val) ? Object.assign(val.bind(instance.proxy), val) : val;
}
}
} else ;
},
set({ _: instance }, key, value) {
const { data, setupState, ctx } = instance;
if (hasSetupBinding(setupState, key)) {
setupState[key] = value;
return true;
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
data[key] = value;
return true;
} else if (hasOwn(instance.props, key)) {
return false;
}
if (key[0] === "$" && key.slice(1) in instance) {
return false;
} else {
{
ctx[key] = value;
}
}
return true;
},
has({
_: { data, setupState, accessCache, ctx, appContext, propsOptions }
}, key) {
let normalizedProps;
return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
},
defineProperty(target, key, descriptor) {
if (descriptor.get != null) {
target._.accessCache[key] = 0;
} else if (hasOwn(descriptor, "value")) {
this.set(target, key, descriptor.value, null);
}
return Reflect.defineProperty(target, key, descriptor);
}
};
const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend(
{},
PublicInstanceProxyHandlers,
{
get(target, key) {
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has = key[0] !== "_" && !isGloballyAllowed(key);
return has;
}
}
);
function deepMergeData(to, from) {
for (const key in from) {
const toVal = to[key];
const fromVal = from[key];
if (key in to && isPlainObject(toVal) && isPlainObject(fromVal)) {
deepMergeData(toVal, fromVal);
} else {
to[key] = fromVal;
}
}
return to;
}
function defineProps() {
return null;
}
function defineEmits() {
return null;
}
function defineExpose(exposed) {
}
function defineOptions(options) {
}
function defineSlots() {
return null;
}
function defineModel() {
}
function withDefaults(props, defaults) {
return null;
}
function useSlots() {
return getContext().slots;
}
function useAttrs() {
return getContext().attrs;
}
function useModel(props, name, options) {
const i = getCurrentInstance();
if (options && options.local) {
const proxy = ref(props[name]);
watch(
() => props[name],
(v) => proxy.value = v
);
watch(proxy, (value) => {
if (value !== props[name]) {
i.emit(`update:${name}`, value);
}
});
return proxy;
} else {
return {
__v_isRef: true,
get value() {
return props[name];
},
set value(value) {
i.emit(`update:${name}`, value);
}
};
}
}
function getContext() {
const i = getCurrentInstance();
return i.setupContext || (i.setupContext = createSetupContext(i));
}
function normalizePropsOrEmits(props) {
return isArray(props) ? props.reduce(
(normalized, p) => (normalized[p] = null, normalized),
{}
) : props;
}
function mergeDefaults(raw, defaults) {
const props = normalizePropsOrEmits(raw);
for (const key in defaults) {
if (key.startsWith("__skip"))
continue;
let opt = props[key];
if (opt) {
if (isArray(opt) || isFunction(opt)) {
opt = props[key] = { type: opt, default: defaults[key] };
} else {
opt.default = defaults[key];
}
} else if (opt === null) {
opt = props[key] = { default: defaults[key] };
} else ;
if (opt && defaults[`__skip_${key}`]) {
opt.skipFactory = true;
}
}
return props;
}
function mergeModels(a, b) {
if (!a || !b)
return a || b;
if (isArray(a) && isArray(b))
return a.concat(b);
return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
}
function createPropsRestProxy(props, excludedKeys) {
const ret = {};
for (const key in props) {
if (!excludedKeys.includes(key)) {
Object.defineProperty(ret, key, {
enumerable: true,
get: () => props[key]
});
}
}
return ret;
}
function withAsyncContext(getAwaitable) {
const ctx = getCurrentInstance();
let awaitable = getAwaitable();
unsetCurrentInstance();
if (isPromise(awaitable)) {
awaitable = awaitable.catch((e) => {
setCurrentInstance(ctx);
throw e;
});
}
return [awaitable, () => setCurrentInstance(ctx)];
}
let shouldCacheAccess = true;
function applyOptions(instance) {
const options = resolveMergedOptions(instance);
const publicThis = instance.proxy;
const ctx = instance.ctx;
shouldCacheAccess = false;
if (options.beforeCreate) {
callHook$1(options.beforeCreate, instance, "bc");
}
const {
// state
data: dataOptions,
computed: computedOptions,
methods,
watch: watchOptions,
provide: provideOptions,
inject: injectOptions,
// lifecycle
created,
beforeMount,
mounted,
beforeUpdate,
updated,
activated,
deactivated,
beforeDestroy,
beforeUnmount,
destroyed,
unmounted,
render,
renderTracked,
renderTriggered,
errorCaptured,
serverPrefetch,
// public API
expose,
inheritAttrs,
// assets
components,
directives,
filters
} = options;
const checkDuplicateProperties = null;
if (injectOptions) {
resolveInjections(injectOptions, ctx, checkDuplicateProperties);
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (isFunction(methodHandler)) {
{
ctx[key] = methodHandler.bind(publicThis);
}
}
}
}
if (dataOptions) {
const data = dataOptions.call(publicThis, publicThis);
if (!isObject(data)) ; else {
instance.data = reactive(data);
}
}
shouldCacheAccess = true;
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : NOOP;
const c = computed({
get,
set
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: (v) => c.value = v
});
}
}
if (watchOptions) {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
}
if (provideOptions) {
const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
Reflect.ownKeys(provides).forEach((key) => {
provide(key, provides[key]);
});
}
if (created) {
callHook$1(created, instance, "c");
}
function registerLifecycleHook(register, hook) {
if (isArray(hook)) {
hook.forEach((_hook) => register(_hook.bind(publicThis)));
} else if (hook) {
register(hook.bind(publicThis));
}
}
registerLifecycleHook(onBeforeMount, beforeMount);
registerLifecycleHook(onMounted, mounted);
registerLifecycleHook(onBeforeUpdate, beforeUpdate);
registerLifecycleHook(onUpdated, updated);
registerLifecycleHook(onActivated, activated);
registerLifecycleHook(onDeactivated, deactivated);
registerLifecycleHook(onErrorCaptured, errorCaptured);
registerLifecycleHook(onRenderTracked, renderTracked);
registerLifecycleHook(onRenderTriggered, renderTriggered);
registerLifecycleHook(onBeforeUnmount, beforeUnmount);
registerLifecycleHook(onUnmounted, unmounted);
registerLifecycleHook(onServerPrefetch, serverPrefetch);
{
if (beforeDestroy && softAssertCompatEnabled("OPTIONS_BEFORE_DESTROY", instance)) {
registerLifecycleHook(onBeforeUnmount, beforeDestroy);
}
if (destroyed && softAssertCompatEnabled("OPTIONS_DESTROYED", instance)) {
registerLifecycleHook(onUnmounted, destroyed);
}
}
if (isArray(expose)) {
if (expose.length) {
const exposed = instance.exposed || (instance.exposed = {});
expose.forEach((key) => {
Object.defineProperty(exposed, key, {
get: () => publicThis[key],
set: (val) => publicThis[key] = val
});
});
} else if (!instance.exposed) {
instance.exposed = {};
}
}
if (render && instance.render === NOOP) {
instance.render = render;
}
if (inheritAttrs != null) {
instance.inheritAttrs = inheritAttrs;
}
if (components)
instance.components = components;
if (directives)
instance.directives = directives;
if (filters && isCompatEnabled$1("FILTERS", instance)) {
instance.filters = filters;
}
}
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
if (isArray(injectOptions)) {
injectOptions = normalizeInject(injectOptions);
}
for (const key in injectOptions) {
const opt = injectOptions[key];
let injected;
if (isObject(opt)) {
if ("default" in opt) {
injected = inject(
opt.from || key,
opt.default,
true
/* treat default function as factory */
);
} else {
injected = inject(opt.from || key);
}
} else {
injected = inject(opt);
}
if (isRef(injected)) {
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => injected.value,
set: (v) => injected.value = v
});
} else {
ctx[key] = injected;
}
}
}
function callHook$1(hook, instance, type) {
callWithAsyncErrorHandling(
isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
instance,
type
);
}
function createWatcher(raw, ctx, publicThis, key) {
const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
if (isString(raw)) {
const handler = ctx[raw];
if (isFunction(handler)) {
watch(getter, handler);
}
} else if (isFunction(raw)) {
watch(getter, raw.bind(publicThis));
} else if (isObject(raw)) {
if (isArray(raw)) {
raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
} else {
const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
if (isFunction(handler)) {
watch(getter, handler, raw);
}
}
} else ;
}
function resolveMergedOptions(instance) {
const base = instance.type;
const { mixins, extends: extendsOptions } = base;
const {
mixins: globalMixins,
optionsCache: cache,
config: { optionMergeStrategies }
} = instance.appContext;
const cached = cache.get(base);
let resolved;
if (cached) {
resolved = cached;
} else if (!globalMixins.length && !mixins && !extendsOptions) {
if (isCompatEnabled$1("PRIVATE_APIS", instance)) {
resolved = extend({}, base);
resolved.parent = instance.parent && instance.parent.proxy;
resolved.propsData = instance.vnode.props;
} else {
resolved = base;
}
} else {
resolved = {};
if (globalMixins.length) {
globalMixins.forEach(
(m) => mergeOptions(resolved, m, optionMergeStrategies, true)
);
}
mergeOptions(resolved, base, optionMergeStrategies);
}
if (isObject(base)) {
cache.set(base, resolved);
}
return resolved;
}
function mergeOptions(to, from, strats, asMixin = false) {
if (isFunction(from)) {
from = from.options;
}
const { mixins, extends: extendsOptions } = from;
if (extendsOptions) {
mergeOptions(to, extendsOptions, strats, true);
}
if (mixins) {
mixins.forEach(
(m) => mergeOptions(to, m, strats, true)
);
}
for (const key in from) {
if (asMixin && key === "expose") ; else {
const strat = internalOptionMergeStrats[key] || strats && strats[key];
to[key] = strat ? strat(to[key], from[key]) : from[key];
}
}
return to;
}
const internalOptionMergeStrats = {
data: mergeDataFn,
props: mergeEmitsOrPropsOptions,
emits: mergeEmitsOrPropsOptions,
// objects
methods: mergeObjectOptions,
computed: mergeObjectOptions,
// lifecycle
beforeCreate: mergeAsArray$1,
created: mergeAsArray$1,
beforeMount: mergeAsArray$1,
mounted: mergeAsArray$1,
beforeUpdate: mergeAsArray$1,
updated: mergeAsArray$1,
beforeDestroy: mergeAsArray$1,
beforeUnmount: mergeAsArray$1,
destroyed: mergeAsArray$1,
unmounted: mergeAsArray$1,
activated: mergeAsArray$1,
deactivated: mergeAsArray$1,
errorCaptured: mergeAsArray$1,
serverPrefetch: mergeAsArray$1,
// assets
components: mergeObjectOptions,
directives: mergeObjectOptions,
// watch
watch: mergeWatchOptions,
// provide / inject
provide: mergeDataFn,
inject: mergeInject
};
{
internalOptionMergeStrats.filters = mergeObjectOptions;
}
function mergeDataFn(to, from) {
if (!from) {
return to;
}
if (!to) {
return from;
}
return function mergedDataFn() {
return (isCompatEnabled$1("OPTIONS_DATA_MERGE", null) ? deepMergeData : extend)(
isFunction(to) ? to.call(this, this) : to,
isFunction(from) ? from.call(this, this) : from
);
};
}
function mergeInject(to, from) {
return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
}
function normalizeInject(raw) {
if (isArray(raw)) {
const res = {};
for (let i = 0; i < raw.length; i++) {
res[raw[i]] = raw[i];
}
return res;
}
return raw;
}
function mergeAsArray$1(to, from) {
return to ? [...new Set([].concat(to, from))] : from;
}
function mergeObjectOptions(to, from) {
return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
}
function mergeEmitsOrPropsOptions(to, from) {
if (to) {
if (isArray(to) && isArray(from)) {
return [.../* @__PURE__ */ new Set([...to, ...from])];
}
return extend(
/* @__PURE__ */ Object.create(null),
normalizePropsOrEmits(to),
normalizePropsOrEmits(from != null ? from : {})
);
} else {
return from;
}
}
function mergeWatchOptions(to, from) {
if (!to)
return from;
if (!from)
return to;
const merged = extend(/* @__PURE__ */ Object.create(null), to);
for (const key in from) {
merged[key] = mergeAsArray$1(to[key], from[key]);
}
return merged;
}
function installLegacyOptionMergeStrats(config) {
config.optionMergeStrategies = new Proxy({}, {
get(target, key) {
if (key in target) {
return target[key];
}
if (key in internalOptionMergeStrats && softAssertCompatEnabled(
"CONFIG_OPTION_MERGE_STRATS",
null
)) {
return internalOptionMergeStrats[key];
}
}
});
}
let singletonApp;
let singletonCtor;
function createCompatVue$1(createApp, createSingletonApp) {
singletonApp = createSingletonApp({});
const Vue = singletonCtor = function Vue2(options = {}) {
return createCompatApp(options, Vue2);
};
function createCompatApp(options = {}, Ctor) {
assertCompatEnabled("GLOBAL_MOUNT", null);
const { data } = options;
if (data && !isFunction(data) && softAssertCompatEnabled("OPTIONS_DATA_FN", null)) {
options.data = () => data;
}
const app = createApp(options);
if (Ctor !== Vue) {
applySingletonPrototype(app, Ctor);
}
const vm = app._createRoot(options);
if (options.el) {
return vm.$mount(options.el);
} else {
return vm;
}
}
Vue.version = `2.6.14-compat:${"3.3.13"}`;
Vue.config = singletonApp.config;
Vue.use = (p, ...options) => {
if (p && isFunction(p.install)) {
p.install(Vue, ...options);
} else if (isFunction(p)) {
p(Vue, ...options);
}
return Vue;
};
Vue.mixin = (m) => {
singletonApp.mixin(m);
return Vue;
};
Vue.component = (name, comp) => {
if (comp) {
singletonApp.component(name, comp);
return Vue;
} else {
return singletonApp.component(name);
}
};
Vue.directive = (name, dir) => {
if (dir) {
singletonApp.directive(name, dir);
return Vue;
} else {
return singletonApp.directive(name);
}
};
Vue.options = { _base: Vue };
let cid = 1;
Vue.cid = cid;
Vue.nextTick = nextTick;
const extendCache = /* @__PURE__ */ new WeakMap();
function extendCtor(extendOptions = {}) {
assertCompatEnabled("GLOBAL_EXTEND", null);
if (isFunction(extendOptions)) {
extendOptions = extendOptions.options;
}
if (extendCache.has(extendOptions)) {
return extendCache.get(extendOptions);
}
const Super = this;
function SubVue(inlineOptions) {
if (!inlineOptions) {
return createCompatApp(SubVue.options, SubVue);
} else {
return createCompatApp(
mergeOptions(
extend({}, SubVue.options),
inlineOptions,
internalOptionMergeStrats
),
SubVue
);
}
}
SubVue.super = Super;
SubVue.prototype = Object.create(Vue.prototype);
SubVue.prototype.constructor = SubVue;
const mergeBase = {};
for (const key in Super.options) {
const superValue = Super.options[key];
mergeBase[key] = isArray(superValue) ? superValue.slice() : isObject(superValue) ? extend(/* @__PURE__ */ Object.create(null), superValue) : superValue;
}
SubVue.options = mergeOptions(
mergeBase,
extendOptions,
internalOptionMergeStrats
);
SubVue.options._base = SubVue;
SubVue.extend = extendCtor.bind(SubVue);
SubVue.mixin = Super.mixin;
SubVue.use = Super.use;
SubVue.cid = ++cid;
extendCache.set(extendOptions, SubVue);
return SubVue;
}
Vue.extend = extendCtor.bind(Vue);
Vue.set = (target, key, value) => {
assertCompatEnabled("GLOBAL_SET", null);
target[key] = value;
};
Vue.delete = (target, key) => {
assertCompatEnabled("GLOBAL_DELETE", null);
delete target[key];
};
Vue.observable = (target) => {
assertCompatEnabled("GLOBAL_OBSERVABLE", null);
return reactive(target);
};
Vue.filter = (name, filter) => {
if (filter) {
singletonApp.filter(name, filter);
return Vue;
} else {
return singletonApp.filter(name);
}
};
const util = {
warn: NOOP,
extend,
mergeOptions: (parent, child, vm) => mergeOptions(
parent,
child,
vm ? void 0 : internalOptionMergeStrats
),
defineReactive
};
Object.defineProperty(Vue, "util", {
get() {
assertCompatEnabled("GLOBAL_PRIVATE_UTIL", null);
return util;
}
});
Vue.configureCompat = configureCompat;
return Vue;
}
function installAppCompatProperties(app, context, render) {
installFilterMethod(app, context);
installLegacyOptionMergeStrats(app.config);
if (!singletonApp) {
return;
}
installCompatMount(app, context, render);
installLegacyAPIs(app);
applySingletonAppMutations(app);
}
function installFilterMethod(app, context) {
context.filters = {};
app.filter = (name, filter) => {
assertCompatEnabled("FILTERS", null);
if (!filter) {
return context.filters[name];
}
context.filters[name] = filter;
return app;
};
}
function installLegacyAPIs(app) {
Object.defineProperties(app, {
// so that app.use() can work with legacy plugins that extend prototypes
prototype: {
get() {
return app.config.globalProperties;
}
},
nextTick: { value: nextTick },
extend: { value: singletonCtor.extend },
set: { value: singletonCtor.set },
delete: { value: singletonCtor.delete },
observable: { value: singletonCtor.observable },
util: {
get() {
return singletonCtor.util;
}
}
});
}
function applySingletonAppMutations(app) {
app._context.mixins = [...singletonApp._context.mixins];
["components", "directives", "filters"].forEach((key) => {
app._context[key] = Object.create(singletonApp._context[key]);
});
for (const key in singletonApp.config) {
if (key === "isNativeTag")
continue;
if (isRuntimeOnly() && (key === "isCustomElement" || key === "compilerOptions")) {
continue;
}
const val = singletonApp.config[key];
app.config[key] = isObject(val) ? Object.create(val) : val;
if (key === "ignoredElements" && isCompatEnabled$1("CONFIG_IGNORED_ELEMENTS", null) && !isRuntimeOnly() && isArray(val)) {
app.config.compilerOptions.isCustomElement = (tag) => {
return val.some((v) => isString(v) ? v === tag : v.test(tag));
};
}
}
applySingletonPrototype(app, singletonCtor);
}
function applySingletonPrototype(app, Ctor) {
const enabled = isCompatEnabled$1("GLOBAL_PROTOTYPE", null);
if (enabled) {
app.config.globalProperties = Object.create(Ctor.prototype);
}
const descriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
for (const key in descriptors) {
if (key !== "constructor") {
if (enabled) {
Object.defineProperty(
app.config.globalProperties,
key,
descriptors[key]
);
}
}
}
}
function installCompatMount(app, context, render) {
let isMounted = false;
app._createRoot = (options) => {
const component = app._component;
const vnode = createVNode(component, options.propsData || null);
vnode.appContext = context;
const hasNoRender = !isFunction(component) && !component.render && !component.template;
const emptyRender = () => {
};
const instance = createComponentInstance(vnode, null, null);
if (hasNoRender) {
instance.render = emptyRender;
}
setupComponent(instance);
vnode.component = instance;
vnode.isCompatRoot = true;
instance.ctx._compat_mount = (selectorOrEl) => {
if (isMounted) {
return;
}
let container;
if (typeof selectorOrEl === "string") {
const result = document.querySelector(selectorOrEl);
if (!result) {
return;
}
container = result;
} else {
container = selectorOrEl || document.createElement("div");
}
const isSVG = container instanceof SVGElement;
if (hasNoRender && instance.render === emptyRender) {
instance.render = null;
component.template = container.innerHTML;
finishComponentSetup(
instance,
false,
true
/* skip options */
);
}
container.innerHTML = "";
render(vnode, container, isSVG);
if (container instanceof Element) {
container.removeAttribute("v-cloak");
container.setAttribute("data-v-app", "");
}
isMounted = true;
app._container = container;
container.__vue_app__ = app;
return instance.proxy;
};
instance.ctx._compat_destroy = () => {
if (isMounted) {
render(null, app._container);
delete app._container.__vue_app__;
} else {
const { bum, scope, um } = instance;
if (bum) {
invokeArrayFns(bum);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
instance.emit("hook:beforeDestroy");
}
if (scope) {
scope.stop();
}
if (um) {
invokeArrayFns(um);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
instance.emit("hook:destroyed");
}
}
};
return instance.proxy;
};
}
const methodsToPatch = [
"push",
"pop",
"shift",
"unshift",
"splice",
"sort",
"reverse"
];
const patched = /* @__PURE__ */ new WeakSet();
function defineReactive(obj, key, val) {
if (isObject(val) && !isReactive(val) && !patched.has(val)) {
const reactiveVal = reactive(val);
if (isArray(val)) {
methodsToPatch.forEach((m) => {
val[m] = (...args) => {
Array.prototype[m].call(reactiveVal, ...args);
};
});
} else {
Object.keys(val).forEach((key2) => {
try {
defineReactiveSimple(val, key2, val[key2]);
} catch (e) {
}
});
}
}
const i = obj.$;
if (i && obj === i.proxy) {
defineReactiveSimple(i.ctx, key, val);
i.accessCache = /* @__PURE__ */ Object.create(null);
} else if (isReactive(obj)) {
obj[key] = val;
} else {
defineReactiveSimple(obj, key, val);
}
}
function defineReactiveSimple(obj, key, val) {
val = isObject(val) ? reactive(val) : val;
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get() {
track(obj, "get", key);
return val;
},
set(newVal) {
val = isObject(newVal) ? reactive(newVal) : newVal;
trigger(obj, "set", key, newVal);
}
});
}
function createAppContext() {
return {
app: null,
config: {
isNativeTag: NO,
performance: false,
globalProperties: {},
optionMergeStrategies: {},
errorHandler: void 0,
warnHandler: void 0,
compilerOptions: {}
},
mixins: [],
components: {},
directives: {},
provides: /* @__PURE__ */ Object.create(null),
optionsCache: /* @__PURE__ */ new WeakMap(),
propsCache: /* @__PURE__ */ new WeakMap(),
emitsCache: /* @__PURE__ */ new WeakMap()
};
}
let uid$1 = 0;
function createAppAPI(render, hydrate) {
return function createApp(rootComponent, rootProps = null) {
if (!isFunction(rootComponent)) {
rootComponent = extend({}, rootComponent);
}
if (rootProps != null && !isObject(rootProps)) {
rootProps = null;
}
const context = createAppContext();
const installedPlugins = /* @__PURE__ */ new WeakSet();
let isMounted = false;
const app = context.app = {
_uid: uid$1++,
_component: rootComponent,
_props: rootProps,
_container: null,
_context: context,
_instance: null,
version,
get config() {
return context.config;
},
set config(v) {
},
use(plugin, ...options) {
if (installedPlugins.has(plugin)) ; else if (plugin && isFunction(plugin.install)) {
installedPlugins.add(plugin);
plugin.install(app, ...options);
} else if (isFunction(plugin)) {
installedPlugins.add(plugin);
plugin(app, ...options);
} else ;
return app;
},
mixin(mixin) {
{
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
}
}
return app;
},
component(name, component) {
if (!component) {
return context.components[name];
}
context.components[name] = component;
return app;
},
directive(name, directive) {
if (!directive) {
return context.directives[name];
}
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate, isSVG) {
if (!isMounted) {
const vnode = createVNode(rootComponent, rootProps);
vnode.appContext = context;
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
} else {
render(vnode, rootContainer, isSVG);
}
isMounted = true;
app._container = rootContainer;
rootContainer.__vue_app__ = app;
return getExposeProxy(vnode.component) || vnode.component.proxy;
}
},
unmount() {
if (isMounted) {
render(null, app._container);
delete app._container.__vue_app__;
}
},
provide(key, value) {
context.provides[key] = value;
return app;
},
runWithContext(fn) {
currentApp = app;
try {
return fn();
} finally {
currentApp = null;
}
}
};
{
installAppCompatProperties(app, context, render);
}
return app;
};
}
let currentApp = null;
function provide(key, value) {
if (!currentInstance) ; else {
let provides = currentInstance.provides;
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
provides[key] = value;
}
}
function inject(key, defaultValue, treatDefaultAsFactory = false) {
const instance = currentInstance || currentRenderingInstance;
if (instance || currentApp) {
const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
if (provides && key in provides) {
return provides[key];
} else if (arguments.length > 1) {
return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
} else ;
}
}
function hasInjectionContext() {
return !!(currentInstance || currentRenderingInstance || currentApp);
}
function createPropsDefaultThis(instance, rawProps, propKey) {
return new Proxy(
{},
{
get(_, key) {
if (key === "$options") {
return resolveMergedOptions(instance);
}
if (key in rawProps) {
return rawProps[key];
}
const injections = instance.type.inject;
if (injections) {
if (isArray(injections)) {
if (injections.includes(key)) {
return inject(key);
}
} else if (key in injections) {
return inject(key);
}
}
}
}
);
}
function shouldSkipAttr(key, instance) {
if (key === "is") {
return true;
}
if ((key === "class" || key === "style") && isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance)) {
return true;
}
if (isOn(key) && isCompatEnabled$1("INSTANCE_LISTENERS", instance)) {
return true;
}
if (key.startsWith("routerView") || key === "registerRouteInstance") {
return true;
}
return false;
}
function initProps(instance, rawProps, isStateful, isSSR = false) {
const props = {};
const attrs = {};
def(attrs, InternalObjectKey, 1);
instance.propsDefaults = /* @__PURE__ */ Object.create(null);
setFullProps(instance, rawProps, props, attrs);
for (const key in instance.propsOptions[0]) {
if (!(key in props)) {
props[key] = void 0;
}
}
if (isStateful) {
instance.props = isSSR ? props : shallowReactive(props);
} else {
if (!instance.type.props) {
instance.props = attrs;
} else {
instance.props = props;
}
}
instance.attrs = attrs;
}
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const {
props,
attrs,
vnode: { patchFlag }
} = instance;
const rawCurrentProps = toRaw(props);
const [options] = instance.propsOptions;
let hasAttrsChanged = false;
if (
// always force full diff in dev
// - #1942 if hmr is enabled with sfc component
// - vite#872 non-sfc component used by sfc component
(optimized || patchFlag > 0) && !(patchFlag & 16)
) {
if (patchFlag & 8) {
const propsToUpdate = instance.vnode.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
let key = propsToUpdate[i];
if (isEmitListener(instance.emitsOptions, key)) {
continue;
}
const value = rawProps[key];
if (options) {
if (hasOwn(attrs, key)) {
if (value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
} else {
const camelizedKey = camelize(key);
props[camelizedKey] = resolvePropValue(
options,
rawCurrentProps,
camelizedKey,
value,
instance,
false
/* isAbsent */
);
}
} else {
{
if (isOn(key) && key.endsWith("Native")) {
key = key.slice(0, -6);
} else if (shouldSkipAttr(key, instance)) {
continue;
}
}
if (value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
}
}
}
} else {
if (setFullProps(instance, rawProps, props, attrs)) {
hasAttrsChanged = true;
}
let kebabKey;
for (const key in rawCurrentProps) {
if (!rawProps || // for camelCase
!hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
// and converted to camelCase (#955)
((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
if (options) {
if (rawPrevProps && // for camelCase
(rawPrevProps[key] !== void 0 || // for kebab-case
rawPrevProps[kebabKey] !== void 0)) {
props[key] = resolvePropValue(
options,
rawCurrentProps,
key,
void 0,
instance,
true
/* isAbsent */
);
}
} else {
delete props[key];
}
}
}
if (attrs !== rawCurrentProps) {
for (const key in attrs) {
if (!rawProps || !hasOwn(rawProps, key) && !hasOwn(rawProps, key + "Native")) {
delete attrs[key];
hasAttrsChanged = true;
}
}
}
}
if (hasAttrsChanged) {
trigger(instance, "set", "$attrs");
}
}
function setFullProps(instance, rawProps, props, attrs) {
const [options, needCastKeys] = instance.propsOptions;
let hasAttrsChanged = false;
let rawCastValues;
if (rawProps) {
for (let key in rawProps) {
if (isReservedProp(key)) {
continue;
}
{
if (key.startsWith("onHook:")) {
softAssertCompatEnabled(
"INSTANCE_EVENT_HOOKS",
instance,
key.slice(2).toLowerCase()
);
}
if (key === "inline-template") {
continue;
}
}
const value = rawProps[key];
let camelKey;
if (options && hasOwn(options, camelKey = camelize(key))) {
if (!needCastKeys || !needCastKeys.includes(camelKey)) {
props[camelKey] = value;
} else {
(rawCastValues || (rawCastValues = {}))[camelKey] = value;
}
} else if (!isEmitListener(instance.emitsOptions, key)) {
{
if (isOn(key) && key.endsWith("Native")) {
key = key.slice(0, -6);
} else if (shouldSkipAttr(key, instance)) {
continue;
}
}
if (!(key in attrs) || value !== attrs[key]) {
attrs[key] = value;
hasAttrsChanged = true;
}
}
}
}
if (needCastKeys) {
const rawCurrentProps = toRaw(props);
const castValues = rawCastValues || EMPTY_OBJ;
for (let i = 0; i < needCastKeys.length; i++) {
const key = needCastKeys[i];
props[key] = resolvePropValue(
options,
rawCurrentProps,
key,
castValues[key],
instance,
!hasOwn(castValues, key)
);
}
}
return hasAttrsChanged;
}
function resolvePropValue(options, props, key, value, instance, isAbsent) {
const opt = options[key];
if (opt != null) {
const hasDefault = hasOwn(opt, "default");
if (hasDefault && value === void 0) {
const defaultValue = opt.default;
if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
const { propsDefaults } = instance;
if (key in propsDefaults) {
value = propsDefaults[key];
} else {
setCurrentInstance(instance);
value = propsDefaults[key] = defaultValue.call(
isCompatEnabled$1("PROPS_DEFAULT_THIS", instance) ? createPropsDefaultThis(instance, props) : null,
props
);
unsetCurrentInstance();
}
} else {
value = defaultValue;
}
}
if (opt[0 /* shouldCast */]) {
if (isAbsent && !hasDefault) {
value = false;
} else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
value = true;
}
}
}
return value;
}
function normalizePropsOptions(comp, appContext, asMixin = false) {
const cache = appContext.propsCache;
const cached = cache.get(comp);
if (cached) {
return cached;
}
const raw = comp.props;
const normalized = {};
const needCastKeys = [];
let hasExtends = false;
if (!isFunction(comp)) {
const extendProps = (raw2) => {
if (isFunction(raw2)) {
raw2 = raw2.options;
}
hasExtends = true;
const [props, keys] = normalizePropsOptions(raw2, appContext, true);
extend(normalized, props);
if (keys)
needCastKeys.push(...keys);
};
if (!asMixin && appContext.mixins.length) {
appContext.mixins.forEach(extendProps);
}
if (comp.extends) {
extendProps(comp.extends);
}
if (comp.mixins) {
comp.mixins.forEach(extendProps);
}
}
if (!raw && !hasExtends) {
if (isObject(comp)) {
cache.set(comp, EMPTY_ARR);
}
return EMPTY_ARR;
}
if (isArray(raw)) {
for (let i = 0; i < raw.length; i++) {
const normalizedKey = camelize(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = EMPTY_OBJ;
}
}
} else if (raw) {
for (const key in raw) {
const normalizedKey = camelize(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
if (prop) {
const booleanIndex = getTypeIndex(Boolean, prop.type);
const stringIndex = getTypeIndex(String, prop.type);
prop[0 /* shouldCast */] = booleanIndex > -1;
prop[1 /* shouldCastTrue */] = stringIndex < 0 || booleanIndex < stringIndex;
if (booleanIndex > -1 || hasOwn(prop, "default")) {
needCastKeys.push(normalizedKey);
}
}
}
}
}
const res = [normalized, needCastKeys];
if (isObject(comp)) {
cache.set(comp, res);
}
return res;
}
function validatePropName(key) {
if (key[0] !== "$") {
return true;
}
return false;
}
function getType(ctor) {
const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
return match ? match[2] : ctor === null ? "null" : "";
}
function isSameType(a, b) {
return getType(a) === getType(b);
}
function getTypeIndex(type, expectedTypes) {
if (isArray(expectedTypes)) {
return expectedTypes.findIndex((t) => isSameType(t, type));
} else if (isFunction(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1;
}
return -1;
}
const isInternalKey = (key) => key[0] === "_" || key === "$stable";
const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => {
if (rawSlot._n) {
return rawSlot;
}
const normalized = withCtx((...args) => {
if (false) ;
return normalizeSlotValue(rawSlot(...args));
}, ctx);
normalized._c = false;
return normalized;
};
const normalizeObjectSlots = (rawSlots, slots, instance) => {
const ctx = rawSlots._ctx;
for (const key in rawSlots) {
if (isInternalKey(key))
continue;
const value = rawSlots[key];
if (isFunction(value)) {
slots[key] = normalizeSlot(key, value, ctx);
} else if (value != null) {
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const initSlots = (instance, children) => {
if (instance.vnode.shapeFlag & 32) {
const type = children._;
if (type) {
instance.slots = toRaw(children);
def(children, "_", type);
} else {
normalizeObjectSlots(
children,
instance.slots = {});
}
} else {
instance.slots = {};
if (children) {
normalizeVNodeSlots(instance, children);
}
}
def(instance.slots, InternalObjectKey, 1);
};
const updateSlots = (instance, children, optimized) => {
const { vnode, slots } = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32) {
const type = children._;
if (type) {
if (optimized && type === 1) {
needDeletionCheck = false;
} else {
extend(slots, children);
if (!optimized && type === 1) {
delete slots._;
}
}
} else {
needDeletionCheck = !children.$stable;
normalizeObjectSlots(children, slots);
}
deletionComparisonTarget = children;
} else if (children) {
normalizeVNodeSlots(instance, children);
deletionComparisonTarget = { default: 1 };
}
if (needDeletionCheck) {
for (const key in slots) {
if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
delete slots[key];
}
}
}
};
function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
if (isArray(rawRef)) {
rawRef.forEach(
(r, i) => setRef(
r,
oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
parentSuspense,
vnode,
isUnmount
)
);
return;
}
if (isAsyncWrapper(vnode) && !isUnmount) {
return;
}
const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
const value = isUnmount ? null : refValue;
const { i: owner, r: ref } = rawRef;
const oldRef = oldRawRef && oldRawRef.r;
const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
const setupState = owner.setupState;
if (oldRef != null && oldRef !== ref) {
if (isString(oldRef)) {
refs[oldRef] = null;
if (hasOwn(setupState, oldRef)) {
setupState[oldRef] = null;
}
} else if (isRef(oldRef)) {
oldRef.value = null;
}
}
if (isFunction(ref)) {
callWithErrorHandling(ref, owner, 12, [value, refs]);
} else {
const _isString = isString(ref);
const _isRef = isRef(ref);
if (_isString || _isRef) {
const doSet = () => {
if (rawRef.f) {
const existing = _isString ? hasOwn(setupState, ref) ? setupState[ref] : refs[ref] : ref.value;
if (isUnmount) {
isArray(existing) && remove(existing, refValue);
} else {
if (!isArray(existing)) {
if (_isString) {
refs[ref] = [refValue];
if (hasOwn(setupState, ref)) {
setupState[ref] = refs[ref];
}
} else {
ref.value = [refValue];
if (rawRef.k)
refs[rawRef.k] = ref.value;
}
} else if (!existing.includes(refValue)) {
existing.push(refValue);
}
}
} else if (_isString) {
refs[ref] = value;
if (hasOwn(setupState, ref)) {
setupState[ref] = value;
}
} else if (_isRef) {
ref.value = value;
if (rawRef.k)
refs[rawRef.k] = value;
} else ;
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
} else {
doSet();
}
}
}
}
let hasMismatch = false;
const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== "foreignObject";
const isComment = (node) => node.nodeType === 8 /* COMMENT */;
function createHydrationFunctions(rendererInternals) {
const {
mt: mountComponent,
p: patch,
o: {
patchProp,
createText,
nextSibling,
parentNode,
remove,
insert,
createComment
}
} = rendererInternals;
const hydrate = (vnode, container) => {
if (!container.hasChildNodes()) {
patch(null, vnode, container);
flushPostFlushCbs();
container._vnode = vnode;
return;
}
hasMismatch = false;
hydrateNode(container.firstChild, vnode, null, null, null);
flushPostFlushCbs();
container._vnode = vnode;
if (hasMismatch && true) {
console.error(`Hydration completed but contains mismatches.`);
}
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
const isFragmentStart = isComment(node) && node.data === "[";
const onMismatch = () => handleMismatch(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
isFragmentStart
);
const { type, ref, shapeFlag, patchFlag } = vnode;
let domType = node.nodeType;
vnode.el = node;
if (patchFlag === -2) {
optimized = false;
vnode.dynamicChildren = null;
}
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3 /* TEXT */) {
if (vnode.children === "") {
insert(vnode.el = createText(""), parentNode(node), node);
nextNode = node;
} else {
nextNode = onMismatch();
}
} else {
if (node.data !== vnode.children) {
hasMismatch = true;
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (isTemplateNode(node)) {
nextNode = nextSibling(node);
replaceNode(
vnode.el = node.content.firstChild,
node,
parentComponent
);
} else if (domType !== 8 /* COMMENT */ || isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = nextSibling(node);
}
break;
case Static:
if (isFragmentStart) {
node = nextSibling(node);
domType = node.nodeType;
}
if (domType === 1 /* ELEMENT */ || domType === 3 /* TEXT */) {
nextNode = node;
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.nodeType === 1 /* ELEMENT */ ? nextNode.outerHTML : nextNode.data;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return isFragmentStart ? nextSibling(nextNode) : nextNode;
} else {
onMismatch();
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = hydrateFragment(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
break;
default:
if (shapeFlag & 1) {
if ((domType !== 1 /* ELEMENT */ || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
nextNode = onMismatch();
} else {
nextNode = hydrateElement(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
} else if (shapeFlag & 6) {
vnode.slotScopeIds = slotScopeIds;
const container = parentNode(node);
if (isFragmentStart) {
nextNode = locateClosingAnchor(node);
} else if (isComment(node) && node.data === "teleport start") {
nextNode = locateClosingAnchor(node, node.data, "teleport end");
} else {
nextNode = nextSibling(node);
}
mountComponent(
vnode,
container,
null,
parentComponent,
parentSuspense,
isSVGContainer(container),
optimized
);
if (isAsyncWrapper(vnode)) {
let subTree;
if (isFragmentStart) {
subTree = createVNode(Fragment);
subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
} else {
subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
}
subTree.el = node;
vnode.component.subTree = subTree;
}
} else if (shapeFlag & 64) {
if (domType !== 8 /* COMMENT */) {
nextNode = onMismatch();
} else {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized,
rendererInternals,
hydrateChildren
);
}
} else if (shapeFlag & 128) {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
isSVGContainer(parentNode(node)),
slotScopeIds,
optimized,
rendererInternals,
hydrateNode
);
} else ;
}
if (ref != null) {
setRef(ref, null, parentSuspense, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
const forcePatch = type === "input" || type === "option";
if (forcePatch || patchFlag !== -1) {
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
let needCallTransitionHooks = false;
if (isTemplateNode(el)) {
needCallTransitionHooks = needTransition(parentSuspense, transition) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
const content = el.content.firstChild;
if (needCallTransitionHooks) {
transition.beforeEnter(content);
}
replaceNode(content, el, parentComponent);
vnode.el = el = content;
}
if (props) {
if (forcePatch || !optimized || patchFlag & (16 | 32)) {
for (const key in props) {
if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers
key[0] === ".") {
patchProp(
el,
key,
null,
props[key],
false,
void 0,
parentComponent
);
}
}
} else if (props.onClick) {
patchProp(
el,
"onClick",
null,
props.onClick,
false,
void 0,
parentComponent
);
}
}
let vnodeHooks;
if (vnodeHooks = props && props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
if (shapeFlag & 16 && // skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(
el.firstChild,
vnode,
el,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
while (next) {
hasMismatch = true;
const cur = next;
next = next.nextSibling;
remove(cur);
}
} else if (shapeFlag & 8) {
if (el.textContent !== vnode.children) {
hasMismatch = true;
el.textContent = vnode.children;
}
}
}
return el.nextSibling;
};
const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!parentVNode.dynamicChildren;
const children = parentVNode.children;
const l = children.length;
for (let i = 0; i < l; i++) {
const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
if (node) {
node = hydrateNode(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
} else if (vnode.type === Text && !vnode.children) {
continue;
} else {
hasMismatch = true;
patch(
null,
vnode,
container,
null,
parentComponent,
parentSuspense,
isSVGContainer(container),
slotScopeIds
);
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
const { slotScopeIds: fragmentSlotScopeIds } = vnode;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
const container = parentNode(node);
const next = hydrateChildren(
nextSibling(node),
vnode,
container,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
if (next && isComment(next) && next.data === "]") {
return nextSibling(vnode.anchor = next);
} else {
hasMismatch = true;
insert(vnode.anchor = createComment(`]`), container, next);
return next;
}
};
const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
hasMismatch = true;
vnode.el = null;
if (isFragment) {
const end = locateClosingAnchor(node);
while (true) {
const next2 = nextSibling(node);
if (next2 && next2 !== end) {
remove(next2);
} else {
break;
}
}
}
const next = nextSibling(node);
const container = parentNode(node);
remove(node);
patch(
null,
vnode,
container,
next,
parentComponent,
parentSuspense,
isSVGContainer(container),
slotScopeIds
);
return next;
};
const locateClosingAnchor = (node, open = "[", close = "]") => {
let match = 0;
while (node) {
node = nextSibling(node);
if (node && isComment(node)) {
if (node.data === open)
match++;
if (node.data === close) {
if (match === 0) {
return nextSibling(node);
} else {
match--;
}
}
}
}
return node;
};
const replaceNode = (newNode, oldNode, parentComponent) => {
const parentNode2 = oldNode.parentNode;
if (parentNode2) {
parentNode2.replaceChild(newNode, oldNode);
}
let parent = parentComponent;
while (parent) {
if (parent.vnode.el === oldNode) {
parent.vnode.el = parent.subTree.el = newNode;
}
parent = parent.parent;
}
};
const isTemplateNode = (node) => {
return node.nodeType === 1 /* ELEMENT */ && node.tagName.toLowerCase() === "template";
};
return [hydrate, hydrateNode];
}
const queuePostRenderEffect = queueEffectWithSuspense ;
function createRenderer(options) {
return baseCreateRenderer(options);
}
function createHydrationRenderer(options) {
return baseCreateRenderer(options, createHydrationFunctions);
}
function baseCreateRenderer(options, createHydrationFns) {
const target = getGlobalThis();
target.__VUE__ = true;
const {
insert: hostInsert,
remove: hostRemove,
patchProp: hostPatchProp,
createElement: hostCreateElement,
createText: hostCreateText,
createComment: hostCreateComment,
setText: hostSetText,
setElementText: hostSetElementText,
parentNode: hostParentNode,
nextSibling: hostNextSibling,
setScopeId: hostSetScopeId = NOOP,
insertStaticContent: hostInsertStaticContent
} = options;
const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = !!n2.dynamicChildren) => {
if (n1 === n2) {
return;
}
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
}
if (n2.patchFlag === -2) {
optimized = false;
n2.dynamicChildren = null;
}
const { type, ref, shapeFlag } = n2;
switch (type) {
case Text:
processText(n1, n2, container, anchor);
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, isSVG);
}
break;
case Fragment:
processFragment(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
break;
default:
if (shapeFlag & 1) {
processElement(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else if (shapeFlag & 6) {
processComponent(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else if (shapeFlag & 64) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized,
internals
);
} else if (shapeFlag & 128) {
type.process(
n1,
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized,
internals
);
} else ;
}
if (ref != null && parentComponent) {
setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateText(n2.children),
container,
anchor
);
} else {
const el = n2.el = n1.el;
if (n2.children !== n1.children) {
hostSetText(el, n2.children);
}
}
};
const processCommentNode = (n1, n2, container, anchor) => {
if (n1 == null) {
hostInsert(
n2.el = hostCreateComment(n2.children || ""),
container,
anchor
);
} else {
n2.el = n1.el;
}
};
const mountStaticNode = (n2, container, anchor, isSVG) => {
[n2.el, n2.anchor] = hostInsertStaticContent(
n2.children,
container,
anchor,
isSVG,
n2.el,
n2.anchor
);
};
const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostInsert(el, container, nextSibling);
el = next;
}
hostInsert(anchor, container, nextSibling);
};
const removeStaticNode = ({ el, anchor }) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
hostRemove(el);
el = next;
}
hostRemove(anchor);
};
const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
isSVG = isSVG || n2.type === "svg";
if (n1 == null) {
mountElement(
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else {
patchElement(
n1,
n2,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
};
const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
let el;
let vnodeHook;
const { type, props, shapeFlag, transition, dirs } = vnode;
el = vnode.el = hostCreateElement(
vnode.type,
isSVG,
props && props.is,
props
);
if (shapeFlag & 8) {
hostSetElementText(el, vnode.children);
} else if (shapeFlag & 16) {
mountChildren(
vnode.children,
el,
null,
parentComponent,
parentSuspense,
isSVG && type !== "foreignObject",
slotScopeIds,
optimized
);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
if (props) {
for (const key in props) {
if (key !== "value" && !isReservedProp(key)) {
hostPatchProp(
el,
key,
null,
props[key],
isSVG,
vnode.children,
parentComponent,
parentSuspense,
unmountChildren
);
}
}
if ("value" in props) {
hostPatchProp(el, "value", null, props.value);
}
if (vnodeHook = props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
const needCallTransitionHooks = needTransition(parentSuspense, transition);
if (needCallTransitionHooks) {
transition.beforeEnter(el);
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
};
const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
if (scopeId) {
hostSetScopeId(el, scopeId);
}
if (slotScopeIds) {
for (let i = 0; i < slotScopeIds.length; i++) {
hostSetScopeId(el, slotScopeIds[i]);
}
}
if (parentComponent) {
let subTree = parentComponent.subTree;
if (vnode === subTree) {
const parentVNode = parentComponent.vnode;
setScopeId(
el,
parentVNode,
parentVNode.scopeId,
parentVNode.slotScopeIds,
parentComponent.parent
);
}
}
};
const mountChildren = (children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, start = 0) => {
for (let i = start; i < children.length; i++) {
const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
patch(
null,
child,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
};
const patchElement = (n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
const el = n2.el = n1.el;
let { patchFlag, dynamicChildren, dirs } = n2;
patchFlag |= n1.patchFlag & 16;
const oldProps = n1.props || EMPTY_OBJ;
const newProps = n2.props || EMPTY_OBJ;
let vnodeHook;
parentComponent && toggleRecurse(parentComponent, false);
if (vnodeHook = newProps.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
}
parentComponent && toggleRecurse(parentComponent, true);
const areChildrenSVG = isSVG && n2.type !== "foreignObject";
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
el,
parentComponent,
parentSuspense,
areChildrenSVG,
slotScopeIds
);
} else if (!optimized) {
patchChildren(
n1,
n2,
el,
null,
parentComponent,
parentSuspense,
areChildrenSVG,
slotScopeIds,
false
);
}
if (patchFlag > 0) {
if (patchFlag & 16) {
patchProps(
el,
n2,
oldProps,
newProps,
parentComponent,
parentSuspense,
isSVG
);
} else {
if (patchFlag & 2) {
if (oldProps.class !== newProps.class) {
hostPatchProp(el, "class", null, newProps.class, isSVG);
}
}
if (patchFlag & 4) {
hostPatchProp(el, "style", oldProps.style, newProps.style, isSVG);
}
if (patchFlag & 8) {
const propsToUpdate = n2.dynamicProps;
for (let i = 0; i < propsToUpdate.length; i++) {
const key = propsToUpdate[i];
const prev = oldProps[key];
const next = newProps[key];
if (next !== prev || key === "value") {
hostPatchProp(
el,
key,
prev,
next,
isSVG,
n1.children,
parentComponent,
parentSuspense,
unmountChildren
);
}
}
}
}
if (patchFlag & 1) {
if (n1.children !== n2.children) {
hostSetElementText(el, n2.children);
}
}
} else if (!optimized && dynamicChildren == null) {
patchProps(
el,
n2,
oldProps,
newProps,
parentComponent,
parentSuspense,
isSVG
);
}
if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
}, parentSuspense);
}
};
const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, isSVG, slotScopeIds) => {
for (let i = 0; i < newChildren.length; i++) {
const oldVNode = oldChildren[i];
const newVNode = newChildren[i];
const container = (
// oldVNode may be an errored async setup() component inside Suspense
// which will not have a mounted element
oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
// of the Fragment itself so it can move its children.
(oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
// which also requires the correct parent container
!isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
oldVNode.shapeFlag & (6 | 64)) ? hostParentNode(oldVNode.el) : (
// In other cases, the parent container is not actually used so we
// just pass the block element here to avoid a DOM parentNode call.
fallbackContainer
)
);
patch(
oldVNode,
newVNode,
container,
null,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
true
);
}
};
const patchProps = (el, vnode, oldProps, newProps, parentComponent, parentSuspense, isSVG) => {
if (oldProps !== newProps) {
if (oldProps !== EMPTY_OBJ) {
for (const key in oldProps) {
if (!isReservedProp(key) && !(key in newProps)) {
hostPatchProp(
el,
key,
oldProps[key],
null,
isSVG,
vnode.children,
parentComponent,
parentSuspense,
unmountChildren
);
}
}
}
for (const key in newProps) {
if (isReservedProp(key))
continue;
const next = newProps[key];
const prev = oldProps[key];
if (next !== prev && key !== "value") {
hostPatchProp(
el,
key,
prev,
next,
isSVG,
vnode.children,
parentComponent,
parentSuspense,
unmountChildren
);
}
}
if ("value" in newProps) {
hostPatchProp(el, "value", oldProps.value, newProps.value);
}
}
};
const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
mountChildren(
n2.children,
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else {
if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
// of renderSlot() with no valid children
n1.dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
container,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds
);
if (
// #2080 if the stable fragment has a key, it's a <template v-for> that may
// get moved around. Make sure all root level vnodes inherit el.
// #2134 or if it's a component root, it may also get moved around
// as the component is being moved.
n2.key != null || parentComponent && n2 === parentComponent.subTree
) {
traverseStaticChildren(
n1,
n2,
true
/* shallow */
);
}
} else {
patchChildren(
n1,
n2,
container,
fragmentEndAnchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
}
};
const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
n2.slotScopeIds = slotScopeIds;
if (n1 == null) {
if (n2.shapeFlag & 512) {
parentComponent.ctx.activate(
n2,
container,
anchor,
isSVG,
optimized
);
} else {
mountComponent(
n2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
optimized
);
}
} else {
updateComponent(n1, n2, optimized);
}
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const compatMountInstance = initialVNode.isCompatRoot && initialVNode.component;
const instance = compatMountInstance || (initialVNode.component = createComponentInstance(
initialVNode,
parentComponent,
parentSuspense
));
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
}
if (!compatMountInstance) {
setupComponent(instance);
}
if (instance.asyncDep) {
parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
if (!initialVNode.el) {
const placeholder = instance.subTree = createVNode(Comment);
processCommentNode(null, placeholder, container, anchor);
}
return;
}
setupRenderEffect(
instance,
initialVNode,
container,
anchor,
parentSuspense,
isSVG,
optimized
);
};
const updateComponent = (n1, n2, optimized) => {
const instance = n2.component = n1.component;
if (shouldUpdateComponent(n1, n2, optimized)) {
if (instance.asyncDep && !instance.asyncResolved) {
updateComponentPreRender(instance, n2, optimized);
return;
} else {
instance.next = n2;
invalidateJob(instance.update);
instance.update();
}
} else {
n2.el = n1.el;
instance.vnode = n2;
}
};
const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, isSVG, optimized) => {
const componentUpdateFn = () => {
if (!instance.isMounted) {
let vnodeHook;
const { el, props } = initialVNode;
const { bm, m, parent } = instance;
const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
toggleRecurse(instance, false);
if (bm) {
invokeArrayFns(bm);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
instance.emit("hook:beforeMount");
}
toggleRecurse(instance, true);
if (el && hydrateNode) {
const hydrateSubTree = () => {
instance.subTree = renderComponentRoot(instance);
hydrateNode(
el,
instance.subTree,
instance,
parentSuspense,
null
);
};
if (isAsyncWrapperVNode) {
initialVNode.type.__asyncLoader().then(
// note: we are moving the render call into an async callback,
// which means it won't track dependencies - but it's ok because
// a server-rendered async wrapper is already in resolved state
// and it will never need to change.
() => !instance.isUnmounted && hydrateSubTree()
);
} else {
hydrateSubTree();
}
} else {
const subTree = instance.subTree = renderComponentRoot(instance);
patch(
null,
subTree,
container,
anchor,
instance,
parentSuspense,
isSVG
);
initialVNode.el = subTree.el;
}
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
const scopedInitialVNode = initialVNode;
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
parentSuspense
);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
queuePostRenderEffect(
() => instance.emit("hook:mounted"),
parentSuspense
);
}
if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
instance.a && queuePostRenderEffect(instance.a, parentSuspense);
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
queuePostRenderEffect(
() => instance.emit("hook:activated"),
parentSuspense
);
}
}
instance.isMounted = true;
initialVNode = container = anchor = null;
} else {
let { next, bu, u, parent, vnode } = instance;
let originNext = next;
let vnodeHook;
toggleRecurse(instance, false);
if (next) {
next.el = vnode.el;
updateComponentPreRender(instance, next, optimized);
} else {
next = vnode;
}
if (bu) {
invokeArrayFns(bu);
}
if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parent, next, vnode);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
instance.emit("hook:beforeUpdate");
}
toggleRecurse(instance, true);
const nextTree = renderComponentRoot(instance);
const prevTree = instance.subTree;
instance.subTree = nextTree;
patch(
prevTree,
nextTree,
// parent may have changed if it's in a teleport
hostParentNode(prevTree.el),
// anchor may have changed if it's in a fragment
getNextHostNode(prevTree),
instance,
parentSuspense,
isSVG
);
next.el = nextTree.el;
if (originNext === null) {
updateHOCHostEl(instance, nextTree.el);
}
if (u) {
queuePostRenderEffect(u, parentSuspense);
}
if (vnodeHook = next.props && next.props.onVnodeUpdated) {
queuePostRenderEffect(
() => invokeVNodeHook(vnodeHook, parent, next, vnode),
parentSuspense
);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
queuePostRenderEffect(
() => instance.emit("hook:updated"),
parentSuspense
);
}
}
};
const effect = instance.effect = new ReactiveEffect(
componentUpdateFn,
() => queueJob(update),
instance.scope
// track it in component's effect scope
);
const update = instance.update = () => effect.run();
update.id = instance.uid;
toggleRecurse(instance, true);
update();
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
updateProps(instance, nextVNode.props, prevProps, optimized);
updateSlots(instance, nextVNode.children, optimized);
pauseTracking();
flushPreFlushCbs(instance);
resetTracking();
};
const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
const c1 = n1 && n1.children;
const prevShapeFlag = n1 ? n1.shapeFlag : 0;
const c2 = n2.children;
const { patchFlag, shapeFlag } = n2;
if (patchFlag > 0) {
if (patchFlag & 128) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
return;
} else if (patchFlag & 256) {
patchUnkeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
return;
}
}
if (shapeFlag & 8) {
if (prevShapeFlag & 16) {
unmountChildren(c1, parentComponent, parentSuspense);
}
if (c2 !== c1) {
hostSetElementText(container, c2);
}
} else {
if (prevShapeFlag & 16) {
if (shapeFlag & 16) {
patchKeyedChildren(
c1,
c2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else {
unmountChildren(c1, parentComponent, parentSuspense, true);
}
} else {
if (prevShapeFlag & 8) {
hostSetElementText(container, "");
}
if (shapeFlag & 16) {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
}
}
};
const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
c1 = c1 || EMPTY_ARR;
c2 = c2 || EMPTY_ARR;
const oldLength = c1.length;
const newLength = c2.length;
const commonLength = Math.min(oldLength, newLength);
let i;
for (i = 0; i < commonLength; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
patch(
c1[i],
nextChild,
container,
null,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
if (oldLength > newLength) {
unmountChildren(
c1,
parentComponent,
parentSuspense,
true,
false,
commonLength
);
} else {
mountChildren(
c2,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized,
commonLength
);
}
};
const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
let i = 0;
const l2 = c2.length;
let e1 = c1.length - 1;
let e2 = l2 - 1;
while (i <= e1 && i <= e2) {
const n1 = c1[i];
const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else {
break;
}
i++;
}
while (i <= e1 && i <= e2) {
const n1 = c1[e1];
const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
if (isSameVNodeType(n1, n2)) {
patch(
n1,
n2,
container,
null,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else {
break;
}
e1--;
e2--;
}
if (i > e1) {
if (i <= e2) {
const nextPos = e2 + 1;
const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
while (i <= e2) {
patch(
null,
c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
i++;
}
}
} else if (i > e2) {
while (i <= e1) {
unmount(c1[i], parentComponent, parentSuspense, true);
i++;
}
} else {
const s1 = i;
const s2 = i;
const keyToNewIndexMap = /* @__PURE__ */ new Map();
for (i = s2; i <= e2; i++) {
const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
if (nextChild.key != null) {
keyToNewIndexMap.set(nextChild.key, i);
}
}
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
let maxNewIndexSoFar = 0;
const newIndexToOldIndexMap = new Array(toBePatched);
for (i = 0; i < toBePatched; i++)
newIndexToOldIndexMap[i] = 0;
for (i = s1; i <= e1; i++) {
const prevChild = c1[i];
if (patched >= toBePatched) {
unmount(prevChild, parentComponent, parentSuspense, true);
continue;
}
let newIndex;
if (prevChild.key != null) {
newIndex = keyToNewIndexMap.get(prevChild.key);
} else {
for (j = s2; j <= e2; j++) {
if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
newIndex = j;
break;
}
}
}
if (newIndex === void 0) {
unmount(prevChild, parentComponent, parentSuspense, true);
} else {
newIndexToOldIndexMap[newIndex - s2] = i + 1;
if (newIndex >= maxNewIndexSoFar) {
maxNewIndexSoFar = newIndex;
} else {
moved = true;
}
patch(
prevChild,
c2[newIndex],
container,
null,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
patched++;
}
}
const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
j = increasingNewIndexSequence.length - 1;
for (i = toBePatched - 1; i >= 0; i--) {
const nextIndex = s2 + i;
const nextChild = c2[nextIndex];
const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
patch(
null,
nextChild,
container,
anchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
} else if (moved) {
if (j < 0 || i !== increasingNewIndexSequence[j]) {
move(nextChild, container, anchor, 2);
} else {
j--;
}
}
}
}
};
const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
const { el, type, transition, children, shapeFlag } = vnode;
if (shapeFlag & 6) {
move(vnode.component.subTree, container, anchor, moveType);
return;
}
if (shapeFlag & 128) {
vnode.suspense.move(container, anchor, moveType);
return;
}
if (shapeFlag & 64) {
type.move(vnode, container, anchor, internals);
return;
}
if (type === Fragment) {
hostInsert(el, container, anchor);
for (let i = 0; i < children.length; i++) {
move(children[i], container, anchor, moveType);
}
hostInsert(vnode.anchor, container, anchor);
return;
}
if (type === Static) {
moveStaticNode(vnode, container, anchor);
return;
}
const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
if (needTransition2) {
if (moveType === 0) {
transition.beforeEnter(el);
hostInsert(el, container, anchor);
queuePostRenderEffect(() => transition.enter(el), parentSuspense);
} else {
const { leave, delayLeave, afterLeave } = transition;
const remove2 = () => hostInsert(el, container, anchor);
const performLeave = () => {
leave(el, () => {
remove2();
afterLeave && afterLeave();
});
};
if (delayLeave) {
delayLeave(el, remove2, performLeave);
} else {
performLeave();
}
}
} else {
hostInsert(el, container, anchor);
}
};
const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
const {
type,
props,
ref,
children,
dynamicChildren,
shapeFlag,
patchFlag,
dirs
} = vnode;
if (ref != null) {
setRef(ref, null, parentSuspense, vnode, true);
}
if (shapeFlag & 256) {
parentComponent.ctx.deactivate(vnode);
return;
}
const shouldInvokeDirs = shapeFlag & 1 && dirs;
const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
let vnodeHook;
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
if (shapeFlag & 6) {
unmountComponent(vnode.component, parentSuspense, doRemove);
} else {
if (shapeFlag & 128) {
vnode.suspense.unmount(parentSuspense, doRemove);
return;
}
if (shouldInvokeDirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
}
if (shapeFlag & 64) {
vnode.type.remove(
vnode,
parentComponent,
parentSuspense,
optimized,
internals,
doRemove
);
} else if (dynamicChildren && // #1153: fast path should not be taken for non-stable (v-for) fragments
(type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
unmountChildren(
dynamicChildren,
parentComponent,
parentSuspense,
false,
true
);
} else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
unmountChildren(children, parentComponent, parentSuspense);
}
if (doRemove) {
remove(vnode);
}
}
if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
}, parentSuspense);
}
};
const remove = (vnode) => {
const { type, el, anchor, transition } = vnode;
if (type === Fragment) {
{
removeFragment(el, anchor);
}
return;
}
if (type === Static) {
removeStaticNode(vnode);
return;
}
const performRemove = () => {
hostRemove(el);
if (transition && !transition.persisted && transition.afterLeave) {
transition.afterLeave();
}
};
if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
const { leave, delayLeave } = transition;
const performLeave = () => leave(el, performRemove);
if (delayLeave) {
delayLeave(vnode.el, performRemove, performLeave);
} else {
performLeave();
}
} else {
performRemove();
}
};
const removeFragment = (cur, end) => {
let next;
while (cur !== end) {
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
const { bum, scope, update, subTree, um } = instance;
if (bum) {
invokeArrayFns(bum);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
instance.emit("hook:beforeDestroy");
}
scope.stop();
if (update) {
update.active = false;
unmount(subTree, instance, parentSuspense, doRemove);
}
if (um) {
queuePostRenderEffect(um, parentSuspense);
}
if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
queuePostRenderEffect(
() => instance.emit("hook:destroyed"),
parentSuspense
);
}
queuePostRenderEffect(() => {
instance.isUnmounted = true;
}, parentSuspense);
if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
parentSuspense.deps--;
if (parentSuspense.deps === 0) {
parentSuspense.resolve();
}
}
};
const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
for (let i = start; i < children.length; i++) {
unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
}
};
const getNextHostNode = (vnode) => {
if (vnode.shapeFlag & 6) {
return getNextHostNode(vnode.component.subTree);
}
if (vnode.shapeFlag & 128) {
return vnode.suspense.next();
}
return hostNextSibling(vnode.anchor || vnode.el);
};
const render = (vnode, container, isSVG) => {
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
}
} else {
patch(container._vnode || null, vnode, container, null, null, null, isSVG);
}
flushPreFlushCbs();
flushPostFlushCbs();
container._vnode = vnode;
};
const internals = {
p: patch,
um: unmount,
m: move,
r: remove,
mt: mountComponent,
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
n: getNextHostNode,
o: options
};
let hydrate;
let hydrateNode;
if (createHydrationFns) {
[hydrate, hydrateNode] = createHydrationFns(
internals
);
}
return {
render,
hydrate,
createApp: createAppAPI(render, hydrate)
};
}
function toggleRecurse({ effect, update }, allowed) {
effect.allowRecurse = update.allowRecurse = allowed;
}
function needTransition(parentSuspense, transition) {
return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
}
function traverseStaticChildren(n1, n2, shallow = false) {
const ch1 = n1.children;
const ch2 = n2.children;
if (isArray(ch1) && isArray(ch2)) {
for (let i = 0; i < ch1.length; i++) {
const c1 = ch1[i];
let c2 = ch2[i];
if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
c2 = ch2[i] = cloneIfMounted(ch2[i]);
c2.el = c1.el;
}
if (!shallow)
traverseStaticChildren(c1, c2);
}
if (c2.type === Text) {
c2.el = c1.el;
}
}
}
}
function getSequence(arr) {
const p = arr.slice();
const result = [0];
let i, j, u, v, c;
const len = arr.length;
for (i = 0; i < len; i++) {
const arrI = arr[i];
if (arrI !== 0) {
j = result[result.length - 1];
if (arr[j] < arrI) {
p[i] = j;
result.push(i);
continue;
}
u = 0;
v = result.length - 1;
while (u < v) {
c = u + v >> 1;
if (arr[result[c]] < arrI) {
u = c + 1;
} else {
v = c;
}
}
if (arrI < arr[result[u]]) {
if (u > 0) {
p[i] = result[u - 1];
}
result[u] = i;
}
}
}
u = result.length;
v = result[u - 1];
while (u-- > 0) {
result[u] = v;
v = p[v];
}
return result;
}
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (isString(targetSelector)) {
if (!select) {
return null;
} else {
const target = select(targetSelector);
return target;
}
} else {
return targetSelector;
}
};
const TeleportImpl = {
name: "Teleport",
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals) {
const {
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
o: { insert, querySelector, createText, createComment }
} = internals;
const disabled = isTeleportDisabled(n2.props);
let { shapeFlag, children, dynamicChildren } = n2;
if (n1 == null) {
const placeholder = n2.el = createText("");
const mainAnchor = n2.anchor = createText("");
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const target = n2.target = resolveTarget(n2.props, querySelector);
const targetAnchor = n2.targetAnchor = createText("");
if (target) {
insert(targetAnchor, target);
isSVG = isSVG || isTargetSVG(target);
}
const mount = (container2, anchor2) => {
if (shapeFlag & 16) {
mountChildren(
children,
container2,
anchor2,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized
);
}
};
if (disabled) {
mount(container, mainAnchor);
} else if (target) {
mount(target, targetAnchor);
}
} else {
n2.el = n1.el;
const mainAnchor = n2.anchor = n1.anchor;
const target = n2.target = n1.target;
const targetAnchor = n2.targetAnchor = n1.targetAnchor;
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
isSVG = isSVG || isTargetSVG(target);
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
currentContainer,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds
);
traverseStaticChildren(n1, n2, true);
} else if (!optimized) {
patchChildren(
n1,
n2,
currentContainer,
currentAnchor,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
false
);
}
if (disabled) {
if (!wasDisabled) {
moveTeleport(
n2,
container,
mainAnchor,
internals,
1
);
} else {
if (n2.props && n1.props && n2.props.to !== n1.props.to) {
n2.props.to = n1.props.to;
}
}
} else {
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = n2.target = resolveTarget(
n2.props,
querySelector
);
if (nextTarget) {
moveTeleport(
n2,
nextTarget,
null,
internals,
0
);
}
} else if (wasDisabled) {
moveTeleport(
n2,
target,
targetAnchor,
internals,
1
);
}
}
}
updateCssVars(n2);
},
remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
if (target) {
hostRemove(targetAnchor);
}
doRemove && hostRemove(anchor);
if (shapeFlag & 16) {
const shouldRemove = doRemove || !isTeleportDisabled(props);
for (let i = 0; i < children.length; i++) {
const child = children[i];
unmount(
child,
parentComponent,
parentSuspense,
shouldRemove,
!!child.dynamicChildren
);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
if (moveType === 0) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2;
if (isReorder) {
insert(el, container, parentAnchor);
}
if (!isReorder || isTeleportDisabled(props)) {
if (shapeFlag & 16) {
for (let i = 0; i < children.length; i++) {
move(
children[i],
container,
parentAnchor,
2
);
}
}
}
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
o: { nextSibling, parentNode, querySelector }
}, hydrateChildren) {
const target = vnode.target = resolveTarget(
vnode.props,
querySelector
);
if (target) {
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16) {
if (isTeleportDisabled(vnode.props)) {
vnode.anchor = hydrateChildren(
nextSibling(node),
vnode,
parentNode(node),
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
vnode.targetAnchor = targetNode;
} else {
vnode.anchor = nextSibling(node);
let targetAnchor = targetNode;
while (targetAnchor) {
targetAnchor = nextSibling(targetAnchor);
if (targetAnchor && targetAnchor.nodeType === 8 && targetAnchor.data === "teleport anchor") {
vnode.targetAnchor = targetAnchor;
target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
break;
}
}
hydrateChildren(
targetNode,
vnode,
target,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
}
updateCssVars(vnode);
}
return vnode.anchor && nextSibling(vnode.anchor);
}
const Teleport = TeleportImpl;
function updateCssVars(vnode) {
const ctx = vnode.ctx;
if (ctx && ctx.ut) {
let node = vnode.children[0].el;
while (node && node !== vnode.targetAnchor) {
if (node.nodeType === 1)
node.setAttribute("data-v-owner", ctx.uid);
node = node.nextSibling;
}
ctx.ut();
}
}
const normalizedAsyncComponentMap = /* @__PURE__ */ new WeakMap();
function convertLegacyAsyncComponent(comp) {
if (normalizedAsyncComponentMap.has(comp)) {
return normalizedAsyncComponentMap.get(comp);
}
let resolve;
let reject;
const fallbackPromise = new Promise((r, rj) => {
resolve = r, reject = rj;
});
const res = comp(resolve, reject);
let converted;
if (isPromise(res)) {
converted = defineAsyncComponent(() => res);
} else if (isObject(res) && !isVNode(res) && !isArray(res)) {
converted = defineAsyncComponent({
loader: () => res.component,
loadingComponent: res.loading,
errorComponent: res.error,
delay: res.delay,
timeout: res.timeout
});
} else if (res == null) {
converted = defineAsyncComponent(() => fallbackPromise);
} else {
converted = comp;
}
normalizedAsyncComponentMap.set(comp, converted);
return converted;
}
function convertLegacyComponent(comp, instance) {
if (comp.__isBuiltIn) {
return comp;
}
if (isFunction(comp) && comp.cid) {
comp = comp.options;
}
if (isFunction(comp) && checkCompatEnabled$1("COMPONENT_ASYNC", instance, comp)) {
return convertLegacyAsyncComponent(comp);
}
if (isObject(comp) && comp.functional && softAssertCompatEnabled(
"COMPONENT_FUNCTIONAL",
instance,
comp
)) {
return convertLegacyFunctionalComponent(comp);
}
return comp;
}
const Fragment = Symbol.for("v-fgt");
const Text = Symbol.for("v-txt");
const Comment = Symbol.for("v-cmt");
const Static = Symbol.for("v-stc");
const blockStack = [];
let currentBlock = null;
function openBlock(disableTracking = false) {
blockStack.push(currentBlock = disableTracking ? null : []);
}
function closeBlock() {
blockStack.pop();
currentBlock = blockStack[blockStack.length - 1] || null;
}
let isBlockTreeEnabled = 1;
function setBlockTracking(value) {
isBlockTreeEnabled += value;
}
function setupBlock(vnode) {
vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
closeBlock();
if (isBlockTreeEnabled > 0 && currentBlock) {
currentBlock.push(vnode);
}
return vnode;
}
function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
return setupBlock(
createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
true
/* isBlock */
)
);
}
function createBlock(type, props, children, patchFlag, dynamicProps) {
return setupBlock(
createVNode(
type,
props,
children,
patchFlag,
dynamicProps,
true
/* isBlock: prevent a block from tracking itself */
)
);
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
return n1.type === n2.type && n1.key === n2.key;
}
function transformVNodeArgs(transformer) {
}
const InternalObjectKey = `__vInternal`;
const normalizeKey = ({ key }) => key != null ? key : null;
const normalizeRef = ({
ref,
ref_key,
ref_for
}) => {
if (typeof ref === "number") {
ref = "" + ref;
}
return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
};
function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
const vnode = {
__v_isVNode: true,
__v_skip: true,
type,
props,
key: props && normalizeKey(props),
ref: props && normalizeRef(props),
scopeId: currentScopeId,
slotScopeIds: null,
children,
component: null,
suspense: null,
ssContent: null,
ssFallback: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetAnchor: null,
staticCount: 0,
shapeFlag,
patchFlag,
dynamicProps,
dynamicChildren: null,
appContext: null,
ctx: currentRenderingInstance
};
if (needFullChildrenNormalization) {
normalizeChildren(vnode, children);
if (shapeFlag & 128) {
type.normalize(vnode);
}
} else if (children) {
vnode.shapeFlag |= isString(children) ? 8 : 16;
}
if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
!isBlockNode && // has current parent block
currentBlock && // presence of a patch flag indicates this node needs patching on updates.
// component nodes also should always be patched, because even if the
// component doesn't need to update, it needs to persist the instance on to
// the next vnode so that it can be properly unmounted later.
(vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
// vnode should not be considered dynamic due to handler caching.
vnode.patchFlag !== 32) {
currentBlock.push(vnode);
}
{
convertLegacyVModelProps(vnode);
defineLegacyVNodeProperties(vnode);
}
return vnode;
}
const createVNode = _createVNode;
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
type = Comment;
}
if (isVNode(type)) {
const cloned = cloneVNode(
type,
props,
true
/* mergeRef: true */
);
if (children) {
normalizeChildren(cloned, children);
}
if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
if (cloned.shapeFlag & 6) {
currentBlock[currentBlock.indexOf(type)] = cloned;
} else {
currentBlock.push(cloned);
}
}
cloned.patchFlag |= -2;
return cloned;
}
if (isClassComponent(type)) {
type = type.__vccOpts;
}
{
type = convertLegacyComponent(type, currentRenderingInstance);
}
if (props) {
props = guardReactiveProps(props);
let { class: klass, style } = props;
if (klass && !isString(klass)) {
props.class = normalizeClass(klass);
}
if (isObject(style)) {
if (isProxy(style) && !isArray(style)) {
style = extend({}, style);
}
props.style = normalizeStyle(style);
}
}
const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
return createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
isBlockNode,
true
);
}
function guardReactiveProps(props) {
if (!props)
return null;
return isProxy(props) || InternalObjectKey in props ? extend({}, props) : props;
}
function cloneVNode(vnode, extraProps, mergeRef = false) {
const { props, ref, patchFlag, children } = vnode;
const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
const cloned = {
__v_isVNode: true,
__v_skip: true,
type: vnode.type,
props: mergedProps,
key: mergedProps && normalizeKey(mergedProps),
ref: extraProps && extraProps.ref ? (
// #2078 in the case of <component :is="vnode" ref="extra"/>
// if the vnode itself already has a ref, cloneVNode will need to merge
// the refs so the single vnode can be set on multiple refs
mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
) : ref,
scopeId: vnode.scopeId,
slotScopeIds: vnode.slotScopeIds,
children: children,
target: vnode.target,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
// if the vnode is cloned with extra props, we can no longer assume its
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
// note: preserve flag for fragments since they use the flag for children
// fast paths only.
patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
appContext: vnode.appContext,
dirs: vnode.dirs,
transition: vnode.transition,
// These should technically only be non-null on mounted VNodes. However,
// they *should* be copied for kept-alive vnodes. So we just always copy
// them since them being non-null during a mount doesn't affect the logic as
// they will simply be overwritten.
component: vnode.component,
suspense: vnode.suspense,
ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
el: vnode.el,
anchor: vnode.anchor,
ctx: vnode.ctx,
ce: vnode.ce
};
{
defineLegacyVNodeProperties(cloned);
}
return cloned;
}
function createTextVNode(text = " ", flag = 0) {
return createVNode(Text, null, text, flag);
}
function createStaticVNode(content, numberOfNodes) {
const vnode = createVNode(Static, null, content);
vnode.staticCount = numberOfNodes;
return vnode;
}
function createCommentVNode(text = "", asBlock = false) {
return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
}
function normalizeVNode(child) {
if (child == null || typeof child === "boolean") {
return createVNode(Comment);
} else if (isArray(child)) {
return createVNode(
Fragment,
null,
// #3666, avoid reference pollution when reusing vnode
child.slice()
);
} else if (typeof child === "object") {
return cloneIfMounted(child);
} else {
return createVNode(Text, null, String(child));
}
}
function cloneIfMounted(child) {
return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
}
function normalizeChildren(vnode, children) {
let type = 0;
const { shapeFlag } = vnode;
if (children == null) {
children = null;
} else if (isArray(children)) {
type = 16;
} else if (typeof children === "object") {
if (shapeFlag & (1 | 64)) {
const slot = children.default;
if (slot) {
slot._c && (slot._d = false);
normalizeChildren(vnode, slot());
slot._c && (slot._d = true);
}
return;
} else {
type = 32;
const slotFlag = children._;
if (!slotFlag && !(InternalObjectKey in children)) {
children._ctx = currentRenderingInstance;
} else if (slotFlag === 3 && currentRenderingInstance) {
if (currentRenderingInstance.slots._ === 1) {
children._ = 1;
} else {
children._ = 2;
vnode.patchFlag |= 1024;
}
}
}
} else if (isFunction(children)) {
children = { default: children, _ctx: currentRenderingInstance };
type = 32;
} else {
children = String(children);
if (shapeFlag & 64) {
type = 16;
children = [createTextVNode(children)];
} else {
type = 8;
}
}
vnode.children = children;
vnode.shapeFlag |= type;
}
function mergeProps(...args) {
const ret = {};
for (let i = 0; i < args.length; i++) {
const toMerge = args[i];
for (const key in toMerge) {
if (key === "class") {
if (ret.class !== toMerge.class) {
ret.class = normalizeClass([ret.class, toMerge.class]);
}
} else if (key === "style") {
ret.style = normalizeStyle([ret.style, toMerge.style]);
} else if (isOn(key)) {
const existing = ret[key];
const incoming = toMerge[key];
if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
ret[key] = existing ? [].concat(existing, incoming) : incoming;
}
} else if (key !== "") {
ret[key] = toMerge[key];
}
}
}
return ret;
}
function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
callWithAsyncErrorHandling(hook, instance, 7, [
vnode,
prevVNode
]);
}
const emptyAppContext = createAppContext();
let uid = 0;
function createComponentInstance(vnode, parent, suspense) {
const type = vnode.type;
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
const instance = {
uid: uid++,
vnode,
type,
parent,
appContext,
root: null,
// to be immediately set
next: null,
subTree: null,
// will be set synchronously right after creation
effect: null,
update: null,
// will be set synchronously right after creation
scope: new EffectScope(
true
/* detached */
),
render: null,
proxy: null,
exposed: null,
exposeProxy: null,
withProxy: null,
provides: parent ? parent.provides : Object.create(appContext.provides),
accessCache: null,
renderCache: [],
// local resolved assets
components: null,
directives: null,
// resolved props and emits options
propsOptions: normalizePropsOptions(type, appContext),
emitsOptions: normalizeEmitsOptions(type, appContext),
// emit
emit: null,
// to be set immediately
emitted: null,
// props default value
propsDefaults: EMPTY_OBJ,
// inheritAttrs
inheritAttrs: type.inheritAttrs,
// state
ctx: EMPTY_OBJ,
data: EMPTY_OBJ,
props: EMPTY_OBJ,
attrs: EMPTY_OBJ,
slots: EMPTY_OBJ,
refs: EMPTY_OBJ,
setupState: EMPTY_OBJ,
setupContext: null,
attrsProxy: null,
slotsProxy: null,
// suspense related
suspense,
suspenseId: suspense ? suspense.pendingId : 0,
asyncDep: null,
asyncResolved: false,
// lifecycle hooks
// not using enums here because it results in computed properties
isMounted: false,
isUnmounted: false,
isDeactivated: false,
bc: null,
c: null,
bm: null,
m: null,
bu: null,
u: null,
um: null,
bum: null,
da: null,
a: null,
rtg: null,
rtc: null,
ec: null,
sp: null
};
{
instance.ctx = { _: instance };
}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
if (vnode.ce) {
vnode.ce(instance);
}
return instance;
}
let currentInstance = null;
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
let internalSetCurrentInstance;
let globalCurrentInstanceSetters;
let settersKey = "__VUE_INSTANCE_SETTERS__";
{
if (!(globalCurrentInstanceSetters = getGlobalThis()[settersKey])) {
globalCurrentInstanceSetters = getGlobalThis()[settersKey] = [];
}
globalCurrentInstanceSetters.push((i) => currentInstance = i);
internalSetCurrentInstance = (instance) => {
if (globalCurrentInstanceSetters.length > 1) {
globalCurrentInstanceSetters.forEach((s) => s(instance));
} else {
globalCurrentInstanceSetters[0](instance);
}
};
}
const setCurrentInstance = (instance) => {
internalSetCurrentInstance(instance);
instance.scope.on();
};
const unsetCurrentInstance = () => {
currentInstance && currentInstance.scope.off();
internalSetCurrentInstance(null);
};
function isStatefulComponent(instance) {
return instance.vnode.shapeFlag & 4;
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false) {
isInSSRComponentSetup = isSSR;
const { props, children } = instance.vnode;
const isStateful = isStatefulComponent(instance);
initProps(instance, props, isStateful, isSSR);
initSlots(instance, children);
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
isInSSRComponentSetup = false;
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
const Component = instance.type;
instance.accessCache = /* @__PURE__ */ Object.create(null);
instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
const { setup } = Component;
if (setup) {
const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
setCurrentInstance(instance);
pauseTracking();
const setupResult = callWithErrorHandling(
setup,
instance,
0,
[instance.props, setupContext]
);
resetTracking();
unsetCurrentInstance();
if (isPromise(setupResult)) {
setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
if (isSSR) {
return setupResult.then((resolvedResult) => {
handleSetupResult(instance, resolvedResult, isSSR);
}).catch((e) => {
handleError(e, instance, 0);
});
} else {
instance.asyncDep = setupResult;
}
} else {
handleSetupResult(instance, setupResult, isSSR);
}
} else {
finishComponentSetup(instance, isSSR);
}
}
function handleSetupResult(instance, setupResult, isSSR) {
if (isFunction(setupResult)) {
if (instance.type.__ssrInlineRender) {
instance.ssrRender = setupResult;
} else {
instance.render = setupResult;
}
} else if (isObject(setupResult)) {
instance.setupState = proxyRefs(setupResult);
} else ;
finishComponentSetup(instance, isSSR);
}
let compile$1;
let installWithProxy;
function registerRuntimeCompiler(_compile) {
compile$1 = _compile;
installWithProxy = (i) => {
if (i.render._rc) {
i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
}
};
}
const isRuntimeOnly = () => !compile$1;
function finishComponentSetup(instance, isSSR, skipOptions) {
const Component = instance.type;
{
convertLegacyRenderFn(instance);
}
if (!instance.render) {
if (!isSSR && compile$1 && !Component.render) {
const template = instance.vnode.props && instance.vnode.props["inline-template"] || Component.template || resolveMergedOptions(instance).template;
if (template) {
const { isCustomElement, compilerOptions } = instance.appContext.config;
const { delimiters, compilerOptions: componentCompilerOptions } = Component;
const finalCompilerOptions = extend(
extend(
{
isCustomElement,
delimiters
},
compilerOptions
),
componentCompilerOptions
);
{
finalCompilerOptions.compatConfig = Object.create(globalCompatConfig);
if (Component.compatConfig) {
extend(finalCompilerOptions.compatConfig, Component.compatConfig);
}
}
Component.render = compile$1(template, finalCompilerOptions);
}
}
instance.render = Component.render || NOOP;
if (installWithProxy) {
installWithProxy(instance);
}
}
if (!skipOptions) {
setCurrentInstance(instance);
pauseTracking();
try {
applyOptions(instance);
} finally {
resetTracking();
unsetCurrentInstance();
}
}
}
function getAttrsProxy(instance) {
return instance.attrsProxy || (instance.attrsProxy = new Proxy(
instance.attrs,
{
get(target, key) {
track(instance, "get", "$attrs");
return target[key];
}
}
));
}
function createSetupContext(instance) {
const expose = (exposed) => {
instance.exposed = exposed || {};
};
{
return {
get attrs() {
return getAttrsProxy(instance);
},
slots: instance.slots,
emit: instance.emit,
expose
};
}
}
function getExposeProxy(instance) {
if (instance.exposed) {
return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
get(target, key) {
if (key in target) {
return target[key];
} else if (key in publicPropertiesMap) {
return publicPropertiesMap[key](instance);
}
},
has(target, key) {
return key in target || key in publicPropertiesMap;
}
}));
}
}
function getComponentName(Component, includeInferred = true) {
return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
}
function isClassComponent(value) {
return isFunction(value) && "__vccOpts" in value;
}
const computed = (getterOrOptions, debugOptions) => {
return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
};
function h(type, propsOrChildren, children) {
const l = arguments.length;
if (l === 2) {
if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
if (isVNode(propsOrChildren)) {
return createVNode(type, null, [propsOrChildren]);
}
return createVNode(type, propsOrChildren);
} else {
return createVNode(type, null, propsOrChildren);
}
} else {
if (l > 3) {
children = Array.prototype.slice.call(arguments, 2);
} else if (l === 3 && isVNode(children)) {
children = [children];
}
return createVNode(type, propsOrChildren, children);
}
}
const ssrContextKey = Symbol.for("v-scx");
const useSSRContext = () => {
{
const ctx = inject(ssrContextKey);
return ctx;
}
};
function initCustomFormatter() {
{
return;
}
}
function withMemo(memo, render, cache, index) {
const cached = cache[index];
if (cached && isMemoSame(cached, memo)) {
return cached;
}
const ret = render();
ret.memo = memo.slice();
return cache[index] = ret;
}
function isMemoSame(cached, memo) {
const prev = cached.memo;
if (prev.length != memo.length) {
return false;
}
for (let i = 0; i < prev.length; i++) {
if (hasChanged(prev[i], memo[i])) {
return false;
}
}
if (isBlockTreeEnabled > 0 && currentBlock) {
currentBlock.push(cached);
}
return true;
}
const version = "3.3.13";
const _ssrUtils = {
createComponentInstance,
setupComponent,
renderComponentRoot,
setCurrentRenderingInstance,
isVNode: isVNode,
normalizeVNode
};
const ssrUtils = _ssrUtils ;
const resolveFilter = resolveFilter$1 ;
const _compatUtils = {
warnDeprecation,
createCompatVue: createCompatVue$1,
isCompatEnabled: isCompatEnabled$1,
checkCompatEnabled: checkCompatEnabled$1,
softAssertCompatEnabled
};
const compatUtils = _compatUtils ;
const svgNS = "http://www.w3.org/2000/svg";
const doc = typeof document !== "undefined" ? document : null;
const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
const nodeOps = {
insert: (child, parent, anchor) => {
parent.insertBefore(child, anchor || null);
},
remove: (child) => {
const parent = child.parentNode;
if (parent) {
parent.removeChild(child);
}
},
createElement: (tag, isSVG, is, props) => {
const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? { is } : void 0);
if (tag === "select" && props && props.multiple != null) {
el.setAttribute("multiple", props.multiple);
}
return el;
},
createText: (text) => doc.createTextNode(text),
createComment: (text) => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text;
},
setElementText: (el, text) => {
el.textContent = text;
},
parentNode: (node) => node.parentNode,
nextSibling: (node) => node.nextSibling,
querySelector: (selector) => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, "");
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, isSVG, start, end) {
const before = anchor ? anchor.previousSibling : parent.lastChild;
if (start && (start === end || start.nextSibling)) {
while (true) {
parent.insertBefore(start.cloneNode(true), anchor);
if (start === end || !(start = start.nextSibling))
break;
}
} else {
templateContainer.innerHTML = isSVG ? `<svg>${content}</svg>` : content;
const template = templateContainer.content;
if (isSVG) {
const wrapper = template.firstChild;
while (wrapper.firstChild) {
template.appendChild(wrapper.firstChild);
}
template.removeChild(wrapper);
}
parent.insertBefore(template, anchor);
}
return [
// first
before ? before.nextSibling : parent.firstChild,
// last
anchor ? anchor.previousSibling : parent.lastChild
];
}
};
const TRANSITION$1 = "transition";
const ANIMATION = "animation";
const vtcKey = Symbol("_vtc");
const Transition = (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots);
Transition.displayName = "Transition";
{
Transition.__isBuiltIn = true;
}
const DOMTransitionPropsValidators = {
name: String,
type: String,
css: {
type: Boolean,
default: true
},
duration: [String, Number, Object],
enterFromClass: String,
enterActiveClass: String,
enterToClass: String,
appearFromClass: String,
appearActiveClass: String,
appearToClass: String,
leaveFromClass: String,
leaveActiveClass: String,
leaveToClass: String
};
const TransitionPropsValidators = Transition.props = /* @__PURE__ */ extend(
{},
BaseTransitionPropsValidators,
DOMTransitionPropsValidators
);
const callHook = (hook, args = []) => {
if (isArray(hook)) {
hook.forEach((h2) => h2(...args));
} else if (hook) {
hook(...args);
}
};
const hasExplicitCallback = (hook) => {
return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
};
function resolveTransitionProps(rawProps) {
const baseProps = {};
for (const key in rawProps) {
if (!(key in DOMTransitionPropsValidators)) {
baseProps[key] = rawProps[key];
}
}
if (rawProps.css === false) {
return baseProps;
}
const {
name = "v",
type,
duration,
enterFromClass = `${name}-enter-from`,
enterActiveClass = `${name}-enter-active`,
enterToClass = `${name}-enter-to`,
appearFromClass = enterFromClass,
appearActiveClass = enterActiveClass,
appearToClass = enterToClass,
leaveFromClass = `${name}-leave-from`,
leaveActiveClass = `${name}-leave-active`,
leaveToClass = `${name}-leave-to`
} = rawProps;
const legacyClassEnabled = compatUtils.isCompatEnabled("TRANSITION_CLASSES", null);
let legacyEnterFromClass;
let legacyAppearFromClass;
let legacyLeaveFromClass;
if (legacyClassEnabled) {
const toLegacyClass = (cls) => cls.replace(/-from$/, "");
if (!rawProps.enterFromClass) {
legacyEnterFromClass = toLegacyClass(enterFromClass);
}
if (!rawProps.appearFromClass) {
legacyAppearFromClass = toLegacyClass(appearFromClass);
}
if (!rawProps.leaveFromClass) {
legacyLeaveFromClass = toLegacyClass(leaveFromClass);
}
}
const durations = normalizeDuration(duration);
const enterDuration = durations && durations[0];
const leaveDuration = durations && durations[1];
const {
onBeforeEnter,
onEnter,
onEnterCancelled,
onLeave,
onLeaveCancelled,
onBeforeAppear = onBeforeEnter,
onAppear = onEnter,
onAppearCancelled = onEnterCancelled
} = baseProps;
const finishEnter = (el, isAppear, done) => {
removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
done && done();
};
const finishLeave = (el, done) => {
el._isLeaving = false;
removeTransitionClass(el, leaveFromClass);
removeTransitionClass(el, leaveToClass);
removeTransitionClass(el, leaveActiveClass);
done && done();
};
const makeEnterHook = (isAppear) => {
return (el, done) => {
const hook = isAppear ? onAppear : onEnter;
const resolve = () => finishEnter(el, isAppear, done);
callHook(hook, [el, resolve]);
nextFrame(() => {
removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
if (legacyClassEnabled) {
const legacyClass = isAppear ? legacyAppearFromClass : legacyEnterFromClass;
if (legacyClass) {
removeTransitionClass(el, legacyClass);
}
}
addTransitionClass(el, isAppear ? appearToClass : enterToClass);
if (!hasExplicitCallback(hook)) {
whenTransitionEnds(el, type, enterDuration, resolve);
}
});
};
};
return extend(baseProps, {
onBeforeEnter(el) {
callHook(onBeforeEnter, [el]);
addTransitionClass(el, enterFromClass);
if (legacyClassEnabled && legacyEnterFromClass) {
addTransitionClass(el, legacyEnterFromClass);
}
addTransitionClass(el, enterActiveClass);
},
onBeforeAppear(el) {
callHook(onBeforeAppear, [el]);
addTransitionClass(el, appearFromClass);
if (legacyClassEnabled && legacyAppearFromClass) {
addTransitionClass(el, legacyAppearFromClass);
}
addTransitionClass(el, appearActiveClass);
},
onEnter: makeEnterHook(false),
onAppear: makeEnterHook(true),
onLeave(el, done) {
el._isLeaving = true;
const resolve = () => finishLeave(el, done);
addTransitionClass(el, leaveFromClass);
if (legacyClassEnabled && legacyLeaveFromClass) {
addTransitionClass(el, legacyLeaveFromClass);
}
forceReflow();
addTransitionClass(el, leaveActiveClass);
nextFrame(() => {
if (!el._isLeaving) {
return;
}
removeTransitionClass(el, leaveFromClass);
if (legacyClassEnabled && legacyLeaveFromClass) {
removeTransitionClass(el, legacyLeaveFromClass);
}
addTransitionClass(el, leaveToClass);
if (!hasExplicitCallback(onLeave)) {
whenTransitionEnds(el, type, leaveDuration, resolve);
}
});
callHook(onLeave, [el, resolve]);
},
onEnterCancelled(el) {
finishEnter(el, false);
callHook(onEnterCancelled, [el]);
},
onAppearCancelled(el) {
finishEnter(el, true);
callHook(onAppearCancelled, [el]);
},
onLeaveCancelled(el) {
finishLeave(el);
callHook(onLeaveCancelled, [el]);
}
});
}
function normalizeDuration(duration) {
if (duration == null) {
return null;
} else if (isObject(duration)) {
return [NumberOf(duration.enter), NumberOf(duration.leave)];
} else {
const n = NumberOf(duration);
return [n, n];
}
}
function NumberOf(val) {
const res = toNumber(val);
return res;
}
function addTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
(el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
}
function removeTransitionClass(el, cls) {
cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
const _vtc = el[vtcKey];
if (_vtc) {
_vtc.delete(cls);
if (!_vtc.size) {
el[vtcKey] = void 0;
}
}
}
function nextFrame(cb) {
requestAnimationFrame(() => {
requestAnimationFrame(cb);
});
}
let endId = 0;
function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
const id = el._endId = ++endId;
const resolveIfNotStale = () => {
if (id === el._endId) {
resolve();
}
};
if (explicitTimeout) {
return setTimeout(resolveIfNotStale, explicitTimeout);
}
const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
if (!type) {
return resolve();
}
const endEvent = type + "end";
let ended = 0;
const end = () => {
el.removeEventListener(endEvent, onEnd);
resolveIfNotStale();
};
const onEnd = (e) => {
if (e.target === el && ++ended >= propCount) {
end();
}
};
setTimeout(() => {
if (ended < propCount) {
end();
}
}, timeout + 1);
el.addEventListener(endEvent, onEnd);
}
function getTransitionInfo(el, expectedType) {
const styles = window.getComputedStyle(el);
const getStyleProperties = (key) => (styles[key] || "").split(", ");
const transitionDelays = getStyleProperties(`${TRANSITION$1}Delay`);
const transitionDurations = getStyleProperties(`${TRANSITION$1}Duration`);
const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
const animationTimeout = getTimeout(animationDelays, animationDurations);
let type = null;
let timeout = 0;
let propCount = 0;
if (expectedType === TRANSITION$1) {
if (transitionTimeout > 0) {
type = TRANSITION$1;
timeout = transitionTimeout;
propCount = transitionDurations.length;
}
} else if (expectedType === ANIMATION) {
if (animationTimeout > 0) {
type = ANIMATION;
timeout = animationTimeout;
propCount = animationDurations.length;
}
} else {
timeout = Math.max(transitionTimeout, animationTimeout);
type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION$1 : ANIMATION : null;
propCount = type ? type === TRANSITION$1 ? transitionDurations.length : animationDurations.length : 0;
}
const hasTransform = type === TRANSITION$1 && /\b(transform|all)(,|$)/.test(
getStyleProperties(`${TRANSITION$1}Property`).toString()
);
return {
type,
timeout,
propCount,
hasTransform
};
}
function getTimeout(delays, durations) {
while (delays.length < durations.length) {
delays = delays.concat(delays);
}
return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
}
function toMs(s) {
if (s === "auto")
return 0;
return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
}
function forceReflow() {
return document.body.offsetHeight;
}
function patchClass(el, value, isSVG) {
const transitionClasses = el[vtcKey];
if (transitionClasses) {
value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
}
if (value == null) {
el.removeAttribute("class");
} else if (isSVG) {
el.setAttribute("class", value);
} else {
el.className = value;
}
}
const vShowOldKey = Symbol("_vod");
const vShow = {
beforeMount(el, { value }, { transition }) {
el[vShowOldKey] = el.style.display === "none" ? "" : el.style.display;
if (transition && value) {
transition.beforeEnter(el);
} else {
setDisplay(el, value);
}
},
mounted(el, { value }, { transition }) {
if (transition && value) {
transition.enter(el);
}
},
updated(el, { value, oldValue }, { transition }) {
if (!value === !oldValue)
return;
if (transition) {
if (value) {
transition.beforeEnter(el);
setDisplay(el, true);
transition.enter(el);
} else {
transition.leave(el, () => {
setDisplay(el, false);
});
}
} else {
setDisplay(el, value);
}
},
beforeUnmount(el, { value }) {
setDisplay(el, value);
}
};
function setDisplay(el, value) {
el.style.display = value ? el[vShowOldKey] : "none";
}
function initVShowForSSR() {
vShow.getSSRProps = ({ value }) => {
if (!value) {
return { style: { display: "none" } };
}
};
}
const CSS_VAR_TEXT = Symbol("");
function useCssVars(getter) {
return;
}
function patchStyle(el, prev, next) {
const style = el.style;
const isCssString = isString(next);
if (next && !isCssString) {
if (prev && !isString(prev)) {
for (const key in prev) {
if (next[key] == null) {
setStyle(style, key, "");
}
}
}
for (const key in next) {
setStyle(style, key, next[key]);
}
} else {
const currentDisplay = style.display;
if (isCssString) {
if (prev !== next) {
const cssVarText = style[CSS_VAR_TEXT];
if (cssVarText) {
next += ";" + cssVarText;
}
style.cssText = next;
}
} else if (prev) {
el.removeAttribute("style");
}
if (vShowOldKey in el) {
style.display = currentDisplay;
}
}
}
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (isArray(val)) {
val.forEach((v) => setStyle(style, name, v));
} else {
if (val == null)
val = "";
if (name.startsWith("--")) {
style.setProperty(name, val);
} else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
style.setProperty(
hyphenate(prefixed),
val.replace(importantRE, ""),
"important"
);
} else {
style[prefixed] = val;
}
}
}
}
const prefixes = ["Webkit", "Moz", "ms"];
const prefixCache = {};
function autoPrefix(style, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = camelize(rawName);
if (name !== "filter" && name in style) {
return prefixCache[rawName] = name;
}
name = capitalize(name);
for (let i = 0; i < prefixes.length; i++) {
const prefixed = prefixes[i] + name;
if (prefixed in style) {
return prefixCache[rawName] = prefixed;
}
}
return rawName;
}
const xlinkNS = "http://www.w3.org/1999/xlink";
function patchAttr(el, key, value, isSVG, instance) {
if (isSVG && key.startsWith("xlink:")) {
if (value == null) {
el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
} else {
el.setAttributeNS(xlinkNS, key, value);
}
} else {
if (compatCoerceAttr(el, key, value, instance)) {
return;
}
const isBoolean = isSpecialBooleanAttr(key);
if (value == null || isBoolean && !includeBooleanAttr(value)) {
el.removeAttribute(key);
} else {
el.setAttribute(key, isBoolean ? "" : value);
}
}
}
const isEnumeratedAttr = /* @__PURE__ */ makeMap("contenteditable,draggable,spellcheck") ;
function compatCoerceAttr(el, key, value, instance = null) {
if (isEnumeratedAttr(key)) {
const v2CoercedValue = value === null ? "false" : typeof value !== "boolean" && value !== void 0 ? "true" : null;
if (v2CoercedValue && compatUtils.softAssertCompatEnabled(
"ATTR_ENUMERATED_COERCION",
instance,
key,
value,
v2CoercedValue
)) {
el.setAttribute(key, v2CoercedValue);
return true;
}
} else if (value === false && !isSpecialBooleanAttr(key) && compatUtils.softAssertCompatEnabled(
"ATTR_FALSE_VALUE",
instance,
key
)) {
el.removeAttribute(key);
return true;
}
return false;
}
function patchDOMProp(el, key, value, prevChildren, parentComponent, parentSuspense, unmountChildren) {
if (key === "innerHTML" || key === "textContent") {
if (prevChildren) {
unmountChildren(prevChildren, parentComponent, parentSuspense);
}
el[key] = value == null ? "" : value;
return;
}
const tag = el.tagName;
if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
!tag.includes("-")) {
el._value = value;
const oldValue = tag === "OPTION" ? el.getAttribute("value") : el.value;
const newValue = value == null ? "" : value;
if (oldValue !== newValue) {
el.value = newValue;
}
if (value == null) {
el.removeAttribute(key);
}
return;
}
let needRemove = false;
if (value === "" || value == null) {
const type = typeof el[key];
if (type === "boolean") {
value = includeBooleanAttr(value);
} else if (value == null && type === "string") {
value = "";
needRemove = true;
} else if (type === "number") {
value = 0;
needRemove = true;
}
} else {
if (value === false && compatUtils.isCompatEnabled(
"ATTR_FALSE_VALUE",
parentComponent
)) {
const type = typeof el[key];
if (type === "string" || type === "number") {
value = type === "number" ? 0 : "";
needRemove = true;
}
}
}
try {
el[key] = value;
} catch (e) {
}
needRemove && el.removeAttribute(key);
}
function addEventListener(el, event, handler, options) {
el.addEventListener(event, handler, options);
}
function removeEventListener(el, event, handler, options) {
el.removeEventListener(event, handler, options);
}
const veiKey = Symbol("_vei");
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
const invokers = el[veiKey] || (el[veiKey] = {});
const existingInvoker = invokers[rawName];
if (nextValue && existingInvoker) {
existingInvoker.value = nextValue;
} else {
const [name, options] = parseName(rawName);
if (nextValue) {
const invoker = invokers[rawName] = createInvoker(nextValue, instance);
addEventListener(el, name, invoker, options);
} else if (existingInvoker) {
removeEventListener(el, name, existingInvoker, options);
invokers[rawName] = void 0;
}
}
}
const optionsModifierRE = /(?:Once|Passive|Capture)$/;
function parseName(name) {
let options;
if (optionsModifierRE.test(name)) {
options = {};
let m;
while (m = name.match(optionsModifierRE)) {
name = name.slice(0, name.length - m[0].length);
options[m[0].toLowerCase()] = true;
}
}
const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
return [event, options];
}
let cachedNow = 0;
const p = /* @__PURE__ */ Promise.resolve();
const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
function createInvoker(initialValue, instance) {
const invoker = (e) => {
if (!e._vts) {
e._vts = Date.now();
} else if (e._vts <= invoker.attached) {
return;
}
callWithAsyncErrorHandling(
patchStopImmediatePropagation(e, invoker.value),
instance,
5,
[e]
);
};
invoker.value = initialValue;
invoker.attached = getNow();
return invoker;
}
function patchStopImmediatePropagation(e, value) {
if (isArray(value)) {
const originalStop = e.stopImmediatePropagation;
e.stopImmediatePropagation = () => {
originalStop.call(e);
e._stopped = true;
};
return value.map((fn) => (e2) => !e2._stopped && fn && fn(e2));
} else {
return value;
}
}
const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
const patchProp = (el, key, prevValue, nextValue, isSVG = false, prevChildren, parentComponent, parentSuspense, unmountChildren) => {
if (key === "class") {
patchClass(el, nextValue, isSVG);
} else if (key === "style") {
patchStyle(el, prevValue, nextValue);
} else if (isOn(key)) {
if (!isModelListener(key)) {
patchEvent(el, key, prevValue, nextValue, parentComponent);
}
} else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
patchDOMProp(
el,
key,
nextValue,
prevChildren,
parentComponent,
parentSuspense,
unmountChildren
);
} else {
if (key === "true-value") {
el._trueValue = nextValue;
} else if (key === "false-value") {
el._falseValue = nextValue;
}
patchAttr(el, key, nextValue, isSVG, parentComponent);
}
};
function shouldSetAsProp(el, key, value, isSVG) {
if (isSVG) {
if (key === "innerHTML" || key === "textContent") {
return true;
}
if (key in el && isNativeOn(key) && isFunction(value)) {
return true;
}
return false;
}
if (key === "spellcheck" || key === "draggable" || key === "translate") {
return false;
}
if (key === "form") {
return false;
}
if (key === "list" && el.tagName === "INPUT") {
return false;
}
if (key === "type" && el.tagName === "TEXTAREA") {
return false;
}
if (key === "width" || key === "height") {
const tag = el.tagName;
if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
return false;
}
}
if (isNativeOn(key) && isString(value)) {
return false;
}
return key in el;
}
/*! #__NO_SIDE_EFFECTS__ */
// @__NO_SIDE_EFFECTS__
function defineCustomElement(options, hydrate2) {
const Comp = defineComponent(options);
class VueCustomElement extends VueElement {
constructor(initialProps) {
super(Comp, initialProps, hydrate2);
}
}
VueCustomElement.def = Comp;
return VueCustomElement;
}
/*! #__NO_SIDE_EFFECTS__ */
const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options) => {
return /* @__PURE__ */ defineCustomElement(options, hydrate);
};
const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
};
class VueElement extends BaseClass {
constructor(_def, _props = {}, hydrate2) {
super();
this._def = _def;
this._props = _props;
/**
* @internal
*/
this._instance = null;
this._connected = false;
this._resolved = false;
this._numberProps = null;
this._ob = null;
if (this.shadowRoot && hydrate2) {
hydrate2(this._createVNode(), this.shadowRoot);
} else {
this.attachShadow({ mode: "open" });
if (!this._def.__asyncLoader) {
this._resolveProps(this._def);
}
}
}
connectedCallback() {
this._connected = true;
if (!this._instance) {
if (this._resolved) {
this._update();
} else {
this._resolveDef();
}
}
}
disconnectedCallback() {
this._connected = false;
if (this._ob) {
this._ob.disconnect();
this._ob = null;
}
nextTick(() => {
if (!this._connected) {
render(null, this.shadowRoot);
this._instance = null;
}
});
}
/**
* resolve inner component definition (handle possible async component)
*/
_resolveDef() {
this._resolved = true;
for (let i = 0; i < this.attributes.length; i++) {
this._setAttr(this.attributes[i].name);
}
this._ob = new MutationObserver((mutations) => {
for (const m of mutations) {
this._setAttr(m.attributeName);
}
});
this._ob.observe(this, { attributes: true });
const resolve = (def, isAsync = false) => {
const { props, styles } = def;
let numberProps;
if (props && !isArray(props)) {
for (const key in props) {
const opt = props[key];
if (opt === Number || opt && opt.type === Number) {
if (key in this._props) {
this._props[key] = toNumber(this._props[key]);
}
(numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
}
}
}
this._numberProps = numberProps;
if (isAsync) {
this._resolveProps(def);
}
this._applyStyles(styles);
this._update();
};
const asyncDef = this._def.__asyncLoader;
if (asyncDef) {
asyncDef().then((def) => resolve(def, true));
} else {
resolve(this._def);
}
}
_resolveProps(def) {
const { props } = def;
const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
for (const key of Object.keys(this)) {
if (key[0] !== "_" && declaredPropKeys.includes(key)) {
this._setProp(key, this[key], true, false);
}
}
for (const key of declaredPropKeys.map(camelize)) {
Object.defineProperty(this, key, {
get() {
return this._getProp(key);
},
set(val) {
this._setProp(key, val);
}
});
}
}
_setAttr(key) {
let value = this.getAttribute(key);
const camelKey = camelize(key);
if (this._numberProps && this._numberProps[camelKey]) {
value = toNumber(value);
}
this._setProp(camelKey, value, false);
}
/**
* @internal
*/
_getProp(key) {
return this._props[key];
}
/**
* @internal
*/
_setProp(key, val, shouldReflect = true, shouldUpdate = true) {
if (val !== this._props[key]) {
this._props[key] = val;
if (shouldUpdate && this._instance) {
this._update();
}
if (shouldReflect) {
if (val === true) {
this.setAttribute(hyphenate(key), "");
} else if (typeof val === "string" || typeof val === "number") {
this.setAttribute(hyphenate(key), val + "");
} else if (!val) {
this.removeAttribute(hyphenate(key));
}
}
}
}
_update() {
render(this._createVNode(), this.shadowRoot);
}
_createVNode() {
const vnode = createVNode(this._def, extend({}, this._props));
if (!this._instance) {
vnode.ce = (instance) => {
this._instance = instance;
instance.isCE = true;
const dispatch = (event, args) => {
this.dispatchEvent(
new CustomEvent(event, {
detail: args
})
);
};
instance.emit = (event, ...args) => {
dispatch(event, args);
if (hyphenate(event) !== event) {
dispatch(hyphenate(event), args);
}
};
let parent = this;
while (parent = parent && (parent.parentNode || parent.host)) {
if (parent instanceof VueElement) {
instance.parent = parent._instance;
instance.provides = parent._instance.provides;
break;
}
}
};
}
return vnode;
}
_applyStyles(styles) {
if (styles) {
styles.forEach((css) => {
const s = document.createElement("style");
s.textContent = css;
this.shadowRoot.appendChild(s);
});
}
}
}
function useCssModule(name = "$style") {
{
const instance = getCurrentInstance();
if (!instance) {
return EMPTY_OBJ;
}
const modules = instance.type.__cssModules;
if (!modules) {
return EMPTY_OBJ;
}
const mod = modules[name];
if (!mod) {
return EMPTY_OBJ;
}
return mod;
}
}
const positionMap = /* @__PURE__ */ new WeakMap();
const newPositionMap = /* @__PURE__ */ new WeakMap();
const moveCbKey = Symbol("_moveCb");
const enterCbKey = Symbol("_enterCb");
const TransitionGroupImpl = {
name: "TransitionGroup",
props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
tag: String,
moveClass: String
}),
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
let prevChildren;
let children;
onUpdated(() => {
if (!prevChildren.length) {
return;
}
const moveClass = props.moveClass || `${props.name || "v"}-move`;
if (!hasCSSTransform(
prevChildren[0].el,
instance.vnode.el,
moveClass
)) {
return;
}
prevChildren.forEach(callPendingCbs);
prevChildren.forEach(recordPosition);
const movedChildren = prevChildren.filter(applyTranslation);
forceReflow();
movedChildren.forEach((c) => {
const el = c.el;
const style = el.style;
addTransitionClass(el, moveClass);
style.transform = style.webkitTransform = style.transitionDuration = "";
const cb = el[moveCbKey] = (e) => {
if (e && e.target !== el) {
return;
}
if (!e || /transform$/.test(e.propertyName)) {
el.removeEventListener("transitionend", cb);
el[moveCbKey] = null;
removeTransitionClass(el, moveClass);
}
};
el.addEventListener("transitionend", cb);
});
});
return () => {
const rawProps = toRaw(props);
const cssTransitionProps = resolveTransitionProps(rawProps);
let tag = rawProps.tag || Fragment;
if (!rawProps.tag && compatUtils.checkCompatEnabled(
"TRANSITION_GROUP_ROOT",
instance.parent
)) {
tag = "span";
}
prevChildren = children;
children = slots.default ? getTransitionRawChildren(slots.default()) : [];
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.key != null) {
setTransitionHooks(
child,
resolveTransitionHooks(child, cssTransitionProps, state, instance)
);
}
}
if (prevChildren) {
for (let i = 0; i < prevChildren.length; i++) {
const child = prevChildren[i];
setTransitionHooks(
child,
resolveTransitionHooks(child, cssTransitionProps, state, instance)
);
positionMap.set(child, child.el.getBoundingClientRect());
}
}
return createVNode(tag, null, children);
};
}
};
{
TransitionGroupImpl.__isBuiltIn = true;
}
const removeMode = (props) => delete props.mode;
/* @__PURE__ */ removeMode(TransitionGroupImpl.props);
const TransitionGroup = TransitionGroupImpl;
function callPendingCbs(c) {
const el = c.el;
if (el[moveCbKey]) {
el[moveCbKey]();
}
if (el[enterCbKey]) {
el[enterCbKey]();
}
}
function recordPosition(c) {
newPositionMap.set(c, c.el.getBoundingClientRect());
}
function applyTranslation(c) {
const oldPos = positionMap.get(c);
const newPos = newPositionMap.get(c);
const dx = oldPos.left - newPos.left;
const dy = oldPos.top - newPos.top;
if (dx || dy) {
const s = c.el.style;
s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
s.transitionDuration = "0s";
return c;
}
}
function hasCSSTransform(el, root, moveClass) {
const clone = el.cloneNode();
const _vtc = el[vtcKey];
if (_vtc) {
_vtc.forEach((cls) => {
cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
});
}
moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
clone.style.display = "none";
const container = root.nodeType === 1 ? root : root.parentNode;
container.appendChild(clone);
const { hasTransform } = getTransitionInfo(clone);
container.removeChild(clone);
return hasTransform;
}
const getModelAssigner = (vnode) => {
const fn = vnode.props["onUpdate:modelValue"] || vnode.props["onModelCompat:input"];
return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
};
function onCompositionStart(e) {
e.target.composing = true;
}
function onCompositionEnd(e) {
const target = e.target;
if (target.composing) {
target.composing = false;
target.dispatchEvent(new Event("input"));
}
}
const assignKey = Symbol("_assign");
const vModelText = {
created(el, { modifiers: { lazy, trim, number } }, vnode) {
el[assignKey] = getModelAssigner(vnode);
const castToNumber = number || vnode.props && vnode.props.type === "number";
addEventListener(el, lazy ? "change" : "input", (e) => {
if (e.target.composing)
return;
let domValue = el.value;
if (trim) {
domValue = domValue.trim();
}
if (castToNumber) {
domValue = looseToNumber(domValue);
}
el[assignKey](domValue);
});
if (trim) {
addEventListener(el, "change", () => {
el.value = el.value.trim();
});
}
if (!lazy) {
addEventListener(el, "compositionstart", onCompositionStart);
addEventListener(el, "compositionend", onCompositionEnd);
addEventListener(el, "change", onCompositionEnd);
}
},
// set value on mounted so it's after min/max for type="range"
mounted(el, { value }) {
el.value = value == null ? "" : value;
},
beforeUpdate(el, { value, modifiers: { lazy, trim, number } }, vnode) {
el[assignKey] = getModelAssigner(vnode);
if (el.composing)
return;
const elValue = number || el.type === "number" ? looseToNumber(el.value) : el.value;
const newValue = value == null ? "" : value;
if (elValue === newValue) {
return;
}
if (document.activeElement === el && el.type !== "range") {
if (lazy) {
return;
}
if (trim && el.value.trim() === newValue) {
return;
}
}
el.value = newValue;
}
};
const vModelCheckbox = {
// #4096 array checkboxes need to be deep traversed
deep: true,
created(el, _, vnode) {
el[assignKey] = getModelAssigner(vnode);
addEventListener(el, "change", () => {
const modelValue = el._modelValue;
const elementValue = getValue(el);
const checked = el.checked;
const assign = el[assignKey];
if (isArray(modelValue)) {
const index = looseIndexOf(modelValue, elementValue);
const found = index !== -1;
if (checked && !found) {
assign(modelValue.concat(elementValue));
} else if (!checked && found) {
const filtered = [...modelValue];
filtered.splice(index, 1);
assign(filtered);
}
} else if (isSet(modelValue)) {
const cloned = new Set(modelValue);
if (checked) {
cloned.add(elementValue);
} else {
cloned.delete(elementValue);
}
assign(cloned);
} else {
assign(getCheckboxValue(el, checked));
}
});
},
// set initial checked on mount to wait for true-value/false-value
mounted: setChecked,
beforeUpdate(el, binding, vnode) {
el[assignKey] = getModelAssigner(vnode);
setChecked(el, binding, vnode);
}
};
function setChecked(el, { value, oldValue }, vnode) {
el._modelValue = value;
if (isArray(value)) {
el.checked = looseIndexOf(value, vnode.props.value) > -1;
} else if (isSet(value)) {
el.checked = value.has(vnode.props.value);
} else if (value !== oldValue) {
el.checked = looseEqual(value, getCheckboxValue(el, true));
}
}
const vModelRadio = {
created(el, { value }, vnode) {
el.checked = looseEqual(value, vnode.props.value);
el[assignKey] = getModelAssigner(vnode);
addEventListener(el, "change", () => {
el[assignKey](getValue(el));
});
},
beforeUpdate(el, { value, oldValue }, vnode) {
el[assignKey] = getModelAssigner(vnode);
if (value !== oldValue) {
el.checked = looseEqual(value, vnode.props.value);
}
}
};
const vModelSelect = {
// <select multiple> value need to be deep traversed
deep: true,
created(el, { value, modifiers: { number } }, vnode) {
const isSetModel = isSet(value);
addEventListener(el, "change", () => {
const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
(o) => number ? looseToNumber(getValue(o)) : getValue(o)
);
el[assignKey](
el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
);
});
el[assignKey] = getModelAssigner(vnode);
},
// set value in mounted & updated because <select> relies on its children
// <option>s.
mounted(el, { value }) {
setSelected(el, value);
},
beforeUpdate(el, _binding, vnode) {
el[assignKey] = getModelAssigner(vnode);
},
updated(el, { value }) {
setSelected(el, value);
}
};
function setSelected(el, value) {
const isMultiple = el.multiple;
if (isMultiple && !isArray(value) && !isSet(value)) {
return;
}
for (let i = 0, l = el.options.length; i < l; i++) {
const option = el.options[i];
const optionValue = getValue(option);
if (isMultiple) {
if (isArray(value)) {
option.selected = looseIndexOf(value, optionValue) > -1;
} else {
option.selected = value.has(optionValue);
}
} else {
if (looseEqual(getValue(option), value)) {
if (el.selectedIndex !== i)
el.selectedIndex = i;
return;
}
}
}
if (!isMultiple && el.selectedIndex !== -1) {
el.selectedIndex = -1;
}
}
function getValue(el) {
return "_value" in el ? el._value : el.value;
}
function getCheckboxValue(el, checked) {
const key = checked ? "_trueValue" : "_falseValue";
return key in el ? el[key] : checked;
}
const vModelDynamic = {
created(el, binding, vnode) {
callModelHook(el, binding, vnode, null, "created");
},
mounted(el, binding, vnode) {
callModelHook(el, binding, vnode, null, "mounted");
},
beforeUpdate(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
},
updated(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, "updated");
}
};
function resolveDynamicModel(tagName, type) {
switch (tagName) {
case "SELECT":
return vModelSelect;
case "TEXTAREA":
return vModelText;
default:
switch (type) {
case "checkbox":
return vModelCheckbox;
case "radio":
return vModelRadio;
default:
return vModelText;
}
}
}
function callModelHook(el, binding, vnode, prevVNode, hook) {
const modelToUse = resolveDynamicModel(
el.tagName,
vnode.props && vnode.props.type
);
const fn = modelToUse[hook];
fn && fn(el, binding, vnode, prevVNode);
}
function initVModelForSSR() {
vModelText.getSSRProps = ({ value }) => ({ value });
vModelRadio.getSSRProps = ({ value }, vnode) => {
if (vnode.props && looseEqual(vnode.props.value, value)) {
return { checked: true };
}
};
vModelCheckbox.getSSRProps = ({ value }, vnode) => {
if (isArray(value)) {
if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
return { checked: true };
}
} else if (isSet(value)) {
if (vnode.props && value.has(vnode.props.value)) {
return { checked: true };
}
} else if (value) {
return { checked: true };
}
};
vModelDynamic.getSSRProps = (binding, vnode) => {
if (typeof vnode.type !== "string") {
return;
}
const modelToUse = resolveDynamicModel(
// resolveDynamicModel expects an uppercase tag name, but vnode.type is lowercase
vnode.type.toUpperCase(),
vnode.props && vnode.props.type
);
if (modelToUse.getSSRProps) {
return modelToUse.getSSRProps(binding, vnode);
}
};
}
const systemModifiers = ["ctrl", "shift", "alt", "meta"];
const modifierGuards = {
stop: (e) => e.stopPropagation(),
prevent: (e) => e.preventDefault(),
self: (e) => e.target !== e.currentTarget,
ctrl: (e) => !e.ctrlKey,
shift: (e) => !e.shiftKey,
alt: (e) => !e.altKey,
meta: (e) => !e.metaKey,
left: (e) => "button" in e && e.button !== 0,
middle: (e) => "button" in e && e.button !== 1,
right: (e) => "button" in e && e.button !== 2,
exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
};
const withModifiers = (fn, modifiers) => {
const cache = fn._withMods || (fn._withMods = {});
const cacheKey = modifiers.join(".");
return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
for (let i = 0; i < modifiers.length; i++) {
const guard = modifierGuards[modifiers[i]];
if (guard && guard(event, modifiers))
return;
}
return fn(event, ...args);
});
};
const keyNames = {
esc: "escape",
space: " ",
up: "arrow-up",
left: "arrow-left",
right: "arrow-right",
down: "arrow-down",
delete: "backspace"
};
const withKeys = (fn, modifiers) => {
let globalKeyCodes;
let instance = null;
{
instance = getCurrentInstance();
if (compatUtils.isCompatEnabled("CONFIG_KEY_CODES", instance)) {
if (instance) {
globalKeyCodes = instance.appContext.config.keyCodes;
}
}
}
const cache = fn._withKeys || (fn._withKeys = {});
const cacheKey = modifiers.join(".");
return cache[cacheKey] || (cache[cacheKey] = (event) => {
if (!("key" in event)) {
return;
}
const eventKey = hyphenate(event.key);
if (modifiers.some((k) => k === eventKey || keyNames[k] === eventKey)) {
return fn(event);
}
{
const keyCode = String(event.keyCode);
if (compatUtils.isCompatEnabled(
"V_ON_KEYCODE_MODIFIER",
instance
) && modifiers.some((mod) => mod == keyCode)) {
return fn(event);
}
if (globalKeyCodes) {
for (const mod of modifiers) {
const codes = globalKeyCodes[mod];
if (codes) {
const matches = isArray(codes) ? codes.some((code) => String(code) === keyCode) : String(codes) === keyCode;
if (matches) {
return fn(event);
}
}
}
}
}
});
};
const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
let renderer;
let enabledHydration = false;
function ensureRenderer() {
return renderer || (renderer = createRenderer(rendererOptions));
}
function ensureHydrationRenderer() {
renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
enabledHydration = true;
return renderer;
}
const render = (...args) => {
ensureRenderer().render(...args);
};
const hydrate = (...args) => {
ensureHydrationRenderer().hydrate(...args);
};
const createApp = (...args) => {
const app = ensureRenderer().createApp(...args);
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container)
return;
const component = app._component;
if (!isFunction(component) && !component.render && !component.template) {
component.template = container.innerHTML;
}
container.innerHTML = "";
const proxy = mount(container, false, container instanceof SVGElement);
if (container instanceof Element) {
container.removeAttribute("v-cloak");
container.setAttribute("data-v-app", "");
}
return proxy;
};
return app;
};
const createSSRApp = (...args) => {
const app = ensureHydrationRenderer().createApp(...args);
const { mount } = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (container) {
return mount(container, true, container instanceof SVGElement);
}
};
return app;
};
function normalizeContainer(container) {
if (isString(container)) {
const res = document.querySelector(container);
return res;
}
return container;
}
let ssrDirectiveInitialized = false;
const initDirectivesForSSR = () => {
if (!ssrDirectiveInitialized) {
ssrDirectiveInitialized = true;
initVModelForSSR();
initVShowForSSR();
}
} ;
var runtimeDom = /*#__PURE__*/Object.freeze({
__proto__: null,
BaseTransition: BaseTransition,
BaseTransitionPropsValidators: BaseTransitionPropsValidators,
Comment: Comment,
EffectScope: EffectScope,
Fragment: Fragment,
KeepAlive: KeepAlive,
ReactiveEffect: ReactiveEffect,
Static: Static,
Suspense: Suspense,
Teleport: Teleport,
Text: Text,
Transition: Transition,
TransitionGroup: TransitionGroup,
VueElement: VueElement,
assertNumber: assertNumber,
callWithAsyncErrorHandling: callWithAsyncErrorHandling,
callWithErrorHandling: callWithErrorHandling,
camelize: camelize,
capitalize: capitalize,
cloneVNode: cloneVNode,
compatUtils: compatUtils,
computed: computed,
createApp: createApp,
createBlock: createBlock,
createCommentVNode: createCommentVNode,
createElementBlock: createElementBlock,
createElementVNode: createBaseVNode,
createHydrationRenderer: createHydrationRenderer,
createPropsRestProxy: createPropsRestProxy,
createRenderer: createRenderer,
createSSRApp: createSSRApp,
createSlots: createSlots,
createStaticVNode: createStaticVNode,
createTextVNode: createTextVNode,
createVNode: createVNode,
customRef: customRef,
defineAsyncComponent: defineAsyncComponent,
defineComponent: defineComponent,
defineCustomElement: defineCustomElement,
defineEmits: defineEmits,
defineExpose: defineExpose,
defineModel: defineModel,
defineOptions: defineOptions,
defineProps: defineProps,
defineSSRCustomElement: defineSSRCustomElement,
defineSlots: defineSlots,
get devtools () { return devtools; },
effect: effect,
effectScope: effectScope,
getCurrentInstance: getCurrentInstance,
getCurrentScope: getCurrentScope,
getTransitionRawChildren: getTransitionRawChildren,
guardReactiveProps: guardReactiveProps,
h: h,
handleError: handleError,
hasInjectionContext: hasInjectionContext,
hydrate: hydrate,
initCustomFormatter: initCustomFormatter,
initDirectivesForSSR: initDirectivesForSSR,
inject: inject,
isMemoSame: isMemoSame,
isProxy: isProxy,
isReactive: isReactive,
isReadonly: isReadonly,
isRef: isRef,
isRuntimeOnly: isRuntimeOnly,
isShallow: isShallow,
isVNode: isVNode,
markRaw: markRaw,
mergeDefaults: mergeDefaults,
mergeModels: mergeModels,
mergeProps: mergeProps,
nextTick: nextTick,
normalizeClass: normalizeClass,
normalizeProps: normalizeProps,
normalizeStyle: normalizeStyle,
onActivated: onActivated,
onBeforeMount: onBeforeMount,
onBeforeUnmount: onBeforeUnmount,
onBeforeUpdate: onBeforeUpdate,
onDeactivated: onDeactivated,
onErrorCaptured: onErrorCaptured,
onMounted: onMounted,
onRenderTracked: onRenderTracked,
onRenderTriggered: onRenderTriggered,
onScopeDispose: onScopeDispose,
onServerPrefetch: onServerPrefetch,
onUnmounted: onUnmounted,
onUpdated: onUpdated,
openBlock: openBlock,
popScopeId: popScopeId,
provide: provide,
proxyRefs: proxyRefs,
pushScopeId: pushScopeId,
queuePostFlushCb: queuePostFlushCb,
reactive: reactive,
readonly: readonly,
ref: ref,
registerRuntimeCompiler: registerRuntimeCompiler,
render: render,
renderList: renderList,
renderSlot: renderSlot,
resolveComponent: resolveComponent,
resolveDirective: resolveDirective,
resolveDynamicComponent: resolveDynamicComponent,
resolveFilter: resolveFilter,
resolveTransitionHooks: resolveTransitionHooks,
setBlockTracking: setBlockTracking,
setDevtoolsHook: setDevtoolsHook,
setTransitionHooks: setTransitionHooks,
shallowReactive: shallowReactive,
shallowReadonly: shallowReadonly,
shallowRef: shallowRef,
ssrContextKey: ssrContextKey,
ssrUtils: ssrUtils,
stop: stop,
toDisplayString: toDisplayString,
toHandlerKey: toHandlerKey,
toHandlers: toHandlers,
toRaw: toRaw,
toRef: toRef,
toRefs: toRefs,
toValue: toValue,
transformVNodeArgs: transformVNodeArgs,
triggerRef: triggerRef,
unref: unref,
useAttrs: useAttrs,
useCssModule: useCssModule,
useCssVars: useCssVars,
useModel: useModel,
useSSRContext: useSSRContext,
useSlots: useSlots,
useTransitionState: useTransitionState,
vModelCheckbox: vModelCheckbox,
vModelDynamic: vModelDynamic,
vModelRadio: vModelRadio,
vModelSelect: vModelSelect,
vModelText: vModelText,
vShow: vShow,
version: version,
warn: warn$1,
watch: watch,
watchEffect: watchEffect,
watchPostEffect: watchPostEffect,
watchSyncEffect: watchSyncEffect,
withAsyncContext: withAsyncContext,
withCtx: withCtx,
withDefaults: withDefaults,
withDirectives: withDirectives,
withKeys: withKeys,
withMemo: withMemo,
withModifiers: withModifiers,
withScopeId: withScopeId
});
function wrappedCreateApp(...args) {
const app = createApp(...args);
if (compatUtils.isCompatEnabled("RENDER_FUNCTION", null)) {
app.component("__compat__transition", Transition);
app.component("__compat__transition-group", TransitionGroup);
app.component("__compat__keep-alive", KeepAlive);
app._context.directives.show = vShow;
app._context.directives.model = vModelDynamic;
}
return app;
}
function createCompatVue() {
const Vue = compatUtils.createCompatVue(createApp, wrappedCreateApp);
extend(Vue, runtimeDom);
return Vue;
}
function defaultOnError(error) {
throw error;
}
function defaultOnWarn(msg) {
}
function createCompilerError(code, loc, messages, additionalMessage) {
const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
const error = new SyntaxError(String(msg));
error.code = code;
error.loc = loc;
return error;
}
const errorMessages = {
// parse errors
[0]: "Illegal comment.",
[1]: "CDATA section is allowed only in XML context.",
[2]: "Duplicate attribute.",
[3]: "End tag cannot have attributes.",
[4]: "Illegal '/' in tags.",
[5]: "Unexpected EOF in tag.",
[6]: "Unexpected EOF in CDATA section.",
[7]: "Unexpected EOF in comment.",
[8]: "Unexpected EOF in script.",
[9]: "Unexpected EOF in tag.",
[10]: "Incorrectly closed comment.",
[11]: "Incorrectly opened comment.",
[12]: "Illegal tag name. Use '<' to print '<'.",
[13]: "Attribute value was expected.",
[14]: "End tag name was expected.",
[15]: "Whitespace was expected.",
[16]: "Unexpected '<!--' in comment.",
[17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
[18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
[19]: "Attribute name cannot start with '='.",
[21]: "'<?' is allowed only in XML context.",
[20]: `Unexpected null character.`,
[22]: "Illegal '/' in tags.",
// Vue-specific parse errors
[23]: "Invalid end tag.",
[24]: "Element is missing end tag.",
[25]: "Interpolation end sign was not found.",
[27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
[26]: "Legal directive name was expected.",
// transform errors
[28]: `v-if/v-else-if is missing expression.`,
[29]: `v-if/else branches must use unique keys.`,
[30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
[31]: `v-for is missing expression.`,
[32]: `v-for has invalid expression.`,
[33]: `<template v-for> key should be placed on the <template> tag.`,
[34]: `v-bind is missing expression.`,
[35]: `v-on is missing expression.`,
[36]: `Unexpected custom directive on <slot> outlet.`,
[37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
[38]: `Duplicate slot names found. `,
[39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
[40]: `v-slot can only be used on components or <template> tags.`,
[41]: `v-model is missing expression.`,
[42]: `v-model value must be a valid JavaScript member expression.`,
[43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
[44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
[45]: `Error parsing JavaScript expression: `,
[46]: `<KeepAlive> expects exactly one child component.`,
// generic errors
[47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
[48]: `ES module mode is not supported in this build of compiler.`,
[49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
[50]: `"scopeId" option is only supported in module mode.`,
// deprecations
[51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
[52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
// just to fulfill types
[53]: ``
};
const FRAGMENT = Symbol(``);
const TELEPORT = Symbol(``);
const SUSPENSE = Symbol(``);
const KEEP_ALIVE = Symbol(``);
const BASE_TRANSITION = Symbol(``);
const OPEN_BLOCK = Symbol(``);
const CREATE_BLOCK = Symbol(``);
const CREATE_ELEMENT_BLOCK = Symbol(``);
const CREATE_VNODE = Symbol(``);
const CREATE_ELEMENT_VNODE = Symbol(``);
const CREATE_COMMENT = Symbol(``);
const CREATE_TEXT = Symbol(``);
const CREATE_STATIC = Symbol(``);
const RESOLVE_COMPONENT = Symbol(``);
const RESOLVE_DYNAMIC_COMPONENT = Symbol(
``
);
const RESOLVE_DIRECTIVE = Symbol(``);
const RESOLVE_FILTER = Symbol(``);
const WITH_DIRECTIVES = Symbol(``);
const RENDER_LIST = Symbol(``);
const RENDER_SLOT = Symbol(``);
const CREATE_SLOTS = Symbol(``);
const TO_DISPLAY_STRING = Symbol(``);
const MERGE_PROPS = Symbol(``);
const NORMALIZE_CLASS = Symbol(``);
const NORMALIZE_STYLE = Symbol(``);
const NORMALIZE_PROPS = Symbol(``);
const GUARD_REACTIVE_PROPS = Symbol(``);
const TO_HANDLERS = Symbol(``);
const CAMELIZE = Symbol(``);
const CAPITALIZE = Symbol(``);
const TO_HANDLER_KEY = Symbol(``);
const SET_BLOCK_TRACKING = Symbol(``);
const PUSH_SCOPE_ID = Symbol(``);
const POP_SCOPE_ID = Symbol(``);
const WITH_CTX = Symbol(``);
const UNREF = Symbol(``);
const IS_REF = Symbol(``);
const WITH_MEMO = Symbol(``);
const IS_MEMO_SAME = Symbol(``);
const helperNameMap = {
[FRAGMENT]: `Fragment`,
[TELEPORT]: `Teleport`,
[SUSPENSE]: `Suspense`,
[KEEP_ALIVE]: `KeepAlive`,
[BASE_TRANSITION]: `BaseTransition`,
[OPEN_BLOCK]: `openBlock`,
[CREATE_BLOCK]: `createBlock`,
[CREATE_ELEMENT_BLOCK]: `createElementBlock`,
[CREATE_VNODE]: `createVNode`,
[CREATE_ELEMENT_VNODE]: `createElementVNode`,
[CREATE_COMMENT]: `createCommentVNode`,
[CREATE_TEXT]: `createTextVNode`,
[CREATE_STATIC]: `createStaticVNode`,
[RESOLVE_COMPONENT]: `resolveComponent`,
[RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
[RESOLVE_DIRECTIVE]: `resolveDirective`,
[RESOLVE_FILTER]: `resolveFilter`,
[WITH_DIRECTIVES]: `withDirectives`,
[RENDER_LIST]: `renderList`,
[RENDER_SLOT]: `renderSlot`,
[CREATE_SLOTS]: `createSlots`,
[TO_DISPLAY_STRING]: `toDisplayString`,
[MERGE_PROPS]: `mergeProps`,
[NORMALIZE_CLASS]: `normalizeClass`,
[NORMALIZE_STYLE]: `normalizeStyle`,
[NORMALIZE_PROPS]: `normalizeProps`,
[GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
[TO_HANDLERS]: `toHandlers`,
[CAMELIZE]: `camelize`,
[CAPITALIZE]: `capitalize`,
[TO_HANDLER_KEY]: `toHandlerKey`,
[SET_BLOCK_TRACKING]: `setBlockTracking`,
[PUSH_SCOPE_ID]: `pushScopeId`,
[POP_SCOPE_ID]: `popScopeId`,
[WITH_CTX]: `withCtx`,
[UNREF]: `unref`,
[IS_REF]: `isRef`,
[WITH_MEMO]: `withMemo`,
[IS_MEMO_SAME]: `isMemoSame`
};
function registerRuntimeHelpers(helpers) {
Object.getOwnPropertySymbols(helpers).forEach((s) => {
helperNameMap[s] = helpers[s];
});
}
const locStub = {
source: "",
start: { line: 1, column: 1, offset: 0 },
end: { line: 1, column: 1, offset: 0 }
};
function createRoot(children, loc = locStub) {
return {
type: 0,
children,
helpers: /* @__PURE__ */ new Set(),
components: [],
directives: [],
hoists: [],
imports: [],
cached: 0,
temps: 0,
codegenNode: void 0,
loc
};
}
function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
if (context) {
if (isBlock) {
context.helper(OPEN_BLOCK);
context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
} else {
context.helper(getVNodeHelper(context.inSSR, isComponent));
}
if (directives) {
context.helper(WITH_DIRECTIVES);
}
}
return {
type: 13,
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent,
loc
};
}
function createArrayExpression(elements, loc = locStub) {
return {
type: 17,
loc,
elements
};
}
function createObjectExpression(properties, loc = locStub) {
return {
type: 15,
loc,
properties
};
}
function createObjectProperty(key, value) {
return {
type: 16,
loc: locStub,
key: isString(key) ? createSimpleExpression(key, true) : key,
value
};
}
function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
return {
type: 4,
loc,
content,
isStatic,
constType: isStatic ? 3 : constType
};
}
function createCompoundExpression(children, loc = locStub) {
return {
type: 8,
loc,
children
};
}
function createCallExpression(callee, args = [], loc = locStub) {
return {
type: 14,
loc,
callee,
arguments: args
};
}
function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
return {
type: 18,
params,
returns,
newline,
isSlot,
loc
};
}
function createConditionalExpression(test, consequent, alternate, newline = true) {
return {
type: 19,
test,
consequent,
alternate,
newline,
loc: locStub
};
}
function createCacheExpression(index, value, isVNode = false) {
return {
type: 20,
index,
value,
isVNode,
loc: locStub
};
}
function createBlockStatement(body) {
return {
type: 21,
body,
loc: locStub
};
}
function getVNodeHelper(ssr, isComponent) {
return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
}
function getVNodeBlockHelper(ssr, isComponent) {
return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
}
function convertToBlock(node, { helper, removeHelper, inSSR }) {
if (!node.isBlock) {
node.isBlock = true;
removeHelper(getVNodeHelper(inSSR, node.isComponent));
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(inSSR, node.isComponent));
}
}
const isStaticExp = (p) => p.type === 4 && p.isStatic;
const isBuiltInType = (tag, expected) => tag === expected || tag === hyphenate(expected);
function isCoreComponent(tag) {
if (isBuiltInType(tag, "Teleport")) {
return TELEPORT;
} else if (isBuiltInType(tag, "Suspense")) {
return SUSPENSE;
} else if (isBuiltInType(tag, "KeepAlive")) {
return KEEP_ALIVE;
} else if (isBuiltInType(tag, "BaseTransition")) {
return BASE_TRANSITION;
}
}
const nonIdentifierRE = /^\d|[^\$\w]/;
const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
const isMemberExpressionNode = (path, context) => {
try {
let ret = parser.parseExpression(path, {
plugins: context.expressionPlugins
});
if (ret.type === "TSAsExpression" || ret.type === "TSTypeAssertion") {
ret = ret.expression;
}
return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined";
} catch (e) {
return false;
}
};
const isMemberExpression = isMemberExpressionNode;
function getInnerRange(loc, offset, length) {
const source = loc.source.slice(offset, offset + length);
const newLoc = {
source,
start: advancePositionWithClone(loc.start, loc.source, offset),
end: loc.end
};
if (length != null) {
newLoc.end = advancePositionWithClone(
loc.start,
loc.source,
offset + length
);
}
return newLoc;
}
function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
return advancePositionWithMutation(
extend({}, pos),
source,
numberOfCharacters
);
}
function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
let linesCount = 0;
let lastNewLinePos = -1;
for (let i = 0; i < numberOfCharacters; i++) {
if (source.charCodeAt(i) === 10) {
linesCount++;
lastNewLinePos = i;
}
}
pos.offset += numberOfCharacters;
pos.line += linesCount;
pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
return pos;
}
function findDir(node, name, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
return p;
}
}
}
function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (dynamicOnly)
continue;
if (p.name === name && (p.value || allowEmpty)) {
return p;
}
} else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
return p;
}
}
}
function isStaticArgOf(arg, name) {
return !!(arg && isStaticExp(arg) && arg.content === name);
}
function hasDynamicKeyVBind(node) {
return node.props.some(
(p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
p.arg.type !== 4 || // v-bind:[_ctx.foo]
!p.arg.isStatic)
// v-bind:[foo]
);
}
function isText$1(node) {
return node.type === 5 || node.type === 2;
}
function isVSlot(p) {
return p.type === 7 && p.name === "slot";
}
function isTemplateNode(node) {
return node.type === 1 && node.tagType === 3;
}
function isSlotOutlet(node) {
return node.type === 1 && node.tagType === 2;
}
const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
function getUnnormalizedProps(props, callPath = []) {
if (props && !isString(props) && props.type === 14) {
const callee = props.callee;
if (!isString(callee) && propsHelperSet.has(callee)) {
return getUnnormalizedProps(
props.arguments[0],
callPath.concat(props)
);
}
}
return [props, callPath];
}
function injectProp(node, prop, context) {
let propsWithInjection;
let props = node.type === 13 ? node.props : node.arguments[2];
let callPath = [];
let parentCall;
if (props && !isString(props) && props.type === 14) {
const ret = getUnnormalizedProps(props);
props = ret[0];
callPath = ret[1];
parentCall = callPath[callPath.length - 1];
}
if (props == null || isString(props)) {
propsWithInjection = createObjectExpression([prop]);
} else if (props.type === 14) {
const first = props.arguments[0];
if (!isString(first) && first.type === 15) {
if (!hasProp(prop, first)) {
first.properties.unshift(prop);
}
} else {
if (props.callee === TO_HANDLERS) {
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
createObjectExpression([prop]),
props
]);
} else {
props.arguments.unshift(createObjectExpression([prop]));
}
}
!propsWithInjection && (propsWithInjection = props);
} else if (props.type === 15) {
if (!hasProp(prop, props)) {
props.properties.unshift(prop);
}
propsWithInjection = props;
} else {
propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
createObjectExpression([prop]),
props
]);
if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
parentCall = callPath[callPath.length - 2];
}
}
if (node.type === 13) {
if (parentCall) {
parentCall.arguments[0] = propsWithInjection;
} else {
node.props = propsWithInjection;
}
} else {
if (parentCall) {
parentCall.arguments[0] = propsWithInjection;
} else {
node.arguments[2] = propsWithInjection;
}
}
}
function hasProp(prop, props) {
let result = false;
if (prop.key.type === 4) {
const propKeyName = prop.key.content;
result = props.properties.some(
(p) => p.key.type === 4 && p.key.content === propKeyName
);
}
return result;
}
function toValidAssetId(name, type) {
return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
})}`;
}
function hasScopeRef(node, ids) {
if (!node || Object.keys(ids).length === 0) {
return false;
}
switch (node.type) {
case 1:
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && (hasScopeRef(p.arg, ids) || hasScopeRef(p.exp, ids))) {
return true;
}
}
return node.children.some((c) => hasScopeRef(c, ids));
case 11:
if (hasScopeRef(node.source, ids)) {
return true;
}
return node.children.some((c) => hasScopeRef(c, ids));
case 9:
return node.branches.some((b) => hasScopeRef(b, ids));
case 10:
if (hasScopeRef(node.condition, ids)) {
return true;
}
return node.children.some((c) => hasScopeRef(c, ids));
case 4:
return !node.isStatic && isSimpleIdentifier(node.content) && !!ids[node.content];
case 8:
return node.children.some((c) => isObject(c) && hasScopeRef(c, ids));
case 5:
case 12:
return hasScopeRef(node.content, ids);
case 2:
case 3:
return false;
default:
return false;
}
}
function getMemoedVNodeCall(node) {
if (node.type === 14 && node.callee === WITH_MEMO) {
return node.arguments[1].returns;
} else {
return node;
}
}
const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
function getCompatValue(key, context) {
const config = context.options ? context.options.compatConfig : context.compatConfig;
const value = config && config[key];
if (key === "MODE") {
return value || 3;
} else {
return value;
}
}
function isCompatEnabled(key, context) {
const mode = getCompatValue("MODE", context);
const value = getCompatValue(key, context);
return mode === 3 ? value === true : value !== false;
}
function checkCompatEnabled(key, context, loc, ...args) {
const enabled = isCompatEnabled(key, context);
return enabled;
}
const decodeRE = /&(gt|lt|amp|apos|quot);/g;
const decodeMap = {
gt: ">",
lt: "<",
amp: "&",
apos: "'",
quot: '"'
};
const defaultParserOptions = {
delimiters: [`{{`, `}}`],
getNamespace: () => 0,
getTextMode: () => 0,
isVoidTag: NO,
isPreTag: NO,
isCustomElement: NO,
decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
onError: defaultOnError,
onWarn: defaultOnWarn,
comments: false
};
function baseParse(content, options = {}) {
const context = createParserContext(content, options);
const start = getCursor(context);
return createRoot(
parseChildren(context, 0, []),
getSelection(context, start)
);
}
function createParserContext(content, rawOptions) {
const options = extend({}, defaultParserOptions);
let key;
for (key in rawOptions) {
options[key] = rawOptions[key] === void 0 ? defaultParserOptions[key] : rawOptions[key];
}
return {
options,
column: 1,
line: 1,
offset: 0,
originalSource: content,
source: content,
inPre: false,
inVPre: false,
onWarn: options.onWarn
};
}
function parseChildren(context, mode, ancestors) {
const parent = last(ancestors);
const ns = parent ? parent.ns : 0;
const nodes = [];
while (!isEnd(context, mode, ancestors)) {
const s = context.source;
let node = void 0;
if (mode === 0 || mode === 1) {
if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
node = parseInterpolation(context, mode);
} else if (mode === 0 && s[0] === "<") {
if (s.length === 1) {
emitError(context, 5, 1);
} else if (s[1] === "!") {
if (startsWith(s, "<!--")) {
node = parseComment(context);
} else if (startsWith(s, "<!DOCTYPE")) {
node = parseBogusComment(context);
} else if (startsWith(s, "<![CDATA[")) {
if (ns !== 0) {
node = parseCDATA(context, ancestors);
} else {
emitError(context, 1);
node = parseBogusComment(context);
}
} else {
emitError(context, 11);
node = parseBogusComment(context);
}
} else if (s[1] === "/") {
if (s.length === 2) {
emitError(context, 5, 2);
} else if (s[2] === ">") {
emitError(context, 14, 2);
advanceBy(context, 3);
continue;
} else if (/[a-z]/i.test(s[2])) {
emitError(context, 23);
parseTag(context, 1 /* End */, parent);
continue;
} else {
emitError(
context,
12,
2
);
node = parseBogusComment(context);
}
} else if (/[a-z]/i.test(s[1])) {
node = parseElement(context, ancestors);
if (isCompatEnabled(
"COMPILER_NATIVE_TEMPLATE",
context
) && node && node.tag === "template" && !node.props.some(
(p) => p.type === 7 && isSpecialTemplateDirective(p.name)
)) {
node = node.children;
}
} else if (s[1] === "?") {
emitError(
context,
21,
1
);
node = parseBogusComment(context);
} else {
emitError(context, 12, 1);
}
}
}
if (!node) {
node = parseText(context, mode);
}
if (isArray(node)) {
for (let i = 0; i < node.length; i++) {
pushNode(nodes, node[i]);
}
} else {
pushNode(nodes, node);
}
}
let removedWhitespace = false;
if (mode !== 2 && mode !== 1) {
const shouldCondense = context.options.whitespace !== "preserve";
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (node.type === 2) {
if (!context.inPre) {
if (!/[^\t\r\n\f ]/.test(node.content)) {
const prev = nodes[i - 1];
const next = nodes[i + 1];
if (!prev || !next || shouldCondense && (prev.type === 3 && next.type === 3 || prev.type === 3 && next.type === 1 || prev.type === 1 && next.type === 3 || prev.type === 1 && next.type === 1 && /[\r\n]/.test(node.content))) {
removedWhitespace = true;
nodes[i] = null;
} else {
node.content = " ";
}
} else if (shouldCondense) {
node.content = node.content.replace(/[\t\r\n\f ]+/g, " ");
}
} else {
node.content = node.content.replace(/\r\n/g, "\n");
}
} else if (node.type === 3 && !context.options.comments) {
removedWhitespace = true;
nodes[i] = null;
}
}
if (context.inPre && parent && context.options.isPreTag(parent.tag)) {
const first = nodes[0];
if (first && first.type === 2) {
first.content = first.content.replace(/^\r?\n/, "");
}
}
}
return removedWhitespace ? nodes.filter(Boolean) : nodes;
}
function pushNode(nodes, node) {
if (node.type === 2) {
const prev = last(nodes);
if (prev && prev.type === 2 && prev.loc.end.offset === node.loc.start.offset) {
prev.content += node.content;
prev.loc.end = node.loc.end;
prev.loc.source += node.loc.source;
return;
}
}
nodes.push(node);
}
function parseCDATA(context, ancestors) {
advanceBy(context, 9);
const nodes = parseChildren(context, 3, ancestors);
if (context.source.length === 0) {
emitError(context, 6);
} else {
advanceBy(context, 3);
}
return nodes;
}
function parseComment(context) {
const start = getCursor(context);
let content;
const match = /--(\!)?>/.exec(context.source);
if (!match) {
content = context.source.slice(4);
advanceBy(context, context.source.length);
emitError(context, 7);
} else {
if (match.index <= 3) {
emitError(context, 0);
}
if (match[1]) {
emitError(context, 10);
}
content = context.source.slice(4, match.index);
const s = context.source.slice(0, match.index);
let prevIndex = 1, nestedIndex = 0;
while ((nestedIndex = s.indexOf("<!--", prevIndex)) !== -1) {
advanceBy(context, nestedIndex - prevIndex + 1);
if (nestedIndex + 4 < s.length) {
emitError(context, 16);
}
prevIndex = nestedIndex + 1;
}
advanceBy(context, match.index + match[0].length - prevIndex + 1);
}
return {
type: 3,
content,
loc: getSelection(context, start)
};
}
function parseBogusComment(context) {
const start = getCursor(context);
const contentStart = context.source[1] === "?" ? 1 : 2;
let content;
const closeIndex = context.source.indexOf(">");
if (closeIndex === -1) {
content = context.source.slice(contentStart);
advanceBy(context, context.source.length);
} else {
content = context.source.slice(contentStart, closeIndex);
advanceBy(context, closeIndex + 1);
}
return {
type: 3,
content,
loc: getSelection(context, start)
};
}
function parseElement(context, ancestors) {
const wasInPre = context.inPre;
const wasInVPre = context.inVPre;
const parent = last(ancestors);
const element = parseTag(context, 0 /* Start */, parent);
const isPreBoundary = context.inPre && !wasInPre;
const isVPreBoundary = context.inVPre && !wasInVPre;
if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
if (isPreBoundary) {
context.inPre = false;
}
if (isVPreBoundary) {
context.inVPre = false;
}
return element;
}
ancestors.push(element);
const mode = context.options.getTextMode(element, parent);
const children = parseChildren(context, mode, ancestors);
ancestors.pop();
{
const inlineTemplateProp = element.props.find(
(p) => p.type === 6 && p.name === "inline-template"
);
if (inlineTemplateProp && checkCompatEnabled(
"COMPILER_INLINE_TEMPLATE",
context,
inlineTemplateProp.loc
)) {
const loc = getSelection(context, element.loc.end);
inlineTemplateProp.value = {
type: 2,
content: loc.source,
loc
};
}
}
element.children = children;
if (startsWithEndTagOpen(context.source, element.tag)) {
parseTag(context, 1 /* End */, parent);
} else {
emitError(context, 24, 0, element.loc.start);
if (context.source.length === 0 && element.tag.toLowerCase() === "script") {
const first = children[0];
if (first && startsWith(first.loc.source, "<!--")) {
emitError(context, 8);
}
}
}
element.loc = getSelection(context, element.loc.start);
if (isPreBoundary) {
context.inPre = false;
}
if (isVPreBoundary) {
context.inVPre = false;
}
return element;
}
const isSpecialTemplateDirective = /* @__PURE__ */ makeMap(
`if,else,else-if,for,slot`
);
function parseTag(context, type, parent) {
const start = getCursor(context);
const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
const tag = match[1];
const ns = context.options.getNamespace(tag, parent);
advanceBy(context, match[0].length);
advanceSpaces(context);
const cursor = getCursor(context);
const currentSource = context.source;
if (context.options.isPreTag(tag)) {
context.inPre = true;
}
let props = parseAttributes(context, type);
if (type === 0 /* Start */ && !context.inVPre && props.some((p) => p.type === 7 && p.name === "pre")) {
context.inVPre = true;
extend(context, cursor);
context.source = currentSource;
props = parseAttributes(context, type).filter((p) => p.name !== "v-pre");
}
let isSelfClosing = false;
if (context.source.length === 0) {
emitError(context, 9);
} else {
isSelfClosing = startsWith(context.source, "/>");
if (type === 1 /* End */ && isSelfClosing) {
emitError(context, 4);
}
advanceBy(context, isSelfClosing ? 2 : 1);
}
if (type === 1 /* End */) {
return;
}
let tagType = 0;
if (!context.inVPre) {
if (tag === "slot") {
tagType = 2;
} else if (tag === "template") {
if (props.some(
(p) => p.type === 7 && isSpecialTemplateDirective(p.name)
)) {
tagType = 3;
}
} else if (isComponent(tag, props, context)) {
tagType = 1;
}
}
return {
type: 1,
ns,
tag,
tagType,
props,
isSelfClosing,
children: [],
loc: getSelection(context, start),
codegenNode: void 0
// to be created during transform phase
};
}
function isComponent(tag, props, context) {
const options = context.options;
if (options.isCustomElement(tag)) {
return false;
}
if (tag === "component" || /^[A-Z]/.test(tag) || isCoreComponent(tag) || options.isBuiltInComponent && options.isBuiltInComponent(tag) || options.isNativeTag && !options.isNativeTag(tag)) {
return true;
}
for (let i = 0; i < props.length; i++) {
const p = props[i];
if (p.type === 6) {
if (p.name === "is" && p.value) {
if (p.value.content.startsWith("vue:")) {
return true;
} else if (checkCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context,
p.loc
)) {
return true;
}
}
} else {
if (p.name === "is") {
return true;
} else if (
// :is on plain element - only treat as component in compat mode
p.name === "bind" && isStaticArgOf(p.arg, "is") && true && checkCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context,
p.loc
)
) {
return true;
}
}
}
}
function parseAttributes(context, type) {
const props = [];
const attributeNames = /* @__PURE__ */ new Set();
while (context.source.length > 0 && !startsWith(context.source, ">") && !startsWith(context.source, "/>")) {
if (startsWith(context.source, "/")) {
emitError(context, 22);
advanceBy(context, 1);
advanceSpaces(context);
continue;
}
if (type === 1 /* End */) {
emitError(context, 3);
}
const attr = parseAttribute(context, attributeNames);
if (attr.type === 6 && attr.value && attr.name === "class") {
attr.value.content = attr.value.content.replace(/\s+/g, " ").trim();
}
if (type === 0 /* Start */) {
props.push(attr);
}
if (/^[^\t\r\n\f />]/.test(context.source)) {
emitError(context, 15);
}
advanceSpaces(context);
}
return props;
}
function parseAttribute(context, nameSet) {
var _a;
const start = getCursor(context);
const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
const name = match[0];
if (nameSet.has(name)) {
emitError(context, 2);
}
nameSet.add(name);
if (name[0] === "=") {
emitError(context, 19);
}
{
const pattern = /["'<]/g;
let m;
while (m = pattern.exec(name)) {
emitError(
context,
17,
m.index
);
}
}
advanceBy(context, name.length);
let value = void 0;
if (/^[\t\r\n\f ]*=/.test(context.source)) {
advanceSpaces(context);
advanceBy(context, 1);
advanceSpaces(context);
value = parseAttributeValue(context);
if (!value) {
emitError(context, 13);
}
}
const loc = getSelection(context, start);
if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) {
const match2 = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(
name
);
let isPropShorthand = startsWith(name, ".");
let dirName = match2[1] || (isPropShorthand || startsWith(name, ":") ? "bind" : startsWith(name, "@") ? "on" : "slot");
let arg;
if (match2[2]) {
const isSlot = dirName === "slot";
const startOffset = name.lastIndexOf(
match2[2],
name.length - (((_a = match2[3]) == null ? void 0 : _a.length) || 0)
);
const loc2 = getSelection(
context,
getNewPosition(context, start, startOffset),
getNewPosition(
context,
start,
startOffset + match2[2].length + (isSlot && match2[3] || "").length
)
);
let content = match2[2];
let isStatic = true;
if (content.startsWith("[")) {
isStatic = false;
if (!content.endsWith("]")) {
emitError(
context,
27
);
content = content.slice(1);
} else {
content = content.slice(1, content.length - 1);
}
} else if (isSlot) {
content += match2[3] || "";
}
arg = {
type: 4,
content,
isStatic,
constType: isStatic ? 3 : 0,
loc: loc2
};
}
if (value && value.isQuoted) {
const valueLoc = value.loc;
valueLoc.start.offset++;
valueLoc.start.column++;
valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
valueLoc.source = valueLoc.source.slice(1, -1);
}
const modifiers = match2[3] ? match2[3].slice(1).split(".") : [];
if (isPropShorthand)
modifiers.push("prop");
if (dirName === "bind" && arg) {
if (modifiers.includes("sync") && checkCompatEnabled(
"COMPILER_V_BIND_SYNC",
context,
loc,
arg.loc.source
)) {
dirName = "model";
modifiers.splice(modifiers.indexOf("sync"), 1);
}
}
return {
type: 7,
name: dirName,
exp: value && {
type: 4,
content: value.content,
isStatic: false,
// Treat as non-constant by default. This can be potentially set to
// other values by `transformExpression` to make it eligible for hoisting.
constType: 0,
loc: value.loc
},
arg,
modifiers,
loc
};
}
if (!context.inVPre && startsWith(name, "v-")) {
emitError(context, 26);
}
return {
type: 6,
name,
value: value && {
type: 2,
content: value.content,
loc: value.loc
},
loc
};
}
function parseAttributeValue(context) {
const start = getCursor(context);
let content;
const quote = context.source[0];
const isQuoted = quote === `"` || quote === `'`;
if (isQuoted) {
advanceBy(context, 1);
const endIndex = context.source.indexOf(quote);
if (endIndex === -1) {
content = parseTextData(
context,
context.source.length,
4
);
} else {
content = parseTextData(context, endIndex, 4);
advanceBy(context, 1);
}
} else {
const match = /^[^\t\r\n\f >]+/.exec(context.source);
if (!match) {
return void 0;
}
const unexpectedChars = /["'<=`]/g;
let m;
while (m = unexpectedChars.exec(match[0])) {
emitError(
context,
18,
m.index
);
}
content = parseTextData(context, match[0].length, 4);
}
return { content, isQuoted, loc: getSelection(context, start) };
}
function parseInterpolation(context, mode) {
const [open, close] = context.options.delimiters;
const closeIndex = context.source.indexOf(close, open.length);
if (closeIndex === -1) {
emitError(context, 25);
return void 0;
}
const start = getCursor(context);
advanceBy(context, open.length);
const innerStart = getCursor(context);
const innerEnd = getCursor(context);
const rawContentLength = closeIndex - open.length;
const rawContent = context.source.slice(0, rawContentLength);
const preTrimContent = parseTextData(context, rawContentLength, mode);
const content = preTrimContent.trim();
const startOffset = preTrimContent.indexOf(content);
if (startOffset > 0) {
advancePositionWithMutation(innerStart, rawContent, startOffset);
}
const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
advancePositionWithMutation(innerEnd, rawContent, endOffset);
advanceBy(context, close.length);
return {
type: 5,
content: {
type: 4,
isStatic: false,
// Set `isConstant` to false by default and will decide in transformExpression
constType: 0,
content,
loc: getSelection(context, innerStart, innerEnd)
},
loc: getSelection(context, start)
};
}
function parseText(context, mode) {
const endTokens = mode === 3 ? ["]]>"] : ["<", context.options.delimiters[0]];
let endIndex = context.source.length;
for (let i = 0; i < endTokens.length; i++) {
const index = context.source.indexOf(endTokens[i], 1);
if (index !== -1 && endIndex > index) {
endIndex = index;
}
}
const start = getCursor(context);
const content = parseTextData(context, endIndex, mode);
return {
type: 2,
content,
loc: getSelection(context, start)
};
}
function parseTextData(context, length, mode) {
const rawText = context.source.slice(0, length);
advanceBy(context, length);
if (mode === 2 || mode === 3 || !rawText.includes("&")) {
return rawText;
} else {
return context.options.decodeEntities(
rawText,
mode === 4
);
}
}
function getCursor(context) {
const { column, line, offset } = context;
return { column, line, offset };
}
function getSelection(context, start, end) {
end = end || getCursor(context);
return {
start,
end,
source: context.originalSource.slice(start.offset, end.offset)
};
}
function last(xs) {
return xs[xs.length - 1];
}
function startsWith(source, searchString) {
return source.startsWith(searchString);
}
function advanceBy(context, numberOfCharacters) {
const { source } = context;
advancePositionWithMutation(context, source, numberOfCharacters);
context.source = source.slice(numberOfCharacters);
}
function advanceSpaces(context) {
const match = /^[\t\r\n\f ]+/.exec(context.source);
if (match) {
advanceBy(context, match[0].length);
}
}
function getNewPosition(context, start, numberOfCharacters) {
return advancePositionWithClone(
start,
context.originalSource.slice(start.offset, numberOfCharacters),
numberOfCharacters
);
}
function emitError(context, code, offset, loc = getCursor(context)) {
if (offset) {
loc.offset += offset;
loc.column += offset;
}
context.options.onError(
createCompilerError(code, {
start: loc,
end: loc,
source: ""
})
);
}
function isEnd(context, mode, ancestors) {
const s = context.source;
switch (mode) {
case 0:
if (startsWith(s, "</")) {
for (let i = ancestors.length - 1; i >= 0; --i) {
if (startsWithEndTagOpen(s, ancestors[i].tag)) {
return true;
}
}
}
break;
case 1:
case 2: {
const parent = last(ancestors);
if (parent && startsWithEndTagOpen(s, parent.tag)) {
return true;
}
break;
}
case 3:
if (startsWith(s, "]]>")) {
return true;
}
break;
}
return !s;
}
function startsWithEndTagOpen(source, tag) {
return startsWith(source, "</") && source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && /[\t\r\n\f />]/.test(source[2 + tag.length] || ">");
}
function hoistStatic(root, context) {
walk(
root,
context,
// Root node is unfortunately non-hoistable due to potential parent
// fallthrough attributes.
isSingleElementRoot(root, root.children[0])
);
}
function isSingleElementRoot(root, child) {
const { children } = root;
return children.length === 1 && child.type === 1 && !isSlotOutlet(child);
}
function walk(node, context, doNotHoistNode = false) {
const { children } = node;
const originalCount = children.length;
let hoistedCount = 0;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (child.type === 1 && child.tagType === 0) {
const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
if (constantType > 0) {
if (constantType >= 2) {
child.codegenNode.patchFlag = -1 + (``);
child.codegenNode = context.hoist(child.codegenNode);
hoistedCount++;
continue;
}
} else {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) {
const flag = getPatchFlag(codegenNode);
if ((!flag || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
const props = getNodeProps(child);
if (props) {
codegenNode.props = context.hoist(props);
}
}
if (codegenNode.dynamicProps) {
codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
}
}
}
}
if (child.type === 1) {
const isComponent = child.tagType === 1;
if (isComponent) {
context.scopes.vSlot++;
}
walk(child, context);
if (isComponent) {
context.scopes.vSlot--;
}
} else if (child.type === 11) {
walk(child, context, child.children.length === 1);
} else if (child.type === 9) {
for (let i2 = 0; i2 < child.branches.length; i2++) {
walk(
child.branches[i2],
context,
child.branches[i2].children.length === 1
);
}
}
}
if (hoistedCount && context.transformHoist) {
context.transformHoist(children, context, node);
}
if (hoistedCount && hoistedCount === originalCount && node.type === 1 && node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
const hoisted = context.hoist(
createArrayExpression(node.codegenNode.children)
);
if (context.hmr) {
hoisted.content = `[...${hoisted.content}]`;
}
node.codegenNode.children = hoisted;
}
}
function getConstantType(node, context) {
const { constantCache } = context;
switch (node.type) {
case 1:
if (node.tagType !== 0) {
return 0;
}
const cached = constantCache.get(node);
if (cached !== void 0) {
return cached;
}
const codegenNode = node.codegenNode;
if (codegenNode.type !== 13) {
return 0;
}
if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject") {
return 0;
}
const flag = getPatchFlag(codegenNode);
if (!flag) {
let returnType2 = 3;
const generatedPropsType = getGeneratedPropsConstantType(node, context);
if (generatedPropsType === 0) {
constantCache.set(node, 0);
return 0;
}
if (generatedPropsType < returnType2) {
returnType2 = generatedPropsType;
}
for (let i = 0; i < node.children.length; i++) {
const childType = getConstantType(node.children[i], context);
if (childType === 0) {
constantCache.set(node, 0);
return 0;
}
if (childType < returnType2) {
returnType2 = childType;
}
}
if (returnType2 > 1) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7 && p.name === "bind" && p.exp) {
const expType = getConstantType(p.exp, context);
if (expType === 0) {
constantCache.set(node, 0);
return 0;
}
if (expType < returnType2) {
returnType2 = expType;
}
}
}
}
if (codegenNode.isBlock) {
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 7) {
constantCache.set(node, 0);
return 0;
}
}
context.removeHelper(OPEN_BLOCK);
context.removeHelper(
getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
);
codegenNode.isBlock = false;
context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
}
constantCache.set(node, returnType2);
return returnType2;
} else {
constantCache.set(node, 0);
return 0;
}
case 2:
case 3:
return 3;
case 9:
case 11:
case 10:
return 0;
case 5:
case 12:
return getConstantType(node.content, context);
case 4:
return node.constType;
case 8:
let returnType = 3;
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child) || isSymbol(child)) {
continue;
}
const childType = getConstantType(child, context);
if (childType === 0) {
return 0;
} else if (childType < returnType) {
returnType = childType;
}
}
return returnType;
default:
return 0;
}
}
const allowHoistedHelperSet = /* @__PURE__ */ new Set([
NORMALIZE_CLASS,
NORMALIZE_STYLE,
NORMALIZE_PROPS,
GUARD_REACTIVE_PROPS
]);
function getConstantTypeOfHelperCall(value, context) {
if (value.type === 14 && !isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
const arg = value.arguments[0];
if (arg.type === 4) {
return getConstantType(arg, context);
} else if (arg.type === 14) {
return getConstantTypeOfHelperCall(arg, context);
}
}
return 0;
}
function getGeneratedPropsConstantType(node, context) {
let returnType = 3;
const props = getNodeProps(node);
if (props && props.type === 15) {
const { properties } = props;
for (let i = 0; i < properties.length; i++) {
const { key, value } = properties[i];
const keyType = getConstantType(key, context);
if (keyType === 0) {
return keyType;
}
if (keyType < returnType) {
returnType = keyType;
}
let valueType;
if (value.type === 4) {
valueType = getConstantType(value, context);
} else if (value.type === 14) {
valueType = getConstantTypeOfHelperCall(value, context);
} else {
valueType = 0;
}
if (valueType === 0) {
return valueType;
}
if (valueType < returnType) {
returnType = valueType;
}
}
}
return returnType;
}
function getNodeProps(node) {
const codegenNode = node.codegenNode;
if (codegenNode.type === 13) {
return codegenNode.props;
}
}
function getPatchFlag(node) {
const flag = node.patchFlag;
return flag ? parseInt(flag, 10) : void 0;
}
function createTransformContext(root, {
filename = "",
prefixIdentifiers = false,
hoistStatic: hoistStatic2 = false,
hmr = false,
cacheHandlers = false,
nodeTransforms = [],
directiveTransforms = {},
transformHoist = null,
isBuiltInComponent = NOOP,
isCustomElement = NOOP,
expressionPlugins = [],
scopeId = null,
slotted = true,
ssr = false,
inSSR = false,
ssrCssVars = ``,
bindingMetadata = EMPTY_OBJ,
inline = false,
isTS = false,
onError = defaultOnError,
onWarn = defaultOnWarn,
compatConfig
}) {
const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
const context = {
// options
selfName: nameMatch && capitalize(camelize(nameMatch[1])),
prefixIdentifiers,
hoistStatic: hoistStatic2,
hmr,
cacheHandlers,
nodeTransforms,
directiveTransforms,
transformHoist,
isBuiltInComponent,
isCustomElement,
expressionPlugins,
scopeId,
slotted,
ssr,
inSSR,
ssrCssVars,
bindingMetadata,
inline,
isTS,
onError,
onWarn,
compatConfig,
// state
root,
helpers: /* @__PURE__ */ new Map(),
components: /* @__PURE__ */ new Set(),
directives: /* @__PURE__ */ new Set(),
hoists: [],
imports: [],
constantCache: /* @__PURE__ */ new WeakMap(),
temps: 0,
cached: 0,
identifiers: /* @__PURE__ */ Object.create(null),
scopes: {
vFor: 0,
vSlot: 0,
vPre: 0,
vOnce: 0
},
parent: null,
currentNode: root,
childIndex: 0,
inVOnce: false,
// methods
helper(name) {
const count = context.helpers.get(name) || 0;
context.helpers.set(name, count + 1);
return name;
},
removeHelper(name) {
const count = context.helpers.get(name);
if (count) {
const currentCount = count - 1;
if (!currentCount) {
context.helpers.delete(name);
} else {
context.helpers.set(name, currentCount);
}
}
},
helperString(name) {
return `_${helperNameMap[context.helper(name)]}`;
},
replaceNode(node) {
context.parent.children[context.childIndex] = context.currentNode = node;
},
removeNode(node) {
const list = context.parent.children;
const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
if (!node || node === context.currentNode) {
context.currentNode = null;
context.onNodeRemoved();
} else {
if (context.childIndex > removalIndex) {
context.childIndex--;
context.onNodeRemoved();
}
}
context.parent.children.splice(removalIndex, 1);
},
onNodeRemoved: () => {
},
addIdentifiers(exp) {
{
if (isString(exp)) {
addId(exp);
} else if (exp.identifiers) {
exp.identifiers.forEach(addId);
} else if (exp.type === 4) {
addId(exp.content);
}
}
},
removeIdentifiers(exp) {
{
if (isString(exp)) {
removeId(exp);
} else if (exp.identifiers) {
exp.identifiers.forEach(removeId);
} else if (exp.type === 4) {
removeId(exp.content);
}
}
},
hoist(exp) {
if (isString(exp))
exp = createSimpleExpression(exp);
context.hoists.push(exp);
const identifier = createSimpleExpression(
`_hoisted_${context.hoists.length}`,
false,
exp.loc,
2
);
identifier.hoisted = exp;
return identifier;
},
cache(exp, isVNode = false) {
return createCacheExpression(context.cached++, exp, isVNode);
}
};
{
context.filters = /* @__PURE__ */ new Set();
}
function addId(id) {
const { identifiers } = context;
if (identifiers[id] === void 0) {
identifiers[id] = 0;
}
identifiers[id]++;
}
function removeId(id) {
context.identifiers[id]--;
}
return context;
}
function transform(root, options) {
const context = createTransformContext(root, options);
traverseNode(root, context);
if (options.hoistStatic) {
hoistStatic(root, context);
}
if (!options.ssr) {
createRootCodegen(root, context);
}
root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
root.components = [...context.components];
root.directives = [...context.directives];
root.imports = context.imports;
root.hoists = context.hoists;
root.temps = context.temps;
root.cached = context.cached;
{
root.filters = [...context.filters];
}
}
function createRootCodegen(root, context) {
const { helper } = context;
const { children } = root;
if (children.length === 1) {
const child = children[0];
if (isSingleElementRoot(root, child) && child.codegenNode) {
const codegenNode = child.codegenNode;
if (codegenNode.type === 13) {
convertToBlock(codegenNode, context);
}
root.codegenNode = codegenNode;
} else {
root.codegenNode = child;
}
} else if (children.length > 1) {
let patchFlag = 64;
root.codegenNode = createVNodeCall(
context,
helper(FRAGMENT),
void 0,
root.children,
patchFlag + (``),
void 0,
void 0,
true,
void 0,
false
/* isComponent */
);
} else ;
}
function traverseChildren(parent, context) {
let i = 0;
const nodeRemoved = () => {
i--;
};
for (; i < parent.children.length; i++) {
const child = parent.children[i];
if (isString(child))
continue;
context.parent = parent;
context.childIndex = i;
context.onNodeRemoved = nodeRemoved;
traverseNode(child, context);
}
}
function traverseNode(node, context) {
context.currentNode = node;
const { nodeTransforms } = context;
const exitFns = [];
for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
const onExit = nodeTransforms[i2](node, context);
if (onExit) {
if (isArray(onExit)) {
exitFns.push(...onExit);
} else {
exitFns.push(onExit);
}
}
if (!context.currentNode) {
return;
} else {
node = context.currentNode;
}
}
switch (node.type) {
case 3:
if (!context.ssr) {
context.helper(CREATE_COMMENT);
}
break;
case 5:
if (!context.ssr) {
context.helper(TO_DISPLAY_STRING);
}
break;
case 9:
for (let i2 = 0; i2 < node.branches.length; i2++) {
traverseNode(node.branches[i2], context);
}
break;
case 10:
case 11:
case 1:
case 0:
traverseChildren(node, context);
break;
}
context.currentNode = node;
let i = exitFns.length;
while (i--) {
exitFns[i]();
}
}
function createStructuralDirectiveTransform(name, fn) {
const matches = isString(name) ? (n) => n === name : (n) => name.test(n);
return (node, context) => {
if (node.type === 1) {
const { props } = node;
if (node.tagType === 3 && props.some(isVSlot)) {
return;
}
const exitFns = [];
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 7 && matches(prop.name)) {
props.splice(i, 1);
i--;
const onExit = fn(node, prop, context);
if (onExit)
exitFns.push(onExit);
}
}
return exitFns;
}
};
}
const PURE_ANNOTATION = `/*#__PURE__*/`;
const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
function createCodegenContext(ast, {
mode = "function",
prefixIdentifiers = mode === "module",
sourceMap = false,
filename = `template.vue.html`,
scopeId = null,
optimizeImports = false,
runtimeGlobalName = `Vue`,
runtimeModuleName = `vue`,
ssrRuntimeModuleName = "vue/server-renderer",
ssr = false,
isTS = false,
inSSR = false
}) {
const context = {
mode,
prefixIdentifiers,
sourceMap,
filename,
scopeId,
optimizeImports,
runtimeGlobalName,
runtimeModuleName,
ssrRuntimeModuleName,
ssr,
isTS,
inSSR,
source: ast.loc.source,
code: ``,
column: 1,
line: 1,
offset: 0,
indentLevel: 0,
pure: false,
map: void 0,
helper(key) {
return `_${helperNameMap[key]}`;
},
push(code, node) {
context.code += code;
if (context.map) {
if (node) {
let name;
if (node.type === 4 && !node.isStatic) {
const content = node.content.replace(/^_ctx\./, "");
if (content !== node.content && isSimpleIdentifier(content)) {
name = content;
}
}
addMapping(node.loc.start, name);
}
advancePositionWithMutation(context, code);
if (node && node.loc !== locStub) {
addMapping(node.loc.end);
}
}
},
indent() {
newline(++context.indentLevel);
},
deindent(withoutNewLine = false) {
if (withoutNewLine) {
--context.indentLevel;
} else {
newline(--context.indentLevel);
}
},
newline() {
newline(context.indentLevel);
}
};
function newline(n) {
context.push("\n" + ` `.repeat(n));
}
function addMapping(loc, name) {
context.map.addMapping({
name,
source: context.filename,
original: {
line: loc.line,
column: loc.column - 1
// source-map column is 0 based
},
generated: {
line: context.line,
column: context.column - 1
}
});
}
if (sourceMap) {
context.map = new sourceMapJs.SourceMapGenerator();
context.map.setSourceContent(filename, context.source);
}
return context;
}
function generate(ast, options = {}) {
const context = createCodegenContext(ast, options);
if (options.onContextCreated)
options.onContextCreated(context);
const {
mode,
push,
prefixIdentifiers,
indent,
deindent,
newline,
scopeId,
ssr
} = context;
const helpers = Array.from(ast.helpers);
const hasHelpers = helpers.length > 0;
const useWithBlock = !prefixIdentifiers && mode !== "module";
const genScopeId = scopeId != null && mode === "module";
const isSetupInlined = !!options.inline;
const preambleContext = isSetupInlined ? createCodegenContext(ast, options) : context;
if (mode === "module") {
genModulePreamble(ast, preambleContext, genScopeId, isSetupInlined);
} else {
genFunctionPreamble(ast, preambleContext);
}
const functionName = ssr ? `ssrRender` : `render`;
const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
if (options.bindingMetadata && !options.inline) {
args.push("$props", "$setup", "$data", "$options");
}
const signature = options.isTS ? args.map((arg) => `${arg}: any`).join(",") : args.join(", ");
if (isSetupInlined) {
push(`(${signature}) => {`);
} else {
push(`function ${functionName}(${signature}) {`);
}
indent();
if (useWithBlock) {
push(`with (_ctx) {`);
indent();
if (hasHelpers) {
push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue`);
push(`
`);
newline();
}
}
if (ast.components.length) {
genAssets(ast.components, "component", context);
if (ast.directives.length || ast.temps > 0) {
newline();
}
}
if (ast.directives.length) {
genAssets(ast.directives, "directive", context);
if (ast.temps > 0) {
newline();
}
}
if (ast.filters && ast.filters.length) {
newline();
genAssets(ast.filters, "filter", context);
newline();
}
if (ast.temps > 0) {
push(`let `);
for (let i = 0; i < ast.temps; i++) {
push(`${i > 0 ? `, ` : ``}_temp${i}`);
}
}
if (ast.components.length || ast.directives.length || ast.temps) {
push(`
`);
newline();
}
if (!ssr) {
push(`return `);
}
if (ast.codegenNode) {
genNode(ast.codegenNode, context);
} else {
push(`null`);
}
if (useWithBlock) {
deindent();
push(`}`);
}
deindent();
push(`}`);
return {
ast,
code: context.code,
preamble: isSetupInlined ? preambleContext.code : ``,
// SourceMapGenerator does have toJSON() method but it's not in the types
map: context.map ? context.map.toJSON() : void 0
};
}
function genFunctionPreamble(ast, context) {
const {
ssr,
prefixIdentifiers,
push,
newline,
runtimeModuleName,
runtimeGlobalName,
ssrRuntimeModuleName
} = context;
const VueBinding = ssr ? `require(${JSON.stringify(runtimeModuleName)})` : runtimeGlobalName;
const helpers = Array.from(ast.helpers);
if (helpers.length > 0) {
if (prefixIdentifiers) {
push(`const { ${helpers.map(aliasHelper).join(", ")} } = ${VueBinding}
`);
} else {
push(`const _Vue = ${VueBinding}
`);
if (ast.hoists.length) {
const staticHelpers = [
CREATE_VNODE,
CREATE_ELEMENT_VNODE,
CREATE_COMMENT,
CREATE_TEXT,
CREATE_STATIC
].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
push(`const { ${staticHelpers} } = _Vue
`);
}
}
}
if (ast.ssrHelpers && ast.ssrHelpers.length) {
push(
`const { ${ast.ssrHelpers.map(aliasHelper).join(", ")} } = require("${ssrRuntimeModuleName}")
`
);
}
genHoists(ast.hoists, context);
newline();
push(`return `);
}
function genModulePreamble(ast, context, genScopeId, inline) {
const {
push,
newline,
optimizeImports,
runtimeModuleName,
ssrRuntimeModuleName
} = context;
if (genScopeId && ast.hoists.length) {
ast.helpers.add(PUSH_SCOPE_ID);
ast.helpers.add(POP_SCOPE_ID);
}
if (ast.helpers.size) {
const helpers = Array.from(ast.helpers);
if (optimizeImports) {
push(
`import { ${helpers.map((s) => helperNameMap[s]).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
`
);
push(
`
// Binding optimization for webpack code-split
const ${helpers.map((s) => `_${helperNameMap[s]} = ${helperNameMap[s]}`).join(", ")}
`
);
} else {
push(
`import { ${helpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from ${JSON.stringify(runtimeModuleName)}
`
);
}
}
if (ast.ssrHelpers && ast.ssrHelpers.length) {
push(
`import { ${ast.ssrHelpers.map((s) => `${helperNameMap[s]} as _${helperNameMap[s]}`).join(", ")} } from "${ssrRuntimeModuleName}"
`
);
}
if (ast.imports.length) {
genImports(ast.imports, context);
newline();
}
genHoists(ast.hoists, context);
newline();
if (!inline) {
push(`export `);
}
}
function genAssets(assets, type, { helper, push, newline, isTS }) {
const resolver = helper(
type === "filter" ? RESOLVE_FILTER : type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
);
for (let i = 0; i < assets.length; i++) {
let id = assets[i];
const maybeSelfReference = id.endsWith("__self");
if (maybeSelfReference) {
id = id.slice(0, -6);
}
push(
`const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
);
if (i < assets.length - 1) {
newline();
}
}
}
function genHoists(hoists, context) {
if (!hoists.length) {
return;
}
context.pure = true;
const { push, newline, helper, scopeId, mode } = context;
const genScopeId = scopeId != null && mode !== "function";
newline();
if (genScopeId) {
push(
`const _withScopeId = n => (${helper(
PUSH_SCOPE_ID
)}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`
);
newline();
}
for (let i = 0; i < hoists.length; i++) {
const exp = hoists[i];
if (exp) {
const needScopeIdWrapper = genScopeId && exp.type === 13;
push(
`const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`
);
genNode(exp, context);
if (needScopeIdWrapper) {
push(`)`);
}
newline();
}
}
context.pure = false;
}
function genImports(importsOptions, context) {
if (!importsOptions.length) {
return;
}
importsOptions.forEach((imports) => {
context.push(`import `);
genNode(imports.exp, context);
context.push(` from '${imports.path}'`);
context.newline();
});
}
function isText(n) {
return isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
}
function genNodeListAsArray(nodes, context) {
const multilines = nodes.length > 3 || nodes.some((n) => isArray(n) || !isText(n));
context.push(`[`);
multilines && context.indent();
genNodeList(nodes, context, multilines);
multilines && context.deindent();
context.push(`]`);
}
function genNodeList(nodes, context, multilines = false, comma = true) {
const { push, newline } = context;
for (let i = 0; i < nodes.length; i++) {
const node = nodes[i];
if (isString(node)) {
push(node);
} else if (isArray(node)) {
genNodeListAsArray(node, context);
} else {
genNode(node, context);
}
if (i < nodes.length - 1) {
if (multilines) {
comma && push(",");
newline();
} else {
comma && push(", ");
}
}
}
}
function genNode(node, context) {
if (isString(node)) {
context.push(node);
return;
}
if (isSymbol(node)) {
context.push(context.helper(node));
return;
}
switch (node.type) {
case 1:
case 9:
case 11:
genNode(node.codegenNode, context);
break;
case 2:
genText(node, context);
break;
case 4:
genExpression(node, context);
break;
case 5:
genInterpolation(node, context);
break;
case 12:
genNode(node.codegenNode, context);
break;
case 8:
genCompoundExpression(node, context);
break;
case 3:
genComment(node, context);
break;
case 13:
genVNodeCall(node, context);
break;
case 14:
genCallExpression(node, context);
break;
case 15:
genObjectExpression(node, context);
break;
case 17:
genArrayExpression(node, context);
break;
case 18:
genFunctionExpression(node, context);
break;
case 19:
genConditionalExpression(node, context);
break;
case 20:
genCacheExpression(node, context);
break;
case 21:
genNodeList(node.body, context, true, false);
break;
case 22:
genTemplateLiteral(node, context);
break;
case 23:
genIfStatement(node, context);
break;
case 24:
genAssignmentExpression(node, context);
break;
case 25:
genSequenceExpression(node, context);
break;
case 26:
genReturnStatement(node, context);
break;
}
}
function genText(node, context) {
context.push(JSON.stringify(node.content), node);
}
function genExpression(node, context) {
const { content, isStatic } = node;
context.push(isStatic ? JSON.stringify(content) : content, node);
}
function genInterpolation(node, context) {
const { push, helper, pure } = context;
if (pure)
push(PURE_ANNOTATION);
push(`${helper(TO_DISPLAY_STRING)}(`);
genNode(node.content, context);
push(`)`);
}
function genCompoundExpression(node, context) {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (isString(child)) {
context.push(child);
} else {
genNode(child, context);
}
}
}
function genExpressionAsPropertyKey(node, context) {
const { push } = context;
if (node.type === 8) {
push(`[`);
genCompoundExpression(node, context);
push(`]`);
} else if (node.isStatic) {
const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
push(text, node);
} else {
push(`[${node.content}]`, node);
}
}
function genComment(node, context) {
const { push, helper, pure } = context;
if (pure) {
push(PURE_ANNOTATION);
}
push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
}
function genVNodeCall(node, context) {
const { push, helper, pure } = context;
const {
tag,
props,
children,
patchFlag,
dynamicProps,
directives,
isBlock,
disableTracking,
isComponent
} = node;
if (directives) {
push(helper(WITH_DIRECTIVES) + `(`);
}
if (isBlock) {
push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
}
if (pure) {
push(PURE_ANNOTATION);
}
const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
push(helper(callHelper) + `(`, node);
genNodeList(
genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
context
);
push(`)`);
if (isBlock) {
push(`)`);
}
if (directives) {
push(`, `);
genNode(directives, context);
push(`)`);
}
}
function genNullableArgs(args) {
let i = args.length;
while (i--) {
if (args[i] != null)
break;
}
return args.slice(0, i + 1).map((arg) => arg || `null`);
}
function genCallExpression(node, context) {
const { push, helper, pure } = context;
const callee = isString(node.callee) ? node.callee : helper(node.callee);
if (pure) {
push(PURE_ANNOTATION);
}
push(callee + `(`, node);
genNodeList(node.arguments, context);
push(`)`);
}
function genObjectExpression(node, context) {
const { push, indent, deindent, newline } = context;
const { properties } = node;
if (!properties.length) {
push(`{}`, node);
return;
}
const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
push(multilines ? `{` : `{ `);
multilines && indent();
for (let i = 0; i < properties.length; i++) {
const { key, value } = properties[i];
genExpressionAsPropertyKey(key, context);
push(`: `);
genNode(value, context);
if (i < properties.length - 1) {
push(`,`);
newline();
}
}
multilines && deindent();
push(multilines ? `}` : ` }`);
}
function genArrayExpression(node, context) {
genNodeListAsArray(node.elements, context);
}
function genFunctionExpression(node, context) {
const { push, indent, deindent } = context;
const { params, returns, body, newline, isSlot } = node;
if (isSlot) {
push(`_${helperNameMap[WITH_CTX]}(`);
}
push(`(`, node);
if (isArray(params)) {
genNodeList(params, context);
} else if (params) {
genNode(params, context);
}
push(`) => `);
if (newline || body) {
push(`{`);
indent();
}
if (returns) {
if (newline) {
push(`return `);
}
if (isArray(returns)) {
genNodeListAsArray(returns, context);
} else {
genNode(returns, context);
}
} else if (body) {
genNode(body, context);
}
if (newline || body) {
deindent();
push(`}`);
}
if (isSlot) {
if (node.isNonScopedSlot) {
push(`, undefined, true`);
}
push(`)`);
}
}
function genConditionalExpression(node, context) {
const { test, consequent, alternate, newline: needNewline } = node;
const { push, indent, deindent, newline } = context;
if (test.type === 4) {
const needsParens = !isSimpleIdentifier(test.content);
needsParens && push(`(`);
genExpression(test, context);
needsParens && push(`)`);
} else {
push(`(`);
genNode(test, context);
push(`)`);
}
needNewline && indent();
context.indentLevel++;
needNewline || push(` `);
push(`? `);
genNode(consequent, context);
context.indentLevel--;
needNewline && newline();
needNewline || push(` `);
push(`: `);
const isNested = alternate.type === 19;
if (!isNested) {
context.indentLevel++;
}
genNode(alternate, context);
if (!isNested) {
context.indentLevel--;
}
needNewline && deindent(
true
/* without newline */
);
}
function genCacheExpression(node, context) {
const { push, helper, indent, deindent, newline } = context;
push(`_cache[${node.index}] || (`);
if (node.isVNode) {
indent();
push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
newline();
}
push(`_cache[${node.index}] = `);
genNode(node.value, context);
if (node.isVNode) {
push(`,`);
newline();
push(`${helper(SET_BLOCK_TRACKING)}(1),`);
newline();
push(`_cache[${node.index}]`);
deindent();
}
push(`)`);
}
function genTemplateLiteral(node, context) {
const { push, indent, deindent } = context;
push("`");
const l = node.elements.length;
const multilines = l > 3;
for (let i = 0; i < l; i++) {
const e = node.elements[i];
if (isString(e)) {
push(e.replace(/(`|\$|\\)/g, "\\$1"));
} else {
push("${");
if (multilines)
indent();
genNode(e, context);
if (multilines)
deindent();
push("}");
}
}
push("`");
}
function genIfStatement(node, context) {
const { push, indent, deindent } = context;
const { test, consequent, alternate } = node;
push(`if (`);
genNode(test, context);
push(`) {`);
indent();
genNode(consequent, context);
deindent();
push(`}`);
if (alternate) {
push(` else `);
if (alternate.type === 23) {
genIfStatement(alternate, context);
} else {
push(`{`);
indent();
genNode(alternate, context);
deindent();
push(`}`);
}
}
}
function genAssignmentExpression(node, context) {
genNode(node.left, context);
context.push(` = `);
genNode(node.right, context);
}
function genSequenceExpression(node, context) {
context.push(`(`);
genNodeList(node.expressions, context);
context.push(`)`);
}
function genReturnStatement({ returns }, context) {
context.push(`return `);
if (isArray(returns)) {
genNodeListAsArray(returns, context);
} else {
genNode(returns, context);
}
}
function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
const rootExp = root.type === "Program" && root.body[0].type === "ExpressionStatement" && root.body[0].expression;
estreeWalker.walk(root, {
enter(node, parent) {
parent && parentStack.push(parent);
if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
return this.skip();
}
if (node.type === "Identifier") {
const isLocal = !!knownIds[node.name];
const isRefed = isReferencedIdentifier(node, parent, parentStack);
if (includeAll || isRefed && !isLocal) {
onIdentifier(node, parent, parentStack, isRefed, isLocal);
}
} else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
node.inPattern = true;
} else if (isFunctionType(node)) {
walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
} else if (node.type === "BlockStatement") {
walkBlockDeclarations(
node,
(id) => markScopeIdentifier(node, id, knownIds)
);
}
},
leave(node, parent) {
parent && parentStack.pop();
if (node !== rootExp && node.scopeIds) {
for (const id of node.scopeIds) {
knownIds[id]--;
if (knownIds[id] === 0) {
delete knownIds[id];
}
}
}
}
});
}
function isReferencedIdentifier(id, parent, parentStack) {
if (!parent) {
return true;
}
if (id.name === "arguments") {
return false;
}
if (isReferenced(id, parent)) {
return true;
}
switch (parent.type) {
case "AssignmentExpression":
case "AssignmentPattern":
return true;
case "ObjectPattern":
case "ArrayPattern":
return isInDestructureAssignment(parent, parentStack);
}
return false;
}
function isInDestructureAssignment(parent, parentStack) {
if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
let i = parentStack.length;
while (i--) {
const p = parentStack[i];
if (p.type === "AssignmentExpression") {
return true;
} else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
break;
}
}
}
return false;
}
function walkFunctionParams(node, onIdent) {
for (const p of node.params) {
for (const id of extractIdentifiers(p)) {
onIdent(id);
}
}
}
function walkBlockDeclarations(block, onIdent) {
for (const stmt of block.body) {
if (stmt.type === "VariableDeclaration") {
if (stmt.declare)
continue;
for (const decl of stmt.declarations) {
for (const id of extractIdentifiers(decl.id)) {
onIdent(id);
}
}
} else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
if (stmt.declare || !stmt.id)
continue;
onIdent(stmt.id);
} else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
if (variable && variable.type === "VariableDeclaration") {
for (const decl of variable.declarations) {
for (const id of extractIdentifiers(decl.id)) {
onIdent(id);
}
}
}
}
}
}
function extractIdentifiers(param, nodes = []) {
switch (param.type) {
case "Identifier":
nodes.push(param);
break;
case "MemberExpression":
let object = param;
while (object.type === "MemberExpression") {
object = object.object;
}
nodes.push(object);
break;
case "ObjectPattern":
for (const prop of param.properties) {
if (prop.type === "RestElement") {
extractIdentifiers(prop.argument, nodes);
} else {
extractIdentifiers(prop.value, nodes);
}
}
break;
case "ArrayPattern":
param.elements.forEach((element) => {
if (element)
extractIdentifiers(element, nodes);
});
break;
case "RestElement":
extractIdentifiers(param.argument, nodes);
break;
case "AssignmentPattern":
extractIdentifiers(param.left, nodes);
break;
}
return nodes;
}
function markScopeIdentifier(node, child, knownIds) {
const { name } = child;
if (node.scopeIds && node.scopeIds.has(name)) {
return;
}
if (name in knownIds) {
knownIds[name]++;
} else {
knownIds[name] = 1;
}
(node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
}
const isFunctionType = (node) => {
return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
};
const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
function isReferenced(node, parent, grandparent) {
switch (parent.type) {
case "MemberExpression":
case "OptionalMemberExpression":
if (parent.property === node) {
return !!parent.computed;
}
return parent.object === node;
case "JSXMemberExpression":
return parent.object === node;
case "VariableDeclarator":
return parent.init === node;
case "ArrowFunctionExpression":
return parent.body === node;
case "PrivateName":
return false;
case "ClassMethod":
case "ClassPrivateMethod":
case "ObjectMethod":
if (parent.key === node) {
return !!parent.computed;
}
return false;
case "ObjectProperty":
if (parent.key === node) {
return !!parent.computed;
}
return !grandparent || grandparent.type !== "ObjectPattern";
case "ClassProperty":
if (parent.key === node) {
return !!parent.computed;
}
return true;
case "ClassPrivateProperty":
return parent.key !== node;
case "ClassDeclaration":
case "ClassExpression":
return parent.superClass === node;
case "AssignmentExpression":
return parent.right === node;
case "AssignmentPattern":
return parent.right === node;
case "LabeledStatement":
return false;
case "CatchClause":
return false;
case "RestElement":
return false;
case "BreakStatement":
case "ContinueStatement":
return false;
case "FunctionDeclaration":
case "FunctionExpression":
return false;
case "ExportNamespaceSpecifier":
case "ExportDefaultSpecifier":
return false;
case "ExportSpecifier":
if (grandparent == null ? void 0 : grandparent.source) {
return false;
}
return parent.local === node;
case "ImportDefaultSpecifier":
case "ImportNamespaceSpecifier":
case "ImportSpecifier":
return false;
case "ImportAttribute":
return false;
case "JSXAttribute":
return false;
case "ObjectPattern":
case "ArrayPattern":
return false;
case "MetaProperty":
return false;
case "ObjectTypeProperty":
return parent.key !== node;
case "TSEnumMember":
return parent.id !== node;
case "TSPropertySignature":
if (parent.key === node) {
return !!parent.computed;
}
return true;
}
return true;
}
const TS_NODE_TYPES = [
"TSAsExpression",
// foo as number
"TSTypeAssertion",
// (<number>foo)
"TSNonNullExpression",
// foo!
"TSInstantiationExpression",
// foo<string>
"TSSatisfiesExpression"
// foo satisfies T
];
const isLiteralWhitelisted = /* @__PURE__ */ makeMap("true,false,null,this");
const constantBailRE = /\w\s*\(|\.[^\d]/;
const transformExpression = (node, context) => {
if (node.type === 5) {
node.content = processExpression(
node.content,
context
);
} else if (node.type === 1) {
for (let i = 0; i < node.props.length; i++) {
const dir = node.props[i];
if (dir.type === 7 && dir.name !== "for") {
const exp = dir.exp;
const arg = dir.arg;
if (exp && exp.type === 4 && !(dir.name === "on" && arg)) {
dir.exp = processExpression(
exp,
context,
// slot args must be processed as function params
dir.name === "slot"
);
}
if (arg && arg.type === 4 && !arg.isStatic) {
dir.arg = processExpression(arg, context);
}
}
}
}
};
function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
if (!context.prefixIdentifiers || !node.content.trim()) {
return node;
}
const { inline, bindingMetadata } = context;
const rewriteIdentifier = (raw, parent, id) => {
const type = hasOwn(bindingMetadata, raw) && bindingMetadata[raw];
if (inline) {
const isAssignmentLVal = parent && parent.type === "AssignmentExpression" && parent.left === id;
const isUpdateArg = parent && parent.type === "UpdateExpression" && parent.argument === id;
const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
if (isConst(type) || type === "setup-reactive-const" || localVars[raw]) {
return raw;
} else if (type === "setup-ref") {
return `${raw}.value`;
} else if (type === "setup-maybe-ref") {
return isAssignmentLVal || isUpdateArg || isDestructureAssignment ? `${raw}.value` : `${context.helperString(UNREF)}(${raw})`;
} else if (type === "setup-let") {
if (isAssignmentLVal) {
const { right: rVal, operator } = parent;
const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
const rExpString = stringifyExpression(
processExpression(
createSimpleExpression(rExp, false),
context,
false,
false,
knownIds
)
);
return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
} else if (isUpdateArg) {
id.start = parent.start;
id.end = parent.end;
const { prefix: isPrefix, operator } = parent;
const prefix = isPrefix ? operator : ``;
const postfix = isPrefix ? `` : operator;
return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore
` : ``} ? ${prefix}${raw}.value${postfix} : ${prefix}${raw}${postfix}`;
} else if (isDestructureAssignment) {
return raw;
} else {
return `${context.helperString(UNREF)}(${raw})`;
}
} else if (type === "props") {
return genPropsAccessExp(raw);
} else if (type === "props-aliased") {
return genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
}
} else {
if (type && type.startsWith("setup") || type === "literal-const") {
return `$setup.${raw}`;
} else if (type === "props-aliased") {
return `$props['${bindingMetadata.__propsAliases[raw]}']`;
} else if (type) {
return `$${type}.${raw}`;
}
}
return `_ctx.${raw}`;
};
const rawExp = node.content;
const bailConstant = constantBailRE.test(rawExp);
if (isSimpleIdentifier(rawExp)) {
const isScopeVarReference = context.identifiers[rawExp];
const isAllowedGlobal = isGloballyAllowed(rawExp);
const isLiteral = isLiteralWhitelisted(rawExp);
if (!asParams && !isScopeVarReference && !isLiteral && (!isAllowedGlobal || bindingMetadata[rawExp])) {
if (isConst(bindingMetadata[rawExp])) {
node.constType = 1;
}
node.content = rewriteIdentifier(rawExp);
} else if (!isScopeVarReference) {
if (isLiteral) {
node.constType = 3;
} else {
node.constType = 2;
}
}
return node;
}
let ast;
const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
try {
ast = parser.parse(source, {
plugins: context.expressionPlugins
}).program;
} catch (e) {
context.onError(
createCompilerError(
45,
node.loc,
void 0,
e.message
)
);
return node;
}
const ids = [];
const parentStack = [];
const knownIds = Object.create(context.identifiers);
walkIdentifiers(
ast,
(node2, parent, _, isReferenced, isLocal) => {
if (isStaticPropertyKey(node2, parent)) {
return;
}
if (node2.name.startsWith("_filter_")) {
return;
}
const needPrefix = isReferenced && canPrefix(node2);
if (needPrefix && !isLocal) {
if (isStaticProperty(parent) && parent.shorthand) {
node2.prefix = `${node2.name}: `;
}
node2.name = rewriteIdentifier(node2.name, parent, node2);
ids.push(node2);
} else {
if (!(needPrefix && isLocal) && !bailConstant) {
node2.isConstant = true;
}
ids.push(node2);
}
},
true,
// invoke on ALL identifiers
parentStack,
knownIds
);
const children = [];
ids.sort((a, b) => a.start - b.start);
ids.forEach((id, i) => {
const start = id.start - 1;
const end = id.end - 1;
const last = ids[i - 1];
const leadingText = rawExp.slice(last ? last.end - 1 : 0, start);
if (leadingText.length || id.prefix) {
children.push(leadingText + (id.prefix || ``));
}
const source2 = rawExp.slice(start, end);
children.push(
createSimpleExpression(
id.name,
false,
{
source: source2,
start: advancePositionWithClone(node.loc.start, source2, start),
end: advancePositionWithClone(node.loc.start, source2, end)
},
id.isConstant ? 3 : 0
)
);
if (i === ids.length - 1 && end < rawExp.length) {
children.push(rawExp.slice(end));
}
});
let ret;
if (children.length) {
ret = createCompoundExpression(children, node.loc);
} else {
ret = node;
ret.constType = bailConstant ? 0 : 3;
}
ret.identifiers = Object.keys(knownIds);
return ret;
}
function canPrefix(id) {
if (isGloballyAllowed(id.name)) {
return false;
}
if (id.name === "require") {
return false;
}
return true;
}
function stringifyExpression(exp) {
if (isString(exp)) {
return exp;
} else if (exp.type === 4) {
return exp.content;
} else {
return exp.children.map(stringifyExpression).join("");
}
}
function isConst(type) {
return type === "setup-const" || type === "literal-const";
}
const transformIf = createStructuralDirectiveTransform(
/^(if|else|else-if)$/,
(node, dir, context) => {
return processIf(node, dir, context, (ifNode, branch, isRoot) => {
const siblings = context.parent.children;
let i = siblings.indexOf(ifNode);
let key = 0;
while (i-- >= 0) {
const sibling = siblings[i];
if (sibling && sibling.type === 9) {
key += sibling.branches.length;
}
}
return () => {
if (isRoot) {
ifNode.codegenNode = createCodegenNodeForBranch(
branch,
key,
context
);
} else {
const parentCondition = getParentCondition(ifNode.codegenNode);
parentCondition.alternate = createCodegenNodeForBranch(
branch,
key + ifNode.branches.length - 1,
context
);
}
};
});
}
);
function processIf(node, dir, context, processCodegen) {
if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
const loc = dir.exp ? dir.exp.loc : node.loc;
context.onError(
createCompilerError(28, dir.loc)
);
dir.exp = createSimpleExpression(`true`, false, loc);
}
if (context.prefixIdentifiers && dir.exp) {
dir.exp = processExpression(dir.exp, context);
}
if (dir.name === "if") {
const branch = createIfBranch(node, dir);
const ifNode = {
type: 9,
loc: node.loc,
branches: [branch]
};
context.replaceNode(ifNode);
if (processCodegen) {
return processCodegen(ifNode, branch, true);
}
} else {
const siblings = context.parent.children;
let i = siblings.indexOf(node);
while (i-- >= -1) {
const sibling = siblings[i];
if (sibling && sibling.type === 3) {
context.removeNode(sibling);
continue;
}
if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
context.removeNode(sibling);
continue;
}
if (sibling && sibling.type === 9) {
if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
context.onError(
createCompilerError(30, node.loc)
);
}
context.removeNode();
const branch = createIfBranch(node, dir);
{
const key = branch.userKey;
if (key) {
sibling.branches.forEach(({ userKey }) => {
if (isSameKey(userKey, key)) {
context.onError(
createCompilerError(
29,
branch.userKey.loc
)
);
}
});
}
}
sibling.branches.push(branch);
const onExit = processCodegen && processCodegen(sibling, branch, false);
traverseNode(branch, context);
if (onExit)
onExit();
context.currentNode = null;
} else {
context.onError(
createCompilerError(30, node.loc)
);
}
break;
}
}
}
function createIfBranch(node, dir) {
const isTemplateIf = node.tagType === 3;
return {
type: 10,
loc: node.loc,
condition: dir.name === "else" ? void 0 : dir.exp,
children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
userKey: findProp(node, `key`),
isTemplateIf
};
}
function createCodegenNodeForBranch(branch, keyIndex, context) {
if (branch.condition) {
return createConditionalExpression(
branch.condition,
createChildrenCodegenNode(branch, keyIndex, context),
// make sure to pass in asBlock: true so that the comment node call
// closes the current block.
createCallExpression(context.helper(CREATE_COMMENT), [
'""',
"true"
])
);
} else {
return createChildrenCodegenNode(branch, keyIndex, context);
}
}
function createChildrenCodegenNode(branch, keyIndex, context) {
const { helper } = context;
const keyProperty = createObjectProperty(
`key`,
createSimpleExpression(
`${keyIndex}`,
false,
locStub,
2
)
);
const { children } = branch;
const firstChild = children[0];
const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
if (needFragmentWrapper) {
if (children.length === 1 && firstChild.type === 11) {
const vnodeCall = firstChild.codegenNode;
injectProp(vnodeCall, keyProperty, context);
return vnodeCall;
} else {
let patchFlag = 64;
return createVNodeCall(
context,
helper(FRAGMENT),
createObjectExpression([keyProperty]),
children,
patchFlag + (``),
void 0,
void 0,
true,
false,
false,
branch.loc
);
}
} else {
const ret = firstChild.codegenNode;
const vnodeCall = getMemoedVNodeCall(ret);
if (vnodeCall.type === 13) {
convertToBlock(vnodeCall, context);
}
injectProp(vnodeCall, keyProperty, context);
return ret;
}
}
function isSameKey(a, b) {
if (!a || a.type !== b.type) {
return false;
}
if (a.type === 6) {
if (a.value.content !== b.value.content) {
return false;
}
} else {
const exp = a.exp;
const branchExp = b.exp;
if (exp.type !== branchExp.type) {
return false;
}
if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
return false;
}
}
return true;
}
function getParentCondition(node) {
while (true) {
if (node.type === 19) {
if (node.alternate.type === 19) {
node = node.alternate;
} else {
return node;
}
} else if (node.type === 20) {
node = node.value;
}
}
}
const transformFor = createStructuralDirectiveTransform(
"for",
(node, dir, context) => {
const { helper, removeHelper } = context;
return processFor(node, dir, context, (forNode) => {
const renderExp = createCallExpression(helper(RENDER_LIST), [
forNode.source
]);
const isTemplate = isTemplateNode(node);
const memo = findDir(node, "memo");
const keyProp = findProp(node, `key`);
const keyExp = keyProp && (keyProp.type === 6 ? createSimpleExpression(keyProp.value.content, true) : keyProp.exp);
const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
if (isTemplate) {
if (memo) {
memo.exp = processExpression(
memo.exp,
context
);
}
if (keyProperty && keyProp.type !== 6) {
keyProperty.value = processExpression(
keyProperty.value,
context
);
}
}
const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
forNode.codegenNode = createVNodeCall(
context,
helper(FRAGMENT),
void 0,
renderExp,
fragmentFlag + (``),
void 0,
void 0,
true,
!isStableFragment,
false,
node.loc
);
return () => {
let childBlock;
const { children } = forNode;
if (isTemplate) {
node.children.some((c) => {
if (c.type === 1) {
const key = findProp(c, "key");
if (key) {
context.onError(
createCompilerError(
33,
key.loc
)
);
return true;
}
}
});
}
const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
if (slotOutlet) {
childBlock = slotOutlet.codegenNode;
if (isTemplate && keyProperty) {
injectProp(childBlock, keyProperty, context);
}
} else if (needFragmentWrapper) {
childBlock = createVNodeCall(
context,
helper(FRAGMENT),
keyProperty ? createObjectExpression([keyProperty]) : void 0,
node.children,
64 + (``),
void 0,
void 0,
true,
void 0,
false
/* isComponent */
);
} else {
childBlock = children[0].codegenNode;
if (isTemplate && keyProperty) {
injectProp(childBlock, keyProperty, context);
}
if (childBlock.isBlock !== !isStableFragment) {
if (childBlock.isBlock) {
removeHelper(OPEN_BLOCK);
removeHelper(
getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
);
} else {
removeHelper(
getVNodeHelper(context.inSSR, childBlock.isComponent)
);
}
}
childBlock.isBlock = !isStableFragment;
if (childBlock.isBlock) {
helper(OPEN_BLOCK);
helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
} else {
helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
}
}
if (memo) {
const loop = createFunctionExpression(
createForLoopParams(forNode.parseResult, [
createSimpleExpression(`_cached`)
])
);
loop.body = createBlockStatement([
createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
createCompoundExpression([
`if (_cached`,
...keyExp ? [` && _cached.key === `, keyExp] : [],
` && ${context.helperString(
IS_MEMO_SAME
)}(_cached, _memo)) return _cached`
]),
createCompoundExpression([`const _item = `, childBlock]),
createSimpleExpression(`_item.memo = _memo`),
createSimpleExpression(`return _item`)
]);
renderExp.arguments.push(
loop,
createSimpleExpression(`_cache`),
createSimpleExpression(String(context.cached++))
);
} else {
renderExp.arguments.push(
createFunctionExpression(
createForLoopParams(forNode.parseResult),
childBlock,
true
/* force newline */
)
);
}
};
});
}
);
function processFor(node, dir, context, processCodegen) {
if (!dir.exp) {
context.onError(
createCompilerError(31, dir.loc)
);
return;
}
const parseResult = parseForExpression(
// can only be simple expression because vFor transform is applied
// before expression transform.
dir.exp,
context
);
if (!parseResult) {
context.onError(
createCompilerError(32, dir.loc)
);
return;
}
const { addIdentifiers, removeIdentifiers, scopes } = context;
const { source, value, key, index } = parseResult;
const forNode = {
type: 11,
loc: dir.loc,
source,
valueAlias: value,
keyAlias: key,
objectIndexAlias: index,
parseResult,
children: isTemplateNode(node) ? node.children : [node]
};
context.replaceNode(forNode);
scopes.vFor++;
if (context.prefixIdentifiers) {
value && addIdentifiers(value);
key && addIdentifiers(key);
index && addIdentifiers(index);
}
const onExit = processCodegen && processCodegen(forNode);
return () => {
scopes.vFor--;
if (context.prefixIdentifiers) {
value && removeIdentifiers(value);
key && removeIdentifiers(key);
index && removeIdentifiers(index);
}
if (onExit)
onExit();
};
}
const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
const stripParensRE = /^\(|\)$/g;
function parseForExpression(input, context) {
const loc = input.loc;
const exp = input.content;
const inMatch = exp.match(forAliasRE);
if (!inMatch)
return;
const [, LHS, RHS] = inMatch;
const result = {
source: createAliasExpression(
loc,
RHS.trim(),
exp.indexOf(RHS, LHS.length)
),
value: void 0,
key: void 0,
index: void 0
};
if (context.prefixIdentifiers) {
result.source = processExpression(
result.source,
context
);
}
let valueContent = LHS.trim().replace(stripParensRE, "").trim();
const trimmedOffset = LHS.indexOf(valueContent);
const iteratorMatch = valueContent.match(forIteratorRE);
if (iteratorMatch) {
valueContent = valueContent.replace(forIteratorRE, "").trim();
const keyContent = iteratorMatch[1].trim();
let keyOffset;
if (keyContent) {
keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
result.key = createAliasExpression(loc, keyContent, keyOffset);
if (context.prefixIdentifiers) {
result.key = processExpression(result.key, context, true);
}
}
if (iteratorMatch[2]) {
const indexContent = iteratorMatch[2].trim();
if (indexContent) {
result.index = createAliasExpression(
loc,
indexContent,
exp.indexOf(
indexContent,
result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
)
);
if (context.prefixIdentifiers) {
result.index = processExpression(result.index, context, true);
}
}
}
}
if (valueContent) {
result.value = createAliasExpression(loc, valueContent, trimmedOffset);
if (context.prefixIdentifiers) {
result.value = processExpression(result.value, context, true);
}
}
return result;
}
function createAliasExpression(range, content, offset) {
return createSimpleExpression(
content,
false,
getInnerRange(range, offset, content.length)
);
}
function createForLoopParams({ value, key, index }, memoArgs = []) {
return createParamsList([value, key, index, ...memoArgs]);
}
function createParamsList(args) {
let i = args.length;
while (i--) {
if (args[i])
break;
}
return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
}
const defaultFallback = createSimpleExpression(`undefined`, false);
const trackSlotScopes = (node, context) => {
if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
const vSlot = findDir(node, "slot");
if (vSlot) {
const slotProps = vSlot.exp;
if (context.prefixIdentifiers) {
slotProps && context.addIdentifiers(slotProps);
}
context.scopes.vSlot++;
return () => {
if (context.prefixIdentifiers) {
slotProps && context.removeIdentifiers(slotProps);
}
context.scopes.vSlot--;
};
}
}
};
const trackVForSlotScopes = (node, context) => {
let vFor;
if (isTemplateNode(node) && node.props.some(isVSlot) && (vFor = findDir(node, "for"))) {
const result = vFor.parseResult = parseForExpression(
vFor.exp,
context
);
if (result) {
const { value, key, index } = result;
const { addIdentifiers, removeIdentifiers } = context;
value && addIdentifiers(value);
key && addIdentifiers(key);
index && addIdentifiers(index);
return () => {
value && removeIdentifiers(value);
key && removeIdentifiers(key);
index && removeIdentifiers(index);
};
}
}
};
const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
props,
children,
false,
true,
children.length ? children[0].loc : loc
);
function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
context.helper(WITH_CTX);
const { children, loc } = node;
const slotsProperties = [];
const dynamicSlots = [];
let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
if (!context.ssr && context.prefixIdentifiers) {
hasDynamicSlots = hasScopeRef(node, context.identifiers);
}
const onComponentSlot = findDir(node, "slot", true);
if (onComponentSlot) {
const { arg, exp } = onComponentSlot;
if (arg && !isStaticExp(arg)) {
hasDynamicSlots = true;
}
slotsProperties.push(
createObjectProperty(
arg || createSimpleExpression("default", true),
buildSlotFn(exp, void 0, children, loc)
)
);
}
let hasTemplateSlots = false;
let hasNamedDefaultSlot = false;
const implicitDefaultChildren = [];
const seenSlotNames = /* @__PURE__ */ new Set();
let conditionalBranchIndex = 0;
for (let i = 0; i < children.length; i++) {
const slotElement = children[i];
let slotDir;
if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
if (slotElement.type !== 3) {
implicitDefaultChildren.push(slotElement);
}
continue;
}
if (onComponentSlot) {
context.onError(
createCompilerError(37, slotDir.loc)
);
break;
}
hasTemplateSlots = true;
const { children: slotChildren, loc: slotLoc } = slotElement;
const {
arg: slotName = createSimpleExpression(`default`, true),
exp: slotProps,
loc: dirLoc
} = slotDir;
let staticSlotName;
if (isStaticExp(slotName)) {
staticSlotName = slotName ? slotName.content : `default`;
} else {
hasDynamicSlots = true;
}
const vFor = findDir(slotElement, "for");
const slotFunction = buildSlotFn(
slotProps,
vFor == null ? void 0 : vFor.exp,
slotChildren,
slotLoc
);
let vIf;
let vElse;
if (vIf = findDir(slotElement, "if")) {
hasDynamicSlots = true;
dynamicSlots.push(
createConditionalExpression(
vIf.exp,
buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
defaultFallback
)
);
} else if (vElse = findDir(
slotElement,
/^else(-if)?$/,
true
/* allowEmpty */
)) {
let j = i;
let prev;
while (j--) {
prev = children[j];
if (prev.type !== 3) {
break;
}
}
if (prev && isTemplateNode(prev) && findDir(prev, "if")) {
children.splice(i, 1);
i--;
let conditional = dynamicSlots[dynamicSlots.length - 1];
while (conditional.alternate.type === 19) {
conditional = conditional.alternate;
}
conditional.alternate = vElse.exp ? createConditionalExpression(
vElse.exp,
buildDynamicSlot(
slotName,
slotFunction,
conditionalBranchIndex++
),
defaultFallback
) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
} else {
context.onError(
createCompilerError(30, vElse.loc)
);
}
} else if (vFor) {
hasDynamicSlots = true;
const parseResult = vFor.parseResult || parseForExpression(vFor.exp, context);
if (parseResult) {
dynamicSlots.push(
createCallExpression(context.helper(RENDER_LIST), [
parseResult.source,
createFunctionExpression(
createForLoopParams(parseResult),
buildDynamicSlot(slotName, slotFunction),
true
/* force newline */
)
])
);
} else {
context.onError(
createCompilerError(32, vFor.loc)
);
}
} else {
if (staticSlotName) {
if (seenSlotNames.has(staticSlotName)) {
context.onError(
createCompilerError(
38,
dirLoc
)
);
continue;
}
seenSlotNames.add(staticSlotName);
if (staticSlotName === "default") {
hasNamedDefaultSlot = true;
}
}
slotsProperties.push(createObjectProperty(slotName, slotFunction));
}
}
if (!onComponentSlot) {
const buildDefaultSlotProperty = (props, children2) => {
const fn = buildSlotFn(props, void 0, children2, loc);
if (context.compatConfig) {
fn.isNonScopedSlot = true;
}
return createObjectProperty(`default`, fn);
};
if (!hasTemplateSlots) {
slotsProperties.push(buildDefaultSlotProperty(void 0, children));
} else if (implicitDefaultChildren.length && // #3766
// with whitespace: 'preserve', whitespaces between slots will end up in
// implicitDefaultChildren. Ignore if all implicit children are whitespaces.
implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
if (hasNamedDefaultSlot) {
context.onError(
createCompilerError(
39,
implicitDefaultChildren[0].loc
)
);
} else {
slotsProperties.push(
buildDefaultSlotProperty(void 0, implicitDefaultChildren)
);
}
}
}
const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
let slots = createObjectExpression(
slotsProperties.concat(
createObjectProperty(
`_`,
// 2 = compiled but dynamic = can skip normalization, but must run diff
// 1 = compiled and static = can skip normalization AND diff as optimized
createSimpleExpression(
slotFlag + (``),
false
)
)
),
loc
);
if (dynamicSlots.length) {
slots = createCallExpression(context.helper(CREATE_SLOTS), [
slots,
createArrayExpression(dynamicSlots)
]);
}
return {
slots,
hasDynamicSlots
};
}
function buildDynamicSlot(name, fn, index) {
const props = [
createObjectProperty(`name`, name),
createObjectProperty(`fn`, fn)
];
if (index != null) {
props.push(
createObjectProperty(`key`, createSimpleExpression(String(index), true))
);
}
return createObjectExpression(props);
}
function hasForwardedSlots(children) {
for (let i = 0; i < children.length; i++) {
const child = children[i];
switch (child.type) {
case 1:
if (child.tagType === 2 || hasForwardedSlots(child.children)) {
return true;
}
break;
case 9:
if (hasForwardedSlots(child.branches))
return true;
break;
case 10:
case 11:
if (hasForwardedSlots(child.children))
return true;
break;
}
}
return false;
}
function isNonWhitespaceContent(node) {
if (node.type !== 2 && node.type !== 12)
return true;
return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
}
const directiveImportMap = /* @__PURE__ */ new WeakMap();
const transformElement = (node, context) => {
return function postTransformElement() {
node = context.currentNode;
if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
return;
}
const { tag, props } = node;
const isComponent = node.tagType === 1;
let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
let vnodeProps;
let vnodeChildren;
let vnodePatchFlag;
let patchFlag = 0;
let vnodeDynamicProps;
let dynamicPropNames;
let vnodeDirectives;
let shouldUseBlock = (
// dynamic component may resolve to plain elements
isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
// updates inside get proper isSVG flag at runtime. (#639, #643)
// This is technically web-specific, but splitting the logic out of core
// leads to too much unnecessary complexity.
(tag === "svg" || tag === "foreignObject")
);
if (props.length > 0) {
const propsBuildResult = buildProps(
node,
context,
void 0,
isComponent,
isDynamicComponent
);
vnodeProps = propsBuildResult.props;
patchFlag = propsBuildResult.patchFlag;
dynamicPropNames = propsBuildResult.dynamicPropNames;
const directives = propsBuildResult.directives;
vnodeDirectives = directives && directives.length ? createArrayExpression(
directives.map((dir) => buildDirectiveArgs(dir, context))
) : void 0;
if (propsBuildResult.shouldUseBlock) {
shouldUseBlock = true;
}
}
if (node.children.length > 0) {
if (vnodeTag === KEEP_ALIVE) {
shouldUseBlock = true;
patchFlag |= 1024;
}
const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
vnodeTag !== TELEPORT && // explained above.
vnodeTag !== KEEP_ALIVE;
if (shouldBuildAsSlots) {
const { slots, hasDynamicSlots } = buildSlots(node, context);
vnodeChildren = slots;
if (hasDynamicSlots) {
patchFlag |= 1024;
}
} else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
const child = node.children[0];
const type = child.type;
const hasDynamicTextChild = type === 5 || type === 8;
if (hasDynamicTextChild && getConstantType(child, context) === 0) {
patchFlag |= 1;
}
if (hasDynamicTextChild || type === 2) {
vnodeChildren = child;
} else {
vnodeChildren = node.children;
}
} else {
vnodeChildren = node.children;
}
}
if (patchFlag !== 0) {
{
vnodePatchFlag = String(patchFlag);
}
if (dynamicPropNames && dynamicPropNames.length) {
vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
}
}
node.codegenNode = createVNodeCall(
context,
vnodeTag,
vnodeProps,
vnodeChildren,
vnodePatchFlag,
vnodeDynamicProps,
vnodeDirectives,
!!shouldUseBlock,
false,
isComponent,
node.loc
);
};
};
function resolveComponentType(node, context, ssr = false) {
let { tag } = node;
const isExplicitDynamic = isComponentTag(tag);
const isProp = findProp(node, "is");
if (isProp) {
if (isExplicitDynamic || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
)) {
const exp = isProp.type === 6 ? isProp.value && createSimpleExpression(isProp.value.content, true) : isProp.exp;
if (exp) {
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
exp
]);
}
} else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
tag = isProp.value.content.slice(4);
}
}
const isDir = !isExplicitDynamic && findDir(node, "is");
if (isDir && isDir.exp) {
return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
isDir.exp
]);
}
const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
if (builtIn) {
if (!ssr)
context.helper(builtIn);
return builtIn;
}
{
const fromSetup = resolveSetupReference(tag, context);
if (fromSetup) {
return fromSetup;
}
const dotIndex = tag.indexOf(".");
if (dotIndex > 0) {
const ns = resolveSetupReference(tag.slice(0, dotIndex), context);
if (ns) {
return ns + tag.slice(dotIndex);
}
}
}
if (context.selfName && capitalize(camelize(tag)) === context.selfName) {
context.helper(RESOLVE_COMPONENT);
context.components.add(tag + `__self`);
return toValidAssetId(tag, `component`);
}
context.helper(RESOLVE_COMPONENT);
context.components.add(tag);
return toValidAssetId(tag, `component`);
}
function resolveSetupReference(name, context) {
const bindings = context.bindingMetadata;
if (!bindings || bindings.__isScriptSetup === false) {
return;
}
const camelName = camelize(name);
const PascalName = capitalize(camelName);
const checkType = (type) => {
if (bindings[name] === type) {
return name;
}
if (bindings[camelName] === type) {
return camelName;
}
if (bindings[PascalName] === type) {
return PascalName;
}
};
const fromConst = checkType("setup-const") || checkType("setup-reactive-const") || checkType("literal-const");
if (fromConst) {
return context.inline ? (
// in inline mode, const setup bindings (e.g. imports) can be used as-is
fromConst
) : `$setup[${JSON.stringify(fromConst)}]`;
}
const fromMaybeRef = checkType("setup-let") || checkType("setup-ref") || checkType("setup-maybe-ref");
if (fromMaybeRef) {
return context.inline ? (
// setup scope bindings that may be refs need to be unrefed
`${context.helperString(UNREF)}(${fromMaybeRef})`
) : `$setup[${JSON.stringify(fromMaybeRef)}]`;
}
const fromProps = checkType("props");
if (fromProps) {
return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`;
}
}
function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
const { tag, loc: elementLoc, children } = node;
let properties = [];
const mergeArgs = [];
const runtimeDirectives = [];
const hasChildren = children.length > 0;
let shouldUseBlock = false;
let patchFlag = 0;
let hasRef = false;
let hasClassBinding = false;
let hasStyleBinding = false;
let hasHydrationEventBinding = false;
let hasDynamicKeys = false;
let hasVnodeHook = false;
const dynamicPropNames = [];
const pushMergeArg = (arg) => {
if (properties.length) {
mergeArgs.push(
createObjectExpression(dedupeProperties(properties), elementLoc)
);
properties = [];
}
if (arg)
mergeArgs.push(arg);
};
const analyzePatchFlag = ({ key, value }) => {
if (isStaticExp(key)) {
const name = key.content;
const isEventHandler = isOn(name);
if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
// dedicated fast path.
name.toLowerCase() !== "onclick" && // omit v-model handlers
name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
!isReservedProp(name)) {
hasHydrationEventBinding = true;
}
if (isEventHandler && isReservedProp(name)) {
hasVnodeHook = true;
}
if (isEventHandler && value.type === 14) {
value = value.arguments[0];
}
if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
return;
}
if (name === "ref") {
hasRef = true;
} else if (name === "class") {
hasClassBinding = true;
} else if (name === "style") {
hasStyleBinding = true;
} else if (name !== "key" && !dynamicPropNames.includes(name)) {
dynamicPropNames.push(name);
}
if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
dynamicPropNames.push(name);
}
} else {
hasDynamicKeys = true;
}
};
for (let i = 0; i < props.length; i++) {
const prop = props[i];
if (prop.type === 6) {
const { loc, name, value } = prop;
let isStatic = true;
if (name === "ref") {
hasRef = true;
if (context.scopes.vFor > 0) {
properties.push(
createObjectProperty(
createSimpleExpression("ref_for", true),
createSimpleExpression("true")
)
);
}
if (value && context.inline) {
const binding = context.bindingMetadata[value.content];
if (binding === "setup-let" || binding === "setup-ref" || binding === "setup-maybe-ref") {
isStatic = false;
properties.push(
createObjectProperty(
createSimpleExpression("ref_key", true),
createSimpleExpression(value.content, true, value.loc)
)
);
}
}
}
if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
))) {
continue;
}
properties.push(
createObjectProperty(
createSimpleExpression(
name,
true,
getInnerRange(loc, 0, name.length)
),
createSimpleExpression(
value ? value.content : "",
isStatic,
value ? value.loc : loc
)
)
);
} else {
const { name, arg, exp, loc, modifiers } = prop;
const isVBind = name === "bind";
const isVOn = name === "on";
if (name === "slot") {
if (!isComponent) {
context.onError(
createCompilerError(40, loc)
);
}
continue;
}
if (name === "once" || name === "memo") {
continue;
}
if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || isCompatEnabled(
"COMPILER_IS_ON_ELEMENT",
context
))) {
continue;
}
if (isVOn && ssr) {
continue;
}
if (
// #938: elements with dynamic keys should be forced into blocks
isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
// before children
isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
) {
shouldUseBlock = true;
}
if (isVBind && isStaticArgOf(arg, "ref") && context.scopes.vFor > 0) {
properties.push(
createObjectProperty(
createSimpleExpression("ref_for", true),
createSimpleExpression("true")
)
);
}
if (!arg && (isVBind || isVOn)) {
hasDynamicKeys = true;
if (exp) {
if (isVBind) {
pushMergeArg();
{
if (isCompatEnabled(
"COMPILER_V_BIND_OBJECT_ORDER",
context
)) {
mergeArgs.unshift(exp);
continue;
}
}
mergeArgs.push(exp);
} else {
pushMergeArg({
type: 14,
loc,
callee: context.helper(TO_HANDLERS),
arguments: isComponent ? [exp] : [exp, `true`]
});
}
} else {
context.onError(
createCompilerError(
isVBind ? 34 : 35,
loc
)
);
}
continue;
}
if (isVBind && modifiers.includes("prop")) {
patchFlag |= 32;
}
const directiveTransform = context.directiveTransforms[name];
if (directiveTransform) {
const { props: props2, needRuntime } = directiveTransform(prop, node, context);
!ssr && props2.forEach(analyzePatchFlag);
if (isVOn && arg && !isStaticExp(arg)) {
pushMergeArg(createObjectExpression(props2, elementLoc));
} else {
properties.push(...props2);
}
if (needRuntime) {
runtimeDirectives.push(prop);
if (isSymbol(needRuntime)) {
directiveImportMap.set(prop, needRuntime);
}
}
} else if (!isBuiltInDirective(name)) {
runtimeDirectives.push(prop);
if (hasChildren) {
shouldUseBlock = true;
}
}
}
}
let propsExpression = void 0;
if (mergeArgs.length) {
pushMergeArg();
if (mergeArgs.length > 1) {
propsExpression = createCallExpression(
context.helper(MERGE_PROPS),
mergeArgs,
elementLoc
);
} else {
propsExpression = mergeArgs[0];
}
} else if (properties.length) {
propsExpression = createObjectExpression(
dedupeProperties(properties),
elementLoc
);
}
if (hasDynamicKeys) {
patchFlag |= 16;
} else {
if (hasClassBinding && !isComponent) {
patchFlag |= 2;
}
if (hasStyleBinding && !isComponent) {
patchFlag |= 4;
}
if (dynamicPropNames.length) {
patchFlag |= 8;
}
if (hasHydrationEventBinding) {
patchFlag |= 32;
}
}
if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
patchFlag |= 512;
}
if (!context.inSSR && propsExpression) {
switch (propsExpression.type) {
case 15:
let classKeyIndex = -1;
let styleKeyIndex = -1;
let hasDynamicKey = false;
for (let i = 0; i < propsExpression.properties.length; i++) {
const key = propsExpression.properties[i].key;
if (isStaticExp(key)) {
if (key.content === "class") {
classKeyIndex = i;
} else if (key.content === "style") {
styleKeyIndex = i;
}
} else if (!key.isHandlerKey) {
hasDynamicKey = true;
}
}
const classProp = propsExpression.properties[classKeyIndex];
const styleProp = propsExpression.properties[styleKeyIndex];
if (!hasDynamicKey) {
if (classProp && !isStaticExp(classProp.value)) {
classProp.value = createCallExpression(
context.helper(NORMALIZE_CLASS),
[classProp.value]
);
}
if (styleProp && // the static style is compiled into an object,
// so use `hasStyleBinding` to ensure that it is a dynamic style binding
(hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
// v-bind:style with static literal object
styleProp.value.type === 17)) {
styleProp.value = createCallExpression(
context.helper(NORMALIZE_STYLE),
[styleProp.value]
);
}
} else {
propsExpression = createCallExpression(
context.helper(NORMALIZE_PROPS),
[propsExpression]
);
}
break;
case 14:
break;
default:
propsExpression = createCallExpression(
context.helper(NORMALIZE_PROPS),
[
createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
propsExpression
])
]
);
break;
}
}
return {
props: propsExpression,
directives: runtimeDirectives,
patchFlag,
dynamicPropNames,
shouldUseBlock
};
}
function dedupeProperties(properties) {
const knownProps = /* @__PURE__ */ new Map();
const deduped = [];
for (let i = 0; i < properties.length; i++) {
const prop = properties[i];
if (prop.key.type === 8 || !prop.key.isStatic) {
deduped.push(prop);
continue;
}
const name = prop.key.content;
const existing = knownProps.get(name);
if (existing) {
if (name === "style" || name === "class" || isOn(name)) {
mergeAsArray(existing, prop);
}
} else {
knownProps.set(name, prop);
deduped.push(prop);
}
}
return deduped;
}
function mergeAsArray(existing, incoming) {
if (existing.value.type === 17) {
existing.value.elements.push(incoming.value);
} else {
existing.value = createArrayExpression(
[existing.value, incoming.value],
existing.loc
);
}
}
function buildDirectiveArgs(dir, context) {
const dirArgs = [];
const runtime = directiveImportMap.get(dir);
if (runtime) {
dirArgs.push(context.helperString(runtime));
} else {
const fromSetup = resolveSetupReference("v-" + dir.name, context);
if (fromSetup) {
dirArgs.push(fromSetup);
} else {
context.helper(RESOLVE_DIRECTIVE);
context.directives.add(dir.name);
dirArgs.push(toValidAssetId(dir.name, `directive`));
}
}
const { loc } = dir;
if (dir.exp)
dirArgs.push(dir.exp);
if (dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(dir.arg);
}
if (Object.keys(dir.modifiers).length) {
if (!dir.arg) {
if (!dir.exp) {
dirArgs.push(`void 0`);
}
dirArgs.push(`void 0`);
}
const trueExpression = createSimpleExpression(`true`, false, loc);
dirArgs.push(
createObjectExpression(
dir.modifiers.map(
(modifier) => createObjectProperty(modifier, trueExpression)
),
loc
)
);
}
return createArrayExpression(dirArgs, dir.loc);
}
function stringifyDynamicPropNames(props) {
let propsNamesString = `[`;
for (let i = 0, l = props.length; i < l; i++) {
propsNamesString += JSON.stringify(props[i]);
if (i < l - 1)
propsNamesString += ", ";
}
return propsNamesString + `]`;
}
function isComponentTag(tag) {
return tag === "component" || tag === "Component";
}
const transformSlotOutlet = (node, context) => {
if (isSlotOutlet(node)) {
const { children, loc } = node;
const { slotName, slotProps } = processSlotOutlet(node, context);
const slotArgs = [
context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
slotName,
"{}",
"undefined",
"true"
];
let expectedLen = 2;
if (slotProps) {
slotArgs[2] = slotProps;
expectedLen = 3;
}
if (children.length) {
slotArgs[3] = createFunctionExpression([], children, false, false, loc);
expectedLen = 4;
}
if (context.scopeId && !context.slotted) {
expectedLen = 5;
}
slotArgs.splice(expectedLen);
node.codegenNode = createCallExpression(
context.helper(RENDER_SLOT),
slotArgs,
loc
);
}
};
function processSlotOutlet(node, context) {
let slotName = `"default"`;
let slotProps = void 0;
const nonNameProps = [];
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
if (p.value) {
if (p.name === "name") {
slotName = JSON.stringify(p.value.content);
} else {
p.name = camelize(p.name);
nonNameProps.push(p);
}
}
} else {
if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
if (p.exp)
slotName = p.exp;
} else {
if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
p.arg.content = camelize(p.arg.content);
}
nonNameProps.push(p);
}
}
}
if (nonNameProps.length > 0) {
const { props, directives } = buildProps(
node,
context,
nonNameProps,
false,
false
);
slotProps = props;
if (directives.length) {
context.onError(
createCompilerError(
36,
directives[0].loc
)
);
}
}
return {
slotName,
slotProps
};
}
const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
const transformOn$1 = (dir, node, context, augmentor) => {
const { loc, modifiers, arg } = dir;
if (!dir.exp && !modifiers.length) {
context.onError(createCompilerError(35, loc));
}
let eventName;
if (arg.type === 4) {
if (arg.isStatic) {
let rawName = arg.content;
if (rawName.startsWith("vue:")) {
rawName = `vnode-${rawName.slice(4)}`;
}
const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
// for non-element and vnode lifecycle event listeners, auto convert
// it to camelCase. See issue #2249
toHandlerKey(camelize(rawName))
) : (
// preserve case for plain element listeners that have uppercase
// letters, as these may be custom elements' custom events
`on:${rawName}`
);
eventName = createSimpleExpression(eventString, true, arg.loc);
} else {
eventName = createCompoundExpression([
`${context.helperString(TO_HANDLER_KEY)}(`,
arg,
`)`
]);
}
} else {
eventName = arg;
eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
eventName.children.push(`)`);
}
let exp = dir.exp;
if (exp && !exp.content.trim()) {
exp = void 0;
}
let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
if (exp) {
const isMemberExp = isMemberExpression(exp.content, context);
const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
const hasMultipleStatements = exp.content.includes(`;`);
if (context.prefixIdentifiers) {
isInlineStatement && context.addIdentifiers(`$event`);
exp = dir.exp = processExpression(
exp,
context,
false,
hasMultipleStatements
);
isInlineStatement && context.removeIdentifiers(`$event`);
shouldCache = context.cacheHandlers && // unnecessary to cache inside v-once
!context.inVOnce && // runtime constants don't need to be cached
// (this is analyzed by compileScript in SFC <script setup>)
!(exp.type === 4 && exp.constType > 0) && // #1541 bail if this is a member exp handler passed to a component -
// we need to use the original function to preserve arity,
// e.g. <transition> relies on checking cb.length to determine
// transition end handling. Inline function is ok since its arity
// is preserved even when cached.
!(isMemberExp && node.tagType === 1) && // bail if the function references closure variables (v-for, v-slot)
// it must be passed fresh to avoid stale values.
!hasScopeRef(exp, context.identifiers);
if (shouldCache && isMemberExp) {
if (exp.type === 4) {
exp.content = `${exp.content} && ${exp.content}(...args)`;
} else {
exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
}
}
}
if (isInlineStatement || shouldCache && isMemberExp) {
exp = createCompoundExpression([
`${isInlineStatement ? context.isTS ? `($event: any)` : `$event` : `${context.isTS ? `
//@ts-ignore
` : ``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
exp,
hasMultipleStatements ? `}` : `)`
]);
}
}
let ret = {
props: [
createObjectProperty(
eventName,
exp || createSimpleExpression(`() => {}`, false, loc)
)
]
};
if (augmentor) {
ret = augmentor(ret);
}
if (shouldCache) {
ret.props[0].value = context.cache(ret.props[0].value);
}
ret.props.forEach((p) => p.key.isHandlerKey = true);
return ret;
};
const transformBind = (dir, _node, context) => {
const { exp, modifiers, loc } = dir;
const arg = dir.arg;
if (arg.type !== 4) {
arg.children.unshift(`(`);
arg.children.push(`) || ""`);
} else if (!arg.isStatic) {
arg.content = `${arg.content} || ""`;
}
if (modifiers.includes("camel")) {
if (arg.type === 4) {
if (arg.isStatic) {
arg.content = camelize(arg.content);
} else {
arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
}
} else {
arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
arg.children.push(`)`);
}
}
if (!context.inSSR) {
if (modifiers.includes("prop")) {
injectPrefix(arg, ".");
}
if (modifiers.includes("attr")) {
injectPrefix(arg, "^");
}
}
if (!exp || exp.type === 4 && !exp.content.trim()) {
context.onError(createCompilerError(34, loc));
return {
props: [createObjectProperty(arg, createSimpleExpression("", true, loc))]
};
}
return {
props: [createObjectProperty(arg, exp)]
};
};
const injectPrefix = (arg, prefix) => {
if (arg.type === 4) {
if (arg.isStatic) {
arg.content = prefix + arg.content;
} else {
arg.content = `\`${prefix}\${${arg.content}}\``;
}
} else {
arg.children.unshift(`'${prefix}' + (`);
arg.children.push(`)`);
}
};
const transformText = (node, context) => {
if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
return () => {
const children = node.children;
let currentContainer = void 0;
let hasText = false;
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child)) {
hasText = true;
for (let j = i + 1; j < children.length; j++) {
const next = children[j];
if (isText$1(next)) {
if (!currentContainer) {
currentContainer = children[i] = createCompoundExpression(
[child],
child.loc
);
}
currentContainer.children.push(` + `, next);
children.splice(j, 1);
j--;
} else {
currentContainer = void 0;
break;
}
}
}
}
if (!hasText || // if this is a plain element with a single text child, leave it
// as-is since the runtime has dedicated fast path for this by directly
// setting textContent of the element.
// for component root it's always normalized anyway.
children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
// custom directives can potentially add DOM elements arbitrarily,
// we need to avoid setting textContent of the element at runtime
// to avoid accidentally overwriting the DOM elements added
// by the user through custom directives.
!node.props.find(
(p) => p.type === 7 && !context.directiveTransforms[p.name]
) && // in compat mode, <template> tags with no special directives
// will be rendered as a fragment so its children must be
// converted into vnodes.
!(node.tag === "template"))) {
return;
}
for (let i = 0; i < children.length; i++) {
const child = children[i];
if (isText$1(child) || child.type === 8) {
const callArgs = [];
if (child.type !== 2 || child.content !== " ") {
callArgs.push(child);
}
if (!context.ssr && getConstantType(child, context) === 0) {
callArgs.push(
1 + (``)
);
}
children[i] = {
type: 12,
content: child,
loc: child.loc,
codegenNode: createCallExpression(
context.helper(CREATE_TEXT),
callArgs
)
};
}
}
};
}
};
const seen$1 = /* @__PURE__ */ new WeakSet();
const transformOnce = (node, context) => {
if (node.type === 1 && findDir(node, "once", true)) {
if (seen$1.has(node) || context.inVOnce || context.inSSR) {
return;
}
seen$1.add(node);
context.inVOnce = true;
context.helper(SET_BLOCK_TRACKING);
return () => {
context.inVOnce = false;
const cur = context.currentNode;
if (cur.codegenNode) {
cur.codegenNode = context.cache(
cur.codegenNode,
true
/* isVNode */
);
}
};
}
};
const transformModel$1 = (dir, node, context) => {
const { exp, arg } = dir;
if (!exp) {
context.onError(
createCompilerError(41, dir.loc)
);
return createTransformProps();
}
const rawExp = exp.loc.source;
const expString = exp.type === 4 ? exp.content : rawExp;
const bindingType = context.bindingMetadata[rawExp];
if (bindingType === "props" || bindingType === "props-aliased") {
context.onError(createCompilerError(44, exp.loc));
return createTransformProps();
}
const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
if (!expString.trim() || !isMemberExpression(expString, context) && !maybeRef) {
context.onError(
createCompilerError(42, exp.loc)
);
return createTransformProps();
}
if (context.prefixIdentifiers && isSimpleIdentifier(expString) && context.identifiers[expString]) {
context.onError(
createCompilerError(43, exp.loc)
);
return createTransformProps();
}
const propName = arg ? arg : createSimpleExpression("modelValue", true);
const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
let assignmentExp;
const eventArg = context.isTS ? `($event: any)` : `$event`;
if (maybeRef) {
if (bindingType === "setup-ref") {
assignmentExp = createCompoundExpression([
`${eventArg} => ((`,
createSimpleExpression(rawExp, false, exp.loc),
`).value = $event)`
]);
} else {
const altAssignment = bindingType === "setup-let" ? `${rawExp} = $event` : `null`;
assignmentExp = createCompoundExpression([
`${eventArg} => (${context.helperString(IS_REF)}(${rawExp}) ? (`,
createSimpleExpression(rawExp, false, exp.loc),
`).value = $event : ${altAssignment})`
]);
}
} else {
assignmentExp = createCompoundExpression([
`${eventArg} => ((`,
exp,
`) = $event)`
]);
}
const props = [
// modelValue: foo
createObjectProperty(propName, dir.exp),
// "onUpdate:modelValue": $event => (foo = $event)
createObjectProperty(eventName, assignmentExp)
];
if (context.prefixIdentifiers && !context.inVOnce && context.cacheHandlers && !hasScopeRef(exp, context.identifiers)) {
props[1].value = context.cache(props[1].value);
}
if (dir.modifiers.length && node.tagType === 1) {
const modifiers = dir.modifiers.map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
props.push(
createObjectProperty(
modifiersKey,
createSimpleExpression(
`{ ${modifiers} }`,
false,
dir.loc,
2
)
)
);
}
return createTransformProps(props);
};
function createTransformProps(props = []) {
return { props };
}
const validDivisionCharRE = /[\w).+\-_$\]]/;
const transformFilter = (node, context) => {
if (!isCompatEnabled("COMPILER_FILTER", context)) {
return;
}
if (node.type === 5) {
rewriteFilter(node.content, context);
}
if (node.type === 1) {
node.props.forEach((prop) => {
if (prop.type === 7 && prop.name !== "for" && prop.exp) {
rewriteFilter(prop.exp, context);
}
});
}
};
function rewriteFilter(node, context) {
if (node.type === 4) {
parseFilter(node, context);
} else {
for (let i = 0; i < node.children.length; i++) {
const child = node.children[i];
if (typeof child !== "object")
continue;
if (child.type === 4) {
parseFilter(child, context);
} else if (child.type === 8) {
rewriteFilter(node, context);
} else if (child.type === 5) {
rewriteFilter(child.content, context);
}
}
}
}
function parseFilter(node, context) {
const exp = node.content;
let inSingle = false;
let inDouble = false;
let inTemplateString = false;
let inRegex = false;
let curly = 0;
let square = 0;
let paren = 0;
let lastFilterIndex = 0;
let c, prev, i, expression, filters = [];
for (i = 0; i < exp.length; i++) {
prev = c;
c = exp.charCodeAt(i);
if (inSingle) {
if (c === 39 && prev !== 92)
inSingle = false;
} else if (inDouble) {
if (c === 34 && prev !== 92)
inDouble = false;
} else if (inTemplateString) {
if (c === 96 && prev !== 92)
inTemplateString = false;
} else if (inRegex) {
if (c === 47 && prev !== 92)
inRegex = false;
} else if (c === 124 && // pipe
exp.charCodeAt(i + 1) !== 124 && exp.charCodeAt(i - 1) !== 124 && !curly && !square && !paren) {
if (expression === void 0) {
lastFilterIndex = i + 1;
expression = exp.slice(0, i).trim();
} else {
pushFilter();
}
} else {
switch (c) {
case 34:
inDouble = true;
break;
case 39:
inSingle = true;
break;
case 96:
inTemplateString = true;
break;
case 40:
paren++;
break;
case 41:
paren--;
break;
case 91:
square++;
break;
case 93:
square--;
break;
case 123:
curly++;
break;
case 125:
curly--;
break;
}
if (c === 47) {
let j = i - 1;
let p;
for (; j >= 0; j--) {
p = exp.charAt(j);
if (p !== " ")
break;
}
if (!p || !validDivisionCharRE.test(p)) {
inRegex = true;
}
}
}
}
if (expression === void 0) {
expression = exp.slice(0, i).trim();
} else if (lastFilterIndex !== 0) {
pushFilter();
}
function pushFilter() {
filters.push(exp.slice(lastFilterIndex, i).trim());
lastFilterIndex = i + 1;
}
if (filters.length) {
for (i = 0; i < filters.length; i++) {
expression = wrapFilter(expression, filters[i], context);
}
node.content = expression;
}
}
function wrapFilter(exp, filter, context) {
context.helper(RESOLVE_FILTER);
const i = filter.indexOf("(");
if (i < 0) {
context.filters.add(filter);
return `${toValidAssetId(filter, "filter")}(${exp})`;
} else {
const name = filter.slice(0, i);
const args = filter.slice(i + 1);
context.filters.add(name);
return `${toValidAssetId(name, "filter")}(${exp}${args !== ")" ? "," + args : args}`;
}
}
const seen = /* @__PURE__ */ new WeakSet();
const transformMemo = (node, context) => {
if (node.type === 1) {
const dir = findDir(node, "memo");
if (!dir || seen.has(node)) {
return;
}
seen.add(node);
return () => {
const codegenNode = node.codegenNode || context.currentNode.codegenNode;
if (codegenNode && codegenNode.type === 13) {
if (node.tagType !== 1) {
convertToBlock(codegenNode, context);
}
node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
dir.exp,
createFunctionExpression(void 0, codegenNode),
`_cache`,
String(context.cached++)
]);
}
};
}
};
function getBaseTransformPreset(prefixIdentifiers) {
return [
[
transformOnce,
transformIf,
transformMemo,
transformFor,
...[transformFilter] ,
...prefixIdentifiers ? [
// order is important
trackVForSlotScopes,
transformExpression
] : [],
transformSlotOutlet,
transformElement,
trackSlotScopes,
transformText
],
{
on: transformOn$1,
bind: transformBind,
model: transformModel$1
}
];
}
function baseCompile(template, options = {}) {
const onError = options.onError || defaultOnError;
const isModuleMode = options.mode === "module";
const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
if (!prefixIdentifiers && options.cacheHandlers) {
onError(createCompilerError(49));
}
if (options.scopeId && !isModuleMode) {
onError(createCompilerError(50));
}
const ast = isString(template) ? baseParse(template, options) : template;
const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
if (options.isTS) {
const { expressionPlugins } = options;
if (!expressionPlugins || !expressionPlugins.includes("typescript")) {
options.expressionPlugins = [...expressionPlugins || [], "typescript"];
}
}
transform(
ast,
extend({}, options, {
prefixIdentifiers,
nodeTransforms: [
...nodeTransforms,
...options.nodeTransforms || []
// user transforms
],
directiveTransforms: extend(
{},
directiveTransforms,
options.directiveTransforms || {}
// user transforms
)
})
);
return generate(
ast,
extend({}, options, {
prefixIdentifiers
})
);
}
const noopDirectiveTransform = () => ({ props: [] });
const V_MODEL_RADIO = Symbol(``);
const V_MODEL_CHECKBOX = Symbol(``);
const V_MODEL_TEXT = Symbol(``);
const V_MODEL_SELECT = Symbol(``);
const V_MODEL_DYNAMIC = Symbol(``);
const V_ON_WITH_MODIFIERS = Symbol(``);
const V_ON_WITH_KEYS = Symbol(``);
const V_SHOW = Symbol(``);
const TRANSITION = Symbol(``);
const TRANSITION_GROUP = Symbol(``);
registerRuntimeHelpers({
[V_MODEL_RADIO]: `vModelRadio`,
[V_MODEL_CHECKBOX]: `vModelCheckbox`,
[V_MODEL_TEXT]: `vModelText`,
[V_MODEL_SELECT]: `vModelSelect`,
[V_MODEL_DYNAMIC]: `vModelDynamic`,
[V_ON_WITH_MODIFIERS]: `withModifiers`,
[V_ON_WITH_KEYS]: `withKeys`,
[V_SHOW]: `vShow`,
[TRANSITION]: `Transition`,
[TRANSITION_GROUP]: `TransitionGroup`
});
var namedCharacterReferences = {
GT: ">",
gt: ">",
LT: "<",
lt: "<",
"ac;": "∾",
"af;": "",
AMP: "&",
amp: "&",
"ap;": "≈",
"DD;": "ⅅ",
"dd;": "ⅆ",
deg: "°",
"ee;": "ⅇ",
"eg;": "⪚",
"el;": "⪙",
ETH: "Ð",
eth: "ð",
"gE;": "≧",
"ge;": "≥",
"Gg;": "⋙",
"gg;": "≫",
"gl;": "≷",
"GT;": ">",
"Gt;": "≫",
"gt;": ">",
"ic;": "",
"ii;": "ⅈ",
"Im;": "ℑ",
"in;": "∈",
"it;": "",
"lE;": "≦",
"le;": "≤",
"lg;": "≶",
"Ll;": "⋘",
"ll;": "≪",
"LT;": "<",
"Lt;": "≪",
"lt;": "<",
"mp;": "∓",
"Mu;": "Μ",
"mu;": "μ",
"ne;": "≠",
"ni;": "∋",
not: "¬",
"Nu;": "Ν",
"nu;": "ν",
"Or;": "⩔",
"or;": "∨",
"oS;": "Ⓢ",
"Pi;": "Π",
"pi;": "π",
"pm;": "±",
"Pr;": "⪻",
"pr;": "≺",
"Re;": "ℜ",
REG: "®",
reg: "®",
"rx;": "℞",
"Sc;": "⪼",
"sc;": "≻",
shy: "",
uml: "¨",
"wp;": "℘",
"wr;": "≀",
"Xi;": "Ξ",
"xi;": "ξ",
yen: "¥",
"acd;": "∿",
"acE;": "∾̳",
"Acy;": "А",
"acy;": "а",
"Afr;": "𝔄",
"afr;": "𝔞",
"AMP;": "&",
"amp;": "&",
"And;": "⩓",
"and;": "∧",
"ang;": "∠",
"apE;": "⩰",
"ape;": "≊",
"ast;": "*",
Auml: "Ä",
auml: "ä",
"Bcy;": "Б",
"bcy;": "б",
"Bfr;": "𝔅",
"bfr;": "𝔟",
"bne;": "=⃥",
"bot;": "⊥",
"Cap;": "⋒",
"cap;": "∩",
cent: "¢",
"Cfr;": "ℭ",
"cfr;": "𝔠",
"Chi;": "Χ",
"chi;": "χ",
"cir;": "○",
COPY: "©",
copy: "©",
"Cup;": "⋓",
"cup;": "∪",
"Dcy;": "Д",
"dcy;": "д",
"deg;": "°",
"Del;": "∇",
"Dfr;": "𝔇",
"dfr;": "𝔡",
"die;": "¨",
"div;": "÷",
"Dot;": "¨",
"dot;": "˙",
"Ecy;": "Э",
"ecy;": "э",
"Efr;": "𝔈",
"efr;": "𝔢",
"egs;": "⪖",
"ell;": "ℓ",
"els;": "⪕",
"ENG;": "Ŋ",
"eng;": "ŋ",
"Eta;": "Η",
"eta;": "η",
"ETH;": "Ð",
"eth;": "ð",
Euml: "Ë",
euml: "ë",
"Fcy;": "Ф",
"fcy;": "ф",
"Ffr;": "𝔉",
"ffr;": "𝔣",
"gap;": "⪆",
"Gcy;": "Г",
"gcy;": "г",
"gEl;": "⪌",
"gel;": "⋛",
"geq;": "≥",
"ges;": "⩾",
"Gfr;": "𝔊",
"gfr;": "𝔤",
"ggg;": "⋙",
"gla;": "⪥",
"glE;": "⪒",
"glj;": "⪤",
"gnE;": "≩",
"gne;": "⪈",
"Hat;": "^",
"Hfr;": "ℌ",
"hfr;": "𝔥",
"Icy;": "И",
"icy;": "и",
"iff;": "⇔",
"Ifr;": "ℑ",
"ifr;": "𝔦",
"Int;": "∬",
"int;": "∫",
Iuml: "Ï",
iuml: "ï",
"Jcy;": "Й",
"jcy;": "й",
"Jfr;": "𝔍",
"jfr;": "𝔧",
"Kcy;": "К",
"kcy;": "к",
"Kfr;": "𝔎",
"kfr;": "𝔨",
"lap;": "⪅",
"lat;": "⪫",
"Lcy;": "Л",
"lcy;": "л",
"lEg;": "⪋",
"leg;": "⋚",
"leq;": "≤",
"les;": "⩽",
"Lfr;": "𝔏",
"lfr;": "𝔩",
"lgE;": "⪑",
"lnE;": "≨",
"lne;": "⪇",
"loz;": "◊",
"lrm;": "",
"Lsh;": "↰",
"lsh;": "↰",
macr: "¯",
"Map;": "⤅",
"map;": "↦",
"Mcy;": "М",
"mcy;": "м",
"Mfr;": "𝔐",
"mfr;": "𝔪",
"mho;": "℧",
"mid;": "∣",
"nap;": "≉",
nbsp: " ",
"Ncy;": "Н",
"ncy;": "н",
"Nfr;": "𝔑",
"nfr;": "𝔫",
"ngE;": "≧̸",
"nge;": "≱",
"nGg;": "⋙̸",
"nGt;": "≫⃒",
"ngt;": "≯",
"nis;": "⋼",
"niv;": "∋",
"nlE;": "≦̸",
"nle;": "≰",
"nLl;": "⋘̸",
"nLt;": "≪⃒",
"nlt;": "≮",
"Not;": "⫬",
"not;": "¬",
"npr;": "⊀",
"nsc;": "⊁",
"num;": "#",
"Ocy;": "О",
"ocy;": "о",
"Ofr;": "𝔒",
"ofr;": "𝔬",
"ogt;": "⧁",
"ohm;": "Ω",
"olt;": "⧀",
"ord;": "⩝",
ordf: "ª",
ordm: "º",
"orv;": "⩛",
Ouml: "Ö",
ouml: "ö",
"par;": "∥",
para: "¶",
"Pcy;": "П",
"pcy;": "п",
"Pfr;": "𝔓",
"pfr;": "𝔭",
"Phi;": "Φ",
"phi;": "φ",
"piv;": "ϖ",
"prE;": "⪳",
"pre;": "⪯",
"Psi;": "Ψ",
"psi;": "ψ",
"Qfr;": "𝔔",
"qfr;": "𝔮",
QUOT: "\"",
quot: "\"",
"Rcy;": "Р",
"rcy;": "р",
"REG;": "®",
"reg;": "®",
"Rfr;": "ℜ",
"rfr;": "𝔯",
"Rho;": "Ρ",
"rho;": "ρ",
"rlm;": "",
"Rsh;": "↱",
"rsh;": "↱",
"scE;": "⪴",
"sce;": "⪰",
"Scy;": "С",
"scy;": "с",
sect: "§",
"Sfr;": "𝔖",
"sfr;": "𝔰",
"shy;": "",
"sim;": "∼",
"smt;": "⪪",
"sol;": "/",
"squ;": "□",
"Sub;": "⋐",
"sub;": "⊂",
"Sum;": "∑",
"sum;": "∑",
"Sup;": "⋑",
"sup;": "⊃",
sup1: "¹",
sup2: "²",
sup3: "³",
"Tab;": "\t",
"Tau;": "Τ",
"tau;": "τ",
"Tcy;": "Т",
"tcy;": "т",
"Tfr;": "𝔗",
"tfr;": "𝔱",
"top;": "⊤",
"Ucy;": "У",
"ucy;": "у",
"Ufr;": "𝔘",
"ufr;": "𝔲",
"uml;": "¨",
Uuml: "Ü",
uuml: "ü",
"Vcy;": "В",
"vcy;": "в",
"Vee;": "⋁",
"vee;": "∨",
"Vfr;": "𝔙",
"vfr;": "𝔳",
"Wfr;": "𝔚",
"wfr;": "𝔴",
"Xfr;": "𝔛",
"xfr;": "𝔵",
"Ycy;": "Ы",
"ycy;": "ы",
"yen;": "¥",
"Yfr;": "𝔜",
"yfr;": "𝔶",
yuml: "ÿ",
"Zcy;": "З",
"zcy;": "з",
"Zfr;": "ℨ",
"zfr;": "𝔷",
"zwj;": "",
Acirc: "Â",
acirc: "â",
acute: "´",
AElig: "Æ",
aelig: "æ",
"andd;": "⩜",
"andv;": "⩚",
"ange;": "⦤",
"Aopf;": "𝔸",
"aopf;": "𝕒",
"apid;": "≋",
"apos;": "'",
Aring: "Å",
aring: "å",
"Ascr;": "𝒜",
"ascr;": "𝒶",
"Auml;": "Ä",
"auml;": "ä",
"Barv;": "⫧",
"bbrk;": "⎵",
"Beta;": "Β",
"beta;": "β",
"beth;": "ℶ",
"bNot;": "⫭",
"bnot;": "⌐",
"Bopf;": "𝔹",
"bopf;": "𝕓",
"boxH;": "═",
"boxh;": "─",
"boxV;": "║",
"boxv;": "│",
"Bscr;": "ℬ",
"bscr;": "𝒷",
"bsim;": "∽",
"bsol;": "\\",
"bull;": "•",
"bump;": "≎",
"caps;": "∩︀",
"Cdot;": "Ċ",
"cdot;": "ċ",
cedil: "¸",
"cent;": "¢",
"CHcy;": "Ч",
"chcy;": "ч",
"circ;": "ˆ",
"cirE;": "⧃",
"cire;": "≗",
"comp;": "∁",
"cong;": "≅",
"Copf;": "ℂ",
"copf;": "𝕔",
"COPY;": "©",
"copy;": "©",
"Cscr;": "𝒞",
"cscr;": "𝒸",
"csub;": "⫏",
"csup;": "⫐",
"cups;": "∪︀",
"Darr;": "↡",
"dArr;": "⇓",
"darr;": "↓",
"dash;": "‐",
"dHar;": "⥥",
"diam;": "⋄",
"DJcy;": "Ђ",
"djcy;": "ђ",
"Dopf;": "𝔻",
"dopf;": "𝕕",
"Dscr;": "𝒟",
"dscr;": "𝒹",
"DScy;": "Ѕ",
"dscy;": "ѕ",
"dsol;": "⧶",
"dtri;": "▿",
"DZcy;": "Џ",
"dzcy;": "џ",
"ecir;": "≖",
Ecirc: "Ê",
ecirc: "ê",
"Edot;": "Ė",
"eDot;": "≑",
"edot;": "ė",
"emsp;": " ",
"ensp;": " ",
"Eopf;": "𝔼",
"eopf;": "𝕖",
"epar;": "⋕",
"epsi;": "ε",
"Escr;": "ℰ",
"escr;": "ℯ",
"Esim;": "⩳",
"esim;": "≂",
"Euml;": "Ë",
"euml;": "ë",
"euro;": "€",
"excl;": "!",
"flat;": "♭",
"fnof;": "ƒ",
"Fopf;": "𝔽",
"fopf;": "𝕗",
"fork;": "⋔",
"Fscr;": "ℱ",
"fscr;": "𝒻",
"Gdot;": "Ġ",
"gdot;": "ġ",
"geqq;": "≧",
"gesl;": "⋛︀",
"GJcy;": "Ѓ",
"gjcy;": "ѓ",
"gnap;": "⪊",
"gneq;": "⪈",
"Gopf;": "𝔾",
"gopf;": "𝕘",
"Gscr;": "𝒢",
"gscr;": "ℊ",
"gsim;": "≳",
"gtcc;": "⪧",
"gvnE;": "≩︀",
"half;": "½",
"hArr;": "⇔",
"harr;": "↔",
"hbar;": "ℏ",
"Hopf;": "ℍ",
"hopf;": "𝕙",
"Hscr;": "ℋ",
"hscr;": "𝒽",
Icirc: "Î",
icirc: "î",
"Idot;": "İ",
"IEcy;": "Е",
"iecy;": "е",
iexcl: "¡",
"imof;": "⊷",
"IOcy;": "Ё",
"iocy;": "ё",
"Iopf;": "𝕀",
"iopf;": "𝕚",
"Iota;": "Ι",
"iota;": "ι",
"Iscr;": "ℐ",
"iscr;": "𝒾",
"isin;": "∈",
"Iuml;": "Ï",
"iuml;": "ï",
"Jopf;": "𝕁",
"jopf;": "𝕛",
"Jscr;": "𝒥",
"jscr;": "𝒿",
"KHcy;": "Х",
"khcy;": "х",
"KJcy;": "Ќ",
"kjcy;": "ќ",
"Kopf;": "𝕂",
"kopf;": "𝕜",
"Kscr;": "𝒦",
"kscr;": "𝓀",
"Lang;": "⟪",
"lang;": "⟨",
laquo: "«",
"Larr;": "↞",
"lArr;": "⇐",
"larr;": "←",
"late;": "⪭",
"lcub;": "{",
"ldca;": "⤶",
"ldsh;": "↲",
"leqq;": "≦",
"lesg;": "⋚︀",
"lHar;": "⥢",
"LJcy;": "Љ",
"ljcy;": "љ",
"lnap;": "⪉",
"lneq;": "⪇",
"Lopf;": "𝕃",
"lopf;": "𝕝",
"lozf;": "⧫",
"lpar;": "(",
"Lscr;": "ℒ",
"lscr;": "𝓁",
"lsim;": "≲",
"lsqb;": "[",
"ltcc;": "⪦",
"ltri;": "◃",
"lvnE;": "≨︀",
"macr;": "¯",
"male;": "♂",
"malt;": "✠",
micro: "µ",
"mlcp;": "⫛",
"mldr;": "…",
"Mopf;": "𝕄",
"mopf;": "𝕞",
"Mscr;": "ℳ",
"mscr;": "𝓂",
"nang;": "∠⃒",
"napE;": "⩰̸",
"nbsp;": " ",
"ncap;": "⩃",
"ncup;": "⩂",
"ngeq;": "≱",
"nges;": "⩾̸",
"ngtr;": "≯",
"nGtv;": "≫̸",
"nisd;": "⋺",
"NJcy;": "Њ",
"njcy;": "њ",
"nldr;": "‥",
"nleq;": "≰",
"nles;": "⩽̸",
"nLtv;": "≪̸",
"nmid;": "∤",
"Nopf;": "ℕ",
"nopf;": "𝕟",
"npar;": "∦",
"npre;": "⪯̸",
"nsce;": "⪰̸",
"Nscr;": "𝒩",
"nscr;": "𝓃",
"nsim;": "≁",
"nsub;": "⊄",
"nsup;": "⊅",
"ntgl;": "≹",
"ntlg;": "≸",
"nvap;": "≍⃒",
"nvge;": "≥⃒",
"nvgt;": ">⃒",
"nvle;": "≤⃒",
"nvlt;": "<⃒",
"oast;": "⊛",
"ocir;": "⊚",
Ocirc: "Ô",
ocirc: "ô",
"odiv;": "⨸",
"odot;": "⊙",
"ogon;": "˛",
"oint;": "∮",
"omid;": "⦶",
"Oopf;": "𝕆",
"oopf;": "𝕠",
"opar;": "⦷",
"ordf;": "ª",
"ordm;": "º",
"oror;": "⩖",
"Oscr;": "𝒪",
"oscr;": "ℴ",
"osol;": "⊘",
"Ouml;": "Ö",
"ouml;": "ö",
"para;": "¶",
"part;": "∂",
"perp;": "⊥",
"phiv;": "ϕ",
"plus;": "+",
"Popf;": "ℙ",
"popf;": "𝕡",
pound: "£",
"prap;": "⪷",
"prec;": "≺",
"prnE;": "⪵",
"prod;": "∏",
"prop;": "∝",
"Pscr;": "𝒫",
"pscr;": "𝓅",
"qint;": "⨌",
"Qopf;": "ℚ",
"qopf;": "𝕢",
"Qscr;": "𝒬",
"qscr;": "𝓆",
"QUOT;": "\"",
"quot;": "\"",
"race;": "∽̱",
"Rang;": "⟫",
"rang;": "⟩",
raquo: "»",
"Rarr;": "↠",
"rArr;": "⇒",
"rarr;": "→",
"rcub;": "}",
"rdca;": "⤷",
"rdsh;": "↳",
"real;": "ℜ",
"rect;": "▭",
"rHar;": "⥤",
"rhov;": "ϱ",
"ring;": "˚",
"Ropf;": "ℝ",
"ropf;": "𝕣",
"rpar;": ")",
"Rscr;": "ℛ",
"rscr;": "𝓇",
"rsqb;": "]",
"rtri;": "▹",
"scap;": "⪸",
"scnE;": "⪶",
"sdot;": "⋅",
"sect;": "§",
"semi;": ";",
"sext;": "✶",
"SHcy;": "Ш",
"shcy;": "ш",
"sime;": "≃",
"simg;": "⪞",
"siml;": "⪝",
"smid;": "∣",
"smte;": "⪬",
"solb;": "⧄",
"Sopf;": "𝕊",
"sopf;": "𝕤",
"spar;": "∥",
"Sqrt;": "√",
"squf;": "▪",
"Sscr;": "𝒮",
"sscr;": "𝓈",
"Star;": "⋆",
"star;": "☆",
"subE;": "⫅",
"sube;": "⊆",
"succ;": "≻",
"sung;": "♪",
"sup1;": "¹",
"sup2;": "²",
"sup3;": "³",
"supE;": "⫆",
"supe;": "⊇",
szlig: "ß",
"tbrk;": "⎴",
"tdot;": "⃛",
THORN: "Þ",
thorn: "þ",
times: "×",
"tint;": "∭",
"toea;": "⤨",
"Topf;": "𝕋",
"topf;": "𝕥",
"tosa;": "⤩",
"trie;": "≜",
"Tscr;": "𝒯",
"tscr;": "𝓉",
"TScy;": "Ц",
"tscy;": "ц",
"Uarr;": "↟",
"uArr;": "⇑",
"uarr;": "↑",
Ucirc: "Û",
ucirc: "û",
"uHar;": "⥣",
"Uopf;": "𝕌",
"uopf;": "𝕦",
"Upsi;": "ϒ",
"upsi;": "υ",
"Uscr;": "𝒰",
"uscr;": "𝓊",
"utri;": "▵",
"Uuml;": "Ü",
"uuml;": "ü",
"vArr;": "⇕",
"varr;": "↕",
"Vbar;": "⫫",
"vBar;": "⫨",
"Vert;": "‖",
"vert;": "|",
"Vopf;": "𝕍",
"vopf;": "𝕧",
"Vscr;": "𝒱",
"vscr;": "𝓋",
"Wopf;": "𝕎",
"wopf;": "𝕨",
"Wscr;": "𝒲",
"wscr;": "𝓌",
"xcap;": "⋂",
"xcup;": "⋃",
"xmap;": "⟼",
"xnis;": "⋻",
"Xopf;": "𝕏",
"xopf;": "𝕩",
"Xscr;": "𝒳",
"xscr;": "𝓍",
"xvee;": "⋁",
"YAcy;": "Я",
"yacy;": "я",
"YIcy;": "Ї",
"yicy;": "ї",
"Yopf;": "𝕐",
"yopf;": "𝕪",
"Yscr;": "𝒴",
"yscr;": "𝓎",
"YUcy;": "Ю",
"yucy;": "ю",
"Yuml;": "Ÿ",
"yuml;": "ÿ",
"Zdot;": "Ż",
"zdot;": "ż",
"Zeta;": "Ζ",
"zeta;": "ζ",
"ZHcy;": "Ж",
"zhcy;": "ж",
"Zopf;": "ℤ",
"zopf;": "𝕫",
"Zscr;": "𝒵",
"zscr;": "𝓏",
"zwnj;": "",
Aacute: "Á",
aacute: "á",
"Acirc;": "Â",
"acirc;": "â",
"acute;": "´",
"AElig;": "Æ",
"aelig;": "æ",
Agrave: "À",
agrave: "à",
"aleph;": "ℵ",
"Alpha;": "Α",
"alpha;": "α",
"Amacr;": "Ā",
"amacr;": "ā",
"amalg;": "⨿",
"angle;": "∠",
"angrt;": "∟",
"angst;": "Å",
"Aogon;": "Ą",
"aogon;": "ą",
"Aring;": "Å",
"aring;": "å",
"asymp;": "≈",
Atilde: "Ã",
atilde: "ã",
"awint;": "⨑",
"bcong;": "≌",
"bdquo;": "„",
"bepsi;": "϶",
"blank;": "␣",
"blk12;": "▒",
"blk14;": "░",
"blk34;": "▓",
"block;": "█",
"boxDL;": "╗",
"boxDl;": "╖",
"boxdL;": "╕",
"boxdl;": "┐",
"boxDR;": "╔",
"boxDr;": "╓",
"boxdR;": "╒",
"boxdr;": "┌",
"boxHD;": "╦",
"boxHd;": "╤",
"boxhD;": "╥",
"boxhd;": "┬",
"boxHU;": "╩",
"boxHu;": "╧",
"boxhU;": "╨",
"boxhu;": "┴",
"boxUL;": "╝",
"boxUl;": "╜",
"boxuL;": "╛",
"boxul;": "┘",
"boxUR;": "╚",
"boxUr;": "╙",
"boxuR;": "╘",
"boxur;": "└",
"boxVH;": "╬",
"boxVh;": "╫",
"boxvH;": "╪",
"boxvh;": "┼",
"boxVL;": "╣",
"boxVl;": "╢",
"boxvL;": "╡",
"boxvl;": "┤",
"boxVR;": "╠",
"boxVr;": "╟",
"boxvR;": "╞",
"boxvr;": "├",
"Breve;": "˘",
"breve;": "˘",
brvbar: "¦",
"bsemi;": "⁏",
"bsime;": "⋍",
"bsolb;": "⧅",
"bumpE;": "⪮",
"bumpe;": "≏",
"caret;": "⁁",
"caron;": "ˇ",
"ccaps;": "⩍",
Ccedil: "Ç",
ccedil: "ç",
"Ccirc;": "Ĉ",
"ccirc;": "ĉ",
"ccups;": "⩌",
"cedil;": "¸",
"check;": "✓",
"clubs;": "♣",
"Colon;": "∷",
"colon;": ":",
"comma;": ",",
"crarr;": "↵",
"Cross;": "⨯",
"cross;": "✗",
"csube;": "⫑",
"csupe;": "⫒",
"ctdot;": "⋯",
"cuepr;": "⋞",
"cuesc;": "⋟",
"cupor;": "⩅",
curren: "¤",
"cuvee;": "⋎",
"cuwed;": "⋏",
"cwint;": "∱",
"Dashv;": "⫤",
"dashv;": "⊣",
"dblac;": "˝",
"ddarr;": "⇊",
"Delta;": "Δ",
"delta;": "δ",
"dharl;": "⇃",
"dharr;": "⇂",
"diams;": "♦",
"disin;": "⋲",
divide: "÷",
"doteq;": "≐",
"dtdot;": "⋱",
"dtrif;": "▾",
"duarr;": "⇵",
"duhar;": "⥯",
Eacute: "É",
eacute: "é",
"Ecirc;": "Ê",
"ecirc;": "ê",
"eDDot;": "⩷",
"efDot;": "≒",
Egrave: "È",
egrave: "è",
"Emacr;": "Ē",
"emacr;": "ē",
"empty;": "∅",
"Eogon;": "Ę",
"eogon;": "ę",
"eplus;": "⩱",
"epsiv;": "ϵ",
"eqsim;": "≂",
"Equal;": "⩵",
"equiv;": "≡",
"erarr;": "⥱",
"erDot;": "≓",
"esdot;": "≐",
"exist;": "∃",
"fflig;": "ff",
"filig;": "fi",
"fjlig;": "fj",
"fllig;": "fl",
"fltns;": "▱",
"forkv;": "⫙",
frac12: "½",
frac14: "¼",
frac34: "¾",
"frasl;": "⁄",
"frown;": "⌢",
"Gamma;": "Γ",
"gamma;": "γ",
"Gcirc;": "Ĝ",
"gcirc;": "ĝ",
"gescc;": "⪩",
"gimel;": "ℷ",
"gneqq;": "≩",
"gnsim;": "⋧",
"grave;": "`",
"gsime;": "⪎",
"gsiml;": "⪐",
"gtcir;": "⩺",
"gtdot;": "⋗",
"Hacek;": "ˇ",
"harrw;": "↭",
"Hcirc;": "Ĥ",
"hcirc;": "ĥ",
"hoarr;": "⇿",
Iacute: "Í",
iacute: "í",
"Icirc;": "Î",
"icirc;": "î",
"iexcl;": "¡",
Igrave: "Ì",
igrave: "ì",
"iiint;": "∭",
"iiota;": "℩",
"IJlig;": "IJ",
"ijlig;": "ij",
"Imacr;": "Ī",
"imacr;": "ī",
"image;": "ℑ",
"imath;": "ı",
"imped;": "Ƶ",
"infin;": "∞",
"Iogon;": "Į",
"iogon;": "į",
"iprod;": "⨼",
iquest: "¿",
"isinE;": "⋹",
"isins;": "⋴",
"isinv;": "∈",
"Iukcy;": "І",
"iukcy;": "і",
"Jcirc;": "Ĵ",
"jcirc;": "ĵ",
"jmath;": "ȷ",
"Jukcy;": "Є",
"jukcy;": "є",
"Kappa;": "Κ",
"kappa;": "κ",
"lAarr;": "⇚",
"langd;": "⦑",
"laquo;": "«",
"larrb;": "⇤",
"lates;": "⪭︀",
"lBarr;": "⤎",
"lbarr;": "⤌",
"lbbrk;": "❲",
"lbrke;": "⦋",
"lceil;": "⌈",
"ldquo;": "“",
"lescc;": "⪨",
"lhard;": "↽",
"lharu;": "↼",
"lhblk;": "▄",
"llarr;": "⇇",
"lltri;": "◺",
"lneqq;": "≨",
"lnsim;": "⋦",
"loang;": "⟬",
"loarr;": "⇽",
"lobrk;": "⟦",
"lopar;": "⦅",
"lrarr;": "⇆",
"lrhar;": "⇋",
"lrtri;": "⊿",
"lsime;": "⪍",
"lsimg;": "⪏",
"lsquo;": "‘",
"ltcir;": "⩹",
"ltdot;": "⋖",
"ltrie;": "⊴",
"ltrif;": "◂",
"mdash;": "—",
"mDDot;": "∺",
"micro;": "µ",
middot: "·",
"minus;": "−",
"mumap;": "⊸",
"nabla;": "∇",
"napid;": "≋̸",
"napos;": "ʼn",
"natur;": "♮",
"nbump;": "≎̸",
"ncong;": "≇",
"ndash;": "–",
"neArr;": "⇗",
"nearr;": "↗",
"nedot;": "≐̸",
"nesim;": "≂̸",
"ngeqq;": "≧̸",
"ngsim;": "≵",
"nhArr;": "⇎",
"nharr;": "↮",
"nhpar;": "⫲",
"nlArr;": "⇍",
"nlarr;": "↚",
"nleqq;": "≦̸",
"nless;": "≮",
"nlsim;": "≴",
"nltri;": "⋪",
"notin;": "∉",
"notni;": "∌",
"npart;": "∂̸",
"nprec;": "⊀",
"nrArr;": "⇏",
"nrarr;": "↛",
"nrtri;": "⋫",
"nsime;": "≄",
"nsmid;": "∤",
"nspar;": "∦",
"nsubE;": "⫅̸",
"nsube;": "⊈",
"nsucc;": "⊁",
"nsupE;": "⫆̸",
"nsupe;": "⊉",
Ntilde: "Ñ",
ntilde: "ñ",
"numsp;": " ",
"nvsim;": "∼⃒",
"nwArr;": "⇖",
"nwarr;": "↖",
Oacute: "Ó",
oacute: "ó",
"Ocirc;": "Ô",
"ocirc;": "ô",
"odash;": "⊝",
"OElig;": "Œ",
"oelig;": "œ",
"ofcir;": "⦿",
Ograve: "Ò",
ograve: "ò",
"ohbar;": "⦵",
"olarr;": "↺",
"olcir;": "⦾",
"oline;": "‾",
"Omacr;": "Ō",
"omacr;": "ō",
"Omega;": "Ω",
"omega;": "ω",
"operp;": "⦹",
"oplus;": "⊕",
"orarr;": "↻",
"order;": "ℴ",
Oslash: "Ø",
oslash: "ø",
Otilde: "Õ",
otilde: "õ",
"ovbar;": "⌽",
"parsl;": "⫽",
"phone;": "☎",
"plusb;": "⊞",
"pluse;": "⩲",
plusmn: "±",
"pound;": "£",
"prcue;": "≼",
"Prime;": "″",
"prime;": "′",
"prnap;": "⪹",
"prsim;": "≾",
"quest;": "?",
"rAarr;": "⇛",
"radic;": "√",
"rangd;": "⦒",
"range;": "⦥",
"raquo;": "»",
"rarrb;": "⇥",
"rarrc;": "⤳",
"rarrw;": "↝",
"ratio;": "∶",
"RBarr;": "⤐",
"rBarr;": "⤏",
"rbarr;": "⤍",
"rbbrk;": "❳",
"rbrke;": "⦌",
"rceil;": "⌉",
"rdquo;": "”",
"reals;": "ℝ",
"rhard;": "⇁",
"rharu;": "⇀",
"rlarr;": "⇄",
"rlhar;": "⇌",
"rnmid;": "⫮",
"roang;": "⟭",
"roarr;": "⇾",
"robrk;": "⟧",
"ropar;": "⦆",
"rrarr;": "⇉",
"rsquo;": "’",
"rtrie;": "⊵",
"rtrif;": "▸",
"sbquo;": "‚",
"sccue;": "≽",
"Scirc;": "Ŝ",
"scirc;": "ŝ",
"scnap;": "⪺",
"scsim;": "≿",
"sdotb;": "⊡",
"sdote;": "⩦",
"seArr;": "⇘",
"searr;": "↘",
"setmn;": "∖",
"sharp;": "♯",
"Sigma;": "Σ",
"sigma;": "σ",
"simeq;": "≃",
"simgE;": "⪠",
"simlE;": "⪟",
"simne;": "≆",
"slarr;": "←",
"smile;": "⌣",
"smtes;": "⪬︀",
"sqcap;": "⊓",
"sqcup;": "⊔",
"sqsub;": "⊏",
"sqsup;": "⊐",
"srarr;": "→",
"starf;": "★",
"strns;": "¯",
"subnE;": "⫋",
"subne;": "⊊",
"supnE;": "⫌",
"supne;": "⊋",
"swArr;": "⇙",
"swarr;": "↙",
"szlig;": "ß",
"Theta;": "Θ",
"theta;": "θ",
"thkap;": "≈",
"THORN;": "Þ",
"thorn;": "þ",
"Tilde;": "∼",
"tilde;": "˜",
"times;": "×",
"TRADE;": "™",
"trade;": "™",
"trisb;": "⧍",
"TSHcy;": "Ћ",
"tshcy;": "ћ",
"twixt;": "≬",
Uacute: "Ú",
uacute: "ú",
"Ubrcy;": "Ў",
"ubrcy;": "ў",
"Ucirc;": "Û",
"ucirc;": "û",
"udarr;": "⇅",
"udhar;": "⥮",
Ugrave: "Ù",
ugrave: "ù",
"uharl;": "↿",
"uharr;": "↾",
"uhblk;": "▀",
"ultri;": "◸",
"Umacr;": "Ū",
"umacr;": "ū",
"Union;": "⋃",
"Uogon;": "Ų",
"uogon;": "ų",
"uplus;": "⊎",
"upsih;": "ϒ",
"UpTee;": "⊥",
"Uring;": "Ů",
"uring;": "ů",
"urtri;": "◹",
"utdot;": "⋰",
"utrif;": "▴",
"uuarr;": "⇈",
"varpi;": "ϖ",
"vBarv;": "⫩",
"VDash;": "⊫",
"Vdash;": "⊩",
"vDash;": "⊨",
"vdash;": "⊢",
"veeeq;": "≚",
"vltri;": "⊲",
"vnsub;": "⊂⃒",
"vnsup;": "⊃⃒",
"vprop;": "∝",
"vrtri;": "⊳",
"Wcirc;": "Ŵ",
"wcirc;": "ŵ",
"Wedge;": "⋀",
"wedge;": "∧",
"xcirc;": "◯",
"xdtri;": "▽",
"xhArr;": "⟺",
"xharr;": "⟷",
"xlArr;": "⟸",
"xlarr;": "⟵",
"xodot;": "⨀",
"xrArr;": "⟹",
"xrarr;": "⟶",
"xutri;": "△",
Yacute: "Ý",
yacute: "ý",
"Ycirc;": "Ŷ",
"ycirc;": "ŷ",
"Aacute;": "Á",
"aacute;": "á",
"Abreve;": "Ă",
"abreve;": "ă",
"Agrave;": "À",
"agrave;": "à",
"andand;": "⩕",
"angmsd;": "∡",
"angsph;": "∢",
"apacir;": "⩯",
"approx;": "≈",
"Assign;": "≔",
"Atilde;": "Ã",
"atilde;": "ã",
"barvee;": "⊽",
"Barwed;": "⌆",
"barwed;": "⌅",
"becaus;": "∵",
"bernou;": "ℬ",
"bigcap;": "⋂",
"bigcup;": "⋃",
"bigvee;": "⋁",
"bkarow;": "⤍",
"bottom;": "⊥",
"bowtie;": "⋈",
"boxbox;": "⧉",
"bprime;": "‵",
"brvbar;": "¦",
"bullet;": "•",
"Bumpeq;": "≎",
"bumpeq;": "≏",
"Cacute;": "Ć",
"cacute;": "ć",
"capand;": "⩄",
"capcap;": "⩋",
"capcup;": "⩇",
"capdot;": "⩀",
"Ccaron;": "Č",
"ccaron;": "č",
"Ccedil;": "Ç",
"ccedil;": "ç",
"circeq;": "≗",
"cirmid;": "⫯",
"Colone;": "⩴",
"colone;": "≔",
"commat;": "@",
"compfn;": "∘",
"Conint;": "∯",
"conint;": "∮",
"coprod;": "∐",
"copysr;": "℗",
"cularr;": "↶",
"CupCap;": "≍",
"cupcap;": "⩆",
"cupcup;": "⩊",
"cupdot;": "⊍",
"curarr;": "↷",
"curren;": "¤",
"cylcty;": "⌭",
"Dagger;": "‡",
"dagger;": "†",
"daleth;": "ℸ",
"Dcaron;": "Ď",
"dcaron;": "ď",
"dfisht;": "⥿",
"divide;": "÷",
"divonx;": "⋇",
"dlcorn;": "⌞",
"dlcrop;": "⌍",
"dollar;": "$",
"DotDot;": "⃜",
"drcorn;": "⌟",
"drcrop;": "⌌",
"Dstrok;": "Đ",
"dstrok;": "đ",
"Eacute;": "É",
"eacute;": "é",
"easter;": "⩮",
"Ecaron;": "Ě",
"ecaron;": "ě",
"ecolon;": "≕",
"Egrave;": "È",
"egrave;": "è",
"egsdot;": "⪘",
"elsdot;": "⪗",
"emptyv;": "∅",
"emsp13;": " ",
"emsp14;": " ",
"eparsl;": "⧣",
"eqcirc;": "≖",
"equals;": "=",
"equest;": "≟",
"Exists;": "∃",
"female;": "♀",
"ffilig;": "ffi",
"ffllig;": "ffl",
"ForAll;": "∀",
"forall;": "∀",
"frac12;": "½",
"frac13;": "⅓",
"frac14;": "¼",
"frac15;": "⅕",
"frac16;": "⅙",
"frac18;": "⅛",
"frac23;": "⅔",
"frac25;": "⅖",
"frac34;": "¾",
"frac35;": "⅗",
"frac38;": "⅜",
"frac45;": "⅘",
"frac56;": "⅚",
"frac58;": "⅝",
"frac78;": "⅞",
"gacute;": "ǵ",
"Gammad;": "Ϝ",
"gammad;": "ϝ",
"Gbreve;": "Ğ",
"gbreve;": "ğ",
"Gcedil;": "Ģ",
"gesdot;": "⪀",
"gesles;": "⪔",
"gtlPar;": "⦕",
"gtrarr;": "⥸",
"gtrdot;": "⋗",
"gtrsim;": "≳",
"hairsp;": " ",
"hamilt;": "ℋ",
"HARDcy;": "Ъ",
"hardcy;": "ъ",
"hearts;": "♥",
"hellip;": "…",
"hercon;": "⊹",
"homtht;": "∻",
"horbar;": "―",
"hslash;": "ℏ",
"Hstrok;": "Ħ",
"hstrok;": "ħ",
"hybull;": "⁃",
"hyphen;": "‐",
"Iacute;": "Í",
"iacute;": "í",
"Igrave;": "Ì",
"igrave;": "ì",
"iiiint;": "⨌",
"iinfin;": "⧜",
"incare;": "℅",
"inodot;": "ı",
"intcal;": "⊺",
"iquest;": "¿",
"isinsv;": "⋳",
"Itilde;": "Ĩ",
"itilde;": "ĩ",
"Jsercy;": "Ј",
"jsercy;": "ј",
"kappav;": "ϰ",
"Kcedil;": "Ķ",
"kcedil;": "ķ",
"kgreen;": "ĸ",
"Lacute;": "Ĺ",
"lacute;": "ĺ",
"lagran;": "ℒ",
"Lambda;": "Λ",
"lambda;": "λ",
"langle;": "⟨",
"larrfs;": "⤝",
"larrhk;": "↩",
"larrlp;": "↫",
"larrpl;": "⤹",
"larrtl;": "↢",
"lAtail;": "⤛",
"latail;": "⤙",
"lbrace;": "{",
"lbrack;": "[",
"Lcaron;": "Ľ",
"lcaron;": "ľ",
"Lcedil;": "Ļ",
"lcedil;": "ļ",
"ldquor;": "„",
"lesdot;": "⩿",
"lesges;": "⪓",
"lfisht;": "⥼",
"lfloor;": "⌊",
"lharul;": "⥪",
"llhard;": "⥫",
"Lmidot;": "Ŀ",
"lmidot;": "ŀ",
"lmoust;": "⎰",
"loplus;": "⨭",
"lowast;": "∗",
"lowbar;": "_",
"lparlt;": "⦓",
"lrhard;": "⥭",
"lsaquo;": "‹",
"lsquor;": "‚",
"Lstrok;": "Ł",
"lstrok;": "ł",
"lthree;": "⋋",
"ltimes;": "⋉",
"ltlarr;": "⥶",
"ltrPar;": "⦖",
"mapsto;": "↦",
"marker;": "▮",
"mcomma;": "⨩",
"midast;": "*",
"midcir;": "⫰",
"middot;": "·",
"minusb;": "⊟",
"minusd;": "∸",
"mnplus;": "∓",
"models;": "⊧",
"mstpos;": "∾",
"Nacute;": "Ń",
"nacute;": "ń",
"nbumpe;": "≏̸",
"Ncaron;": "Ň",
"ncaron;": "ň",
"Ncedil;": "Ņ",
"ncedil;": "ņ",
"nearhk;": "⤤",
"nequiv;": "≢",
"nesear;": "⤨",
"nexist;": "∄",
"nltrie;": "⋬",
"notinE;": "⋹̸",
"nparsl;": "⫽⃥",
"nprcue;": "⋠",
"nrarrc;": "⤳̸",
"nrarrw;": "↝̸",
"nrtrie;": "⋭",
"nsccue;": "⋡",
"nsimeq;": "≄",
"Ntilde;": "Ñ",
"ntilde;": "ñ",
"numero;": "№",
"nVDash;": "⊯",
"nVdash;": "⊮",
"nvDash;": "⊭",
"nvdash;": "⊬",
"nvHarr;": "⤄",
"nvlArr;": "⤂",
"nvrArr;": "⤃",
"nwarhk;": "⤣",
"nwnear;": "⤧",
"Oacute;": "Ó",
"oacute;": "ó",
"Odblac;": "Ő",
"odblac;": "ő",
"odsold;": "⦼",
"Ograve;": "Ò",
"ograve;": "ò",
"ominus;": "⊖",
"origof;": "⊶",
"Oslash;": "Ø",
"oslash;": "ø",
"Otilde;": "Õ",
"otilde;": "õ",
"Otimes;": "⨷",
"otimes;": "⊗",
"parsim;": "⫳",
"percnt;": "%",
"period;": ".",
"permil;": "‰",
"phmmat;": "ℳ",
"planck;": "ℏ",
"plankv;": "ℏ",
"plusdo;": "∔",
"plusdu;": "⨥",
"plusmn;": "±",
"preceq;": "⪯",
"primes;": "ℙ",
"prnsim;": "⋨",
"propto;": "∝",
"prurel;": "⊰",
"puncsp;": " ",
"qprime;": "⁗",
"Racute;": "Ŕ",
"racute;": "ŕ",
"rangle;": "⟩",
"rarrap;": "⥵",
"rarrfs;": "⤞",
"rarrhk;": "↪",
"rarrlp;": "↬",
"rarrpl;": "⥅",
"Rarrtl;": "⤖",
"rarrtl;": "↣",
"rAtail;": "⤜",
"ratail;": "⤚",
"rbrace;": "}",
"rbrack;": "]",
"Rcaron;": "Ř",
"rcaron;": "ř",
"Rcedil;": "Ŗ",
"rcedil;": "ŗ",
"rdquor;": "”",
"rfisht;": "⥽",
"rfloor;": "⌋",
"rharul;": "⥬",
"rmoust;": "⎱",
"roplus;": "⨮",
"rpargt;": "⦔",
"rsaquo;": "›",
"rsquor;": "’",
"rthree;": "⋌",
"rtimes;": "⋊",
"Sacute;": "Ś",
"sacute;": "ś",
"Scaron;": "Š",
"scaron;": "š",
"Scedil;": "Ş",
"scedil;": "ş",
"scnsim;": "⋩",
"searhk;": "⤥",
"seswar;": "⤩",
"sfrown;": "⌢",
"SHCHcy;": "Щ",
"shchcy;": "щ",
"sigmaf;": "ς",
"sigmav;": "ς",
"simdot;": "⩪",
"smashp;": "⨳",
"SOFTcy;": "Ь",
"softcy;": "ь",
"solbar;": "⌿",
"spades;": "♠",
"sqcaps;": "⊓︀",
"sqcups;": "⊔︀",
"sqsube;": "⊑",
"sqsupe;": "⊒",
"Square;": "□",
"square;": "□",
"squarf;": "▪",
"ssetmn;": "∖",
"ssmile;": "⌣",
"sstarf;": "⋆",
"subdot;": "⪽",
"Subset;": "⋐",
"subset;": "⊂",
"subsim;": "⫇",
"subsub;": "⫕",
"subsup;": "⫓",
"succeq;": "⪰",
"supdot;": "⪾",
"Supset;": "⋑",
"supset;": "⊃",
"supsim;": "⫈",
"supsub;": "⫔",
"supsup;": "⫖",
"swarhk;": "⤦",
"swnwar;": "⤪",
"target;": "⌖",
"Tcaron;": "Ť",
"tcaron;": "ť",
"Tcedil;": "Ţ",
"tcedil;": "ţ",
"telrec;": "⌕",
"there4;": "∴",
"thetav;": "ϑ",
"thinsp;": " ",
"thksim;": "∼",
"timesb;": "⊠",
"timesd;": "⨰",
"topbot;": "⌶",
"topcir;": "⫱",
"tprime;": "‴",
"tridot;": "◬",
"Tstrok;": "Ŧ",
"tstrok;": "ŧ",
"Uacute;": "Ú",
"uacute;": "ú",
"Ubreve;": "Ŭ",
"ubreve;": "ŭ",
"Udblac;": "Ű",
"udblac;": "ű",
"ufisht;": "⥾",
"Ugrave;": "Ù",
"ugrave;": "ù",
"ulcorn;": "⌜",
"ulcrop;": "⌏",
"urcorn;": "⌝",
"urcrop;": "⌎",
"Utilde;": "Ũ",
"utilde;": "ũ",
"vangrt;": "⦜",
"varphi;": "ϕ",
"varrho;": "ϱ",
"Vdashl;": "⫦",
"veebar;": "⊻",
"vellip;": "⋮",
"Verbar;": "‖",
"verbar;": "|",
"vsubnE;": "⫋︀",
"vsubne;": "⊊︀",
"vsupnE;": "⫌︀",
"vsupne;": "⊋︀",
"Vvdash;": "⊪",
"wedbar;": "⩟",
"wedgeq;": "≙",
"weierp;": "℘",
"wreath;": "≀",
"xoplus;": "⨁",
"xotime;": "⨂",
"xsqcup;": "⨆",
"xuplus;": "⨄",
"xwedge;": "⋀",
"Yacute;": "Ý",
"yacute;": "ý",
"Zacute;": "Ź",
"zacute;": "ź",
"Zcaron;": "Ž",
"zcaron;": "ž",
"zeetrf;": "ℨ",
"alefsym;": "ℵ",
"angrtvb;": "⊾",
"angzarr;": "⍼",
"asympeq;": "≍",
"backsim;": "∽",
"Because;": "∵",
"because;": "∵",
"bemptyv;": "⦰",
"between;": "≬",
"bigcirc;": "◯",
"bigodot;": "⨀",
"bigstar;": "★",
"bnequiv;": "≡⃥",
"boxplus;": "⊞",
"Cayleys;": "ℭ",
"Cconint;": "∰",
"ccupssm;": "⩐",
"Cedilla;": "¸",
"cemptyv;": "⦲",
"cirscir;": "⧂",
"coloneq;": "≔",
"congdot;": "⩭",
"cudarrl;": "⤸",
"cudarrr;": "⤵",
"cularrp;": "⤽",
"curarrm;": "⤼",
"dbkarow;": "⤏",
"ddagger;": "‡",
"ddotseq;": "⩷",
"demptyv;": "⦱",
"Diamond;": "⋄",
"diamond;": "⋄",
"digamma;": "ϝ",
"dotplus;": "∔",
"DownTee;": "⊤",
"dwangle;": "⦦",
"Element;": "∈",
"Epsilon;": "Ε",
"epsilon;": "ε",
"eqcolon;": "≕",
"equivDD;": "⩸",
"gesdoto;": "⪂",
"gtquest;": "⩼",
"gtrless;": "≷",
"harrcir;": "⥈",
"Implies;": "⇒",
"intprod;": "⨼",
"isindot;": "⋵",
"larrbfs;": "⤟",
"larrsim;": "⥳",
"lbrksld;": "⦏",
"lbrkslu;": "⦍",
"ldrdhar;": "⥧",
"LeftTee;": "⊣",
"lesdoto;": "⪁",
"lessdot;": "⋖",
"lessgtr;": "≶",
"lesssim;": "≲",
"lotimes;": "⨴",
"lozenge;": "◊",
"ltquest;": "⩻",
"luruhar;": "⥦",
"maltese;": "✠",
"minusdu;": "⨪",
"napprox;": "≉",
"natural;": "♮",
"nearrow;": "↗",
"NewLine;": "\n",
"nexists;": "∄",
"NoBreak;": "",
"notinva;": "∉",
"notinvb;": "⋷",
"notinvc;": "⋶",
"NotLess;": "≮",
"notniva;": "∌",
"notnivb;": "⋾",
"notnivc;": "⋽",
"npolint;": "⨔",
"npreceq;": "⪯̸",
"nsqsube;": "⋢",
"nsqsupe;": "⋣",
"nsubset;": "⊂⃒",
"nsucceq;": "⪰̸",
"nsupset;": "⊃⃒",
"nvinfin;": "⧞",
"nvltrie;": "⊴⃒",
"nvrtrie;": "⊵⃒",
"nwarrow;": "↖",
"olcross;": "⦻",
"Omicron;": "Ο",
"omicron;": "ο",
"orderof;": "ℴ",
"orslope;": "⩗",
"OverBar;": "‾",
"pertenk;": "‱",
"planckh;": "ℎ",
"pluscir;": "⨢",
"plussim;": "⨦",
"plustwo;": "⨧",
"precsim;": "≾",
"Product;": "∏",
"quatint;": "⨖",
"questeq;": "≟",
"rarrbfs;": "⤠",
"rarrsim;": "⥴",
"rbrksld;": "⦎",
"rbrkslu;": "⦐",
"rdldhar;": "⥩",
"realine;": "ℛ",
"rotimes;": "⨵",
"ruluhar;": "⥨",
"searrow;": "↘",
"simplus;": "⨤",
"simrarr;": "⥲",
"subedot;": "⫃",
"submult;": "⫁",
"subplus;": "⪿",
"subrarr;": "⥹",
"succsim;": "≿",
"supdsub;": "⫘",
"supedot;": "⫄",
"suphsol;": "⟉",
"suphsub;": "⫗",
"suplarr;": "⥻",
"supmult;": "⫂",
"supplus;": "⫀",
"swarrow;": "↙",
"topfork;": "⫚",
"triplus;": "⨹",
"tritime;": "⨻",
"UpArrow;": "↑",
"Uparrow;": "⇑",
"uparrow;": "↑",
"Upsilon;": "Υ",
"upsilon;": "υ",
"uwangle;": "⦧",
"vzigzag;": "⦚",
"zigrarr;": "⇝",
"andslope;": "⩘",
"angmsdaa;": "⦨",
"angmsdab;": "⦩",
"angmsdac;": "⦪",
"angmsdad;": "⦫",
"angmsdae;": "⦬",
"angmsdaf;": "⦭",
"angmsdag;": "⦮",
"angmsdah;": "⦯",
"angrtvbd;": "⦝",
"approxeq;": "≊",
"awconint;": "∳",
"backcong;": "≌",
"barwedge;": "⌅",
"bbrktbrk;": "⎶",
"bigoplus;": "⨁",
"bigsqcup;": "⨆",
"biguplus;": "⨄",
"bigwedge;": "⋀",
"boxminus;": "⊟",
"boxtimes;": "⊠",
"bsolhsub;": "⟈",
"capbrcup;": "⩉",
"circledR;": "®",
"circledS;": "Ⓢ",
"cirfnint;": "⨐",
"clubsuit;": "♣",
"cupbrcap;": "⩈",
"curlyvee;": "⋎",
"cwconint;": "∲",
"DDotrahd;": "⤑",
"doteqdot;": "≑",
"DotEqual;": "≐",
"dotminus;": "∸",
"drbkarow;": "⤐",
"dzigrarr;": "⟿",
"elinters;": "⏧",
"emptyset;": "∅",
"eqvparsl;": "⧥",
"fpartint;": "⨍",
"geqslant;": "⩾",
"gesdotol;": "⪄",
"gnapprox;": "⪊",
"hksearow;": "⤥",
"hkswarow;": "⤦",
"imagline;": "ℐ",
"imagpart;": "ℑ",
"infintie;": "⧝",
"integers;": "ℤ",
"Integral;": "∫",
"intercal;": "⊺",
"intlarhk;": "⨗",
"laemptyv;": "⦴",
"ldrushar;": "⥋",
"leqslant;": "⩽",
"lesdotor;": "⪃",
"LessLess;": "⪡",
"llcorner;": "⌞",
"lnapprox;": "⪉",
"lrcorner;": "⌟",
"lurdshar;": "⥊",
"mapstoup;": "↥",
"multimap;": "⊸",
"naturals;": "ℕ",
"ncongdot;": "⩭̸",
"NotEqual;": "≠",
"notindot;": "⋵̸",
"NotTilde;": "≁",
"otimesas;": "⨶",
"parallel;": "∥",
"PartialD;": "∂",
"plusacir;": "⨣",
"pointint;": "⨕",
"Precedes;": "≺",
"precneqq;": "⪵",
"precnsim;": "⋨",
"profalar;": "⌮",
"profline;": "⌒",
"profsurf;": "⌓",
"raemptyv;": "⦳",
"realpart;": "ℜ",
"RightTee;": "⊢",
"rppolint;": "⨒",
"rtriltri;": "⧎",
"scpolint;": "⨓",
"setminus;": "∖",
"shortmid;": "∣",
"smeparsl;": "⧤",
"sqsubset;": "⊏",
"sqsupset;": "⊐",
"subseteq;": "⊆",
"Succeeds;": "≻",
"succneqq;": "⪶",
"succnsim;": "⋩",
"SuchThat;": "∋",
"Superset;": "⊃",
"supseteq;": "⊇",
"thetasym;": "ϑ",
"thicksim;": "∼",
"timesbar;": "⨱",
"triangle;": "▵",
"triminus;": "⨺",
"trpezium;": "⏢",
"Uarrocir;": "⥉",
"ulcorner;": "⌜",
"UnderBar;": "_",
"urcorner;": "⌝",
"varkappa;": "ϰ",
"varsigma;": "ς",
"vartheta;": "ϑ",
"backprime;": "‵",
"backsimeq;": "⋍",
"Backslash;": "∖",
"bigotimes;": "⨂",
"CenterDot;": "·",
"centerdot;": "·",
"checkmark;": "✓",
"CircleDot;": "⊙",
"complexes;": "ℂ",
"Congruent;": "≡",
"Coproduct;": "∐",
"dotsquare;": "⊡",
"DoubleDot;": "¨",
"DownArrow;": "↓",
"Downarrow;": "⇓",
"downarrow;": "↓",
"DownBreve;": "̑",
"gtrapprox;": "⪆",
"gtreqless;": "⋛",
"gvertneqq;": "≩︀",
"heartsuit;": "♥",
"HumpEqual;": "≏",
"LeftArrow;": "←",
"Leftarrow;": "⇐",
"leftarrow;": "←",
"LeftFloor;": "⌊",
"lesseqgtr;": "⋚",
"LessTilde;": "≲",
"lvertneqq;": "≨︀",
"Mellintrf;": "ℳ",
"MinusPlus;": "∓",
"ngeqslant;": "⩾̸",
"nleqslant;": "⩽̸",
"NotCupCap;": "≭",
"NotExists;": "∄",
"NotSubset;": "⊂⃒",
"nparallel;": "∦",
"nshortmid;": "∤",
"nsubseteq;": "⊈",
"nsupseteq;": "⊉",
"OverBrace;": "⏞",
"pitchfork;": "⋔",
"PlusMinus;": "±",
"rationals;": "ℚ",
"spadesuit;": "♠",
"subseteqq;": "⫅",
"subsetneq;": "⊊",
"supseteqq;": "⫆",
"supsetneq;": "⊋",
"Therefore;": "∴",
"therefore;": "∴",
"ThinSpace;": " ",
"triangleq;": "≜",
"TripleDot;": "⃛",
"UnionPlus;": "⊎",
"varpropto;": "∝",
"Bernoullis;": "ℬ",
"circledast;": "⊛",
"CirclePlus;": "⊕",
"complement;": "∁",
"curlywedge;": "⋏",
"eqslantgtr;": "⪖",
"EqualTilde;": "≂",
"Fouriertrf;": "ℱ",
"gtreqqless;": "⪌",
"ImaginaryI;": "ⅈ",
"Laplacetrf;": "ℒ",
"LeftVector;": "↼",
"lessapprox;": "⪅",
"lesseqqgtr;": "⪋",
"Lleftarrow;": "⇚",
"lmoustache;": "⎰",
"longmapsto;": "⟼",
"mapstodown;": "↧",
"mapstoleft;": "↤",
"nLeftarrow;": "⇍",
"nleftarrow;": "↚",
"NotElement;": "∉",
"NotGreater;": "≯",
"nsubseteqq;": "⫅̸",
"nsupseteqq;": "⫆̸",
"precapprox;": "⪷",
"Proportion;": "∷",
"RightArrow;": "→",
"Rightarrow;": "⇒",
"rightarrow;": "→",
"RightFloor;": "⌋",
"rmoustache;": "⎱",
"sqsubseteq;": "⊑",
"sqsupseteq;": "⊒",
"subsetneqq;": "⫋",
"succapprox;": "⪸",
"supsetneqq;": "⫌",
"ThickSpace;": " ",
"TildeEqual;": "≃",
"TildeTilde;": "≈",
"UnderBrace;": "⏟",
"UpArrowBar;": "⤒",
"UpTeeArrow;": "↥",
"upuparrows;": "⇈",
"varepsilon;": "ϵ",
"varnothing;": "∅",
"backepsilon;": "϶",
"blacksquare;": "▪",
"circledcirc;": "⊚",
"circleddash;": "⊝",
"CircleMinus;": "⊖",
"CircleTimes;": "⊗",
"curlyeqprec;": "⋞",
"curlyeqsucc;": "⋟",
"diamondsuit;": "♦",
"eqslantless;": "⪕",
"Equilibrium;": "⇌",
"expectation;": "ℰ",
"GreaterLess;": "≷",
"LeftCeiling;": "⌈",
"LessGreater;": "≶",
"MediumSpace;": " ",
"NotLessLess;": "≪̸",
"NotPrecedes;": "⊀",
"NotSucceeds;": "⊁",
"NotSuperset;": "⊃⃒",
"nRightarrow;": "⇏",
"nrightarrow;": "↛",
"OverBracket;": "⎴",
"preccurlyeq;": "≼",
"precnapprox;": "⪹",
"quaternions;": "ℍ",
"RightVector;": "⇀",
"Rrightarrow;": "⇛",
"RuleDelayed;": "⧴",
"SmallCircle;": "∘",
"SquareUnion;": "⊔",
"straightphi;": "ϕ",
"SubsetEqual;": "⊆",
"succcurlyeq;": "≽",
"succnapprox;": "⪺",
"thickapprox;": "≈",
"UpDownArrow;": "↕",
"Updownarrow;": "⇕",
"updownarrow;": "↕",
"VerticalBar;": "∣",
"blacklozenge;": "⧫",
"DownArrowBar;": "⤓",
"DownTeeArrow;": "↧",
"ExponentialE;": "ⅇ",
"exponentiale;": "ⅇ",
"GreaterEqual;": "≥",
"GreaterTilde;": "≳",
"HilbertSpace;": "ℋ",
"HumpDownHump;": "≎",
"Intersection;": "⋂",
"LeftArrowBar;": "⇤",
"LeftTeeArrow;": "↤",
"LeftTriangle;": "⊲",
"LeftUpVector;": "↿",
"NotCongruent;": "≢",
"NotHumpEqual;": "≏̸",
"NotLessEqual;": "≰",
"NotLessTilde;": "≴",
"Proportional;": "∝",
"RightCeiling;": "⌉",
"risingdotseq;": "≓",
"RoundImplies;": "⥰",
"ShortUpArrow;": "↑",
"SquareSubset;": "⊏",
"triangledown;": "▿",
"triangleleft;": "◃",
"UnderBracket;": "⎵",
"varsubsetneq;": "⊊︀",
"varsupsetneq;": "⊋︀",
"VerticalLine;": "|",
"ApplyFunction;": "",
"bigtriangleup;": "△",
"blacktriangle;": "▴",
"DifferentialD;": "ⅆ",
"divideontimes;": "⋇",
"DoubleLeftTee;": "⫤",
"DoubleUpArrow;": "⇑",
"fallingdotseq;": "≒",
"hookleftarrow;": "↩",
"leftarrowtail;": "↢",
"leftharpoonup;": "↼",
"LeftTeeVector;": "⥚",
"LeftVectorBar;": "⥒",
"LessFullEqual;": "≦",
"LongLeftArrow;": "⟵",
"Longleftarrow;": "⟸",
"longleftarrow;": "⟵",
"looparrowleft;": "↫",
"measuredangle;": "∡",
"NotEqualTilde;": "≂̸",
"NotTildeEqual;": "≄",
"NotTildeTilde;": "≉",
"ntriangleleft;": "⋪",
"Poincareplane;": "ℌ",
"PrecedesEqual;": "⪯",
"PrecedesTilde;": "≾",
"RightArrowBar;": "⇥",
"RightTeeArrow;": "↦",
"RightTriangle;": "⊳",
"RightUpVector;": "↾",
"shortparallel;": "∥",
"smallsetminus;": "∖",
"SucceedsEqual;": "⪰",
"SucceedsTilde;": "≿",
"SupersetEqual;": "⊇",
"triangleright;": "▹",
"UpEquilibrium;": "⥮",
"upharpoonleft;": "↿",
"varsubsetneqq;": "⫋︀",
"varsupsetneqq;": "⫌︀",
"VerticalTilde;": "≀",
"VeryThinSpace;": " ",
"curvearrowleft;": "↶",
"DiacriticalDot;": "˙",
"doublebarwedge;": "⌆",
"DoubleRightTee;": "⊨",
"downdownarrows;": "⇊",
"DownLeftVector;": "↽",
"GreaterGreater;": "⪢",
"hookrightarrow;": "↪",
"HorizontalLine;": "─",
"InvisibleComma;": "",
"InvisibleTimes;": "",
"LeftDownVector;": "⇃",
"leftleftarrows;": "⇇",
"LeftRightArrow;": "↔",
"Leftrightarrow;": "⇔",
"leftrightarrow;": "↔",
"leftthreetimes;": "⋋",
"LessSlantEqual;": "⩽",
"LongRightArrow;": "⟶",
"Longrightarrow;": "⟹",
"longrightarrow;": "⟶",
"looparrowright;": "↬",
"LowerLeftArrow;": "↙",
"NestedLessLess;": "≪",
"NotGreaterLess;": "≹",
"NotLessGreater;": "≸",
"NotSubsetEqual;": "⊈",
"NotVerticalBar;": "∤",
"nshortparallel;": "∦",
"ntriangleright;": "⋫",
"OpenCurlyQuote;": "‘",
"ReverseElement;": "∋",
"rightarrowtail;": "↣",
"rightharpoonup;": "⇀",
"RightTeeVector;": "⥛",
"RightVectorBar;": "⥓",
"ShortDownArrow;": "↓",
"ShortLeftArrow;": "←",
"SquareSuperset;": "⊐",
"TildeFullEqual;": "≅",
"trianglelefteq;": "⊴",
"upharpoonright;": "↾",
"UpperLeftArrow;": "↖",
"ZeroWidthSpace;": "",
"bigtriangledown;": "▽",
"circlearrowleft;": "↺",
"CloseCurlyQuote;": "’",
"ContourIntegral;": "∮",
"curvearrowright;": "↷",
"DoubleDownArrow;": "⇓",
"DoubleLeftArrow;": "⇐",
"downharpoonleft;": "⇃",
"DownRightVector;": "⇁",
"leftharpoondown;": "↽",
"leftrightarrows;": "⇆",
"LeftRightVector;": "⥎",
"LeftTriangleBar;": "⧏",
"LeftUpTeeVector;": "⥠",
"LeftUpVectorBar;": "⥘",
"LowerRightArrow;": "↘",
"nLeftrightarrow;": "⇎",
"nleftrightarrow;": "↮",
"NotGreaterEqual;": "≱",
"NotGreaterTilde;": "≵",
"NotHumpDownHump;": "≎̸",
"NotLeftTriangle;": "⋪",
"NotSquareSubset;": "⊏̸",
"ntrianglelefteq;": "⋬",
"OverParenthesis;": "⏜",
"RightDownVector;": "⇂",
"rightleftarrows;": "⇄",
"rightsquigarrow;": "↝",
"rightthreetimes;": "⋌",
"ShortRightArrow;": "→",
"straightepsilon;": "ϵ",
"trianglerighteq;": "⊵",
"UpperRightArrow;": "↗",
"vartriangleleft;": "⊲",
"circlearrowright;": "↻",
"DiacriticalAcute;": "´",
"DiacriticalGrave;": "`",
"DiacriticalTilde;": "˜",
"DoubleRightArrow;": "⇒",
"DownArrowUpArrow;": "⇵",
"downharpoonright;": "⇂",
"EmptySmallSquare;": "◻",
"GreaterEqualLess;": "⋛",
"GreaterFullEqual;": "≧",
"LeftAngleBracket;": "⟨",
"LeftUpDownVector;": "⥑",
"LessEqualGreater;": "⋚",
"NonBreakingSpace;": " ",
"NotPrecedesEqual;": "⪯̸",
"NotRightTriangle;": "⋫",
"NotSucceedsEqual;": "⪰̸",
"NotSucceedsTilde;": "≿̸",
"NotSupersetEqual;": "⊉",
"ntrianglerighteq;": "⋭",
"rightharpoondown;": "⇁",
"rightrightarrows;": "⇉",
"RightTriangleBar;": "⧐",
"RightUpTeeVector;": "⥜",
"RightUpVectorBar;": "⥔",
"twoheadleftarrow;": "↞",
"UnderParenthesis;": "⏝",
"UpArrowDownArrow;": "⇅",
"vartriangleright;": "⊳",
"blacktriangledown;": "▾",
"blacktriangleleft;": "◂",
"DoubleUpDownArrow;": "⇕",
"DoubleVerticalBar;": "∥",
"DownLeftTeeVector;": "⥞",
"DownLeftVectorBar;": "⥖",
"FilledSmallSquare;": "◼",
"GreaterSlantEqual;": "⩾",
"LeftDoubleBracket;": "⟦",
"LeftDownTeeVector;": "⥡",
"LeftDownVectorBar;": "⥙",
"leftrightharpoons;": "⇋",
"LeftTriangleEqual;": "⊴",
"NegativeThinSpace;": "",
"NotGreaterGreater;": "≫̸",
"NotLessSlantEqual;": "⩽̸",
"NotNestedLessLess;": "⪡̸",
"NotReverseElement;": "∌",
"NotSquareSuperset;": "⊐̸",
"NotTildeFullEqual;": "≇",
"RightAngleBracket;": "⟩",
"rightleftharpoons;": "⇌",
"RightUpDownVector;": "⥏",
"SquareSubsetEqual;": "⊑",
"twoheadrightarrow;": "↠",
"VerticalSeparator;": "❘",
"blacktriangleright;": "▸",
"DownRightTeeVector;": "⥟",
"DownRightVectorBar;": "⥗",
"LongLeftRightArrow;": "⟷",
"Longleftrightarrow;": "⟺",
"longleftrightarrow;": "⟷",
"NegativeThickSpace;": "",
"NotLeftTriangleBar;": "⧏̸",
"PrecedesSlantEqual;": "≼",
"ReverseEquilibrium;": "⇋",
"RightDoubleBracket;": "⟧",
"RightDownTeeVector;": "⥝",
"RightDownVectorBar;": "⥕",
"RightTriangleEqual;": "⊵",
"SquareIntersection;": "⊓",
"SucceedsSlantEqual;": "≽",
"DoubleLongLeftArrow;": "⟸",
"DownLeftRightVector;": "⥐",
"LeftArrowRightArrow;": "⇆",
"leftrightsquigarrow;": "↭",
"NegativeMediumSpace;": "",
"NotGreaterFullEqual;": "≧̸",
"NotRightTriangleBar;": "⧐̸",
"RightArrowLeftArrow;": "⇄",
"SquareSupersetEqual;": "⊒",
"CapitalDifferentialD;": "ⅅ",
"DoubleLeftRightArrow;": "⇔",
"DoubleLongRightArrow;": "⟹",
"EmptyVerySmallSquare;": "▫",
"NestedGreaterGreater;": "≫",
"NotDoubleVerticalBar;": "∦",
"NotGreaterSlantEqual;": "⩾̸",
"NotLeftTriangleEqual;": "⋬",
"NotSquareSubsetEqual;": "⋢",
"OpenCurlyDoubleQuote;": "“",
"ReverseUpEquilibrium;": "⥯",
"CloseCurlyDoubleQuote;": "”",
"DoubleContourIntegral;": "∯",
"FilledVerySmallSquare;": "▪",
"NegativeVeryThinSpace;": "",
"NotPrecedesSlantEqual;": "⋠",
"NotRightTriangleEqual;": "⋭",
"NotSucceedsSlantEqual;": "⋡",
"DiacriticalDoubleAcute;": "˝",
"NotSquareSupersetEqual;": "⋣",
"NotNestedGreaterGreater;": "⪢̸",
"ClockwiseContourIntegral;": "∲",
"DoubleLongLeftRightArrow;": "⟺",
"CounterClockwiseContourIntegral;": "∳"
};
let maxCRNameLength;
const decodeHtml = (rawText, asAttr) => {
let offset = 0;
const end = rawText.length;
let decodedText = "";
function advance(length) {
offset += length;
rawText = rawText.slice(length);
}
while (offset < end) {
const head = /&(?:#x?)?/i.exec(rawText);
if (!head || offset + head.index >= end) {
const remaining = end - offset;
decodedText += rawText.slice(0, remaining);
advance(remaining);
break;
}
decodedText += rawText.slice(0, head.index);
advance(head.index);
if (head[0] === "&") {
let name = "";
let value = void 0;
if (/[0-9a-z]/i.test(rawText[1])) {
if (!maxCRNameLength) {
maxCRNameLength = Object.keys(namedCharacterReferences).reduce(
(max, name2) => Math.max(max, name2.length),
0
);
}
for (let length = maxCRNameLength; !value && length > 0; --length) {
name = rawText.slice(1, 1 + length);
value = namedCharacterReferences[name];
}
if (value) {
const semi = name.endsWith(";");
if (asAttr && !semi && /[=a-z0-9]/i.test(rawText[name.length + 1] || "")) {
decodedText += "&" + name;
advance(1 + name.length);
} else {
decodedText += value;
advance(1 + name.length);
}
} else {
decodedText += "&" + name;
advance(1 + name.length);
}
} else {
decodedText += "&";
advance(1);
}
} else {
const hex = head[0] === "&#x";
const pattern = hex ? /^&#x([0-9a-f]+);?/i : /^&#([0-9]+);?/;
const body = pattern.exec(rawText);
if (!body) {
decodedText += head[0];
advance(head[0].length);
} else {
let cp = Number.parseInt(body[1], hex ? 16 : 10);
if (cp === 0) {
cp = 65533;
} else if (cp > 1114111) {
cp = 65533;
} else if (cp >= 55296 && cp <= 57343) {
cp = 65533;
} else if (cp >= 64976 && cp <= 65007 || (cp & 65534) === 65534) ; else if (cp >= 1 && cp <= 8 || cp === 11 || cp >= 13 && cp <= 31 || cp >= 127 && cp <= 159) {
cp = CCR_REPLACEMENTS[cp] || cp;
}
decodedText += String.fromCodePoint(cp);
advance(body[0].length);
}
}
}
return decodedText;
};
const CCR_REPLACEMENTS = {
128: 8364,
130: 8218,
131: 402,
132: 8222,
133: 8230,
134: 8224,
135: 8225,
136: 710,
137: 8240,
138: 352,
139: 8249,
140: 338,
142: 381,
145: 8216,
146: 8217,
147: 8220,
148: 8221,
149: 8226,
150: 8211,
151: 8212,
152: 732,
153: 8482,
154: 353,
155: 8250,
156: 339,
158: 382,
159: 376
};
const isRawTextContainer = /* @__PURE__ */ makeMap(
"style,iframe,script,noscript",
true
);
const parserOptions = {
isVoidTag,
isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag),
isPreTag: (tag) => tag === "pre",
decodeEntities: decodeHtml,
isBuiltInComponent: (tag) => {
if (isBuiltInType(tag, `Transition`)) {
return TRANSITION;
} else if (isBuiltInType(tag, `TransitionGroup`)) {
return TRANSITION_GROUP;
}
},
// https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
getNamespace(tag, parent) {
let ns = parent ? parent.ns : 0;
if (parent && ns === 2) {
if (parent.tag === "annotation-xml") {
if (tag === "svg") {
return 1;
}
if (parent.props.some(
(a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
)) {
ns = 0;
}
} else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
ns = 0;
}
} else if (parent && ns === 1) {
if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
ns = 0;
}
}
if (ns === 0) {
if (tag === "svg") {
return 1;
}
if (tag === "math") {
return 2;
}
}
return ns;
},
// https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
getTextMode({ tag, ns }) {
if (ns === 0) {
if (tag === "textarea" || tag === "title") {
return 1;
}
if (isRawTextContainer(tag)) {
return 2;
}
}
return 0;
}
};
const transformStyle = (node) => {
if (node.type === 1) {
node.props.forEach((p, i) => {
if (p.type === 6 && p.name === "style" && p.value) {
node.props[i] = {
type: 7,
name: `bind`,
arg: createSimpleExpression(`style`, true, p.loc),
exp: parseInlineCSS(p.value.content, p.loc),
modifiers: [],
loc: p.loc
};
}
});
}
};
const parseInlineCSS = (cssText, loc) => {
const normalized = parseStringStyle(cssText);
return createSimpleExpression(
JSON.stringify(normalized),
false,
loc,
3
);
};
function createDOMCompilerError(code, loc) {
return createCompilerError(
code,
loc,
DOMErrorMessages
);
}
const DOMErrorMessages = {
[53]: `v-html is missing expression.`,
[54]: `v-html will override element children.`,
[55]: `v-text is missing expression.`,
[56]: `v-text will override element children.`,
[57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
[58]: `v-model argument is not supported on plain elements.`,
[59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
[60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
[61]: `v-show is missing expression.`,
[62]: `<Transition> expects exactly one child element or component.`,
[63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
};
const transformVHtml = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(53, loc)
);
}
if (node.children.length) {
context.onError(
createDOMCompilerError(54, loc)
);
node.children.length = 0;
}
return {
props: [
createObjectProperty(
createSimpleExpression(`innerHTML`, true, loc),
exp || createSimpleExpression("", true)
)
]
};
};
const transformVText = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(55, loc)
);
}
if (node.children.length) {
context.onError(
createDOMCompilerError(56, loc)
);
node.children.length = 0;
}
return {
props: [
createObjectProperty(
createSimpleExpression(`textContent`, true),
exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
context.helperString(TO_DISPLAY_STRING),
[exp],
loc
) : createSimpleExpression("", true)
)
]
};
};
const transformModel = (dir, node, context) => {
const baseResult = transformModel$1(dir, node, context);
if (!baseResult.props.length || node.tagType === 1) {
return baseResult;
}
if (dir.arg) {
context.onError(
createDOMCompilerError(
58,
dir.arg.loc
)
);
}
const { tag } = node;
const isCustomElement = context.isCustomElement(tag);
if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
let directiveToUse = V_MODEL_TEXT;
let isInvalidType = false;
if (tag === "input" || isCustomElement) {
const type = findProp(node, `type`);
if (type) {
if (type.type === 7) {
directiveToUse = V_MODEL_DYNAMIC;
} else if (type.value) {
switch (type.value.content) {
case "radio":
directiveToUse = V_MODEL_RADIO;
break;
case "checkbox":
directiveToUse = V_MODEL_CHECKBOX;
break;
case "file":
isInvalidType = true;
context.onError(
createDOMCompilerError(
59,
dir.loc
)
);
break;
}
}
} else if (hasDynamicKeyVBind(node)) {
directiveToUse = V_MODEL_DYNAMIC;
} else ;
} else if (tag === "select") {
directiveToUse = V_MODEL_SELECT;
} else ;
if (!isInvalidType) {
baseResult.needRuntime = context.helper(directiveToUse);
}
} else {
context.onError(
createDOMCompilerError(
57,
dir.loc
)
);
}
baseResult.props = baseResult.props.filter(
(p) => !(p.key.type === 4 && p.key.content === "modelValue")
);
return baseResult;
};
const isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
const isNonKeyModifier = /* @__PURE__ */ makeMap(
// event propagation management
`stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
);
const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
const isKeyboardEvent = /* @__PURE__ */ makeMap(
`onkeyup,onkeydown,onkeypress`,
true
);
const resolveModifiers = (key, modifiers, context, loc) => {
const keyModifiers = [];
const nonKeyModifiers = [];
const eventOptionModifiers = [];
for (let i = 0; i < modifiers.length; i++) {
const modifier = modifiers[i];
if (modifier === "native" && checkCompatEnabled(
"COMPILER_V_ON_NATIVE",
context)) {
eventOptionModifiers.push(modifier);
} else if (isEventOptionModifier(modifier)) {
eventOptionModifiers.push(modifier);
} else {
if (maybeKeyModifier(modifier)) {
if (isStaticExp(key)) {
if (isKeyboardEvent(key.content)) {
keyModifiers.push(modifier);
} else {
nonKeyModifiers.push(modifier);
}
} else {
keyModifiers.push(modifier);
nonKeyModifiers.push(modifier);
}
} else {
if (isNonKeyModifier(modifier)) {
nonKeyModifiers.push(modifier);
} else {
keyModifiers.push(modifier);
}
}
}
}
return {
keyModifiers,
nonKeyModifiers,
eventOptionModifiers
};
};
const transformClick = (key, event) => {
const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
`(`,
key,
`) === "onClick" ? "${event}" : (`,
key,
`)`
]) : key;
};
const transformOn = (dir, node, context) => {
return transformOn$1(dir, node, context, (baseResult) => {
const { modifiers } = dir;
if (!modifiers.length)
return baseResult;
let { key, value: handlerExp } = baseResult.props[0];
const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
if (nonKeyModifiers.includes("right")) {
key = transformClick(key, `onContextmenu`);
}
if (nonKeyModifiers.includes("middle")) {
key = transformClick(key, `onMouseup`);
}
if (nonKeyModifiers.length) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
handlerExp,
JSON.stringify(nonKeyModifiers)
]);
}
if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
(!isStaticExp(key) || isKeyboardEvent(key.content))) {
handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
handlerExp,
JSON.stringify(keyModifiers)
]);
}
if (eventOptionModifiers.length) {
const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
}
return {
props: [createObjectProperty(key, handlerExp)]
};
});
};
const transformShow = (dir, node, context) => {
const { exp, loc } = dir;
if (!exp) {
context.onError(
createDOMCompilerError(61, loc)
);
}
return {
props: [],
needRuntime: context.helper(V_SHOW)
};
};
const expReplaceRE = /__VUE_EXP_START__(.*?)__VUE_EXP_END__/g;
const stringifyStatic = (children, context, parent) => {
if (context.scopes.vSlot > 0) {
return;
}
let nc = 0;
let ec = 0;
const currentChunk = [];
const stringifyCurrentChunk = (currentIndex) => {
if (nc >= 20 || ec >= 5) {
const staticCall = createCallExpression(context.helper(CREATE_STATIC), [
JSON.stringify(
currentChunk.map((node) => stringifyNode(node, context)).join("")
).replace(expReplaceRE, `" + $1 + "`),
// the 2nd argument indicates the number of DOM nodes this static vnode
// will insert / hydrate
String(currentChunk.length)
]);
replaceHoist(currentChunk[0], staticCall, context);
if (currentChunk.length > 1) {
for (let i2 = 1; i2 < currentChunk.length; i2++) {
replaceHoist(currentChunk[i2], null, context);
}
const deleteCount = currentChunk.length - 1;
children.splice(currentIndex - currentChunk.length + 1, deleteCount);
return deleteCount;
}
}
return 0;
};
let i = 0;
for (; i < children.length; i++) {
const child = children[i];
const hoisted = getHoistedNode(child);
if (hoisted) {
const node = child;
const result = analyzeNode(node);
if (result) {
nc += result[0];
ec += result[1];
currentChunk.push(node);
continue;
}
}
i -= stringifyCurrentChunk(i);
nc = 0;
ec = 0;
currentChunk.length = 0;
}
stringifyCurrentChunk(i);
};
const getHoistedNode = (node) => (node.type === 1 && node.tagType === 0 || node.type == 12) && node.codegenNode && node.codegenNode.type === 4 && node.codegenNode.hoisted;
const dataAriaRE = /^(data|aria)-/;
const isStringifiableAttr = (name, ns) => {
return (ns === 0 ? isKnownHtmlAttr(name) : ns === 1 ? isKnownSvgAttr(name) : false) || dataAriaRE.test(name);
};
const replaceHoist = (node, replacement, context) => {
const hoistToReplace = node.codegenNode.hoisted;
context.hoists[context.hoists.indexOf(hoistToReplace)] = replacement;
};
const isNonStringifiable = /* @__PURE__ */ makeMap(
`caption,thead,tr,th,tbody,td,tfoot,colgroup,col`
);
function analyzeNode(node) {
if (node.type === 1 && isNonStringifiable(node.tag)) {
return false;
}
if (node.type === 12) {
return [1, 0];
}
let nc = 1;
let ec = node.props.length > 0 ? 1 : 0;
let bailed = false;
const bail = () => {
bailed = true;
return false;
};
function walk(node2) {
for (let i = 0; i < node2.props.length; i++) {
const p = node2.props[i];
if (p.type === 6 && !isStringifiableAttr(p.name, node2.ns)) {
return bail();
}
if (p.type === 7 && p.name === "bind") {
if (p.arg && (p.arg.type === 8 || p.arg.isStatic && !isStringifiableAttr(p.arg.content, node2.ns))) {
return bail();
}
if (p.exp && (p.exp.type === 8 || p.exp.constType < 3)) {
return bail();
}
}
}
for (let i = 0; i < node2.children.length; i++) {
nc++;
const child = node2.children[i];
if (child.type === 1) {
if (child.props.length > 0) {
ec++;
}
walk(child);
if (bailed) {
return false;
}
}
}
return true;
}
return walk(node) ? [nc, ec] : false;
}
function stringifyNode(node, context) {
if (isString(node)) {
return node;
}
if (isSymbol(node)) {
return ``;
}
switch (node.type) {
case 1:
return stringifyElement(node, context);
case 2:
return escapeHtml(node.content);
case 3:
return `<!--${escapeHtml(node.content)}-->`;
case 5:
return escapeHtml(toDisplayString(evaluateConstant(node.content)));
case 8:
return escapeHtml(evaluateConstant(node));
case 12:
return stringifyNode(node.content, context);
default:
return "";
}
}
function stringifyElement(node, context) {
let res = `<${node.tag}`;
let innerHTML = "";
for (let i = 0; i < node.props.length; i++) {
const p = node.props[i];
if (p.type === 6) {
res += ` ${p.name}`;
if (p.value) {
res += `="${escapeHtml(p.value.content)}"`;
}
} else if (p.type === 7) {
if (p.name === "bind") {
const exp = p.exp;
if (exp.content[0] === "_") {
res += ` ${p.arg.content}="__VUE_EXP_START__${exp.content}__VUE_EXP_END__"`;
continue;
}
if (isBooleanAttr(p.arg.content) && exp.content === "false") {
continue;
}
let evaluated = evaluateConstant(exp);
if (evaluated != null) {
const arg = p.arg && p.arg.content;
if (arg === "class") {
evaluated = normalizeClass(evaluated);
} else if (arg === "style") {
evaluated = stringifyStyle(normalizeStyle(evaluated));
}
res += ` ${p.arg.content}="${escapeHtml(
evaluated
)}"`;
}
} else if (p.name === "html") {
innerHTML = evaluateConstant(p.exp);
} else if (p.name === "text") {
innerHTML = escapeHtml(
toDisplayString(evaluateConstant(p.exp))
);
}
}
}
if (context.scopeId) {
res += ` ${context.scopeId}`;
}
res += `>`;
if (innerHTML) {
res += innerHTML;
} else {
for (let i = 0; i < node.children.length; i++) {
res += stringifyNode(node.children[i], context);
}
}
if (!isVoidTag(node.tag)) {
res += `</${node.tag}>`;
}
return res;
}
function evaluateConstant(exp) {
if (exp.type === 4) {
return new Function(`return (${exp.content})`)();
} else {
let res = ``;
exp.children.forEach((c) => {
if (isString(c) || isSymbol(c)) {
return;
}
if (c.type === 2) {
res += c.content;
} else if (c.type === 5) {
res += toDisplayString(evaluateConstant(c.content));
} else {
res += evaluateConstant(c);
}
});
return res;
}
}
const ignoreSideEffectTags = (node, context) => {
if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
context.removeNode();
}
};
const DOMNodeTransforms = [
transformStyle,
...[]
];
const DOMDirectiveTransforms = {
cloak: noopDirectiveTransform,
html: transformVHtml,
text: transformVText,
model: transformModel,
// override compiler-core
on: transformOn,
// override compiler-core
show: transformShow
};
function compile(template, options = {}) {
return baseCompile(
template,
extend({}, parserOptions, options, {
nodeTransforms: [
// ignore <script> and <tag>
// this is not put inside DOMNodeTransforms because that list is used
// by compiler-ssr to generate vnode fallback branches
ignoreSideEffectTags,
...DOMNodeTransforms,
...options.nodeTransforms || []
],
directiveTransforms: extend(
{},
DOMDirectiveTransforms,
options.directiveTransforms || {}
),
transformHoist: stringifyStatic
})
);
}
const compileCache = /* @__PURE__ */ Object.create(null);
function compileToFunction(template, options) {
if (!isString(template)) {
if (template.nodeType) {
template = template.innerHTML;
} else {
return NOOP;
}
}
const key = template;
const cached = compileCache[key];
if (cached) {
return cached;
}
if (template[0] === "#") {
const el = document.querySelector(template);
template = el ? el.innerHTML : ``;
}
const { code } = compile(
template,
extend(
{
hoistStatic: true,
whitespace: "preserve",
onError: void 0,
onWarn: NOOP
},
options
)
);
const render = new Function("Vue", code)(runtimeDom);
render._rc = true;
return compileCache[key] = render;
}
registerRuntimeCompiler(compileToFunction);
const Vue = createCompatVue();
Vue.compile = compileToFunction;
module.exports = Vue;