@@ -487,15 +487,19 @@
var callBound$1 = function callBoundIntrinsic(name, allowMissing) {
var intrinsic = GetIntrinsic$1(name, !!allowMissing);
if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
return callBind(intrinsic);
}
return intrinsic;
};
-var __viteBrowserExternal = {};
+var __viteBrowserExternal = new Proxy({}, {
+ get() {
+ throw new Error('Module "" has been externalized for browser compatibility and cannot be accessed in client code.');
+ }
+});
var __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze( /* @__PURE__ */ Object.defineProperty({
__proto__: null,
"default": __viteBrowserExternal
}, Symbol.toStringTag, {
value: "Module"
}));
var require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
@@ -706,15 +710,15 @@
}
if (isNumber$1(obj)) {
return markBoxed(inspect2(Number(obj)));
}
if (isBigInt(obj)) {
return markBoxed(inspect2(bigIntValueOf.call(obj)));
}
- if (isBoolean(obj)) {
+ if (isBoolean$1(obj)) {
return markBoxed(booleanValueOf.call(obj));
}
if (isString$2(obj)) {
return markBoxed(inspect2(String(obj)));
}
if (!isDate$2(obj) && !isRegExp$1(obj)) {
var ys = arrObjKeys(obj, inspect2);
@@ -763,15 +767,15 @@
return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
}
function isNumber$1(obj) {
return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
}
-function isBoolean(obj) {
+function isBoolean$1(obj) {
return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
}
function isSymbol$1(obj) {
if (hasShammedSymbols) {
return obj && typeof obj === "object" && obj instanceof Symbol;
}
@@ -1810,23 +1814,23 @@
var lib = {
formats,
parse,
stringify: stringify2
};
function makeMap(str, expectsLowerCase) {
- const map = /* @__PURE__ */ Object.create(null);
+ const map2 = /* @__PURE__ */ Object.create(null);
const list = str.split(",");
for (let i = 0; i < list.length; i++) {
- map[list[i]] = true;
+ map2[list[i]] = true;
}
- return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+ return expectsLowerCase ? (val) => !!map2[val.toLowerCase()] : (val) => !!map2[val];
}
-const EMPTY_OBJ = {};
-const EMPTY_ARR = [];
+const EMPTY_OBJ = Object.freeze({});
+const EMPTY_ARR = Object.freeze([]);
const NOOP = () => {};
const NO = () => false;
const onRE = /^on[^a-z]/;
const isOn = (key) => onRE.test(key);
const isModelListener = (key) => key.startsWith("onUpdate:");
const extend$2 = Object.assign;
const remove = (arr, el) => {
@@ -1854,14 +1858,17 @@
return toTypeString(value).slice(8, -1);
};
const isPlainObject$1 = (val) => toTypeString(val) === "[object Object]";
const isIntegerKey = (key) => isString$1(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
const isReservedProp = /* @__PURE__ */ makeMap(
",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));
};
};
@@ -1951,14 +1958,18 @@
if (value[name]) {
res += name + " ";
}
}
}
return res.trim();
}
+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 isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
function includeBooleanAttr(value) {
return !!value || value === "";
}
@@ -2033,14 +2044,18 @@
[`Set(${val.size})`]: [...val.values()]
};
} else if (isObject$2(val) && !isArray$1(val) && !isPlainObject$1(val)) {
return String(val);
}
return val;
};
+
+function warn$1(msg, ...args) {
+ console.warn(`[Vue warn] ${msg}`, ...args);
+}
let activeEffectScope;
class EffectScope {
constructor(detached = false) {
this.detached = detached;
this._active = true;
this.effects = [];
this.cleanups = [];
@@ -2059,14 +2074,16 @@
const currentEffectScope = activeEffectScope;
try {
activeEffectScope = this;
return fn();
} finally {
activeEffectScope = currentEffectScope;
}
+ } else {
+ warn$1(`cannot run an inactive effect scope.`);
}
}
on() {
activeEffectScope = this;
}
off() {
activeEffectScope = this.parent;
@@ -2144,16 +2161,16 @@
}
};
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("");
+const ITERATE_KEY = Symbol("iterate");
+const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate");
class ReactiveEffect {
constructor(fn, scheduler = null, scope) {
this.fn = fn;
this.scheduler = scheduler;
this.active = true;
this.deps = [];
this.parent = void 0;
@@ -2238,15 +2255,21 @@
if (!depsMap) {
targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
}
let dep = depsMap.get(key);
if (!dep) {
depsMap.set(key, dep = createDep());
}
- trackEffects(dep);
+ const eventInfo = {
+ effect: activeEffect,
+ target,
+ type,
+ key
+ };
+ trackEffects(dep, eventInfo);
}
}
function trackEffects(dep, debuggerEventExtraInfo) {
let shouldTrack2 = false;
if (effectTrackDepth <= maxMarkerBits) {
if (!newTracked(dep)) {
@@ -2255,14 +2278,23 @@
}
} else {
shouldTrack2 = !dep.has(activeEffect);
}
if (shouldTrack2) {
dep.add(activeEffect);
activeEffect.deps.push(dep);
+ if (activeEffect.onTrack) {
+ activeEffect.onTrack(
+ extend$2({
+ effect: activeEffect
+ },
+ debuggerEventExtraInfo
+ )
+ );
+ }
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
return;
@@ -2303,48 +2335,61 @@
case "set":
if (isMap(target)) {
deps.push(depsMap.get(ITERATE_KEY));
}
break;
}
}
+ const eventInfo = {
+ target,
+ type,
+ key,
+ newValue,
+ oldValue,
+ oldTarget
+ };
if (deps.length === 1) {
if (deps[0]) {
{
- triggerEffects(deps[0]);
+ triggerEffects(deps[0], eventInfo);
}
}
} else {
const effects = [];
for (const dep of deps) {
if (dep) {
effects.push(...dep);
}
} {
- triggerEffects(createDep(effects));
+ triggerEffects(createDep(effects), eventInfo);
}
}
}
function triggerEffects(dep, debuggerEventExtraInfo) {
const effects = isArray$1(dep) ? dep : [...dep];
for (const effect2 of effects) {
if (effect2.computed) {
- triggerEffect(effect2);
+ triggerEffect(effect2, debuggerEventExtraInfo);
}
}
for (const effect2 of effects) {
if (!effect2.computed) {
- triggerEffect(effect2);
+ triggerEffect(effect2, debuggerEventExtraInfo);
}
}
}
function triggerEffect(effect2, debuggerEventExtraInfo) {
if (effect2 !== activeEffect || effect2.allowRecurse) {
+ if (effect2.onTrigger) {
+ effect2.onTrigger(extend$2({
+ effect: effect2
+ }, debuggerEventExtraInfo));
+ }
if (effect2.scheduler) {
effect2.scheduler();
} else {
effect2.run();
}
}
}
@@ -2352,14 +2397,15 @@
const builtInSymbols = new Set(
/* @__PURE__ */
Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
);
const get$1 = /* @__PURE__ */ createGetter();
const shallowGet = /* @__PURE__ */ createGetter(false, true);
const readonlyGet = /* @__PURE__ */ createGetter(true);
+const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
function createArrayInstrumentations() {
const instrumentations = {};
["includes", "indexOf", "lastIndexOf"].forEach((key) => {
instrumentations[key] = function(...args) {
const arr = toRaw(this);
@@ -2436,42 +2482,42 @@
function createSetter(shallow = false) {
return function set2(target, key, value, receiver) {
let oldValue = target[key];
if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
return false;
}
if (!shallow) {
- if (!isShallow(value) && !isReadonly(value)) {
+ if (!isShallow$1(value) && !isReadonly(value)) {
oldValue = toRaw(oldValue);
value = toRaw(value);
}
if (!isArray$1(target) && isRef(oldValue) && !isRef(value)) {
oldValue.value = value;
return true;
}
}
const hadKey = isArray$1(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);
+ trigger(target, "set", key, value, oldValue);
}
}
return result;
};
}
function deleteProperty(target, key) {
const hadKey = hasOwn(target, key);
- target[key];
+ const oldValue = target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
- trigger(target, "delete", key, void 0);
+ trigger(target, "delete", key, void 0, oldValue);
}
return result;
}
function has$1(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
@@ -2490,26 +2536,43 @@
deleteProperty,
has: has$1,
ownKeys
};
const readonlyHandlers = {
get: readonlyGet,
set(target, key) {
+ {
+ warn$1(
+ `Set operation on key "${String(key)}" failed: target is readonly.`,
+ target
+ );
+ }
return true;
},
deleteProperty(target, key) {
+ {
+ warn$1(
+ `Delete operation on key "${String(key)}" failed: target is readonly.`,
+ target
+ );
+ }
return true;
}
};
const shallowReactiveHandlers = /* @__PURE__ */ extend$2({},
mutableHandlers, {
get: shallowGet,
set: shallowSet
}
);
+const shallowReadonlyHandlers = /* @__PURE__ */ extend$2({},
+ readonlyHandlers, {
+ get: shallowReadonlyGet
+ }
+);
const toShallow = (value) => value;
const getProto = (v) => Reflect.getPrototypeOf(v);
function get(target, key, isReadonly2 = false, isShallow2 = false) {
target = target["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
@@ -2570,50 +2633,55 @@
has: has2,
get: get2
} = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
+ } else {
+ checkIdentityKeys(target, has2, key);
}
const oldValue = 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);
+ trigger(target, "set", key, value, oldValue);
}
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);
+ } else {
+ checkIdentityKeys(target, has2, key);
}
- get2 ? get2.call(target, key) : void 0;
+ const oldValue = get2 ? get2.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
- trigger(target, "delete", key, void 0);
+ trigger(target, "delete", key, void 0, oldValue);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
+ const oldTarget = isMap(target) ? new Map(target) : new Set(target);
const result = target.clear();
if (hadItems) {
- trigger(target, "clear", void 0, void 0);
+ trigger(target, "clear", void 0, void 0, oldTarget);
}
return result;
}
function createForEach(isReadonly2, isShallow2) {
return function forEach3(callback, thisArg) {
const observed = this;
@@ -2660,14 +2728,21 @@
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
+ {
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
+ console.warn(
+ `${capitalize(type)} operation ${key}failed: target is readonly.`,
+ toRaw(this)
+ );
+ }
return type === "delete" ? false : this;
};
}
function createInstrumentations() {
const mutableInstrumentations2 = {
get(key) {
@@ -2788,14 +2863,27 @@
};
const shallowCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(false, true)
};
const readonlyCollectionHandlers = {
get: /* @__PURE__ */ createInstrumentationGetter(true, false)
};
+const shallowReadonlyCollectionHandlers = {
+ get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+};
+
+function checkIdentityKeys(target, has2, key) {
+ const rawKey = toRaw(key);
+ if (rawKey !== key && has2.call(target, rawKey)) {
+ const type = toRawType(target);
+ console.warn(
+ `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+ );
+ }
+}
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) {
@@ -2845,16 +2933,29 @@
true,
readonlyHandlers,
readonlyCollectionHandlers,
readonlyMap
);
}
+function shallowReadonly(target) {
+ return createReactiveObject(
+ target,
+ true,
+ shallowReadonlyHandlers,
+ shallowReadonlyCollectionHandlers,
+ shallowReadonlyMap
+ );
+}
+
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
if (!isObject$2(target)) {
+ {
+ console.warn(`value cannot be made reactive: ${String(target)}`);
+ }
return target;
}
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
return target;
}
const existingProxy = proxyMap.get(target);
if (existingProxy) {
@@ -2879,15 +2980,15 @@
return !!(value && value["__v_isReactive"]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly"]);
}
-function isShallow(value) {
+function isShallow$1(value) {
return !!(value && value["__v_isShallow"]);
}
function isProxy(value) {
return isReactive(value) || isReadonly(value);
}
@@ -2903,25 +3004,34 @@
const toReactive = (value) => isObject$2(value) ? reactive(value) : value;
const toReadonly = (value) => isObject$2(value) ? readonly(value) : value;
function trackRefValue(ref2) {
if (shouldTrack && activeEffect) {
ref2 = toRaw(ref2);
{
- trackEffects(ref2.dep || (ref2.dep = createDep()));
+ trackEffects(ref2.dep || (ref2.dep = createDep()), {
+ target: ref2,
+ type: "get",
+ key: "value"
+ });
}
}
}
function triggerRefValue(ref2, newVal) {
ref2 = toRaw(ref2);
const dep = ref2.dep;
if (dep) {
{
- triggerEffects(dep);
+ triggerEffects(dep, {
+ target: ref2,
+ type: "set",
+ key: "value",
+ newValue: newVal
+ });
}
}
}
function isRef(r) {
return !!(r && r.__v_isRef === true);
}
@@ -2978,27 +3088,176 @@
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
const onlyGetter = isFunction$1(getterOrOptions);
if (onlyGetter) {
getter = getterOrOptions;
- setter = NOOP;
+ setter = () => {
+ console.warn("Write operation failed: computed value is readonly");
+ };
} else {
getter = getterOrOptions.get;
setter = getterOrOptions.set;
}
const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+ if (debugOptions && !isSSR) {
+ cRef.effect.onTrack = debugOptions.onTrack;
+ cRef.effect.onTrigger = debugOptions.onTrigger;
+ }
return cRef;
}
+const stack = [];
+
+function pushWarningContext(vnode) {
+ stack.push(vnode);
+}
+
+function popWarningContext() {
+ stack.pop();
+}
function warn(msg, ...args) {
- return;
+ pauseTracking();
+ const instance = stack.length ? stack[stack.length - 1].component : null;
+ const appWarnHandler = instance && instance.appContext.config.warnHandler;
+ const trace = getComponentTrace();
+ if (appWarnHandler) {
+ callWithErrorHandling(
+ appWarnHandler,
+ instance,
+ 11,
+ [
+ msg + args.join(""),
+ instance && instance.proxy,
+ trace.map(
+ ({
+ vnode
+ }) => `at <${formatComponentName(instance, vnode.type)}>`
+ ).join("\n"),
+ trace
+ ]
+ );
+ } else {
+ const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+ if (trace.length && true) {
+ warnArgs.push(`
+`, ...formatTrace(trace));
+ }
+ console.warn(...warnArgs);
+ }
+ resetTracking();
+}
+
+function getComponentTrace() {
+ let currentVNode = stack[stack.length - 1];
+ if (!currentVNode) {
+ return [];
+ }
+ const normalizedStack = [];
+ while (currentVNode) {
+ const last = normalizedStack[0];
+ if (last && last.vnode === currentVNode) {
+ last.recurseCount++;
+ } else {
+ normalizedStack.push({
+ vnode: currentVNode,
+ recurseCount: 0
+ });
+ }
+ const parentInstance = currentVNode.component && currentVNode.component.parent;
+ currentVNode = parentInstance && parentInstance.vnode;
+ }
+ return normalizedStack;
+}
+
+function formatTrace(trace) {
+ const logs = [];
+ trace.forEach((entry, i) => {
+ logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+ });
+ return logs;
}
+function formatTraceEntry({
+ vnode,
+ recurseCount
+}) {
+ const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+ const isRoot = vnode.component ? vnode.component.parent == null : false;
+ const open = ` at <${formatComponentName(
+ vnode.component,
+ vnode.type,
+ isRoot
+ )}`;
+ const close = `>` + postfix;
+ return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+
+function formatProps(props) {
+ const res = [];
+ const keys = Object.keys(props);
+ keys.slice(0, 3).forEach((key) => {
+ res.push(...formatProp(key, props[key]));
+ });
+ if (keys.length > 3) {
+ res.push(` ...`);
+ }
+ return res;
+}
+
+function formatProp(key, value, raw) {
+ if (isString$1(value)) {
+ value = JSON.stringify(value);
+ return raw ? value : [`${key}=${value}`];
+ } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+ return raw ? value : [`${key}=${value}`];
+ } else if (isRef(value)) {
+ value = formatProp(key, toRaw(value.value), true);
+ return raw ? value : [`${key}=Ref<`, value, `>`];
+ } else if (isFunction$1(value)) {
+ return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+ } else {
+ value = toRaw(value);
+ return raw ? value : [`${key}=`, value];
+ }
+}
+const ErrorTypeStrings = {
+ ["sp"]: "serverPrefetch hook",
+ ["bc"]: "beforeCreate hook",
+ ["c"]: "created hook",
+ ["bm"]: "beforeMount hook",
+ ["m"]: "mounted hook",
+ ["bu"]: "beforeUpdate hook",
+ ["u"]: "updated",
+ ["bum"]: "beforeUnmount hook",
+ ["um"]: "unmounted hook",
+ ["a"]: "activated hook",
+ ["da"]: "deactivated hook",
+ ["ec"]: "errorCaptured hook",
+ ["rtc"]: "renderTracked hook",
+ ["rtg"]: "renderTriggered hook",
+ [0]: "setup function",
+ [1]: "render function",
+ [2]: "watcher getter",
+ [3]: "watcher callback",
+ [4]: "watcher cleanup function",
+ [5]: "native event handler",
+ [6]: "component event handler",
+ [7]: "vnode hook",
+ [8]: "directive hook",
+ [9]: "transition hook",
+ [10]: "app errorHandler",
+ [11]: "app warnHandler",
+ [12]: "ref function",
+ [13]: "async component loader",
+ [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+
function callWithErrorHandling(fn, instance, type, args) {
let res;
try {
res = args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
@@ -3023,15 +3282,15 @@
}
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;
+ const errorInfo = ErrorTypeStrings[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;
}
@@ -3051,26 +3310,39 @@
}
}
logError(err, type, contextVNode, throwInDev);
}
function logError(err, type, contextVNode, throwInDev = true) {
{
- console.error(err);
+ const info = ErrorTypeStrings[type];
+ if (contextVNode) {
+ pushWarningContext(contextVNode);
+ }
+ warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+ if (contextVNode) {
+ popWarningContext();
+ }
+ if (throwInDev) {
+ throw err;
+ } else {
+ 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;
+const RECURSION_LIMIT = 100;
function nextTick(fn) {
const p2 = currentFlushPromise || resolvedPromise;
return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
}
function findInsertionIndex(id) {
@@ -3123,17 +3395,23 @@
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) {
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.pre) {
+ if (checkRecursiveUpdates(seen, cb)) {
+ continue;
+ }
queue.splice(i, 1);
i--;
cb();
}
}
}
@@ -3142,16 +3420,22 @@
const deduped = [...new Set(pendingPostFlushCbs)];
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
activePostFlushCbs.sort((a, b) => getId(a) - getId(b));
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+ if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
+ continue;
+ }
activePostFlushCbs[postFlushIndex]();
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? Infinity : job.id;
@@ -3165,41 +3449,311 @@
}
return diff;
};
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
+ {
+ seen = seen || /* @__PURE__ */ new Map();
+ }
queue.sort(comparator);
- const check = NOOP;
+ const check = (job) => checkRecursiveUpdates(seen, job);
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && job.active !== false) {
- if (false)
- ;
+ if (check(job)) {
+ continue;
+ }
callWithErrorHandling(job, null, 14);
}
}
} finally {
flushIndex = 0;
queue.length = 0;
- flushPostFlushCbs();
+ flushPostFlushCbs(seen);
isFlushing = false;
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
- flushJobs();
+ flushJobs(seen);
+ }
+ }
+}
+
+function checkRecursiveUpdates(seen, fn) {
+ if (!seen.has(fn)) {
+ seen.set(fn, 1);
+ } else {
+ const count = seen.get(fn);
+ if (count > RECURSION_LIMIT) {
+ const instance = fn.ownerInstance;
+ const componentName = instance && getComponentName(instance.type);
+ warn(
+ `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`
+ );
+ return true;
+ } else {
+ seen.set(fn, count + 1);
+ }
+ }
+}
+let isHmrUpdating = false;
+const hmrDirtyComponents = /* @__PURE__ */ new Set();
+{
+ getGlobalThis().__VUE_HMR_RUNTIME__ = {
+ createRecord: tryWrap(createRecord),
+ rerender: tryWrap(rerender),
+ reload: tryWrap(reload)
+ };
+}
+const map = /* @__PURE__ */ new Map();
+
+function registerHMR(instance) {
+ const id = instance.type.__hmrId;
+ let record = map.get(id);
+ if (!record) {
+ createRecord(id, instance.type);
+ record = map.get(id);
+ }
+ record.instances.add(instance);
+}
+
+function unregisterHMR(instance) {
+ map.get(instance.type.__hmrId).instances.delete(instance);
+}
+
+function createRecord(id, initialDef) {
+ if (map.has(id)) {
+ return false;
+ }
+ map.set(id, {
+ initialDef: normalizeClassComponent(initialDef),
+ instances: /* @__PURE__ */ new Set()
+ });
+ return true;
+}
+
+function normalizeClassComponent(component) {
+ return isClassComponent(component) ? component.__vccOpts : component;
+}
+
+function rerender(id, newRender) {
+ const record = map.get(id);
+ if (!record) {
+ return;
+ }
+ record.initialDef.render = newRender;
+ [...record.instances].forEach((instance) => {
+ if (newRender) {
+ instance.render = newRender;
+ normalizeClassComponent(instance.type).render = newRender;
+ }
+ instance.renderCache = [];
+ isHmrUpdating = true;
+ instance.update();
+ isHmrUpdating = false;
+ });
+}
+
+function reload(id, newComp) {
+ const record = map.get(id);
+ if (!record)
+ return;
+ newComp = normalizeClassComponent(newComp);
+ updateComponentDef(record.initialDef, newComp);
+ const instances = [...record.instances];
+ for (const instance of instances) {
+ const oldComp = normalizeClassComponent(instance.type);
+ if (!hmrDirtyComponents.has(oldComp)) {
+ if (oldComp !== record.initialDef) {
+ updateComponentDef(oldComp, newComp);
+ }
+ hmrDirtyComponents.add(oldComp);
+ }
+ instance.appContext.propsCache.delete(instance.type);
+ instance.appContext.emitsCache.delete(instance.type);
+ instance.appContext.optionsCache.delete(instance.type);
+ if (instance.ceReload) {
+ hmrDirtyComponents.add(oldComp);
+ instance.ceReload(newComp.styles);
+ hmrDirtyComponents.delete(oldComp);
+ } else if (instance.parent) {
+ queueJob(instance.parent.update);
+ } else if (instance.appContext.reload) {
+ instance.appContext.reload();
+ } else if (typeof window !== "undefined") {
+ window.location.reload();
+ } else {
+ console.warn(
+ "[HMR] Root or manually mounted instance modified. Full reload required."
+ );
}
}
+ queuePostFlushCb(() => {
+ for (const instance of instances) {
+ hmrDirtyComponents.delete(
+ normalizeClassComponent(instance.type)
+ );
+ }
+ });
+}
+
+function updateComponentDef(oldComp, newComp) {
+ extend$2(oldComp, newComp);
+ for (const key in oldComp) {
+ if (key !== "__file" && !(key in newComp)) {
+ delete oldComp[key];
+ }
+ }
+}
+
+function tryWrap(fn) {
+ return (id, arg) => {
+ try {
+ return fn(id, arg);
+ } catch (e) {
+ console.error(e);
+ console.warn(
+ `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+ );
+ }
+ };
+}
+let devtools;
+let buffer = [];
+let devtoolsNotInstalled = false;
+
+function emit$1(event, ...args) {
+ if (devtools) {
+ devtools.emit(event, ...args);
+ } else if (!devtoolsNotInstalled) {
+ buffer.push({
+ event,
+ args
+ });
+ }
+}
+
+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 (typeof window !== "undefined" && window.HTMLElement && !((_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;
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+ }, 3e3);
+ } else {
+ devtoolsNotInstalled = true;
+ buffer = [];
+ }
+}
+
+function devtoolsInitApp(app, version2) {
+ emit$1("app:init", app, version2, {
+ Fragment,
+ Text: Text$1,
+ Comment,
+ Static
+ });
+}
+
+function devtoolsUnmountApp(app) {
+ emit$1("app:unmount", app);
+}
+const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
+ "component:added"
+);
+const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated");
+const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
+ "component:removed"
+);
+const devtoolsComponentRemoved = (component) => {
+ if (devtools && typeof devtools.cleanupBuffer === "function" && !devtools.cleanupBuffer(component)) {
+ _devtoolsComponentRemoved(component);
+ }
+};
+
+function createDevtoolsComponentHook(hook) {
+ return (component) => {
+ emit$1(
+ hook,
+ component.appContext.app,
+ component.uid,
+ component.parent ? component.parent.uid : void 0,
+ component
+ );
+ };
+}
+const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
+ "perf:start"
+);
+const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
+ "perf:end"
+);
+
+function createDevtoolsPerformanceHook(hook) {
+ return (component, type, time) => {
+ emit$1(hook, component.appContext.app, component.uid, component, type, time);
+ };
+}
+
+function devtoolsComponentEmit(component, event, params) {
+ emit$1(
+ "component:emit",
+ component.appContext.app,
+ component,
+ event,
+ params
+ );
}
function emit(instance, event, ...rawArgs) {
if (instance.isUnmounted)
return;
const props = instance.vnode.props || EMPTY_OBJ;
+ {
+ const {
+ emitsOptions,
+ propsOptions: [propsOptions]
+ } = instance;
+ if (emitsOptions) {
+ if (!(event in emitsOptions) && true) {
+ if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
+ warn(
+ `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`
+ );
+ }
+ } else {
+ const validator2 = emitsOptions[event];
+ if (isFunction$1(validator2)) {
+ const isValid = validator2(...rawArgs);
+ if (!isValid) {
+ warn(
+ `Invalid event arguments: event validation failed for event "${event}".`
+ );
+ }
+ }
+ }
+ }
+ }
let args = rawArgs;
const isModelListener2 = event.startsWith("update:");
const modelArg = isModelListener2 && event.slice(7);
if (modelArg && modelArg in props) {
const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
const {
number,
@@ -3207,14 +3761,26 @@
} = props[modifiersKey] || EMPTY_OBJ;
if (trim2) {
args = rawArgs.map((a) => isString$1(a) ? a.trim() : a);
}
if (number) {
args = rawArgs.map(looseToNumber);
}
+ } {
+ devtoolsComponentEmit(instance, event, args);
+ } {
+ const lowerCaseEvent = event.toLowerCase();
+ if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+ warn(
+ `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
+ instance,
+ instance.type
+ )} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(event)}" instead of "${event}".`
+ );
+ }
}
let handlerName;
let handler = props[handlerName = toHandlerKey(event)] || props[handlerName = toHandlerKey(camelize(event))];
if (!handler && isModelListener2) {
handler = props[handlerName = toHandlerKey(hyphenate(event))];
}
if (handler) {
@@ -3318,24 +3884,29 @@
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
+ } {
+ devtoolsComponentUpdated(ctx);
}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
return renderFnWithContext;
}
+let accessedAttrs = false;
-function markAttrsAccessed() {}
+function markAttrsAccessed() {
+ accessedAttrs = true;
+}
function renderComponentRoot(instance) {
const {
type: Component,
vnode,
proxy,
withProxy,
@@ -3350,14 +3921,17 @@
setupState,
ctx,
inheritAttrs
} = instance;
let result;
let fallthroughAttrs;
const prev = setCurrentRenderingInstance(instance);
+ {
+ accessedAttrs = false;
+ }
try {
if (vnode.shapeFlag & 4) {
const proxyToUse = withProxy || proxy;
result = normalizeVNode(
render.call(
proxyToUse,
proxyToUse,
@@ -3367,20 +3941,21 @@
data2,
ctx
)
);
fallthroughAttrs = attrs;
} else {
const render2 = Component;
- if (false)
- ;
+ if (attrs === props) {
+ markAttrsAccessed();
+ }
result = normalizeVNode(
render2.length > 1 ? render2(
props,
- false ? {
+ true ? {
get attrs() {
markAttrsAccessed();
return attrs;
},
slots,
emit: emit2
} : {
@@ -3397,43 +3972,124 @@
}
} catch (err) {
blockStack.length = 0;
handleError(err, instance, 1);
result = createVNode(Comment);
}
let root2 = result;
+ let setRoot = void 0;
+ if (result.patchFlag > 0 && result.patchFlag & 2048) {
+ [root2, setRoot] = getChildRoot(result);
+ }
if (fallthroughAttrs && inheritAttrs !== false) {
const keys = Object.keys(fallthroughAttrs);
const {
shapeFlag
} = root2;
if (keys.length) {
if (shapeFlag & (1 | 6)) {
if (propsOptions && keys.some(isModelListener)) {
fallthroughAttrs = filterModelListeners(
fallthroughAttrs,
propsOptions
);
}
root2 = cloneVNode(root2, fallthroughAttrs);
+ } else if (!accessedAttrs && root2.type !== Comment) {
+ const allAttrs = Object.keys(attrs);
+ const eventAttrs = [];
+ const extraAttrs = [];
+ for (let i = 0, l = allAttrs.length; i < l; i++) {
+ const key = allAttrs[i];
+ if (isOn(key)) {
+ if (!isModelListener(key)) {
+ eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+ }
+ } else {
+ extraAttrs.push(key);
+ }
+ }
+ if (extraAttrs.length) {
+ warn(
+ `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`
+ );
+ }
+ if (eventAttrs.length) {
+ warn(
+ `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
+ );
+ }
}
}
}
if (vnode.dirs) {
+ if (!isElementRoot(root2)) {
+ warn(
+ `Runtime directive used on component with non-element root node. The directives will not function as intended.`
+ );
+ }
root2 = cloneVNode(root2);
root2.dirs = root2.dirs ? root2.dirs.concat(vnode.dirs) : vnode.dirs;
}
if (vnode.transition) {
+ if (!isElementRoot(root2)) {
+ warn(
+ `Component inside <Transition> renders non-element root node that cannot be animated.`
+ );
+ }
root2.transition = vnode.transition;
- } {
+ }
+ if (setRoot) {
+ setRoot(root2);
+ } else {
result = root2;
}
setCurrentRenderingInstance(prev);
return result;
}
+const getChildRoot = (vnode) => {
+ const rawChildren = vnode.children;
+ const dynamicChildren = vnode.dynamicChildren;
+ const childRoot = filterSingleRoot(rawChildren);
+ if (!childRoot) {
+ return [vnode, void 0];
+ }
+ const index = rawChildren.indexOf(childRoot);
+ const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+ const setRoot = (updatedRoot) => {
+ rawChildren[index] = updatedRoot;
+ if (dynamicChildren) {
+ if (dynamicIndex > -1) {
+ dynamicChildren[dynamicIndex] = updatedRoot;
+ } else if (updatedRoot.patchFlag > 0) {
+ vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+ }
+ }
+ };
+ return [normalizeVNode(childRoot), setRoot];
+};
+
+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];
}
}
@@ -3444,27 +4100,33 @@
for (const key in attrs) {
if (!isModelListener(key) || !(key.slice(9) in props)) {
res[key] = attrs[key];
}
}
return res;
};
+const isElementRoot = (vnode) => {
+ return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
+};
function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
const {
props: prevProps,
children: prevChildren,
component
} = prevVNode;
const {
props: nextProps,
children: nextChildren,
patchFlag
} = nextVNode;
const emits = component.emitsOptions;
+ if ((prevChildren || nextChildren) && isHmrUpdating) {
+ return true;
+ }
if (nextVNode.dirs || nextVNode.transition) {
return true;
}
if (optimized && patchFlag >= 0) {
if (patchFlag & 1024) {
return true;
}
@@ -3537,47 +4199,72 @@
} else {
queuePostFlushCb(fn);
}
}
const INITIAL_WATCHER_VALUE = {};
function watch(source2, cb, options) {
+ if (!isFunction$1(cb)) {
+ warn(
+ `\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`
+ );
+ }
return doWatch(source2, cb, options);
}
function doWatch(source2, cb, {
immediate,
deep,
flush,
onTrack,
onTrigger
} = EMPTY_OBJ) {
var _a;
+ if (!cb) {
+ if (immediate !== void 0) {
+ warn(
+ `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ if (deep !== void 0) {
+ warn(
+ `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ }
+ const warnInvalidSource = (s) => {
+ warn(
+ `Invalid watch source: `,
+ s,
+ `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+ );
+ };
const instance = getCurrentScope() === ((_a = currentInstance) == null ? void 0 : _a.scope) ? currentInstance : null;
let getter;
let forceTrigger = false;
let isMultiSource = false;
if (isRef(source2)) {
getter = () => source2.value;
- forceTrigger = isShallow(source2);
+ forceTrigger = isShallow$1(source2);
} else if (isReactive(source2)) {
getter = () => source2;
deep = true;
} else if (isArray$1(source2)) {
isMultiSource = true;
- forceTrigger = source2.some((s) => isReactive(s) || isShallow(s));
+ forceTrigger = source2.some((s) => isReactive(s) || isShallow$1(s));
getter = () => source2.map((s) => {
if (isRef(s)) {
return s.value;
} else if (isReactive(s)) {
return traverse(s);
} else if (isFunction$1(s)) {
return callWithErrorHandling(s, instance, 2);
- } else
- ;
+ } else {
+ warnInvalidSource(s);
+ }
});
} else if (isFunction$1(source2)) {
if (cb) {
getter = () => callWithErrorHandling(source2, instance, 2);
} else {
getter = () => {
if (instance && instance.isUnmounted) {
@@ -3592,14 +4279,15 @@
3,
[onCleanup]
);
};
}
} else {
getter = NOOP;
+ warnInvalidSource(source2);
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup;
let onCleanup = (fn) => {
@@ -3659,14 +4347,18 @@
} else {
job.pre = true;
if (instance)
job.id = instance.uid;
scheduler = () => queueJob(job);
}
const effect = new ReactiveEffect(getter, scheduler);
+ {
+ effect.onTrack = onTrack;
+ effect.onTrigger = onTrigger;
+ }
if (cb) {
if (immediate) {
job();
} else {
oldValue = effect.run();
}
} else if (flush === "post") {
@@ -3743,17 +4435,24 @@
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
+function validateDirectiveName(name) {
+ if (isBuiltInDirective(name)) {
+ warn("Do not use built-in directive ids as custom directive id: " + name);
+ }
+}
+
function withDirectives(vnode, directives) {
const internalInstance = currentRenderingInstance;
if (internalInstance === null) {
+ warn(`withDirectives can only be used inside render functions.`);
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) {
@@ -3796,32 +4495,14 @@
vnode,
prevVNode
]);
resetTracking();
}
}
}
-const TransitionHookValidator = [Function, Array];
-const BaseTransitionPropsValidators = {
- mode: String,
- appear: Boolean,
- persisted: Boolean,
- onBeforeEnter: TransitionHookValidator,
- onEnter: TransitionHookValidator,
- onAfterEnter: TransitionHookValidator,
- onEnterCancelled: TransitionHookValidator,
- onBeforeLeave: TransitionHookValidator,
- onLeave: TransitionHookValidator,
- onAfterLeave: TransitionHookValidator,
- onLeaveCancelled: TransitionHookValidator,
- onBeforeAppear: TransitionHookValidator,
- onAppear: TransitionHookValidator,
- onAfterAppear: TransitionHookValidator,
- onAppearCancelled: TransitionHookValidator
-};
const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
function onActivated(hook, target) {
registerKeepAliveHook(hook, "a", target);
}
@@ -3880,14 +4561,19 @@
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
+ } else {
+ const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
+ warn(
+ `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`
+ );
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) => (!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");
@@ -3924,15 +4610,24 @@
return Component;
}
}
const res = resolve(instance[type] || Component[type], name) || resolve(instance.appContext[type], name);
if (!res && maybeSelfReference) {
return Component;
}
+ if (warnMissing && !res) {
+ const extra = type === COMPONENTS ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
+ warn(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+ }
return res;
+ } else {
+ warn(
+ `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
+ );
}
}
function resolve(registry2, name) {
return registry2 && (registry2[name] || registry2[camelize(name)] || registry2[capitalize(camelize(name))]);
}
@@ -3941,14 +4636,17 @@
const cached = cache && cache[index];
if (isArray$1(source2) || isString$1(source2)) {
ret = new Array(source2.length);
for (let i = 0, l = source2.length; i < l; i++) {
ret[i] = renderItem(source2[i], i, void 0, cached && cached[i]);
}
} else if (typeof source2 === "number") {
+ if (!Number.isInteger(source2)) {
+ warn(`The v-for range expect an integer value but got ${source2}.`);
+ }
ret = new Array(source2);
for (let i = 0; i < source2; i++) {
ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
}
} else if (isObject$2(source2)) {
if (source2[Symbol.iterator]) {
ret = Array.from(
@@ -3978,40 +4676,44 @@
return getExposeProxy(i) || i.proxy;
return getPublicInstance(i.parent);
};
const publicPropertiesMap = /* @__PURE__ */ extend$2( /* @__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,
+ $props: (i) => shallowReadonly(i.props),
+ $attrs: (i) => shallowReadonly(i.attrs),
+ $slots: (i) => shallowReadonly(i.slots),
+ $refs: (i) => shallowReadonly(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)
});
+const isReservedPrefix = (key) => key === "_" || key === "$";
const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
const PublicInstanceProxyHandlers = {
get({
_: instance
}, key) {
const {
ctx,
setupState,
data: data2,
props,
accessCache,
type,
appContext
} = instance;
+ if (key === "__isVue") {
+ return true;
+ }
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 1:
return setupState[key];
@@ -4039,49 +4741,76 @@
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
track(instance, "get", key);
+ markAttrsAccessed();
+ } else if (key === "$slots") {
+ track(instance, "get", key);
}
return publicGetter(instance);
} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
accessCache[key] = 4;
return ctx[key];
} else if (globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)) {
{
return globalProperties[key];
}
- } else
- ;
+ } else if (currentRenderingInstance && (!isString$1(key) || key.indexOf("__v") !== 0)) {
+ if (data2 !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data2, key)) {
+ warn(
+ `Property ${JSON.stringify(
+ key
+ )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+ );
+ } else if (instance === currentRenderingInstance) {
+ warn(
+ `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
+ );
+ }
+ }
},
set({
_: instance
}, key, value) {
const {
data: data2,
setupState,
ctx
} = instance;
if (hasSetupBinding(setupState, key)) {
setupState[key] = value;
return true;
+ } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
+ warn(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+ return false;
} else if (data2 !== EMPTY_OBJ && hasOwn(data2, key)) {
data2[key] = value;
return true;
} else if (hasOwn(instance.props, key)) {
+ warn(`Attempting to mutate prop "${key}". Props are readonly.`);
return false;
}
if (key[0] === "$" && key.slice(1) in instance) {
+ warn(
+ `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
+ );
return false;
} else {
- {
+ if (key in instance.appContext.config.globalProperties) {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ value
+ });
+ } else {
ctx[key] = value;
}
}
return true;
},
has({
_: {
@@ -4101,20 +4830,99 @@
target._.accessCache[key] = 0;
} else if (hasOwn(descriptor, "value")) {
this.set(target, key, descriptor.value, null);
}
return Reflect.defineProperty(target, key, descriptor);
}
};
+{
+ PublicInstanceProxyHandlers.ownKeys = (target) => {
+ warn(
+ `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+ );
+ return Reflect.ownKeys(target);
+ };
+}
+
+function createDevRenderContext(instance) {
+ const target = {};
+ Object.defineProperty(target, `_`, {
+ configurable: true,
+ enumerable: false,
+ get: () => instance
+ });
+ Object.keys(publicPropertiesMap).forEach((key) => {
+ Object.defineProperty(target, key, {
+ configurable: true,
+ enumerable: false,
+ get: () => publicPropertiesMap[key](instance),
+ set: NOOP
+ });
+ });
+ return target;
+}
+
+function exposePropsOnRenderContext(instance) {
+ const {
+ ctx,
+ propsOptions: [propsOptions]
+ } = instance;
+ if (propsOptions) {
+ Object.keys(propsOptions).forEach((key) => {
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => instance.props[key],
+ set: NOOP
+ });
+ });
+ }
+}
+
+function exposeSetupStateOnRenderContext(instance) {
+ const {
+ ctx,
+ setupState
+ } = instance;
+ Object.keys(toRaw(setupState)).forEach((key) => {
+ if (!setupState.__isScriptSetup) {
+ if (isReservedPrefix(key[0])) {
+ warn(
+ `setup() return property ${JSON.stringify(
+ key
+ )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
+ );
+ return;
+ }
+ Object.defineProperty(ctx, key, {
+ enumerable: true,
+ configurable: true,
+ get: () => setupState[key],
+ set: NOOP
+ });
+ }
+ });
+}
function normalizePropsOrEmits(props) {
return isArray$1(props) ? props.reduce(
(normalized, p2) => (normalized[p2] = null, normalized), {}
) : props;
}
+
+function createDuplicateChecker() {
+ const cache = /* @__PURE__ */ Object.create(null);
+ return (type, key) => {
+ if (cache[key]) {
+ warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
+ } else {
+ cache[key] = type;
+ }
+ };
+}
let shouldCacheAccess = true;
function applyOptions(instance) {
const options = resolveMergedOptions(instance);
const publicThis = instance.proxy;
const ctx = instance.ctx;
shouldCacheAccess = false;
@@ -4146,52 +4954,104 @@
serverPrefetch,
expose,
inheritAttrs,
components,
directives,
filters
} = options;
- const checkDuplicateProperties = null;
+ const checkDuplicateProperties = createDuplicateChecker();
+ {
+ const [propsOptions] = instance.propsOptions;
+ if (propsOptions) {
+ for (const key in propsOptions) {
+ checkDuplicateProperties("Props", key);
+ }
+ }
+ }
if (injectOptions) {
resolveInjections(injectOptions, ctx, checkDuplicateProperties);
}
if (methods) {
for (const key in methods) {
const methodHandler = methods[key];
if (isFunction$1(methodHandler)) {
{
- ctx[key] = methodHandler.bind(publicThis);
+ Object.defineProperty(ctx, key, {
+ value: methodHandler.bind(publicThis),
+ configurable: true,
+ enumerable: true,
+ writable: true
+ });
+ } {
+ checkDuplicateProperties("Methods", key);
}
+ } else {
+ warn(
+ `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+ );
}
}
}
if (dataOptions) {
+ if (!isFunction$1(dataOptions)) {
+ warn(
+ `The data option must be a function. Plain object usage is no longer supported.`
+ );
+ }
const data2 = dataOptions.call(publicThis, publicThis);
- if (!isObject$2(data2))
- ;
- else {
+ if (isPromise(data2)) {
+ warn(
+ `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
+ );
+ }
+ if (!isObject$2(data2)) {
+ warn(`data() should return an object.`);
+ } else {
instance.data = reactive(data2);
+ {
+ for (const key in data2) {
+ checkDuplicateProperties("Data", key);
+ if (!isReservedPrefix(key[0])) {
+ Object.defineProperty(ctx, key, {
+ configurable: true,
+ enumerable: true,
+ get: () => data2[key],
+ set: NOOP
+ });
+ }
+ }
+ }
}
}
shouldCacheAccess = true;
if (computedOptions) {
for (const key in computedOptions) {
const opt = computedOptions[key];
const get2 = isFunction$1(opt) ? opt.bind(publicThis, publicThis) : isFunction$1(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
- const set2 = !isFunction$1(opt) && isFunction$1(opt.set) ? opt.set.bind(publicThis) : NOOP;
+ if (get2 === NOOP) {
+ warn(`Computed property "${key}" has no getter.`);
+ }
+ const set2 = !isFunction$1(opt) && isFunction$1(opt.set) ? opt.set.bind(publicThis) : () => {
+ warn(
+ `Write operation failed: computed property "${key}" is readonly.`
+ );
+ };
const c = computed({
get: get2,
set: set2
});
Object.defineProperty(ctx, key, {
enumerable: true,
configurable: true,
get: () => c.value,
set: (v) => c.value = v
});
+ {
+ checkDuplicateProperties("Computed", key);
+ }
}
}
if (watchOptions) {
for (const key in watchOptions) {
createWatcher(watchOptions[key], ctx, publicThis, key);
}
}
@@ -4274,14 +5134,16 @@
enumerable: true,
configurable: true,
get: () => injected.value,
set: (v) => injected.value = v
});
} else {
ctx[key] = injected;
+ } {
+ checkDuplicateProperties("Inject", key);
}
}
}
function callHook(hook, instance, type) {
callWithAsyncErrorHandling(
isArray$1(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
@@ -4292,28 +5154,33 @@
function createWatcher(raw, ctx, publicThis, key) {
const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
if (isString$1(raw)) {
const handler = ctx[raw];
if (isFunction$1(handler)) {
watch(getter, handler);
+ } else {
+ warn(`Invalid watch handler specified by key "${raw}"`, handler);
}
} else if (isFunction$1(raw)) {
watch(getter, raw.bind(publicThis));
} else if (isObject$2(raw)) {
if (isArray$1(raw)) {
raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
} else {
const handler = isFunction$1(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
if (isFunction$1(handler)) {
watch(getter, handler, raw);
+ } else {
+ warn(`Invalid watch handler specified by key "${raw.handler}"`, handler);
}
}
- } else
- ;
+ } else {
+ warn(`Invalid watch option: "${key}"`, raw);
+ }
}
function resolveMergedOptions(instance) {
const base = instance.type;
const {
mixins,
extends: extendsOptions
@@ -4358,17 +5225,19 @@
}
if (mixins) {
mixins.forEach(
(m) => mergeOptions(to, m, strats, true)
);
}
for (const key in from) {
- if (asMixin && key === "expose")
- ;
- else {
+ if (asMixin && key === "expose") {
+ warn(
+ `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
+ );
+ } else {
const strat = internalOptionMergeStrats[key] || strats && strats[key];
to[key] = strat ? strat(to[key], from[key]) : from[key];
}
}
return to;
}
const internalOptionMergeStrats = {
@@ -4489,91 +5358,160 @@
function createAppAPI(render, hydrate) {
return function createApp2(rootComponent, rootProps = null) {
if (!isFunction$1(rootComponent)) {
rootComponent = extend$2({}, rootComponent);
}
if (rootProps != null && !isObject$2(rootProps)) {
+ warn(`root props passed to app.mount() must be an object.`);
rootProps = null;
}
const context = createAppContext();
+ {
+ Object.defineProperty(context.config, "unwrapInjectedRef", {
+ get() {
+ return true;
+ },
+ set() {
+ warn(
+ `app.config.unwrapInjectedRef has been deprecated. 3.3 now alawys unwraps injected refs in Options API.`
+ );
+ }
+ });
+ }
const installedPlugins = /* @__PURE__ */ new Set();
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) {},
+ set config(v) {
+ {
+ warn(
+ `app.config cannot be replaced. Modify individual options instead.`
+ );
+ }
+ },
use(plugin2, ...options) {
- if (installedPlugins.has(plugin2))
- ;
- else if (plugin2 && isFunction$1(plugin2.install)) {
+ if (installedPlugins.has(plugin2)) {
+ warn(`Plugin has already been applied to target app.`);
+ } else if (plugin2 && isFunction$1(plugin2.install)) {
installedPlugins.add(plugin2);
plugin2.install(app, ...options);
} else if (isFunction$1(plugin2)) {
installedPlugins.add(plugin2);
plugin2(app, ...options);
- } else
- ;
+ } else {
+ warn(
+ `A plugin must either be a function or an object with an "install" function.`
+ );
+ }
return app;
},
mixin(mixin) {
{
if (!context.mixins.includes(mixin)) {
context.mixins.push(mixin);
+ } else {
+ warn(
+ "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+ );
}
}
return app;
},
component(name, component) {
+ {
+ validateComponentName(name, context.config);
+ }
if (!component) {
return context.components[name];
}
+ if (context.components[name]) {
+ warn(`Component "${name}" has already been registered in target app.`);
+ }
context.components[name] = component;
return app;
},
directive(name, directive) {
+ {
+ validateDirectiveName(name);
+ }
if (!directive) {
return context.directives[name];
}
+ if (context.directives[name]) {
+ warn(`Directive "${name}" has already been registered in target app.`);
+ }
context.directives[name] = directive;
return app;
},
mount(rootContainer, isHydrate, isSVG) {
if (!isMounted) {
+ if (rootContainer.__vue_app__) {
+ warn(
+ `There is already an app instance mounted on the host container.
+ If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
+ );
+ }
const vnode = createVNode(
rootComponent,
rootProps
);
vnode.appContext = context;
+ {
+ context.reload = () => {
+ render(cloneVNode(vnode), rootContainer, isSVG);
+ };
+ }
if (isHydrate && hydrate) {
hydrate(vnode, rootContainer);
} else {
render(vnode, rootContainer, isSVG);
}
isMounted = true;
app._container = rootContainer;
rootContainer.__vue_app__ = app;
+ {
+ app._instance = vnode.component;
+ devtoolsInitApp(app, version);
+ }
return getExposeProxy(vnode.component) || vnode.component.proxy;
+ } else {
+ warn(
+ `App has already been mounted.
+If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
+ );
}
},
unmount() {
if (isMounted) {
render(null, app._container);
+ {
+ app._instance = null;
+ devtoolsUnmountApp(app);
+ }
delete app._container.__vue_app__;
+ } else {
+ warn(`Cannot unmount an app that is not mounted.`);
}
},
provide(key, value) {
+ if (key in context.provides) {
+ warn(
+ `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+ );
+ }
context.provides[key] = value;
return app;
},
runWithContext(fn) {
currentApp = app;
try {
return fn();
@@ -4584,17 +5522,19 @@
};
return app;
};
}
let currentApp = null;
function provide(key, value) {
- if (!currentInstance)
- ;
- else {
+ if (!currentInstance) {
+ {
+ warn(`provide() can only be used inside setup().`);
+ }
+ } else {
let provides = currentInstance.provides;
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
if (parentProvides === provides) {
provides = currentInstance.provides = Object.create(parentProvides);
}
provides[key] = value;
}
@@ -4604,54 +5544,67 @@
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$1(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
- } else
- ;
+ } else {
+ warn(`injection "${String(key)}" not found.`);
+ }
+ } else {
+ warn(`inject() can only be used inside setup() or functional components.`);
}
}
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;
}
+ } {
+ validateProps(rawProps || {}, props, instance);
}
if (isStateful) {
instance.props = isSSR ? props : shallowReactive(props);
} else {
if (!instance.type.props) {
instance.props = attrs;
} else {
instance.props = props;
}
}
instance.attrs = attrs;
}
+function isInHmrContext(instance) {
+ while (instance) {
+ if (instance.type.__hmrId)
+ return true;
+ instance = instance.parent;
+ }
+}
+
function updateProps(instance, rawProps, rawPrevProps, optimized) {
const {
props,
attrs,
vnode: {
patchFlag
}
} = instance;
const rawCurrentProps = toRaw(props);
const [options] = instance.propsOptions;
let hasAttrsChanged = false;
- if ((optimized || patchFlag > 0) && !(patchFlag & 16)) {
+ if (!isInHmrContext(instance) && (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;
}
@@ -4711,14 +5664,16 @@
hasAttrsChanged = true;
}
}
}
}
if (hasAttrsChanged) {
trigger(instance, "set", "$attrs");
+ } {
+ validateProps(rawProps || {}, props, instance);
}
}
function setFullProps(instance, rawProps, props, attrs) {
const [options, needCastKeys] = instance.propsOptions;
let hasAttrsChanged = false;
let rawCastValues;
@@ -4828,20 +5783,26 @@
if (isObject$2(comp)) {
cache.set(comp, EMPTY_ARR);
}
return EMPTY_ARR;
}
if (isArray$1(raw)) {
for (let i = 0; i < raw.length; i++) {
+ if (!isString$1(raw[i])) {
+ warn(`props must be strings when using array syntax.`, raw[i]);
+ }
const normalizedKey = camelize(raw[i]);
if (validatePropName(normalizedKey)) {
normalized[normalizedKey] = EMPTY_OBJ;
}
}
} else if (raw) {
+ if (!isObject$2(raw)) {
+ warn(`invalid props options`, raw);
+ }
for (const key in raw) {
const normalizedKey = camelize(key);
if (validatePropName(normalizedKey)) {
const opt = raw[key];
const prop = normalized[normalizedKey] = isArray$1(opt) || isFunction$1(opt) ? {
type: opt
} : extend$2({}, opt);
@@ -4863,14 +5824,16 @@
}
return res;
}
function validatePropName(key) {
if (key[0] !== "$") {
return true;
+ } else {
+ warn(`Invalid prop name: "${key}" is a reserved property.`);
}
return false;
}
function getType(ctor) {
const match2 = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
return match2 ? match2[2] : ctor === null ? "null" : "";
@@ -4884,43 +5847,170 @@
if (isArray$1(expectedTypes)) {
return expectedTypes.findIndex((t) => isSameType(t, type));
} else if (isFunction$1(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1;
}
return -1;
}
+
+function validateProps(rawProps, props, instance) {
+ const resolvedValues = toRaw(props);
+ const options = instance.propsOptions[0];
+ for (const key in options) {
+ let opt = options[key];
+ if (opt == null)
+ continue;
+ validateProp(
+ key,
+ resolvedValues[key],
+ opt,
+ !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))
+ );
+ }
+}
+
+function validateProp(name, value, prop, isAbsent) {
+ const {
+ type,
+ required,
+ validator: validator2,
+ skipCheck
+ } = prop;
+ if (required && isAbsent) {
+ warn('Missing required prop: "' + name + '"');
+ return;
+ }
+ if (value == null && !required) {
+ return;
+ }
+ if (type != null && type !== true && !skipCheck) {
+ let isValid = false;
+ const types = isArray$1(type) ? type : [type];
+ const expectedTypes = [];
+ for (let i = 0; i < types.length && !isValid; i++) {
+ const {
+ valid,
+ expectedType
+ } = assertType(value, types[i]);
+ expectedTypes.push(expectedType || "");
+ isValid = valid;
+ }
+ if (!isValid) {
+ warn(getInvalidTypeMessage(name, value, expectedTypes));
+ return;
+ }
+ }
+ if (validator2 && !validator2(value)) {
+ warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+ }
+}
+const isSimpleType = /* @__PURE__ */ makeMap(
+ "String,Number,Boolean,Function,Symbol,BigInt"
+);
+
+function assertType(value, type) {
+ let valid;
+ const expectedType = getType(type);
+ if (isSimpleType(expectedType)) {
+ const t = typeof value;
+ valid = t === expectedType.toLowerCase();
+ if (!valid && t === "object") {
+ valid = value instanceof type;
+ }
+ } else if (expectedType === "Object") {
+ valid = isObject$2(value);
+ } else if (expectedType === "Array") {
+ valid = isArray$1(value);
+ } else if (expectedType === "null") {
+ valid = value === null;
+ } else {
+ valid = value instanceof type;
+ }
+ return {
+ valid,
+ expectedType
+ };
+}
+
+function getInvalidTypeMessage(name, value, expectedTypes) {
+ let message = `Invalid prop: type check failed for prop "${name}". Expected ${expectedTypes.map(capitalize).join(" | ")}`;
+ const expectedType = expectedTypes[0];
+ const receivedType = toRawType(value);
+ const expectedValue = styleValue(value, expectedType);
+ const receivedValue = styleValue(value, receivedType);
+ if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+ message += ` with value ${expectedValue}`;
+ }
+ message += `, got ${receivedType} `;
+ if (isExplicable(receivedType)) {
+ message += `with value ${receivedValue}.`;
+ }
+ return message;
+}
+
+function styleValue(value, type) {
+ if (type === "String") {
+ return `"${value}"`;
+ } else if (type === "Number") {
+ return `${Number(value)}`;
+ } else {
+ return `${value}`;
+ }
+}
+
+function isExplicable(type) {
+ const explicitTypes = ["string", "number", "boolean"];
+ return explicitTypes.some((elem) => type.toLowerCase() === elem);
+}
+
+function isBoolean(...args) {
+ return args.some((elem) => elem.toLowerCase() === "boolean");
+}
const isInternalKey = (key) => key[0] === "_" || key === "$stable";
const normalizeSlotValue = (value) => isArray$1(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
const normalizeSlot = (key, rawSlot, ctx) => {
if (rawSlot._n) {
return rawSlot;
}
const normalized = withCtx((...args) => {
- if (false)
- ;
+ if (currentInstance) {
+ warn(
+ `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
+ );
+ }
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$1(value)) {
slots[key] = normalizeSlot(key, value, ctx);
} else if (value != null) {
+ {
+ warn(
+ `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
+ );
+ }
const normalized = normalizeSlotValue(value);
slots[key] = () => normalized;
}
}
};
const normalizeVNodeSlots = (instance, children) => {
+ if (!isKeepAlive(instance.vnode) && true) {
+ warn(
+ `Non-function value encountered for default slot. Prefer function slots for better performance.`
+ );
+ }
const normalized = normalizeSlotValue(children);
instance.slots.default = () => normalized;
};
const initSlots = (instance, children) => {
if (instance.vnode.shapeFlag & 32) {
const type = children._;
if (type) {
@@ -4946,15 +6036,18 @@
slots
} = instance;
let needDeletionCheck = true;
let deletionComparisonTarget = EMPTY_OBJ;
if (vnode.shapeFlag & 32) {
const type = children._;
if (type) {
- if (optimized && type === 1) {
+ if (isHmrUpdating) {
+ extend$2(slots, children);
+ trigger(instance, "set", "$slots");
+ } else if (optimized && type === 1) {
needDeletionCheck = false;
} else {
extend$2(slots, children);
if (!optimized && type === 1) {
delete slots._;
}
}
@@ -4996,14 +6089,20 @@
}
const refValue = vnode.shapeFlag & 4 ? getExposeProxy(vnode.component) || vnode.component.proxy : vnode.el;
const value = isUnmount ? null : refValue;
const {
i: owner,
r: ref
} = rawRef;
+ if (!owner) {
+ warn(
+ `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`
+ );
+ return;
+ }
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$1(oldRef)) {
refs[oldRef] = null;
if (hasOwn(setupState, oldRef)) {
@@ -5045,50 +6144,111 @@
if (hasOwn(setupState, ref)) {
setupState[ref] = value;
}
} else if (_isRef) {
ref.value = value;
if (rawRef.k)
refs[rawRef.k] = value;
- } else
- ;
+ } else {
+ warn("Invalid template ref type:", ref, `(${typeof ref})`);
+ }
};
if (value) {
doSet.id = -1;
queuePostRenderEffect(doSet, parentSuspense);
} else {
doSet();
}
+ } else {
+ warn("Invalid template ref type:", ref, `(${typeof ref})`);
}
}
}
+let supported;
+let perf;
+
+function startMeasure(instance, type) {
+ if (instance.appContext.config.performance && isSupported()) {
+ perf.mark(`vue-${type}-${instance.uid}`);
+ } {
+ devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+ }
+}
+
+function endMeasure(instance, type) {
+ if (instance.appContext.config.performance && isSupported()) {
+ const startTag = `vue-${type}-${instance.uid}`;
+ const endTag = startTag + `:end`;
+ perf.mark(endTag);
+ perf.measure(
+ `<${formatComponentName(instance, instance.type)}> ${type}`,
+ startTag,
+ endTag
+ );
+ perf.clearMarks(startTag);
+ perf.clearMarks(endTag);
+ } {
+ devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+ }
+}
+
+function isSupported() {
+ if (supported !== void 0) {
+ return supported;
+ }
+ if (typeof window !== "undefined" && window.performance) {
+ supported = true;
+ perf = window.performance;
+ } else {
+ supported = false;
+ }
+ return supported;
+}
+
+function initFeatureFlags() {
+ const needWarn = [];
+ if (needWarn.length) {
+ const multi = needWarn.length > 1;
+ console.warn(
+ `Feature flag${multi ? `s` : ``} ${needWarn.join(", ")} ${multi ? `are` : `is`} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.
+
+For more details, see https://link.vuejs.org/feature-flags.`
+ );
+ }
+}
const queuePostRenderEffect = queueEffectWithSuspense;
function createRenderer(options) {
return baseCreateRenderer(options);
}
function baseCreateRenderer(options, createHydrationFns) {
+ {
+ initFeatureFlags();
+ }
const target = getGlobalThis();
target.__VUE__ = true;
+ {
+ setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+ }
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) => {
+ const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = isHmrUpdating ? false : !!n2.dynamicChildren) => {
if (n1 === n2) {
return;
}
if (n1 && !isSameVNodeType(n1, n2)) {
anchor = getNextHostNode(n1);
unmount(n1, parentComponent, parentSuspense, true);
n1 = null;
@@ -5108,14 +6268,16 @@
break;
case Comment:
processCommentNode(n1, n2, container, anchor);
break;
case Static:
if (n1 == null) {
mountStaticNode(n2, container, anchor, isSVG);
+ } else {
+ patchStaticNode(n1, n2, container, isSVG);
}
break;
case Fragment:
processFragment(
n1,
n2,
container,
@@ -5174,16 +6336,17 @@
parentComponent,
parentSuspense,
isSVG,
slotScopeIds,
optimized,
internals
);
- } else
- ;
+ } else {
+ warn("Invalid VNode type:", type, `(${typeof type})`);
+ }
}
if (ref != null && parentComponent) {
setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
}
};
const processText = (n1, n2, container, anchor) => {
if (n1 == null) {
@@ -5216,14 +6379,29 @@
container,
anchor,
isSVG,
n2.el,
n2.anchor
);
};
+ const patchStaticNode = (n1, n2, container, isSVG) => {
+ if (n2.children !== n1.children) {
+ const anchor = hostNextSibling(n1.anchor);
+ removeStaticNode(n1);
+ [n2.el, n2.anchor] = hostInsertStaticContent(
+ n2.children,
+ container,
+ anchor,
+ isSVG
+ );
+ } else {
+ n2.el = n1.el;
+ n2.anchor = n1.anchor;
+ }
+ };
const moveStaticNode = ({
el,
anchor
}, container, nextSibling) => {
let next;
while (el && el !== anchor) {
next = hostNextSibling(el);
@@ -5321,14 +6499,23 @@
}
if ("value" in props) {
hostPatchProp(el, "value", null, props.value);
}
if (vnodeHook = props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHook, parentComponent, vnode);
}
+ } {
+ Object.defineProperty(el, "__vnode", {
+ value: vnode,
+ enumerable: false
+ });
+ Object.defineProperty(el, "__vueParentComponent", {
+ value: parentComponent,
+ enumerable: false
+ });
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
const needCallTransitionHooks = (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
if (needCallTransitionHooks) {
transition.beforeEnter(el);
@@ -5349,14 +6536,17 @@
if (slotScopeIds) {
for (let i = 0; i < slotScopeIds.length; i++) {
hostSetScopeId(el, slotScopeIds[i]);
}
}
if (parentComponent) {
let subTree = parentComponent.subTree;
+ if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
+ subTree = filterSingleRoot(subTree.children) || subTree;
+ }
if (vnode === subTree) {
const parentVNode = parentComponent.vnode;
setScopeId(
el,
parentVNode,
parentVNode.scopeId,
parentVNode.slotScopeIds,
@@ -5396,25 +6586,33 @@
if (vnodeHook = newProps.onVnodeBeforeUpdate) {
invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
}
if (dirs) {
invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
}
parentComponent && toggleRecurse(parentComponent, true);
+ if (isHmrUpdating) {
+ patchFlag = 0;
+ optimized = false;
+ dynamicChildren = null;
+ }
const areChildrenSVG = isSVG && n2.type !== "foreignObject";
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
el,
parentComponent,
parentSuspense,
areChildrenSVG,
slotScopeIds
);
+ {
+ traverseStaticChildren(n1, n2);
+ }
} else if (!optimized) {
patchChildren(
n1,
n2,
el,
null,
parentComponent,
@@ -5554,14 +6752,19 @@
const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
let {
patchFlag,
dynamicChildren,
slotScopeIds: fragmentSlotScopeIds
} = n2;
+ if (isHmrUpdating || patchFlag & 2048) {
+ patchFlag = 0;
+ optimized = false;
+ dynamicChildren = null;
+ }
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
if (n1 == null) {
hostInsert(fragmentStartAnchor, container, anchor);
hostInsert(fragmentEndAnchor, container, anchor);
mountChildren(
@@ -5581,20 +6784,16 @@
dynamicChildren,
container,
parentComponent,
parentSuspense,
isSVG,
slotScopeIds
);
- if (n2.key != null || parentComponent && n2 === parentComponent.subTree) {
- traverseStaticChildren(
- n1,
- n2,
- true
- );
+ {
+ traverseStaticChildren(n1, n2);
}
} else {
patchChildren(
n1,
n2,
container,
fragmentEndAnchor,
@@ -5635,18 +6834,30 @@
};
const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => {
const instance = initialVNode.component = createComponentInstance(
initialVNode,
parentComponent,
parentSuspense
);
+ if (instance.type.__hmrId) {
+ registerHMR(instance);
+ } {
+ pushWarningContext(initialVNode);
+ startMeasure(instance, `mount`);
+ }
if (isKeepAlive(initialVNode)) {
instance.ctx.renderer = internals;
} {
+ {
+ startMeasure(instance, `init`);
+ }
setupComponent(instance);
+ {
+ endMeasure(instance, `init`);
+ }
}
if (instance.asyncDep) {
parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect);
if (!initialVNode.el) {
const placeholder = instance.subTree = createVNode(Comment);
processCommentNode(null, placeholder, container, anchor);
}
@@ -5657,20 +6868,30 @@
initialVNode,
container,
anchor,
parentSuspense,
isSVG,
optimized
);
+ {
+ popWarningContext();
+ endMeasure(instance, `mount`);
+ }
};
const updateComponent = (n1, n2, optimized) => {
const instance = n2.component = n1.component;
if (shouldUpdateComponent(n1, n2, optimized)) {
if (instance.asyncDep && !instance.asyncResolved) {
+ {
+ pushWarningContext(n2);
+ }
updateComponentPreRender(instance, n2, optimized);
+ {
+ popWarningContext();
+ }
return;
} else {
instance.next = n2;
invalidateJob(instance.update);
instance.update();
}
} else {
@@ -5698,41 +6919,63 @@
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHook, parent, initialVNode);
}
toggleRecurse(instance, true);
if (el && hydrateNode) {
const hydrateSubTree = () => {
+ {
+ startMeasure(instance, `render`);
+ }
instance.subTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ } {
+ startMeasure(instance, `hydrate`);
+ }
hydrateNode(
el,
instance.subTree,
instance,
parentSuspense,
null
);
+ {
+ endMeasure(instance, `hydrate`);
+ }
};
if (isAsyncWrapperVNode) {
initialVNode.type.__asyncLoader().then(
() => !instance.isUnmounted && hydrateSubTree()
);
} else {
hydrateSubTree();
}
} else {
+ {
+ startMeasure(instance, `render`);
+ }
const subTree = instance.subTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ } {
+ startMeasure(instance, `patch`);
+ }
patch(
null,
subTree,
container,
anchor,
instance,
parentSuspense,
isSVG
);
+ {
+ endMeasure(instance, `patch`);
+ }
initialVNode.el = subTree.el;
}
if (m) {
queuePostRenderEffect(m, parentSuspense);
}
if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
const scopedInitialVNode = initialVNode;
@@ -5741,74 +6984,101 @@
parentSuspense
);
}
if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
instance.a && queuePostRenderEffect(instance.a, parentSuspense);
}
instance.isMounted = true;
+ {
+ devtoolsComponentAdded(instance);
+ }
initialVNode = container = anchor = null;
} else {
let {
next,
bu,
u,
parent,
vnode
} = instance;
let originNext = next;
let vnodeHook;
+ {
+ pushWarningContext(next || instance.vnode);
+ }
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);
}
toggleRecurse(instance, true);
+ {
+ startMeasure(instance, `render`);
+ }
const nextTree = renderComponentRoot(instance);
+ {
+ endMeasure(instance, `render`);
+ }
const prevTree = instance.subTree;
instance.subTree = nextTree;
+ {
+ startMeasure(instance, `patch`);
+ }
patch(
prevTree,
nextTree,
hostParentNode(prevTree.el),
getNextHostNode(prevTree),
instance,
parentSuspense,
isSVG
);
+ {
+ endMeasure(instance, `patch`);
+ }
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
);
+ } {
+ devtoolsComponentUpdated(instance);
+ } {
+ popWarningContext();
}
}
};
const effect = instance.effect = new ReactiveEffect(
componentUpdateFn,
() => queueJob(update),
instance.scope
);
const update = instance.update = () => effect.run();
update.id = instance.uid;
toggleRecurse(instance, true);
+ {
+ effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
+ effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
+ update.ownerInstance = instance;
+ }
update();
};
const updateComponentPreRender = (instance, nextVNode, optimized) => {
nextVNode.component = instance;
const prevProps = instance.vnode.props;
instance.vnode = nextVNode;
instance.next = null;
@@ -6015,14 +7285,21 @@
} 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) {
+ if (keyToNewIndexMap.has(nextChild.key)) {
+ warn(
+ `Duplicate keys found during update:`,
+ JSON.stringify(nextChild.key),
+ `Make sure keys are unique.`
+ );
+ }
keyToNewIndexMap.set(nextChild.key, i);
}
}
let j;
let patched = 0;
const toBePatched = e2 - s2 + 1;
let moved = false;
@@ -6228,15 +7505,23 @@
const {
type,
el,
anchor,
transition
} = vnode;
if (type === Fragment) {
- {
+ if (vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
+ vnode.children.forEach((child) => {
+ if (child.type === Comment) {
+ hostRemove(child.el);
+ } else {
+ remove2(child);
+ }
+ });
+ } else {
removeFragment(el, anchor);
}
return;
}
if (type === Static) {
removeStaticNode(vnode);
return;
@@ -6268,14 +7553,17 @@
next = hostNextSibling(cur);
hostRemove(cur);
cur = next;
}
hostRemove(end);
};
const unmountComponent = (instance, parentSuspense, doRemove) => {
+ if (instance.type.__hmrId) {
+ unregisterHMR(instance);
+ }
const {
bum,
scope,
update,
subTree,
um
} = instance;
@@ -6294,14 +7582,16 @@
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();
}
+ } {
+ devtoolsComponentRemoved(instance);
}
};
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);
}
};
@@ -6373,14 +7663,17 @@
}
if (!shallow)
traverseStaticChildren(c1, c2);
}
if (c2.type === Text$1) {
c2.el = c1.el;
}
+ if (c2.type === Comment && !c2.el) {
+ c2.el = c1.el;
+ }
}
}
}
function getSequence(arr) {
const p2 = arr.slice();
const result = [0];
@@ -6480,16 +7773,26 @@
}
function isVNode(value) {
return value ? value.__v_isVNode === true : false;
}
function isSameVNodeType(n1, n2) {
+ if (n2.shapeFlag & 6 && hmrDirtyComponents.has(n2.type)) {
+ n1.shapeFlag &= ~256;
+ n2.shapeFlag &= ~512;
+ return false;
+ }
return n1.type === n2.type && n1.key === n2.key;
}
+const createVNodeWithArgsTransform = (...args) => {
+ return _createVNode(
+ ...args
+ );
+};
const InternalObjectKey = `__vInternal`;
const normalizeKey = ({
key
}) => key != null ? key : null;
const normalizeRef = ({
ref,
ref_key,
@@ -6539,23 +7842,29 @@
normalizeChildren(vnode, children);
if (shapeFlag & 128) {
type.normalize(vnode);
}
} else if (children) {
vnode.shapeFlag |= isString$1(children) ? 8 : 16;
}
+ if (vnode.key !== vnode.key) {
+ warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+ }
if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock && (vnode.patchFlag > 0 || shapeFlag & 6) && vnode.patchFlag !== 32) {
currentBlock.push(vnode);
}
return vnode;
}
-const createVNode = _createVNode;
+const createVNode = createVNodeWithArgsTransform;
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
if (!type || type === NULL_DYNAMIC_COMPONENT) {
+ if (!type) {
+ warn(`Invalid vnode type when creating vnode: ${type}.`);
+ }
type = Comment;
}
if (isVNode(type)) {
const cloned = cloneVNode(
type,
props,
true
@@ -6589,14 +7898,23 @@
if (isProxy(style) && !isArray$1(style)) {
style = extend$2({}, style);
}
props.style = normalizeStyle(style);
}
}
const shapeFlag = isString$1(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject$2(type) ? 4 : isFunction$1(type) ? 2 : 0;
+ if (shapeFlag & 4 && isProxy(type)) {
+ type = toRaw(type);
+ warn(
+ `Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
+ `
+Component that was made reactive: `,
+ type
+ );
+ }
return createBaseVNode(
type,
props,
children,
patchFlag,
dynamicProps,
shapeFlag,
@@ -6624,15 +7942,15 @@
__v_skip: true,
type: vnode.type,
props: mergedProps,
key: mergedProps && normalizeKey(mergedProps),
ref: extraProps && extraProps.ref ? mergeRef && ref ? isArray$1(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps) : ref,
scopeId: vnode.scopeId,
slotScopeIds: vnode.slotScopeIds,
- children,
+ children: patchFlag === -1 && isArray$1(children) ? children.map(deepCloneVNode) : children,
target: vnode.target,
targetAnchor: vnode.targetAnchor,
staticCount: vnode.staticCount,
shapeFlag: vnode.shapeFlag,
patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
dynamicProps: vnode.dynamicProps,
dynamicChildren: vnode.dynamicChildren,
@@ -6647,14 +7965,22 @@
anchor: vnode.anchor,
ctx: vnode.ctx,
ce: vnode.ce
};
return cloned;
}
+function deepCloneVNode(vnode) {
+ const cloned = cloneVNode(vnode);
+ if (isArray$1(vnode.children)) {
+ cloned.children = vnode.children.map(deepCloneVNode);
+ }
+ return cloned;
+}
+
function createTextVNode(text = " ", flag = 0) {
return createVNode(Text$1, null, text, flag);
}
function createCommentVNode(text = "", asBlock = false) {
return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
}
@@ -6826,17 +8152,15 @@
a: null,
rtg: null,
rtc: null,
ec: null,
sp: null
};
{
- instance.ctx = {
- _: instance
- };
+ instance.ctx = createDevRenderContext(instance);
}
instance.root = parent ? parent.root : instance;
instance.emit = emit.bind(null, instance);
if (vnode.ce) {
vnode.ce(instance);
}
return instance;
@@ -6862,14 +8186,24 @@
internalSetCurrentInstance(instance);
instance.scope.on();
};
const unsetCurrentInstance = () => {
currentInstance && currentInstance.scope.off();
internalSetCurrentInstance(null);
};
+const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
+
+function validateComponentName(name, config) {
+ const appIsNativeTag = config.isNativeTag || NO;
+ if (isBuiltInTag(name) || appIsNativeTag(name)) {
+ warn(
+ "Do not use built-in or reserved HTML elements as component id: " + name
+ );
+ }
+}
function isStatefulComponent(instance) {
return instance.vnode.shapeFlag & 4;
}
let isInSSRComponentSetup = false;
function setupComponent(instance, isSSR = false) {
@@ -6883,42 +8217,74 @@
initSlots(instance, children);
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
isInSSRComponentSetup = false;
return setupResult;
}
function setupStatefulComponent(instance, isSSR) {
+ var _a;
const Component = instance.type;
+ {
+ if (Component.name) {
+ validateComponentName(Component.name, instance.appContext.config);
+ }
+ if (Component.components) {
+ const names = Object.keys(Component.components);
+ for (let i = 0; i < names.length; i++) {
+ validateComponentName(names[i], instance.appContext.config);
+ }
+ }
+ if (Component.directives) {
+ const names = Object.keys(Component.directives);
+ for (let i = 0; i < names.length; i++) {
+ validateDirectiveName(names[i]);
+ }
+ }
+ if (Component.compilerOptions && isRuntimeOnly()) {
+ warn(
+ `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
+ );
+ }
+ }
instance.accessCache = /* @__PURE__ */ Object.create(null);
instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
+ {
+ exposePropsOnRenderContext(instance);
+ }
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]
+ [shallowReadonly(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;
+ if (!instance.suspense) {
+ const name = (_a = Component.name) != null ? _a : "Anonymous";
+ warn(
+ `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
+ );
+ }
}
} else {
handleSetupResult(instance, setupResult, isSSR);
}
} else {
finishComponentSetup(instance, isSSR);
}
@@ -6928,27 +8294,44 @@
if (isFunction$1(setupResult)) {
if (instance.type.__ssrInlineRender) {
instance.ssrRender = setupResult;
} else {
instance.render = setupResult;
}
} else if (isObject$2(setupResult)) {
+ if (isVNode(setupResult)) {
+ warn(
+ `setup() should not return VNodes directly - return a render function instead.`
+ );
+ } {
+ instance.devtoolsRawSetupState = setupResult;
+ }
instance.setupState = proxyRefs(setupResult);
- } else
- ;
+ {
+ exposeSetupStateOnRenderContext(instance);
+ }
+ } else if (setupResult !== void 0) {
+ warn(
+ `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
+ );
+ }
finishComponentSetup(instance, isSSR);
}
let compile;
+const isRuntimeOnly = () => !compile;
function finishComponentSetup(instance, isSSR, skipOptions) {
const Component = instance.type;
if (!instance.render) {
if (!isSSR && compile && !Component.render) {
const template2 = Component.template || resolveMergedOptions(instance).template;
if (template2) {
+ {
+ startMeasure(instance, `compile`);
+ }
const {
isCustomElement,
compilerOptions
} = instance.appContext.config;
const {
delimiters,
compilerOptions: componentCompilerOptions
@@ -6959,50 +8342,104 @@
delimiters
},
compilerOptions
),
componentCompilerOptions
);
Component.render = compile(template2, finalCompilerOptions);
+ {
+ endMeasure(instance, `compile`);
+ }
}
}
instance.render = Component.render || NOOP;
} {
setCurrentInstance(instance);
pauseTracking();
applyOptions(instance);
resetTracking();
unsetCurrentInstance();
}
+ if (!Component.render && instance.render === NOOP && !isSSR) {
+ if (Component.template) {
+ warn(
+ `Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".`
+ );
+ } else {
+ warn(`Component is missing template or render function.`);
+ }
+ }
}
function getAttrsProxy(instance) {
return instance.attrsProxy || (instance.attrsProxy = new Proxy(
instance.attrs, {
get(target, key) {
+ markAttrsAccessed();
track(instance, "get", "$attrs");
return target[key];
+ },
+ set() {
+ warn(`setupContext.attrs is readonly.`);
+ return false;
+ },
+ deleteProperty() {
+ warn(`setupContext.attrs is readonly.`);
+ return false;
}
}
));
}
+function getSlotsProxy(instance) {
+ return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+ get(target, key) {
+ track(instance, "get", "$slots");
+ return target[key];
+ }
+ }));
+}
+
function createSetupContext(instance) {
const expose = (exposed) => {
+ {
+ if (instance.exposed) {
+ warn(`expose() should be called only once per setup().`);
+ }
+ if (exposed != null) {
+ let exposedType = typeof exposed;
+ if (exposedType === "object") {
+ if (isArray$1(exposed)) {
+ exposedType = "array";
+ } else if (isRef(exposed)) {
+ exposedType = "ref";
+ }
+ }
+ if (exposedType !== "object") {
+ warn(
+ `expose() should be passed a plain object, received ${exposedType}.`
+ );
+ }
+ }
+ }
instance.exposed = exposed || {};
};
{
- return {
+ return Object.freeze({
get attrs() {
return getAttrsProxy(instance);
},
- slots: instance.slots,
- emit: instance.emit,
+ get slots() {
+ return getSlotsProxy(instance);
+ },
+ get emit() {
+ return (event, ...args) => instance.emit(event, ...args);
+ },
expose
- };
+ });
}
}
function getExposeProxy(instance) {
if (instance.exposed) {
return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
get(target, key) {
@@ -7014,32 +8451,252 @@
},
has(target, key) {
return key in target || key in publicPropertiesMap;
}
}));
}
}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
function getComponentName(Component, includeInferred = true) {
return isFunction$1(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
}
+function formatComponentName(instance, Component, isRoot = false) {
+ let name = getComponentName(Component);
+ if (!name && Component.__file) {
+ const match2 = Component.__file.match(/([^/\\]+)\.\w+$/);
+ if (match2) {
+ name = match2[1];
+ }
+ }
+ if (!name && instance && instance.parent) {
+ const inferFromRegistry = (registry2) => {
+ for (const key in registry2) {
+ if (registry2[key] === Component) {
+ return key;
+ }
+ }
+ };
+ name = inferFromRegistry(
+ instance.components || instance.parent.type.components
+ ) || inferFromRegistry(instance.appContext.components);
+ }
+ return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+
function isClassComponent(value) {
return isFunction$1(value) && "__vccOpts" in value;
}
const computed = (getterOrOptions, debugOptions) => {
return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
};
const ssrContextKey = Symbol.for("v-scx");
const useSSRContext = () => {
{
const ctx = inject(ssrContextKey);
+ if (!ctx) {
+ warn(
+ `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
+ );
+ }
return ctx;
}
};
+
+function isShallow(value) {
+ return !!(value && value["__v_isShallow"]);
+}
+
+function initCustomFormatter() {
+ if (typeof window === "undefined") {
+ return;
+ }
+ const vueStyle = {
+ style: "color:#3ba776"
+ };
+ const numberStyle = {
+ style: "color:#0b1bc9"
+ };
+ const stringStyle = {
+ style: "color:#b62e24"
+ };
+ const keywordStyle = {
+ style: "color:#9d288c"
+ };
+ const formatter = {
+ header(obj) {
+ if (!isObject$2(obj)) {
+ return null;
+ }
+ if (obj.__isVue) {
+ return ["div", vueStyle, `VueInstance`];
+ } else if (isRef(obj)) {
+ return [
+ "div", {},
+ ["span", vueStyle, genRefFlag(obj)],
+ "<",
+ formatValue(obj.value),
+ `>`
+ ];
+ } else if (isReactive(obj)) {
+ return [
+ "div", {},
+ ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+ "<",
+ formatValue(obj),
+ `>${isReadonly(obj) ? ` (readonly)` : ``}`
+ ];
+ } else if (isReadonly(obj)) {
+ return [
+ "div", {},
+ ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+ "<",
+ formatValue(obj),
+ ">"
+ ];
+ }
+ return null;
+ },
+ hasBody(obj) {
+ return obj && obj.__isVue;
+ },
+ body(obj) {
+ if (obj && obj.__isVue) {
+ return [
+ "div", {},
+ ...formatInstance(obj.$)
+ ];
+ }
+ }
+ };
+
+ function formatInstance(instance) {
+ const blocks = [];
+ if (instance.type.props && instance.props) {
+ blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+ }
+ if (instance.setupState !== EMPTY_OBJ) {
+ blocks.push(createInstanceBlock("setup", instance.setupState));
+ }
+ if (instance.data !== EMPTY_OBJ) {
+ blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+ }
+ const computed2 = extractKeys(instance, "computed");
+ if (computed2) {
+ blocks.push(createInstanceBlock("computed", computed2));
+ }
+ const injected = extractKeys(instance, "inject");
+ if (injected) {
+ blocks.push(createInstanceBlock("injected", injected));
+ }
+ blocks.push([
+ "div", {},
+ [
+ "span", {
+ style: keywordStyle.style + ";opacity:0.66"
+ },
+ "$ (internal): "
+ ],
+ ["object", {
+ object: instance
+ }]
+ ]);
+ return blocks;
+ }
+
+ function createInstanceBlock(type, target) {
+ target = extend$2({}, target);
+ if (!Object.keys(target).length) {
+ return ["span", {}];
+ }
+ return [
+ "div", {
+ style: "line-height:1.25em;margin-bottom:0.6em"
+ },
+ [
+ "div", {
+ style: "color:#476582"
+ },
+ type
+ ],
+ [
+ "div", {
+ style: "padding-left:1.25em"
+ },
+ ...Object.keys(target).map((key) => {
+ return [
+ "div", {},
+ ["span", keywordStyle, key + ": "],
+ formatValue(target[key], false)
+ ];
+ })
+ ]
+ ];
+ }
+
+ function formatValue(v, asRaw = true) {
+ if (typeof v === "number") {
+ return ["span", numberStyle, v];
+ } else if (typeof v === "string") {
+ return ["span", stringStyle, JSON.stringify(v)];
+ } else if (typeof v === "boolean") {
+ return ["span", keywordStyle, v];
+ } else if (isObject$2(v)) {
+ return ["object", {
+ object: asRaw ? toRaw(v) : v
+ }];
+ } else {
+ return ["span", stringStyle, String(v)];
+ }
+ }
+
+ function extractKeys(instance, type) {
+ const Comp = instance.type;
+ if (isFunction$1(Comp)) {
+ return;
+ }
+ const extracted = {};
+ for (const key in instance.ctx) {
+ if (isKeyOfType(Comp, key, type)) {
+ extracted[key] = instance.ctx[key];
+ }
+ }
+ return extracted;
+ }
+
+ function isKeyOfType(Comp, key, type) {
+ const opts = Comp[type];
+ if (isArray$1(opts) && opts.includes(key) || isObject$2(opts) && key in opts) {
+ return true;
+ }
+ if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+ return true;
+ }
+ if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+ return true;
+ }
+ }
+
+ function genRefFlag(v) {
+ if (isShallow(v)) {
+ return `ShallowRef`;
+ }
+ if (v.effect) {
+ return `ComputedRef`;
+ }
+ return `Ref`;
+ }
+ if (window.devtoolsFormatters) {
+ window.devtoolsFormatters.push(formatter);
+ } else {
+ window.devtoolsFormatters = [formatter];
+ }
+}
const version = "3.3.4";
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);
@@ -7138,22 +8795,30 @@
el.removeAttribute("style");
}
if ("_vod" in el) {
style.display = currentDisplay;
}
}
}
+const semicolonRE = /[^\\];\s*$/;
const importantRE = /\s*!important$/;
function setStyle(style, name, val) {
if (isArray$1(val)) {
val.forEach((v) => setStyle(style, name, v));
} else {
if (val == null)
val = "";
+ {
+ if (semicolonRE.test(val)) {
+ warn(
+ `Unexpected semicolon at the end of '${name}' style value: '${val}'`
+ );
+ }
+ }
if (name.startsWith("--")) {
style.setProperty(name, val);
} else {
const prefixed = autoPrefix(style, name);
if (importantRE.test(val)) {
style.setProperty(
hyphenate(prefixed),
@@ -7238,15 +8903,22 @@
} else if (type === "number") {
value = 0;
needRemove = true;
}
}
try {
el[key] = value;
- } catch (e) {}
+ } catch (e) {
+ if (!needRemove) {
+ warn(
+ `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`,
+ e
+ );
+ }
+ }
needRemove && el.removeAttribute(key);
}
function addEventListener(el, event, handler, options) {
el.addEventListener(event, handler, options);
}
@@ -7373,37 +9045,14 @@
return false;
}
if (nativeOnRE.test(key) && isString$1(value)) {
return false;
}
return key in el;
}
-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
-};
-/* @__PURE__ */
-extend$2({},
- BaseTransitionPropsValidators,
- DOMTransitionPropsValidators
-);
const getModelAssigner = (vnode) => {
const fn = vnode.props["onUpdate:modelValue"] || false;
return isArray$1(fn) ? (value) => invokeArrayFns(fn, value) : fn;
};
function onCompositionStart(e) {
e.target.composing = true;
@@ -7587,14 +9236,17 @@
setSelected(el, value);
}
};
function setSelected(el, value) {
const isMultiple = el.multiple;
if (isMultiple && !isArray$1(value) && !isSet(value)) {
+ warn(
+ `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
+ );
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$1(value)) {
@@ -7694,14 +9346,18 @@
let renderer;
function ensureRenderer() {
return renderer || (renderer = createRenderer(rendererOptions));
}
const createApp = (...args) => {
const app = ensureRenderer().createApp(...args);
+ {
+ injectNativeTagCheck(app);
+ injectCompilerOptionsCheck(app);
+ }
const {
mount
} = app;
app.mount = (containerOrSelector) => {
const container = normalizeContainer(containerOrSelector);
if (!container)
return;
@@ -7716,21 +9372,76 @@
container.setAttribute("data-v-app", "");
}
return proxy;
};
return app;
};
+function injectNativeTagCheck(app) {
+ Object.defineProperty(app.config, "isNativeTag", {
+ value: (tag) => isHTMLTag(tag) || isSVGTag(tag),
+ writable: false
+ });
+}
+
+function injectCompilerOptionsCheck(app) {
+ {
+ const isCustomElement = app.config.isCustomElement;
+ Object.defineProperty(app.config, "isCustomElement", {
+ get() {
+ return isCustomElement;
+ },
+ set() {
+ warn(
+ `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
+ );
+ }
+ });
+ const compilerOptions = app.config.compilerOptions;
+ const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
+- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
+- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
+- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
+ Object.defineProperty(app.config, "compilerOptions", {
+ get() {
+ warn(msg);
+ return compilerOptions;
+ },
+ set() {
+ warn(msg);
+ }
+ });
+ }
+}
+
function normalizeContainer(container) {
if (isString$1(container)) {
const res = document.querySelector(container);
+ if (!res) {
+ warn(
+ `Failed to mount app: mount target selector "${container}" returned null.`
+ );
+ }
return res;
}
+ if (window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") {
+ warn(
+ `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`
+ );
+ }
return container;
}
+
+function initDev() {
+ {
+ initCustomFormatter();
+ }
+} {
+ initDev();
+}
var _export_sfc = (sfc, props) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props) {
target[key] = val;
}
return target;
};
@@ -7816,18 +9527,19 @@
createBaseVNode("a", {
href: "#",
onClick: _cache[1] || (_cache[1] = withModifiers((...args) => $options.triggerNext && $options.triggerNext(...args), ["prevent"])),
class: "page-link"
}, toDisplayString(_ctx.$i18n("Next")), 1)
], 2)
])
- ])) : createCommentVNode("", true);
+ ])) : createCommentVNode("v-if", true);
}
var Pagination = /* @__PURE__ */ _export_sfc(_sfc_main$5, [
- ["render", _sfc_render$5]
+ ["render", _sfc_render$5],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/components/Pagination.vue"]
]);
const _sfc_main$4 = {
data() {
return {
searchTerm: "",
sortOn: "getObjPositionInParent",
sortOrder: "ascending",
@@ -7973,15 +9685,16 @@
onClick: _cache[5] || (_cache[5] = withModifiers((...args) => $options.reset && $options.reset(...args), ["stop", "prevent"])),
class: "btn btn-danger"
}, toDisplayString(_ctx.$i18n("Reset")), 1)
])
], 32);
}
var SearchForm = /* @__PURE__ */ _export_sfc(_sfc_main$4, [
- ["render", _sfc_render$4]
+ ["render", _sfc_render$4],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/components/searchForm.vue"]
]);
const _sfc_main$3 = {
props: {
breadcrumbs: {
type: Array,
required: true,
default: () => {
@@ -8058,15 +9771,16 @@
]))
], 64);
}), 128))
])
]);
}
var Breadcrumbs = /* @__PURE__ */ _export_sfc(_sfc_main$3, [
- ["render", _sfc_render$3]
+ ["render", _sfc_render$3],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/components/Breadcrumbs.vue"]
]);
const _sfc_main$2 = {
props: {
item: {
type: Object,
required: true,
default: () => {
@@ -8100,15 +9814,16 @@
}, null, 8, _hoisted_3$2)) : (openBlock(), createElementBlock("img", {
key: 2,
src: `${$props.item["@id"]}/@@iconresolver/${$props.iconMapping[$props.item["@type"]]}`
}, null, 8, _hoisted_4$2))
]);
}
var ResolveIcon = /* @__PURE__ */ _export_sfc(_sfc_main$2, [
- ["render", _sfc_render$2]
+ ["render", _sfc_render$2],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/components/ResolveIcon.vue"]
]);
const _sfc_main$1 = {
components: {
ResolveIcon
},
data() {
return {
@@ -8280,46 +9995,49 @@
]))
], 2)
], 2),
item["review_state"] ? (openBlock(), createElementBlock("span", _hoisted_7$1, [
createBaseVNode("span", {
class: normalizeClass(`state-${item["review_state"]}`)
}, toDisplayString($props.workflowTitleMapping[item["review_state"]]), 3)
- ])) : createCommentVNode("", true)
+ ])) : createCommentVNode("v-if", true)
]);
}), 128))
]);
}
var ListItems = /* @__PURE__ */ _export_sfc(_sfc_main$1, [
- ["render", _sfc_render$1]
+ ["render", _sfc_render$1],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/components/ListItems.vue"]
]);
const _sfc_main = {
components: {
Pagination,
SearchForm,
Breadcrumbs,
ListItems
},
data() {
return {
open: false,
portalURL: "",
baseURL: "",
startURL: "",
+ contextURL: "",
portalPath: "",
fieldName: "",
inputType: "",
data: {},
breadcrumbs: [],
selected: [],
selectableTypes: [],
traversableTypes: [],
iconMapping: {},
workflowTitleMapping: {},
additionalContextData: {},
+ explicitTypeFilter: [],
formData: {
searchTerm: "",
sortOn: "getObjPositionInParent",
sortOrder: "ascending"
}
};
},
@@ -8338,77 +10056,83 @@
);
this.selectableTypes = JSON.parse(
wrapperElement.getAttribute("data-selectabletypes")
);
this.traversableTypes = JSON.parse(
wrapperElement.getAttribute("data-traversabletypes")
);
+ this.explicitTypeFilter = JSON.parse(
+ wrapperElement.getAttribute("data-explicittypefilter")
+ );
this.loadSelectedItems(wrapperElement);
this.$refs.browser.addEventListener("show.bs.collapse", () => {
this.fetchData(this.startURL);
this.fetchWorkflowTitles();
this.open = true;
});
this.$refs.browser.addEventListener("hidden.bs.collapse", () => {
this.open = false;
});
},
methods: {
async fetchData(url, options) {
+ this.contextURL = url.replace("@search", "");
let params = {
metadata_fields: ["UID", "is_folderish", "portal_type", "mime_type"],
sort_on: this.formData.sortOn,
- sort_order: this.formData.sortOrder
+ sort_order: this.formData.sortOrder,
+ "path.query": new URL(url).pathname,
+ "path.depth": 1,
+ "portal_type.not": this.explicitTypeFilter
};
- if (!url) {
- url = this.data["@id"];
- }
const isSearch = url.indexOf("/@search") != -1;
+ if (!isSearch) {
+ url = url + "/@search";
+ }
if (options) {
params = Object.assign(params, options);
}
if (!isSearch) {
- params.expand = "breadcrumbs";
+ const breadcrumbs = await this.axios.get(
+ this.contextURL + "/@breadcrumbs"
+ );
+ this.breadcrumbs = breadcrumbs.data.items;
}
const response = await this.axios.get(url, {
params
});
this.data.items = response.data.items;
this.data.items_total = response.data.items_total;
this.data.batching = response.data.batching;
if (!isSearch) {
- this.data["@id"] = response.data["@id"];
- }
- if (response.data["@components"]) {
- this.breadcrumbs = response.data["@components"].breadcrumbs.items;
+ this.data["@id"] = url;
}
this.additionalContextData["review_state"] = response.data.review_state;
this.additionalContextData["review_state_title"] = this.workflowTitleMapping[response.data.review_state];
},
async fetchWorkflowTitles() {
const response = await this.axios.get(
this.portalURL + "/@vocabularies/plone.app.vocabularies.WorkflowStates"
);
response.data.items.forEach((item) => {
this.workflowTitleMapping[item.token] = item.title.replace(/(\[.+?\])/g, "").trim();
});
},
search(formData) {
this.formData = Object.assign({}, this.formData, formData);
- const url = this.data["@id"] + "/@search";
- const currentURL = new URL(this.data["@id"]);
+ const contextURL = new URL(this.contextURL);
let options = {
- "path.query": currentURL.pathname,
+ "path.query": contextURL.pathname,
"path.depth": 1
};
if (this.formData.searchTerm.length > 2) {
options.SearchableText = this.formData.searchTerm;
options["path.depth"] = -1;
}
- this.fetchData(url, options);
+ this.fetchData(this.contextURL, options);
},
reset(formData) {
this.formData = formData;
this.fetchData(this.startURL);
},
updateSelected(checked) {
this.selected = checked;
@@ -8489,15 +10213,15 @@
}, null, 8, ["breadcrumbs", "fetchData", "portalURL", "workflowTitleMapping", "additionalContextData"]),
$data.data.batching ? (openBlock(), createBlock(_component_Pagination, {
key: 0,
onNext: $options.fetchData,
onPrevious: $options.fetchData,
batching: $data.data.batching,
items_total: $data.data.items_total
- }, null, 8, ["onNext", "onPrevious", "batching", "items_total"])) : createCommentVNode("", true),
+ }, null, 8, ["onNext", "onPrevious", "batching", "items_total"])) : createCommentVNode("v-if", true),
createTextVNode(" " + toDisplayString(_ctx.$i18n("Total")) + " " + toDisplayString($data.data.items_total) + " ", 1),
createVNode(_component_ListItems, {
fetchData: $options.fetchData,
items: $data.data.items,
selectedItems: $data.selected,
inputType: $data.inputType,
selectableTypes: $data.selectableTypes,
@@ -8534,15 +10258,16 @@
"aria-expanded": "false",
"aria-controls": $options.browserName,
"data-bs-target": `#${$options.browserName}`
}, toDisplayString($options.buttonLable), 9, _hoisted_9)
], 512);
}
var App = /* @__PURE__ */ _export_sfc(_sfc_main, [
- ["render", _sfc_render]
+ ["render", _sfc_render],
+ ["__file", "/Users/maethu/webcloud7/ftw.referencewidget/ftw/referencewidget/resources/src/widget/App.vue"]
]);
function _typeof(e) {
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(e2) {
return typeof e2;
} : function(e2) {
return e2 && "function" == typeof Symbol && e2.constructor === Symbol && e2 !== Symbol.prototype ? "symbol" : typeof e2;
@@ -8992,15 +10717,15 @@
forcedJSONParsing: true,
clarifyTimeoutError: false
};
var utils$d = utils$i;
function toFormData$1(obj, formData) {
formData = formData || new FormData();
- var stack = [];
+ var stack2 = [];
function convertValue(value) {
if (value === null)
return "";
if (utils$d.isDate(value)) {
return value.toISOString();
}
@@ -9008,18 +10733,18 @@
return typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
}
return value;
}
function build(data2, parentKey) {
if (utils$d.isPlainObject(data2) || utils$d.isArray(data2)) {
- if (stack.indexOf(data2) !== -1) {
+ if (stack2.indexOf(data2) !== -1) {
throw Error("Circular reference detected in " + parentKey);
}
- stack.push(data2);
+ stack2.push(data2);
utils$d.forEach(data2, function each(value, key) {
if (utils$d.isUndefined(value))
return;
var fullKey = parentKey ? parentKey + "." + key : key;
var arr;
if (value && !parentKey && typeof value === "object") {
if (utils$d.endsWith(key, "{}")) {
@@ -9029,15 +10754,15 @@
!utils$d.isUndefined(el) && formData.append(fullKey, convertValue(el));
});
return;
}
}
build(value, fullKey);
});
- stack.pop();
+ stack2.pop();
} else {
formData.append(parentKey, convertValue(data2));
}
}
build(obj);
return formData;
}
@@ -11197,25 +12922,25 @@
len = contexts.length;
for (; i2 < len; i2++) {
find(selector, contexts[i2], results);
}
return results;
}
- function condense(unmatched, map, filter, context, xml) {
+ function condense(unmatched, map2, filter, context, xml) {
var elem, newUnmatched = [],
i2 = 0,
len = unmatched.length,
- mapped = map != null;
+ mapped = map2 != null;
for (; i2 < len; i2++) {
if (elem = unmatched[i2]) {
if (!filter || filter(elem, context, xml)) {
newUnmatched.push(elem);
if (mapped) {
- map.push(i2);
+ map2.push(i2);
}
}
}
}
return newUnmatched;
}
@@ -14065,23 +15790,23 @@
if (prefix !== "margin") {
jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
}
});
jQuery.fn.extend({
css: function(name, value) {
return access(this, function(elem, name2, value2) {
- var styles, len, map = {},
+ var styles, len, map2 = {},
i = 0;
if (Array.isArray(name2)) {
styles = getStyles(elem);
len = name2.length;
for (; i < len; i++) {
- map[name2[i]] = jQuery.css(elem, name2[i], false, styles);
+ map2[name2[i]] = jQuery.css(elem, name2[i], false, styles);
}
- return map;
+ return map2;
}
return value2 !== void 0 ? jQuery.style(elem, name2, value2) : jQuery.css(elem, name2);
}, name, value, arguments.length > 1);
}
});
function Tween(elem, options, prop, end, easing) {
@@ -15585,22 +17310,22 @@
},
overrideMimeType: function(type) {
if (completed2 == null) {
s.mimeType = type;
}
return this;
},
- statusCode: function(map) {
+ statusCode: function(map2) {
var code;
- if (map) {
+ if (map2) {
if (completed2) {
- jqXHR.always(map[jqXHR.status]);
+ jqXHR.always(map2[jqXHR.status]);
} else {
- for (code in map) {
- statusCode[code] = [statusCode[code], map[code]];
+ for (code in map2) {
+ statusCode[code] = [statusCode[code], map2[code]];
}
}
}
return this;
},
abort: function(statusText) {
var finalText = statusText || strAbort;
@@ -17143,20 +18868,20 @@
if (!is_duplicate) {
list.push(next_obj);
}
return list;
}, []);
}
-function mergeStack(stack, length) {
+function mergeStack(stack2, length) {
const results = [];
for (let i = 0; i < length; i++) {
results.push({});
}
- for (const frame of stack) {
+ for (const frame of stack2) {
const frame_length = frame.length - 1;
for (let x = 0; x < length; x++) {
results[x] = $.extend(
results[x] || {},
frame[x > frame_length ? frame_length : x]
);
}
@@ -17237,20 +18962,20 @@
input.setAttribute("value", invalid_value);
support = input.value !== invalid_value;
}
return support;
}
const checkCSSFeature = (attribute, value, tag = "div") => {
tag = document.createElement(tag);
- let supported = tag.style[attribute] !== void 0;
- if (supported && value !== void 0) {
+ let supported2 = tag.style[attribute] !== void 0;
+ if (supported2 && value !== void 0) {
tag.style[attribute] = value;
- supported = tag.style[attribute] === value;
+ supported2 = tag.style[attribute] === value;
}
- return supported;
+ return supported2;
};
const animation_frame = () => {
return new Promise(window.requestAnimationFrame);
};
const timeout = (ms) => {
return new Promise((resolve2) => setTimeout(resolve2, ms));
};@@ -1,211 +1,211 @@
-(function(Nn, Rn) {
- typeof exports == "object" && typeof module != "undefined" ? module.exports = Rn() : typeof define == "function" && define.amd ? define(Rn) : (Nn = typeof globalThis != "undefined" ? globalThis : Nn || self, Nn.Referencewidget = Rn())
+(function(Wn, Vn) {
+ typeof exports == "object" && typeof module != "undefined" ? module.exports = Vn() : typeof define == "function" && define.amd ? define(Vn) : (Wn = typeof globalThis != "undefined" ? globalThis : Wn || self, Wn.Referencewidget = Vn())
})(this, function() {
"use strict";
- var Nn = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : {};
+ var Wn = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : {};
- function Rn(e) {
+ function Vn(e) {
if (e.__esModule) return e;
var t = Object.defineProperty({}, "__esModule", {
value: !0
});
- return Object.keys(e).forEach(function(n) {
- var o = Object.getOwnPropertyDescriptor(e, n);
- Object.defineProperty(t, n, o.get ? o : {
+ return Object.keys(e).forEach(function(r) {
+ var i = Object.getOwnPropertyDescriptor(e, r);
+ Object.defineProperty(t, r, i.get ? i : {
enumerable: !0,
get: function() {
- return e[n]
+ return e[r]
}
})
}), t
}
- var Uf = function() {
+ var Uc = function() {
if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function") return !1;
if (typeof Symbol.iterator == "symbol") return !0;
var t = {},
- n = Symbol("test"),
- o = Object(n);
- if (typeof n == "string" || Object.prototype.toString.call(n) !== "[object Symbol]" || Object.prototype.toString.call(o) !== "[object Symbol]") return !1;
+ r = Symbol("test"),
+ i = Object(r);
+ if (typeof r == "string" || Object.prototype.toString.call(r) !== "[object Symbol]" || Object.prototype.toString.call(i) !== "[object Symbol]") return !1;
var s = 42;
- t[n] = s;
- for (n in t) return !1;
+ t[r] = s;
+ for (r in t) return !1;
if (typeof Object.keys == "function" && Object.keys(t).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(t).length !== 0) return !1;
var a = Object.getOwnPropertySymbols(t);
- if (a.length !== 1 || a[0] !== n || !Object.prototype.propertyIsEnumerable.call(t, n)) return !1;
+ if (a.length !== 1 || a[0] !== r || !Object.prototype.propertyIsEnumerable.call(t, r)) return !1;
if (typeof Object.getOwnPropertyDescriptor == "function") {
- var c = Object.getOwnPropertyDescriptor(t, n);
+ var c = Object.getOwnPropertyDescriptor(t, r);
if (c.value !== s || c.enumerable !== !0) return !1
}
return !0
},
- wa = typeof Symbol != "undefined" && Symbol,
- Hf = Uf,
- Wf = function() {
- return typeof wa != "function" || typeof Symbol != "function" || typeof wa("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? !1 : Hf()
+ au = typeof Symbol != "undefined" && Symbol,
+ qc = Uc,
+ Hc = function() {
+ return typeof au != "function" || typeof Symbol != "function" || typeof au("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? !1 : qc()
},
- Sa = {
+ uu = {
foo: {}
},
- Vf = Object,
- zf = function() {
+ Bc = Object,
+ Wc = function() {
return {
- __proto__: Sa
- }.foo === Sa.foo && !({
+ __proto__: uu
+ }.foo === uu.foo && !({
__proto__: null
}
- instanceof Vf)
+ instanceof Bc)
},
- Kf = "Function.prototype.bind called on incompatible ",
- vo = Array.prototype.slice,
- Jf = Object.prototype.toString,
- Qf = "[object Function]",
- Xf = function(t) {
- var n = this;
- if (typeof n != "function" || Jf.call(n) !== Qf) throw new TypeError(Kf + n);
- for (var o = vo.call(arguments, 1), s, a = function() {
+ Vc = "Function.prototype.bind called on incompatible ",
+ Vo = Array.prototype.slice,
+ zc = Object.prototype.toString,
+ Kc = "[object Function]",
+ Jc = function(t) {
+ var r = this;
+ if (typeof r != "function" || zc.call(r) !== Kc) throw new TypeError(Vc + r);
+ for (var i = Vo.call(arguments, 1), s, a = function() {
if (this instanceof s) {
- var w = n.apply(this, o.concat(vo.call(arguments)));
- return Object(w) === w ? w : this
- } else return n.apply(t, o.concat(vo.call(arguments)))
- }, c = Math.max(0, n.length - o.length), h = [], y = 0; y < c; y++) h.push("$" + y);
- if (s = Function("binder", "return function (" + h.join(",") + "){ return binder.apply(this,arguments); }")(a), n.prototype) {
- var b = function() {};
- b.prototype = n.prototype, s.prototype = new b, b.prototype = null
+ var _ = r.apply(this, i.concat(Vo.call(arguments)));
+ return Object(_) === _ ? _ : this
+ } else return r.apply(t, i.concat(Vo.call(arguments)))
+ }, c = Math.max(0, r.length - i.length), h = [], y = 0; y < c; y++) h.push("$" + y);
+ if (s = Function("binder", "return function (" + h.join(",") + "){ return binder.apply(this,arguments); }")(a), r.prototype) {
+ var v = function() {};
+ v.prototype = r.prototype, s.prototype = new v, v.prototype = null
}
return s
},
- Gf = Xf,
- bo = Function.prototype.bind || Gf,
- Yf = bo,
- Zf = Yf.call(Function.call, Object.prototype.hasOwnProperty),
- ge, Jr = SyntaxError,
- Ea = Function,
- Qr = TypeError,
- _o = function(e) {
+ Qc = Jc,
+ zo = Function.prototype.bind || Qc,
+ Gc = zo,
+ Xc = Gc.call(Function.call, Object.prototype.hasOwnProperty),
+ xe, dn = SyntaxError,
+ lu = Function,
+ pn = TypeError,
+ Ko = function(e) {
try {
- return Ea('"use strict"; return (' + e + ").constructor;")()
+ return lu('"use strict"; return (' + e + ").constructor;")()
} catch {}
},
- Cr = Object.getOwnPropertyDescriptor;
- if (Cr) try {
- Cr({}, "")
+ jr = Object.getOwnPropertyDescriptor;
+ if (jr) try {
+ jr({}, "")
} catch {
- Cr = null
+ jr = null
}
- var xo = function() {
- throw new Qr
+ var Jo = function() {
+ throw new pn
},
- ec = Cr ? function() {
+ Yc = jr ? function() {
try {
- return arguments.callee, xo
+ return arguments.callee, Jo
} catch {
try {
- return Cr(arguments, "callee").get
+ return jr(arguments, "callee").get
} catch {
- return xo
+ return Jo
}
}
- }() : xo,
- Xr = Wf(),
- tc = zf(),
- Ve = Object.getPrototypeOf || (tc ? function(e) {
+ }() : Jo,
+ hn = Hc(),
+ Zc = Wc(),
+ Ke = Object.getPrototypeOf || (Zc ? function(e) {
return e.__proto__
} : null),
- Gr = {},
- rc = typeof Uint8Array == "undefined" || !Ve ? ge : Ve(Uint8Array),
- Or = {
- "%AggregateError%": typeof AggregateError == "undefined" ? ge : AggregateError,
+ gn = {},
+ ed = typeof Uint8Array == "undefined" || !Ke ? xe : Ke(Uint8Array),
+ Lr = {
+ "%AggregateError%": typeof AggregateError == "undefined" ? xe : AggregateError,
"%Array%": Array,
- "%ArrayBuffer%": typeof ArrayBuffer == "undefined" ? ge : ArrayBuffer,
- "%ArrayIteratorPrototype%": Xr && Ve ? Ve([][Symbol.iterator]()) : ge,
- "%AsyncFromSyncIteratorPrototype%": ge,
- "%AsyncFunction%": Gr,
- "%AsyncGenerator%": Gr,
- "%AsyncGeneratorFunction%": Gr,
- "%AsyncIteratorPrototype%": Gr,
- "%Atomics%": typeof Atomics == "undefined" ? ge : Atomics,
- "%BigInt%": typeof BigInt == "undefined" ? ge : BigInt,
- "%BigInt64Array%": typeof BigInt64Array == "undefined" ? ge : BigInt64Array,
- "%BigUint64Array%": typeof BigUint64Array == "undefined" ? ge : BigUint64Array,
+ "%ArrayBuffer%": typeof ArrayBuffer == "undefined" ? xe : ArrayBuffer,
+ "%ArrayIteratorPrototype%": hn && Ke ? Ke([][Symbol.iterator]()) : xe,
+ "%AsyncFromSyncIteratorPrototype%": xe,
+ "%AsyncFunction%": gn,
+ "%AsyncGenerator%": gn,
+ "%AsyncGeneratorFunction%": gn,
+ "%AsyncIteratorPrototype%": gn,
+ "%Atomics%": typeof Atomics == "undefined" ? xe : Atomics,
+ "%BigInt%": typeof BigInt == "undefined" ? xe : BigInt,
+ "%BigInt64Array%": typeof BigInt64Array == "undefined" ? xe : BigInt64Array,
+ "%BigUint64Array%": typeof BigUint64Array == "undefined" ? xe : BigUint64Array,
"%Boolean%": Boolean,
- "%DataView%": typeof DataView == "undefined" ? ge : DataView,
+ "%DataView%": typeof DataView == "undefined" ? xe : DataView,
"%Date%": Date,
"%decodeURI%": decodeURI,
"%decodeURIComponent%": decodeURIComponent,
"%encodeURI%": encodeURI,
"%encodeURIComponent%": encodeURIComponent,
"%Error%": Error,
"%eval%": eval,
"%EvalError%": EvalError,
- "%Float32Array%": typeof Float32Array == "undefined" ? ge : Float32Array,
- "%Float64Array%": typeof Float64Array == "undefined" ? ge : Float64Array,
- "%FinalizationRegistry%": typeof FinalizationRegistry == "undefined" ? ge : FinalizationRegistry,
- "%Function%": Ea,
- "%GeneratorFunction%": Gr,
- "%Int8Array%": typeof Int8Array == "undefined" ? ge : Int8Array,
- "%Int16Array%": typeof Int16Array == "undefined" ? ge : Int16Array,
- "%Int32Array%": typeof Int32Array == "undefined" ? ge : Int32Array,
+ "%Float32Array%": typeof Float32Array == "undefined" ? xe : Float32Array,
+ "%Float64Array%": typeof Float64Array == "undefined" ? xe : Float64Array,
+ "%FinalizationRegistry%": typeof FinalizationRegistry == "undefined" ? xe : FinalizationRegistry,
+ "%Function%": lu,
+ "%GeneratorFunction%": gn,
+ "%Int8Array%": typeof Int8Array == "undefined" ? xe : Int8Array,
+ "%Int16Array%": typeof Int16Array == "undefined" ? xe : Int16Array,
+ "%Int32Array%": typeof Int32Array == "undefined" ? xe : Int32Array,
"%isFinite%": isFinite,
"%isNaN%": isNaN,
- "%IteratorPrototype%": Xr && Ve ? Ve(Ve([][Symbol.iterator]())) : ge,
- "%JSON%": typeof JSON == "object" ? JSON : ge,
- "%Map%": typeof Map == "undefined" ? ge : Map,
- "%MapIteratorPrototype%": typeof Map == "undefined" || !Xr || !Ve ? ge : Ve(new Map()[Symbol.iterator]()),
+ "%IteratorPrototype%": hn && Ke ? Ke(Ke([][Symbol.iterator]())) : xe,
+ "%JSON%": typeof JSON == "object" ? JSON : xe,
+ "%Map%": typeof Map == "undefined" ? xe : Map,
+ "%MapIteratorPrototype%": typeof Map == "undefined" || !hn || !Ke ? xe : Ke(new Map()[Symbol.iterator]()),
"%Math%": Math,
"%Number%": Number,
"%Object%": Object,
"%parseFloat%": parseFloat,
"%parseInt%": parseInt,
- "%Promise%": typeof Promise == "undefined" ? ge : Promise,
- "%Proxy%": typeof Proxy == "undefined" ? ge : Proxy,
+ "%Promise%": typeof Promise == "undefined" ? xe : Promise,
+ "%Proxy%": typeof Proxy == "undefined" ? xe : Proxy,
"%RangeError%": RangeError,
"%ReferenceError%": ReferenceError,
- "%Reflect%": typeof Reflect == "undefined" ? ge : Reflect,
+ "%Reflect%": typeof Reflect == "undefined" ? xe : Reflect,
"%RegExp%": RegExp,
- "%Set%": typeof Set == "undefined" ? ge : Set,
- "%SetIteratorPrototype%": typeof Set == "undefined" || !Xr || !Ve ? ge : Ve(new Set()[Symbol.iterator]()),
- "%SharedArrayBuffer%": typeof SharedArrayBuffer == "undefined" ? ge : SharedArrayBuffer,
+ "%Set%": typeof Set == "undefined" ? xe : Set,
+ "%SetIteratorPrototype%": typeof Set == "undefined" || !hn || !Ke ? xe : Ke(new Set()[Symbol.iterator]()),
+ "%SharedArrayBuffer%": typeof SharedArrayBuffer == "undefined" ? xe : SharedArrayBuffer,
"%String%": String,
- "%StringIteratorPrototype%": Xr && Ve ? Ve("" [Symbol.iterator]()) : ge,
- "%Symbol%": Xr ? Symbol : ge,
- "%SyntaxError%": Jr,
- "%ThrowTypeError%": ec,
- "%TypedArray%": rc,
- "%TypeError%": Qr,
- "%Uint8Array%": typeof Uint8Array == "undefined" ? ge : Uint8Array,
- "%Uint8ClampedArray%": typeof Uint8ClampedArray == "undefined" ? ge : Uint8ClampedArray,
- "%Uint16Array%": typeof Uint16Array == "undefined" ? ge : Uint16Array,
- "%Uint32Array%": typeof Uint32Array == "undefined" ? ge : Uint32Array,
+ "%StringIteratorPrototype%": hn && Ke ? Ke("" [Symbol.iterator]()) : xe,
+ "%Symbol%": hn ? Symbol : xe,
+ "%SyntaxError%": dn,
+ "%ThrowTypeError%": Yc,
+ "%TypedArray%": ed,
+ "%TypeError%": pn,
+ "%Uint8Array%": typeof Uint8Array == "undefined" ? xe : Uint8Array,
+ "%Uint8ClampedArray%": typeof Uint8ClampedArray == "undefined" ? xe : Uint8ClampedArray,
+ "%Uint16Array%": typeof Uint16Array == "undefined" ? xe : Uint16Array,
+ "%Uint32Array%": typeof Uint32Array == "undefined" ? xe : Uint32Array,
"%URIError%": URIError,
- "%WeakMap%": typeof WeakMap == "undefined" ? ge : WeakMap,
- "%WeakRef%": typeof WeakRef == "undefined" ? ge : WeakRef,
- "%WeakSet%": typeof WeakSet == "undefined" ? ge : WeakSet
+ "%WeakMap%": typeof WeakMap == "undefined" ? xe : WeakMap,
+ "%WeakRef%": typeof WeakRef == "undefined" ? xe : WeakRef,
+ "%WeakSet%": typeof WeakSet == "undefined" ? xe : WeakSet
};
- if (Ve) try {
+ if (Ke) try {
null.error
} catch (e) {
- var nc = Ve(Ve(e));
- Or["%Error.prototype%"] = nc
+ var td = Ke(Ke(e));
+ Lr["%Error.prototype%"] = td
}
- var ic = function e(t) {
- var n;
- if (t === "%AsyncFunction%") n = _o("async function () {}");
- else if (t === "%GeneratorFunction%") n = _o("function* () {}");
- else if (t === "%AsyncGeneratorFunction%") n = _o("async function* () {}");
+ var rd = function e(t) {
+ var r;
+ if (t === "%AsyncFunction%") r = Ko("async function () {}");
+ else if (t === "%GeneratorFunction%") r = Ko("function* () {}");
+ else if (t === "%AsyncGeneratorFunction%") r = Ko("async function* () {}");
else if (t === "%AsyncGenerator%") {
- var o = e("%AsyncGeneratorFunction%");
- o && (n = o.prototype)
+ var i = e("%AsyncGeneratorFunction%");
+ i && (r = i.prototype)
} else if (t === "%AsyncIteratorPrototype%") {
var s = e("%AsyncGenerator%");
- s && Ve && (n = Ve(s.prototype))
+ s && Ke && (r = Ke(s.prototype))
}
- return Or[t] = n, n
+ return Lr[t] = r, r
},
- Ta = {
+ fu = {
"%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
"%ArrayPrototype%": ["Array", "prototype"],
"%ArrayProto_entries%": ["Array", "prototype", "entries"],
"%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
"%ArrayProto_keys%": ["Array", "prototype", "keys"],
"%ArrayProto_values%": ["Array", "prototype", "values"],
"%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
@@ -250,2573 +250,3045 @@
"%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
"%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
"%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
"%URIErrorPrototype%": ["URIError", "prototype"],
"%WeakMapPrototype%": ["WeakMap", "prototype"],
"%WeakSetPrototype%": ["WeakSet", "prototype"]
},
- Dn = bo,
- ui = Zf,
- oc = Dn.call(Function.call, Array.prototype.concat),
- sc = Dn.call(Function.apply, Array.prototype.splice),
- Aa = Dn.call(Function.call, String.prototype.replace),
- li = Dn.call(Function.call, String.prototype.slice),
- ac = Dn.call(Function.call, RegExp.prototype.exec),
- uc = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,
- lc = /\\(\\)?/g,
- fc = function(t) {
- var n = li(t, 0, 1),
- o = li(t, -1);
- if (n === "%" && o !== "%") throw new Jr("invalid intrinsic syntax, expected closing `%`");
- if (o === "%" && n !== "%") throw new Jr("invalid intrinsic syntax, expected opening `%`");
+ zn = zo,
+ Pi = Xc,
+ nd = zn.call(Function.call, Array.prototype.concat),
+ id = zn.call(Function.apply, Array.prototype.splice),
+ cu = zn.call(Function.call, String.prototype.replace),
+ $i = zn.call(Function.call, String.prototype.slice),
+ od = zn.call(Function.call, RegExp.prototype.exec),
+ sd = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g,
+ ad = /\\(\\)?/g,
+ ud = function(t) {
+ var r = $i(t, 0, 1),
+ i = $i(t, -1);
+ if (r === "%" && i !== "%") throw new dn("invalid intrinsic syntax, expected closing `%`");
+ if (i === "%" && r !== "%") throw new dn("invalid intrinsic syntax, expected opening `%`");
var s = [];
- return Aa(t, uc, function(a, c, h, y) {
- s[s.length] = h ? Aa(y, lc, "$1") : c || a
+ return cu(t, sd, function(a, c, h, y) {
+ s[s.length] = h ? cu(y, ad, "$1") : c || a
}), s
},
- cc = function(t, n) {
- var o = t,
+ ld = function(t, r) {
+ var i = t,
s;
- if (ui(Ta, o) && (s = Ta[o], o = "%" + s[0] + "%"), ui(Or, o)) {
- var a = Or[o];
- if (a === Gr && (a = ic(o)), typeof a == "undefined" && !n) throw new Qr("intrinsic " + t + " exists, but is not available. Please file an issue!");
+ if (Pi(fu, i) && (s = fu[i], i = "%" + s[0] + "%"), Pi(Lr, i)) {
+ var a = Lr[i];
+ if (a === gn && (a = rd(i)), typeof a == "undefined" && !r) throw new pn("intrinsic " + t + " exists, but is not available. Please file an issue!");
return {
alias: s,
- name: o,
+ name: i,
value: a
}
}
- throw new Jr("intrinsic " + t + " does not exist!")
+ throw new dn("intrinsic " + t + " does not exist!")
},
- wo = function(t, n) {
- if (typeof t != "string" || t.length === 0) throw new Qr("intrinsic name must be a non-empty string");
- if (arguments.length > 1 && typeof n != "boolean") throw new Qr('"allowMissing" argument must be a boolean');
- if (ac(/^%?[^%]*%?$/, t) === null) throw new Jr("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
- var o = fc(t),
- s = o.length > 0 ? o[0] : "",
- a = cc("%" + s + "%", n),
+ Qo = function(t, r) {
+ if (typeof t != "string" || t.length === 0) throw new pn("intrinsic name must be a non-empty string");
+ if (arguments.length > 1 && typeof r != "boolean") throw new pn('"allowMissing" argument must be a boolean');
+ if (od(/^%?[^%]*%?$/, t) === null) throw new dn("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+ var i = ud(t),
+ s = i.length > 0 ? i[0] : "",
+ a = ld("%" + s + "%", r),
c = a.name,
h = a.value,
y = !1,
- b = a.alias;
- b && (s = b[0], sc(o, oc([0, 1], b)));
- for (var w = 1, N = !0; w < o.length; w += 1) {
- var $ = o[w],
- W = li($, 0, 1),
- q = li($, -1);
- if ((W === '"' || W === "'" || W === "`" || q === '"' || q === "'" || q === "`") && W !== q) throw new Jr("property names with quotes must have matching quotes");
- if (($ === "constructor" || !N) && (y = !0), s += "." + $, c = "%" + s + "%", ui(Or, c)) h = Or[c];
+ v = a.alias;
+ v && (s = v[0], id(i, nd([0, 1], v)));
+ for (var _ = 1, E = !0; _ < i.length; _ += 1) {
+ var P = i[_],
+ q = $i(P, 0, 1),
+ j = $i(P, -1);
+ if ((q === '"' || q === "'" || q === "`" || j === '"' || j === "'" || j === "`") && q !== j) throw new dn("property names with quotes must have matching quotes");
+ if ((P === "constructor" || !E) && (y = !0), s += "." + P, c = "%" + s + "%", Pi(Lr, c)) h = Lr[c];
else if (h != null) {
- if (!($ in h)) {
- if (!n) throw new Qr("base intrinsic for " + t + " exists, but the property is not available.");
+ if (!(P in h)) {
+ if (!r) throw new pn("base intrinsic for " + t + " exists, but the property is not available.");
return
}
- if (Cr && w + 1 >= o.length) {
- var U = Cr(h, $);
- N = !!U, N && "get" in U && !("originalValue" in U.get) ? h = U.get : h = h[$]
- } else N = ui(h, $), h = h[$];
- N && !y && (Or[c] = h)
+ if (jr && _ + 1 >= i.length) {
+ var B = jr(h, P);
+ E = !!B, E && "get" in B && !("originalValue" in B.get) ? h = B.get : h = h[P]
+ } else E = Pi(h, P), h = h[P];
+ E && !y && (Lr[c] = h)
}
}
return h
},
- Ca = {
+ du = {
exports: {}
};
(function(e) {
- var t = bo,
- n = wo,
- o = n("%Function.prototype.apply%"),
- s = n("%Function.prototype.call%"),
- a = n("%Reflect.apply%", !0) || t.call(s, o),
- c = n("%Object.getOwnPropertyDescriptor%", !0),
- h = n("%Object.defineProperty%", !0),
- y = n("%Math.max%");
+ var t = zo,
+ r = Qo,
+ i = r("%Function.prototype.apply%"),
+ s = r("%Function.prototype.call%"),
+ a = r("%Reflect.apply%", !0) || t.call(s, i),
+ c = r("%Object.getOwnPropertyDescriptor%", !0),
+ h = r("%Object.defineProperty%", !0),
+ y = r("%Math.max%");
if (h) try {
h({}, "a", {
value: 1
})
} catch {
h = null
}
- e.exports = function(N) {
- var $ = a(t, s, arguments);
+ e.exports = function(E) {
+ var P = a(t, s, arguments);
if (c && h) {
- var W = c($, "length");
- W.configurable && h($, "length", {
- value: 1 + y(0, N.length - (arguments.length - 1))
+ var q = c(P, "length");
+ q.configurable && h(P, "length", {
+ value: 1 + y(0, E.length - (arguments.length - 1))
})
}
- return $
+ return P
};
- var b = function() {
- return a(t, o, arguments)
+ var v = function() {
+ return a(t, i, arguments)
};
h ? h(e.exports, "apply", {
- value: b
- }) : e.exports.apply = b
- })(Ca);
- var Oa = wo,
- Pa = Ca.exports,
- dc = Pa(Oa("String.prototype.indexOf")),
- pc = function(t, n) {
- var o = Oa(t, !!n);
- return typeof o == "function" && dc(t, ".prototype.") > -1 ? Pa(o) : o
- },
- hc = {},
- gc = Object.freeze(Object.defineProperty({
+ value: v
+ }) : e.exports.apply = v
+ })(du);
+ var pu = Qo,
+ hu = du.exports,
+ fd = hu(pu("String.prototype.indexOf")),
+ cd = function(t, r) {
+ var i = pu(t, !!r);
+ return typeof i == "function" && fd(t, ".prototype.") > -1 ? hu(i) : i
+ },
+ dd = new Proxy({}, {
+ get() {
+ throw new Error('Module "" has been externalized for browser compatibility and cannot be accessed in client code.')
+ }
+ }),
+ pd = Object.freeze(Object.defineProperty({
__proto__: null,
- default: hc
+ default: dd
}, Symbol.toStringTag, {
value: "Module"
})),
- yc = Rn(gc),
- So = typeof Map == "function" && Map.prototype,
- Eo = Object.getOwnPropertyDescriptor && So ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null,
- fi = So && Eo && typeof Eo.get == "function" ? Eo.get : null,
- Na = So && Map.prototype.forEach,
- To = typeof Set == "function" && Set.prototype,
- Ao = Object.getOwnPropertyDescriptor && To ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null,
- ci = To && Ao && typeof Ao.get == "function" ? Ao.get : null,
- Ra = To && Set.prototype.forEach,
- mc = typeof WeakMap == "function" && WeakMap.prototype,
- In = mc ? WeakMap.prototype.has : null,
- vc = typeof WeakSet == "function" && WeakSet.prototype,
- $n = vc ? WeakSet.prototype.has : null,
- bc = typeof WeakRef == "function" && WeakRef.prototype,
- Da = bc ? WeakRef.prototype.deref : null,
- _c = Boolean.prototype.valueOf,
- xc = Object.prototype.toString,
- wc = Function.prototype.toString,
- Sc = String.prototype.match,
- Co = String.prototype.slice,
- pr = String.prototype.replace,
- Ec = String.prototype.toUpperCase,
- Ia = String.prototype.toLowerCase,
- $a = RegExp.prototype.test,
- Ma = Array.prototype.concat,
- Bt = Array.prototype.join,
- Tc = Array.prototype.slice,
- La = Math.floor,
- Oo = typeof BigInt == "function" ? BigInt.prototype.valueOf : null,
- Po = Object.getOwnPropertySymbols,
- No = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? Symbol.prototype.toString : null,
- Yr = typeof Symbol == "function" && typeof Symbol.iterator == "object",
- Ze = typeof Symbol == "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === Yr ? "object" : "symbol") ? Symbol.toStringTag : null,
- Fa = Object.prototype.propertyIsEnumerable,
- ka = (typeof Reflect == "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(e) {
+ hd = Vn(pd),
+ Go = typeof Map == "function" && Map.prototype,
+ Xo = Object.getOwnPropertyDescriptor && Go ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null,
+ Ri = Go && Xo && typeof Xo.get == "function" ? Xo.get : null,
+ gu = Go && Map.prototype.forEach,
+ Yo = typeof Set == "function" && Set.prototype,
+ Zo = Object.getOwnPropertyDescriptor && Yo ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null,
+ Ni = Yo && Zo && typeof Zo.get == "function" ? Zo.get : null,
+ yu = Yo && Set.prototype.forEach,
+ gd = typeof WeakMap == "function" && WeakMap.prototype,
+ Kn = gd ? WeakMap.prototype.has : null,
+ yd = typeof WeakSet == "function" && WeakSet.prototype,
+ Jn = yd ? WeakSet.prototype.has : null,
+ md = typeof WeakRef == "function" && WeakRef.prototype,
+ mu = md ? WeakRef.prototype.deref : null,
+ vd = Boolean.prototype.valueOf,
+ bd = Object.prototype.toString,
+ wd = Function.prototype.toString,
+ _d = String.prototype.match,
+ es = String.prototype.slice,
+ br = String.prototype.replace,
+ xd = String.prototype.toUpperCase,
+ vu = String.prototype.toLowerCase,
+ bu = RegExp.prototype.test,
+ wu = Array.prototype.concat,
+ zt = Array.prototype.join,
+ Sd = Array.prototype.slice,
+ _u = Math.floor,
+ ts = typeof BigInt == "function" ? BigInt.prototype.valueOf : null,
+ rs = Object.getOwnPropertySymbols,
+ ns = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? Symbol.prototype.toString : null,
+ yn = typeof Symbol == "function" && typeof Symbol.iterator == "object",
+ it = typeof Symbol == "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === yn ? "object" : "symbol") ? Symbol.toStringTag : null,
+ xu = Object.prototype.propertyIsEnumerable,
+ Su = (typeof Reflect == "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(e) {
return e.__proto__
} : null);
- function ja(e, t) {
- if (e === 1 / 0 || e === -1 / 0 || e !== e || e && e > -1e3 && e < 1e3 || $a.call(/e/, t)) return t;
- var n = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+ function Eu(e, t) {
+ if (e === 1 / 0 || e === -1 / 0 || e !== e || e && e > -1e3 && e < 1e3 || bu.call(/e/, t)) return t;
+ var r = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
if (typeof e == "number") {
- var o = e < 0 ? -La(-e) : La(e);
- if (o !== e) {
- var s = String(o),
- a = Co.call(t, s.length + 1);
- return pr.call(s, n, "$&_") + "." + pr.call(pr.call(a, /([0-9]{3})/g, "$&_"), /_$/, "")
- }
- }
- return pr.call(t, n, "$&_")
- }
- var Ro = yc,
- qa = Ro.custom,
- Ba = Wa(qa) ? qa : null,
- Ac = function e(t, n, o, s) {
- var a = n || {};
- if (hr(a, "quoteStyle") && a.quoteStyle !== "single" && a.quoteStyle !== "double") throw new TypeError('option "quoteStyle" must be "single" or "double"');
- if (hr(a, "maxStringLength") && (typeof a.maxStringLength == "number" ? a.maxStringLength < 0 && a.maxStringLength !== 1 / 0 : a.maxStringLength !== null)) throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
- var c = hr(a, "customInspect") ? a.customInspect : !0;
+ var i = e < 0 ? -_u(-e) : _u(e);
+ if (i !== e) {
+ var s = String(i),
+ a = es.call(t, s.length + 1);
+ return br.call(s, r, "$&_") + "." + br.call(br.call(a, /([0-9]{3})/g, "$&_"), /_$/, "")
+ }
+ }
+ return br.call(t, r, "$&_")
+ }
+ var is = hd,
+ Tu = is.custom,
+ Ou = Pu(Tu) ? Tu : null,
+ Ed = function e(t, r, i, s) {
+ var a = r || {};
+ if (wr(a, "quoteStyle") && a.quoteStyle !== "single" && a.quoteStyle !== "double") throw new TypeError('option "quoteStyle" must be "single" or "double"');
+ if (wr(a, "maxStringLength") && (typeof a.maxStringLength == "number" ? a.maxStringLength < 0 && a.maxStringLength !== 1 / 0 : a.maxStringLength !== null)) throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
+ var c = wr(a, "customInspect") ? a.customInspect : !0;
if (typeof c != "boolean" && c !== "symbol") throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
- if (hr(a, "indent") && a.indent !== null && a.indent !== " " && !(parseInt(a.indent, 10) === a.indent && a.indent > 0)) throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
- if (hr(a, "numericSeparator") && typeof a.numericSeparator != "boolean") throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
+ if (wr(a, "indent") && a.indent !== null && a.indent !== " " && !(parseInt(a.indent, 10) === a.indent && a.indent > 0)) throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
+ if (wr(a, "numericSeparator") && typeof a.numericSeparator != "boolean") throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
var h = a.numericSeparator;
if (typeof t == "undefined") return "undefined";
if (t === null) return "null";
if (typeof t == "boolean") return t ? "true" : "false";
- if (typeof t == "string") return za(t, a);
+ if (typeof t == "string") return Ru(t, a);
if (typeof t == "number") {
if (t === 0) return 1 / 0 / t > 0 ? "0" : "-0";
var y = String(t);
- return h ? ja(t, y) : y
+ return h ? Eu(t, y) : y
}
if (typeof t == "bigint") {
- var b = String(t) + "n";
- return h ? ja(t, b) : b
+ var v = String(t) + "n";
+ return h ? Eu(t, v) : v
}
- var w = typeof a.depth == "undefined" ? 5 : a.depth;
- if (typeof o == "undefined" && (o = 0), o >= w && w > 0 && typeof t == "object") return Do(t) ? "[Array]" : "[Object]";
- var N = Wc(a, o);
+ var _ = typeof a.depth == "undefined" ? 5 : a.depth;
+ if (typeof i == "undefined" && (i = 0), i >= _ && _ > 0 && typeof t == "object") return os(t) ? "[Array]" : "[Object]";
+ var E = Hd(a, i);
if (typeof s == "undefined") s = [];
- else if (Va(s, t) >= 0) return "[Circular]";
+ else if ($u(s, t) >= 0) return "[Circular]";
- function $(le, nt, ur) {
- if (nt && (s = Tc.call(s), s.push(nt)), ur) {
- var Me = {
+ function P(de, pt, ht) {
+ if (pt && (s = Sd.call(s), s.push(pt)), ht) {
+ var Ue = {
depth: a.depth
};
- return hr(a, "quoteStyle") && (Me.quoteStyle = a.quoteStyle), e(le, Me, o + 1, s)
+ return wr(a, "quoteStyle") && (Ue.quoteStyle = a.quoteStyle), e(de, Ue, i + 1, s)
}
- return e(le, a, o + 1, s)
+ return e(de, a, i + 1, s)
}
- if (typeof t == "function" && !Ha(t)) {
- var W = Mc(t),
- q = di(t, $);
- return "[Function" + (W ? ": " + W : " (anonymous)") + "]" + (q.length > 0 ? " { " + Bt.call(q, ", ") + " }" : "")
+ if (typeof t == "function" && !Au(t)) {
+ var q = Dd(t),
+ j = Di(t, P);
+ return "[Function" + (q ? ": " + q : " (anonymous)") + "]" + (j.length > 0 ? " { " + zt.call(j, ", ") + " }" : "")
}
- if (Wa(t)) {
- var U = Yr ? pr.call(String(t), /^(Symbol\(.*\))_[^)]*$/, "$1") : No.call(t);
- return typeof t == "object" && !Yr ? Mn(U) : U
+ if (Pu(t)) {
+ var B = yn ? br.call(String(t), /^(Symbol\(.*\))_[^)]*$/, "$1") : ns.call(t);
+ return typeof t == "object" && !yn ? Qn(B) : B
}
- if (Bc(t)) {
- for (var de = "<" + Ia.call(String(t.nodeName)), L = t.attributes || [], be = 0; be < L.length; be++) de += " " + L[be].name + "=" + Ua(Cc(L[be].value), "double", a);
- return de += ">", t.childNodes && t.childNodes.length && (de += "..."), de += "</" + Ia.call(String(t.nodeName)) + ">", de
+ if (Fd(t)) {
+ for (var he = "<" + vu.call(String(t.nodeName)), U = t.attributes || [], $e = 0; $e < U.length; $e++) he += " " + U[$e].name + "=" + Cu(Td(U[$e].value), "double", a);
+ return he += ">", t.childNodes && t.childNodes.length && (he += "..."), he += "</" + vu.call(String(t.nodeName)) + ">", he
}
- if (Do(t)) {
+ if (os(t)) {
if (t.length === 0) return "[]";
- var ye = di(t, $);
- return N && !Hc(ye) ? "[" + $o(ye, N) + "]" : "[ " + Bt.call(ye, ", ") + " ]"
+ var oe = Di(t, P);
+ return E && !qd(oe) ? "[" + as(oe, E) + "]" : "[ " + zt.call(oe, ", ") + " ]"
}
- if (Pc(t)) {
- var te = di(t, $);
- return !("cause" in Error.prototype) && "cause" in t && !Fa.call(t, "cause") ? "{ [" + String(t) + "] " + Bt.call(Ma.call("[cause]: " + $(t.cause), te), ", ") + " }" : te.length === 0 ? "[" + String(t) + "]" : "{ [" + String(t) + "] " + Bt.call(te, ", ") + " }"
+ if (Cd(t)) {
+ var Ie = Di(t, P);
+ return !("cause" in Error.prototype) && "cause" in t && !xu.call(t, "cause") ? "{ [" + String(t) + "] " + zt.call(wu.call("[cause]: " + P(t.cause), Ie), ", ") + " }" : Ie.length === 0 ? "[" + String(t) + "]" : "{ [" + String(t) + "] " + zt.call(Ie, ", ") + " }"
}
if (typeof t == "object" && c) {
- if (Ba && typeof t[Ba] == "function" && Ro) return Ro(t, {
- depth: w - o
+ if (Ou && typeof t[Ou] == "function" && is) return is(t, {
+ depth: _ - i
});
if (c !== "symbol" && typeof t.inspect == "function") return t.inspect()
}
- if (Lc(t)) {
- var qe = [];
- return Na && Na.call(t, function(le, nt) {
- qe.push($(nt, t, !0) + " => " + $(le, t))
- }), Ka("Map", fi.call(t), qe, N)
- }
- if (jc(t)) {
- var Ct = [];
- return Ra && Ra.call(t, function(le) {
- Ct.push($(le, t))
- }), Ka("Set", ci.call(t), Ct, N)
- }
- if (Fc(t)) return Io("WeakMap");
- if (qc(t)) return Io("WeakSet");
- if (kc(t)) return Io("WeakRef");
- if (Rc(t)) return Mn($(Number(t)));
- if (Ic(t)) return Mn($(Oo.call(t)));
- if (Dc(t)) return Mn(_c.call(t));
- if (Nc(t)) return Mn($(String(t)));
- if (!Oc(t) && !Ha(t)) {
- var f = di(t, $),
- Be = ka ? ka(t) === Object.prototype : t instanceof Object || t.constructor === Object,
- me = t instanceof Object ? "" : "null prototype",
- rt = !Be && Ze && Object(t) === t && Ze in t ? Co.call(gr(t), 8, -1) : me ? "Object" : "",
- wt = Be || typeof t.constructor != "function" ? "" : t.constructor.name ? t.constructor.name + " " : "",
- Qe = wt + (rt || me ? "[" + Bt.call(Ma.call([], rt || [], me || []), ": ") + "] " : "");
- return f.length === 0 ? Qe + "{}" : N ? Qe + "{" + $o(f, N) + "}" : Qe + "{ " + Bt.call(f, ", ") + " }"
+ if (Id(t)) {
+ var ne = [];
+ return gu && gu.call(t, function(de, pt) {
+ ne.push(P(pt, t, !0) + " => " + P(de, t))
+ }), Nu("Map", Ri.call(t), ne, E)
+ }
+ if (jd(t)) {
+ var xt = [];
+ return yu && yu.call(t, function(de) {
+ xt.push(P(de, t))
+ }), Nu("Set", Ni.call(t), xt, E)
+ }
+ if (Md(t)) return ss("WeakMap");
+ if (Ld(t)) return ss("WeakSet");
+ if (kd(t)) return ss("WeakRef");
+ if (Pd(t)) return Qn(P(Number(t)));
+ if (Rd(t)) return Qn(P(ts.call(t)));
+ if ($d(t)) return Qn(vd.call(t));
+ if (Ad(t)) return Qn(P(String(t)));
+ if (!Od(t) && !Au(t)) {
+ var f = Di(t, P),
+ Ve = Su ? Su(t) === Object.prototype : t instanceof Object || t.constructor === Object,
+ ce = t instanceof Object ? "" : "null prototype",
+ Ye = !Ve && it && Object(t) === t && it in t ? es.call(_r(t), 8, -1) : ce ? "Object" : "",
+ ut = Ve || typeof t.constructor != "function" ? "" : t.constructor.name ? t.constructor.name + " " : "",
+ ke = ut + (Ye || ce ? "[" + zt.call(wu.call([], Ye || [], ce || []), ": ") + "] " : "");
+ return f.length === 0 ? ke + "{}" : E ? ke + "{" + as(f, E) + "}" : ke + "{ " + zt.call(f, ", ") + " }"
}
return String(t)
};
- function Ua(e, t, n) {
- var o = (n.quoteStyle || t) === "double" ? '"' : "'";
- return o + e + o
+ function Cu(e, t, r) {
+ var i = (r.quoteStyle || t) === "double" ? '"' : "'";
+ return i + e + i
}
- function Cc(e) {
- return pr.call(String(e), /"/g, """)
+ function Td(e) {
+ return br.call(String(e), /"/g, """)
}
- function Do(e) {
- return gr(e) === "[object Array]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function os(e) {
+ return _r(e) === "[object Array]" && (!it || !(typeof e == "object" && it in e))
}
- function Oc(e) {
- return gr(e) === "[object Date]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function Od(e) {
+ return _r(e) === "[object Date]" && (!it || !(typeof e == "object" && it in e))
}
- function Ha(e) {
- return gr(e) === "[object RegExp]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function Au(e) {
+ return _r(e) === "[object RegExp]" && (!it || !(typeof e == "object" && it in e))
}
- function Pc(e) {
- return gr(e) === "[object Error]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function Cd(e) {
+ return _r(e) === "[object Error]" && (!it || !(typeof e == "object" && it in e))
}
- function Nc(e) {
- return gr(e) === "[object String]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function Ad(e) {
+ return _r(e) === "[object String]" && (!it || !(typeof e == "object" && it in e))
}
- function Rc(e) {
- return gr(e) === "[object Number]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function Pd(e) {
+ return _r(e) === "[object Number]" && (!it || !(typeof e == "object" && it in e))
}
- function Dc(e) {
- return gr(e) === "[object Boolean]" && (!Ze || !(typeof e == "object" && Ze in e))
+ function $d(e) {
+ return _r(e) === "[object Boolean]" && (!it || !(typeof e == "object" && it in e))
}
- function Wa(e) {
- if (Yr) return e && typeof e == "object" && e instanceof Symbol;
+ function Pu(e) {
+ if (yn) return e && typeof e == "object" && e instanceof Symbol;
if (typeof e == "symbol") return !0;
- if (!e || typeof e != "object" || !No) return !1;
+ if (!e || typeof e != "object" || !ns) return !1;
try {
- return No.call(e), !0
+ return ns.call(e), !0
} catch {}
return !1
}
- function Ic(e) {
- if (!e || typeof e != "object" || !Oo) return !1;
+ function Rd(e) {
+ if (!e || typeof e != "object" || !ts) return !1;
try {
- return Oo.call(e), !0
+ return ts.call(e), !0
} catch {}
return !1
}
- var $c = Object.prototype.hasOwnProperty || function(e) {
+ var Nd = Object.prototype.hasOwnProperty || function(e) {
return e in this
};
- function hr(e, t) {
- return $c.call(e, t)
+ function wr(e, t) {
+ return Nd.call(e, t)
}
- function gr(e) {
- return xc.call(e)
+ function _r(e) {
+ return bd.call(e)
}
- function Mc(e) {
+ function Dd(e) {
if (e.name) return e.name;
- var t = Sc.call(wc.call(e), /^function\s*([\w$]+)/);
+ var t = _d.call(wd.call(e), /^function\s*([\w$]+)/);
return t ? t[1] : null
}
- function Va(e, t) {
+ function $u(e, t) {
if (e.indexOf) return e.indexOf(t);
- for (var n = 0, o = e.length; n < o; n++)
- if (e[n] === t) return n;
+ for (var r = 0, i = e.length; r < i; r++)
+ if (e[r] === t) return r;
return -1
}
- function Lc(e) {
- if (!fi || !e || typeof e != "object") return !1;
+ function Id(e) {
+ if (!Ri || !e || typeof e != "object") return !1;
try {
- fi.call(e);
+ Ri.call(e);
try {
- ci.call(e)
+ Ni.call(e)
} catch {
return !0
}
return e instanceof Map
} catch {}
return !1
}
- function Fc(e) {
- if (!In || !e || typeof e != "object") return !1;
+ function Md(e) {
+ if (!Kn || !e || typeof e != "object") return !1;
try {
- In.call(e, In);
+ Kn.call(e, Kn);
try {
- $n.call(e, $n)
+ Jn.call(e, Jn)
} catch {
return !0
}
return e instanceof WeakMap
} catch {}
return !1
}
- function kc(e) {
- if (!Da || !e || typeof e != "object") return !1;
+ function kd(e) {
+ if (!mu || !e || typeof e != "object") return !1;
try {
- return Da.call(e), !0
+ return mu.call(e), !0
} catch {}
return !1
}
- function jc(e) {
- if (!ci || !e || typeof e != "object") return !1;
+ function jd(e) {
+ if (!Ni || !e || typeof e != "object") return !1;
try {
- ci.call(e);
+ Ni.call(e);
try {
- fi.call(e)
+ Ri.call(e)
} catch {
return !0
}
return e instanceof Set
} catch {}
return !1
}
- function qc(e) {
- if (!$n || !e || typeof e != "object") return !1;
+ function Ld(e) {
+ if (!Jn || !e || typeof e != "object") return !1;
try {
- $n.call(e, $n);
+ Jn.call(e, Jn);
try {
- In.call(e, In)
+ Kn.call(e, Kn)
} catch {
return !0
}
return e instanceof WeakSet
} catch {}
return !1
}
- function Bc(e) {
+ function Fd(e) {
return !e || typeof e != "object" ? !1 : typeof HTMLElement != "undefined" && e instanceof HTMLElement ? !0 : typeof e.nodeName == "string" && typeof e.getAttribute == "function"
}
- function za(e, t) {
+ function Ru(e, t) {
if (e.length > t.maxStringLength) {
- var n = e.length - t.maxStringLength,
- o = "... " + n + " more character" + (n > 1 ? "s" : "");
- return za(Co.call(e, 0, t.maxStringLength), t) + o
+ var r = e.length - t.maxStringLength,
+ i = "... " + r + " more character" + (r > 1 ? "s" : "");
+ return Ru(es.call(e, 0, t.maxStringLength), t) + i
}
- var s = pr.call(pr.call(e, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, Uc);
- return Ua(s, "single", t)
+ var s = br.call(br.call(e, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, Ud);
+ return Cu(s, "single", t)
}
- function Uc(e) {
+ function Ud(e) {
var t = e.charCodeAt(0),
- n = {
+ r = {
8: "b",
9: "t",
10: "n",
12: "f",
13: "r"
} [t];
- return n ? "\\" + n : "\\x" + (t < 16 ? "0" : "") + Ec.call(t.toString(16))
+ return r ? "\\" + r : "\\x" + (t < 16 ? "0" : "") + xd.call(t.toString(16))
}
- function Mn(e) {
+ function Qn(e) {
return "Object(" + e + ")"
}
- function Io(e) {
+ function ss(e) {
return e + " { ? }"
}
- function Ka(e, t, n, o) {
- var s = o ? $o(n, o) : Bt.call(n, ", ");
+ function Nu(e, t, r, i) {
+ var s = i ? as(r, i) : zt.call(r, ", ");
return e + " (" + t + ") {" + s + "}"
}
- function Hc(e) {
+ function qd(e) {
for (var t = 0; t < e.length; t++)
- if (Va(e[t], `
+ if ($u(e[t], `
`) >= 0) return !1;
return !0
}
- function Wc(e, t) {
- var n;
- if (e.indent === " ") n = " ";
- else if (typeof e.indent == "number" && e.indent > 0) n = Bt.call(Array(e.indent + 1), " ");
+ function Hd(e, t) {
+ var r;
+ if (e.indent === " ") r = " ";
+ else if (typeof e.indent == "number" && e.indent > 0) r = zt.call(Array(e.indent + 1), " ");
else return null;
return {
- base: n,
- prev: Bt.call(Array(t + 1), n)
+ base: r,
+ prev: zt.call(Array(t + 1), r)
}
}
- function $o(e, t) {
+ function as(e, t) {
if (e.length === 0) return "";
- var n = `
+ var r = `
` + t.prev + t.base;
- return n + Bt.call(e, "," + n) + `
+ return r + zt.call(e, "," + r) + `
` + t.prev
}
- function di(e, t) {
- var n = Do(e),
- o = [];
- if (n) {
- o.length = e.length;
- for (var s = 0; s < e.length; s++) o[s] = hr(e, s) ? t(e[s], e) : ""
+ function Di(e, t) {
+ var r = os(e),
+ i = [];
+ if (r) {
+ i.length = e.length;
+ for (var s = 0; s < e.length; s++) i[s] = wr(e, s) ? t(e[s], e) : ""
}
- var a = typeof Po == "function" ? Po(e) : [],
+ var a = typeof rs == "function" ? rs(e) : [],
c;
- if (Yr) {
+ if (yn) {
c = {};
for (var h = 0; h < a.length; h++) c["$" + a[h]] = a[h]
}
- for (var y in e) !hr(e, y) || n && String(Number(y)) === y && y < e.length || Yr && c["$" + y] instanceof Symbol || ($a.call(/[^\w$]/, y) ? o.push(t(y, e) + ": " + t(e[y], e)) : o.push(y + ": " + t(e[y], e)));
- if (typeof Po == "function")
- for (var b = 0; b < a.length; b++) Fa.call(e, a[b]) && o.push("[" + t(a[b]) + "]: " + t(e[a[b]], e));
- return o
- }
- var Mo = wo,
- Zr = pc,
- Vc = Ac,
- zc = Mo("%TypeError%"),
- pi = Mo("%WeakMap%", !0),
- hi = Mo("%Map%", !0),
- Kc = Zr("WeakMap.prototype.get", !0),
- Jc = Zr("WeakMap.prototype.set", !0),
- Qc = Zr("WeakMap.prototype.has", !0),
- Xc = Zr("Map.prototype.get", !0),
- Gc = Zr("Map.prototype.set", !0),
- Yc = Zr("Map.prototype.has", !0),
- Lo = function(e, t) {
- for (var n = e, o;
- (o = n.next) !== null; n = o)
- if (o.key === t) return n.next = o.next, o.next = e.next, e.next = o, o
- },
- Zc = function(e, t) {
- var n = Lo(e, t);
- return n && n.value
- },
- ed = function(e, t, n) {
- var o = Lo(e, t);
- o ? o.value = n : e.next = {
+ for (var y in e) !wr(e, y) || r && String(Number(y)) === y && y < e.length || yn && c["$" + y] instanceof Symbol || (bu.call(/[^\w$]/, y) ? i.push(t(y, e) + ": " + t(e[y], e)) : i.push(y + ": " + t(e[y], e)));
+ if (typeof rs == "function")
+ for (var v = 0; v < a.length; v++) xu.call(e, a[v]) && i.push("[" + t(a[v]) + "]: " + t(e[a[v]], e));
+ return i
+ }
+ var us = Qo,
+ mn = cd,
+ Bd = Ed,
+ Wd = us("%TypeError%"),
+ Ii = us("%WeakMap%", !0),
+ Mi = us("%Map%", !0),
+ Vd = mn("WeakMap.prototype.get", !0),
+ zd = mn("WeakMap.prototype.set", !0),
+ Kd = mn("WeakMap.prototype.has", !0),
+ Jd = mn("Map.prototype.get", !0),
+ Qd = mn("Map.prototype.set", !0),
+ Gd = mn("Map.prototype.has", !0),
+ ls = function(e, t) {
+ for (var r = e, i;
+ (i = r.next) !== null; r = i)
+ if (i.key === t) return r.next = i.next, i.next = e.next, e.next = i, i
+ },
+ Xd = function(e, t) {
+ var r = ls(e, t);
+ return r && r.value
+ },
+ Yd = function(e, t, r) {
+ var i = ls(e, t);
+ i ? i.value = r : e.next = {
key: t,
next: e.next,
- value: n
+ value: r
}
},
- td = function(e, t) {
- return !!Lo(e, t)
+ Zd = function(e, t) {
+ return !!ls(e, t)
},
- rd = function() {
- var t, n, o, s = {
+ ep = function() {
+ var t, r, i, s = {
assert: function(a) {
- if (!s.has(a)) throw new zc("Side channel does not contain " + Vc(a))
+ if (!s.has(a)) throw new Wd("Side channel does not contain " + Bd(a))
},
get: function(a) {
- if (pi && a && (typeof a == "object" || typeof a == "function")) {
- if (t) return Kc(t, a)
- } else if (hi) {
- if (n) return Xc(n, a)
- } else if (o) return Zc(o, a)
+ if (Ii && a && (typeof a == "object" || typeof a == "function")) {
+ if (t) return Vd(t, a)
+ } else if (Mi) {
+ if (r) return Jd(r, a)
+ } else if (i) return Xd(i, a)
},
has: function(a) {
- if (pi && a && (typeof a == "object" || typeof a == "function")) {
- if (t) return Qc(t, a)
- } else if (hi) {
- if (n) return Yc(n, a)
- } else if (o) return td(o, a);
+ if (Ii && a && (typeof a == "object" || typeof a == "function")) {
+ if (t) return Kd(t, a)
+ } else if (Mi) {
+ if (r) return Gd(r, a)
+ } else if (i) return Zd(i, a);
return !1
},
set: function(a, c) {
- pi && a && (typeof a == "object" || typeof a == "function") ? (t || (t = new pi), Jc(t, a, c)) : hi ? (n || (n = new hi), Gc(n, a, c)) : (o || (o = {
+ Ii && a && (typeof a == "object" || typeof a == "function") ? (t || (t = new Ii), zd(t, a, c)) : Mi ? (r || (r = new Mi), Qd(r, a, c)) : (i || (i = {
key: {},
next: null
- }), ed(o, a, c))
+ }), Yd(i, a, c))
}
};
return s
},
- nd = String.prototype.replace,
- id = /%20/g,
- Fo = {
+ tp = String.prototype.replace,
+ rp = /%20/g,
+ fs = {
RFC1738: "RFC1738",
RFC3986: "RFC3986"
},
- ko = {
- default: Fo.RFC3986,
+ cs = {
+ default: fs.RFC3986,
formatters: {
RFC1738: function(e) {
- return nd.call(e, id, "+")
+ return tp.call(e, rp, "+")
},
RFC3986: function(e) {
return String(e)
}
},
- RFC1738: Fo.RFC1738,
- RFC3986: Fo.RFC3986
+ RFC1738: fs.RFC1738,
+ RFC3986: fs.RFC3986
},
- od = ko,
- jo = Object.prototype.hasOwnProperty,
- Pr = Array.isArray,
- Ut = function() {
+ np = cs,
+ ds = Object.prototype.hasOwnProperty,
+ Fr = Array.isArray,
+ Kt = function() {
for (var e = [], t = 0; t < 256; ++t) e.push("%" + ((t < 16 ? "0" : "") + t.toString(16)).toUpperCase());
return e
}(),
- sd = function(t) {
+ ip = function(t) {
for (; t.length > 1;) {
- var n = t.pop(),
- o = n.obj[n.prop];
- if (Pr(o)) {
- for (var s = [], a = 0; a < o.length; ++a) typeof o[a] != "undefined" && s.push(o[a]);
- n.obj[n.prop] = s
+ var r = t.pop(),
+ i = r.obj[r.prop];
+ if (Fr(i)) {
+ for (var s = [], a = 0; a < i.length; ++a) typeof i[a] != "undefined" && s.push(i[a]);
+ r.obj[r.prop] = s
}
}
},
- Ja = function(t, n) {
- for (var o = n && n.plainObjects ? Object.create(null) : {}, s = 0; s < t.length; ++s) typeof t[s] != "undefined" && (o[s] = t[s]);
- return o
- },
- ad = function e(t, n, o) {
- if (!n) return t;
- if (typeof n != "object") {
- if (Pr(t)) t.push(n);
- else if (t && typeof t == "object")(o && (o.plainObjects || o.allowPrototypes) || !jo.call(Object.prototype, n)) && (t[n] = !0);
- else return [t, n];
+ Du = function(t, r) {
+ for (var i = r && r.plainObjects ? Object.create(null) : {}, s = 0; s < t.length; ++s) typeof t[s] != "undefined" && (i[s] = t[s]);
+ return i
+ },
+ op = function e(t, r, i) {
+ if (!r) return t;
+ if (typeof r != "object") {
+ if (Fr(t)) t.push(r);
+ else if (t && typeof t == "object")(i && (i.plainObjects || i.allowPrototypes) || !ds.call(Object.prototype, r)) && (t[r] = !0);
+ else return [t, r];
return t
}
- if (!t || typeof t != "object") return [t].concat(n);
+ if (!t || typeof t != "object") return [t].concat(r);
var s = t;
- return Pr(t) && !Pr(n) && (s = Ja(t, o)), Pr(t) && Pr(n) ? (n.forEach(function(a, c) {
- if (jo.call(t, c)) {
+ return Fr(t) && !Fr(r) && (s = Du(t, i)), Fr(t) && Fr(r) ? (r.forEach(function(a, c) {
+ if (ds.call(t, c)) {
var h = t[c];
- h && typeof h == "object" && a && typeof a == "object" ? t[c] = e(h, a, o) : t.push(a)
+ h && typeof h == "object" && a && typeof a == "object" ? t[c] = e(h, a, i) : t.push(a)
} else t[c] = a
- }), t) : Object.keys(n).reduce(function(a, c) {
- var h = n[c];
- return jo.call(a, c) ? a[c] = e(a[c], h, o) : a[c] = h, a
+ }), t) : Object.keys(r).reduce(function(a, c) {
+ var h = r[c];
+ return ds.call(a, c) ? a[c] = e(a[c], h, i) : a[c] = h, a
}, s)
},
- ud = function(t, n) {
- return Object.keys(n).reduce(function(o, s) {
- return o[s] = n[s], o
+ sp = function(t, r) {
+ return Object.keys(r).reduce(function(i, s) {
+ return i[s] = r[s], i
}, t)
},
- ld = function(e, t, n) {
- var o = e.replace(/\+/g, " ");
- if (n === "iso-8859-1") return o.replace(/%[0-9a-f]{2}/gi, unescape);
+ ap = function(e, t, r) {
+ var i = e.replace(/\+/g, " ");
+ if (r === "iso-8859-1") return i.replace(/%[0-9a-f]{2}/gi, unescape);
try {
- return decodeURIComponent(o)
+ return decodeURIComponent(i)
} catch {
- return o
+ return i
}
},
- fd = function(t, n, o, s, a) {
+ up = function(t, r, i, s, a) {
if (t.length === 0) return t;
var c = t;
- if (typeof t == "symbol" ? c = Symbol.prototype.toString.call(t) : typeof t != "string" && (c = String(t)), o === "iso-8859-1") return escape(c).replace(/%u[0-9a-f]{4}/gi, function(w) {
- return "%26%23" + parseInt(w.slice(2), 16) + "%3B"
+ if (typeof t == "symbol" ? c = Symbol.prototype.toString.call(t) : typeof t != "string" && (c = String(t)), i === "iso-8859-1") return escape(c).replace(/%u[0-9a-f]{4}/gi, function(_) {
+ return "%26%23" + parseInt(_.slice(2), 16) + "%3B"
});
for (var h = "", y = 0; y < c.length; ++y) {
- var b = c.charCodeAt(y);
- if (b === 45 || b === 46 || b === 95 || b === 126 || b >= 48 && b <= 57 || b >= 65 && b <= 90 || b >= 97 && b <= 122 || a === od.RFC1738 && (b === 40 || b === 41)) {
+ var v = c.charCodeAt(y);
+ if (v === 45 || v === 46 || v === 95 || v === 126 || v >= 48 && v <= 57 || v >= 65 && v <= 90 || v >= 97 && v <= 122 || a === np.RFC1738 && (v === 40 || v === 41)) {
h += c.charAt(y);
continue
}
- if (b < 128) {
- h = h + Ut[b];
+ if (v < 128) {
+ h = h + Kt[v];
continue
}
- if (b < 2048) {
- h = h + (Ut[192 | b >> 6] + Ut[128 | b & 63]);
+ if (v < 2048) {
+ h = h + (Kt[192 | v >> 6] + Kt[128 | v & 63]);
continue
}
- if (b < 55296 || b >= 57344) {
- h = h + (Ut[224 | b >> 12] + Ut[128 | b >> 6 & 63] + Ut[128 | b & 63]);
+ if (v < 55296 || v >= 57344) {
+ h = h + (Kt[224 | v >> 12] + Kt[128 | v >> 6 & 63] + Kt[128 | v & 63]);
continue
}
- y += 1, b = 65536 + ((b & 1023) << 10 | c.charCodeAt(y) & 1023), h += Ut[240 | b >> 18] + Ut[128 | b >> 12 & 63] + Ut[128 | b >> 6 & 63] + Ut[128 | b & 63]
+ y += 1, v = 65536 + ((v & 1023) << 10 | c.charCodeAt(y) & 1023), h += Kt[240 | v >> 18] + Kt[128 | v >> 12 & 63] + Kt[128 | v >> 6 & 63] + Kt[128 | v & 63]
}
return h
},
- cd = function(t) {
- for (var n = [{
+ lp = function(t) {
+ for (var r = [{
obj: {
o: t
},
prop: "o"
- }], o = [], s = 0; s < n.length; ++s)
- for (var a = n[s], c = a.obj[a.prop], h = Object.keys(c), y = 0; y < h.length; ++y) {
- var b = h[y],
- w = c[b];
- typeof w == "object" && w !== null && o.indexOf(w) === -1 && (n.push({
+ }], i = [], s = 0; s < r.length; ++s)
+ for (var a = r[s], c = a.obj[a.prop], h = Object.keys(c), y = 0; y < h.length; ++y) {
+ var v = h[y],
+ _ = c[v];
+ typeof _ == "object" && _ !== null && i.indexOf(_) === -1 && (r.push({
obj: c,
- prop: b
- }), o.push(w))
+ prop: v
+ }), i.push(_))
}
- return sd(n), t
+ return ip(r), t
},
- dd = function(t) {
+ fp = function(t) {
return Object.prototype.toString.call(t) === "[object RegExp]"
},
- pd = function(t) {
+ cp = function(t) {
return !t || typeof t != "object" ? !1 : !!(t.constructor && t.constructor.isBuffer && t.constructor.isBuffer(t))
},
- hd = function(t, n) {
- return [].concat(t, n)
+ dp = function(t, r) {
+ return [].concat(t, r)
},
- gd = function(t, n) {
- if (Pr(t)) {
- for (var o = [], s = 0; s < t.length; s += 1) o.push(n(t[s]));
- return o
- }
- return n(t)
- },
- Qa = {
- arrayToObject: Ja,
- assign: ud,
- combine: hd,
- compact: cd,
- decode: ld,
- encode: fd,
- isBuffer: pd,
- isRegExp: dd,
- maybeMap: gd,
- merge: ad
- },
- Xa = rd,
- gi = Qa,
- Ln = ko,
- yd = Object.prototype.hasOwnProperty,
- Ga = {
+ pp = function(t, r) {
+ if (Fr(t)) {
+ for (var i = [], s = 0; s < t.length; s += 1) i.push(r(t[s]));
+ return i
+ }
+ return r(t)
+ },
+ Iu = {
+ arrayToObject: Du,
+ assign: sp,
+ combine: dp,
+ compact: lp,
+ decode: ap,
+ encode: up,
+ isBuffer: cp,
+ isRegExp: fp,
+ maybeMap: pp,
+ merge: op
+ },
+ Mu = ep,
+ ki = Iu,
+ Gn = cs,
+ hp = Object.prototype.hasOwnProperty,
+ ku = {
brackets: function(t) {
return t + "[]"
},
comma: "comma",
- indices: function(t, n) {
- return t + "[" + n + "]"
+ indices: function(t, r) {
+ return t + "[" + r + "]"
},
repeat: function(t) {
return t
}
},
- rr = Array.isArray,
- md = Array.prototype.push,
- Ya = function(e, t) {
- md.apply(e, rr(t) ? t : [t])
- },
- vd = Date.prototype.toISOString,
- Za = Ln.default,
- et = {
+ ur = Array.isArray,
+ gp = Array.prototype.push,
+ ju = function(e, t) {
+ gp.apply(e, ur(t) ? t : [t])
+ },
+ yp = Date.prototype.toISOString,
+ Lu = Gn.default,
+ ot = {
addQueryPrefix: !1,
allowDots: !1,
charset: "utf-8",
charsetSentinel: !1,
delimiter: "&",
encode: !0,
- encoder: gi.encode,
+ encoder: ki.encode,
encodeValuesOnly: !1,
- format: Za,
- formatter: Ln.formatters[Za],
+ format: Lu,
+ formatter: Gn.formatters[Lu],
indices: !1,
serializeDate: function(t) {
- return vd.call(t)
+ return yp.call(t)
},
skipNulls: !1,
strictNullHandling: !1
},
- bd = function(t) {
+ mp = function(t) {
return typeof t == "string" || typeof t == "number" || typeof t == "boolean" || typeof t == "symbol" || typeof t == "bigint"
},
- qo = {},
- _d = function e(t, n, o, s, a, c, h, y, b, w, N, $, W, q, U, de) {
- for (var L = t, be = de, ye = 0, te = !1;
- (be = be.get(qo)) !== void 0 && !te;) {
- var qe = be.get(t);
- if (ye += 1, typeof qe != "undefined") {
- if (qe === ye) throw new RangeError("Cyclic object value");
- te = !0
- }
- typeof be.get(qo) == "undefined" && (ye = 0)
- }
- if (typeof y == "function" ? L = y(n, L) : L instanceof Date ? L = N(L) : o === "comma" && rr(L) && (L = gi.maybeMap(L, function(Me) {
- return Me instanceof Date ? N(Me) : Me
- })), L === null) {
- if (a) return h && !q ? h(n, et.encoder, U, "key", $) : n;
- L = ""
+ ps = {},
+ vp = function e(t, r, i, s, a, c, h, y, v, _, E, P, q, j, B, he) {
+ for (var U = t, $e = he, oe = 0, Ie = !1;
+ ($e = $e.get(ps)) !== void 0 && !Ie;) {
+ var ne = $e.get(t);
+ if (oe += 1, typeof ne != "undefined") {
+ if (ne === oe) throw new RangeError("Cyclic object value");
+ Ie = !0
+ }
+ typeof $e.get(ps) == "undefined" && (oe = 0)
+ }
+ if (typeof y == "function" ? U = y(r, U) : U instanceof Date ? U = E(U) : i === "comma" && ur(U) && (U = ki.maybeMap(U, function(Ue) {
+ return Ue instanceof Date ? E(Ue) : Ue
+ })), U === null) {
+ if (a) return h && !j ? h(r, ot.encoder, B, "key", P) : r;
+ U = ""
}
- if (bd(L) || gi.isBuffer(L)) {
+ if (mp(U) || ki.isBuffer(U)) {
if (h) {
- var Ct = q ? n : h(n, et.encoder, U, "key", $);
- return [W(Ct) + "=" + W(h(L, et.encoder, U, "value", $))]
+ var xt = j ? r : h(r, ot.encoder, B, "key", P);
+ return [q(xt) + "=" + q(h(U, ot.encoder, B, "value", P))]
}
- return [W(n) + "=" + W(String(L))]
+ return [q(r) + "=" + q(String(U))]
}
var f = [];
- if (typeof L == "undefined") return f;
- var Be;
- if (o === "comma" && rr(L)) q && h && (L = gi.maybeMap(L, h)), Be = [{
- value: L.length > 0 ? L.join(",") || null : void 0
+ if (typeof U == "undefined") return f;
+ var Ve;
+ if (i === "comma" && ur(U)) j && h && (U = ki.maybeMap(U, h)), Ve = [{
+ value: U.length > 0 ? U.join(",") || null : void 0
}];
- else if (rr(y)) Be = y;
+ else if (ur(y)) Ve = y;
else {
- var me = Object.keys(L);
- Be = b ? me.sort(b) : me
+ var ce = Object.keys(U);
+ Ve = v ? ce.sort(v) : ce
}
- for (var rt = s && rr(L) && L.length === 1 ? n + "[]" : n, wt = 0; wt < Be.length; ++wt) {
- var Qe = Be[wt],
- le = typeof Qe == "object" && typeof Qe.value != "undefined" ? Qe.value : L[Qe];
- if (!(c && le === null)) {
- var nt = rr(L) ? typeof o == "function" ? o(rt, Qe) : rt : rt + (w ? "." + Qe : "[" + Qe + "]");
- de.set(t, ye);
- var ur = Xa();
- ur.set(qo, de), Ya(f, e(le, nt, o, s, a, c, o === "comma" && q && rr(L) ? null : h, y, b, w, N, $, W, q, U, ur))
+ for (var Ye = s && ur(U) && U.length === 1 ? r + "[]" : r, ut = 0; ut < Ve.length; ++ut) {
+ var ke = Ve[ut],
+ de = typeof ke == "object" && typeof ke.value != "undefined" ? ke.value : U[ke];
+ if (!(c && de === null)) {
+ var pt = ur(U) ? typeof i == "function" ? i(Ye, ke) : Ye : Ye + (_ ? "." + ke : "[" + ke + "]");
+ he.set(t, oe);
+ var ht = Mu();
+ ht.set(ps, he), ju(f, e(de, pt, i, s, a, c, i === "comma" && j && ur(U) ? null : h, y, v, _, E, P, q, j, B, ht))
}
}
return f
},
- xd = function(t) {
- if (!t) return et;
+ bp = function(t) {
+ if (!t) return ot;
if (t.encoder !== null && typeof t.encoder != "undefined" && typeof t.encoder != "function") throw new TypeError("Encoder has to be a function.");
- var n = t.charset || et.charset;
+ var r = t.charset || ot.charset;
if (typeof t.charset != "undefined" && t.charset !== "utf-8" && t.charset !== "iso-8859-1") throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
- var o = Ln.default;
+ var i = Gn.default;
if (typeof t.format != "undefined") {
- if (!yd.call(Ln.formatters, t.format)) throw new TypeError("Unknown format option provided.");
- o = t.format
+ if (!hp.call(Gn.formatters, t.format)) throw new TypeError("Unknown format option provided.");
+ i = t.format
}
- var s = Ln.formatters[o],
- a = et.filter;
- return (typeof t.filter == "function" || rr(t.filter)) && (a = t.filter), {
- addQueryPrefix: typeof t.addQueryPrefix == "boolean" ? t.addQueryPrefix : et.addQueryPrefix,
- allowDots: typeof t.allowDots == "undefined" ? et.allowDots : !!t.allowDots,
- charset: n,
- charsetSentinel: typeof t.charsetSentinel == "boolean" ? t.charsetSentinel : et.charsetSentinel,
- delimiter: typeof t.delimiter == "undefined" ? et.delimiter : t.delimiter,
- encode: typeof t.encode == "boolean" ? t.encode : et.encode,
- encoder: typeof t.encoder == "function" ? t.encoder : et.encoder,
- encodeValuesOnly: typeof t.encodeValuesOnly == "boolean" ? t.encodeValuesOnly : et.encodeValuesOnly,
+ var s = Gn.formatters[i],
+ a = ot.filter;
+ return (typeof t.filter == "function" || ur(t.filter)) && (a = t.filter), {
+ addQueryPrefix: typeof t.addQueryPrefix == "boolean" ? t.addQueryPrefix : ot.addQueryPrefix,
+ allowDots: typeof t.allowDots == "undefined" ? ot.allowDots : !!t.allowDots,
+ charset: r,
+ charsetSentinel: typeof t.charsetSentinel == "boolean" ? t.charsetSentinel : ot.charsetSentinel,
+ delimiter: typeof t.delimiter == "undefined" ? ot.delimiter : t.delimiter,
+ encode: typeof t.encode == "boolean" ? t.encode : ot.encode,
+ encoder: typeof t.encoder == "function" ? t.encoder : ot.encoder,
+ encodeValuesOnly: typeof t.encodeValuesOnly == "boolean" ? t.encodeValuesOnly : ot.encodeValuesOnly,
filter: a,
- format: o,
+ format: i,
formatter: s,
- serializeDate: typeof t.serializeDate == "function" ? t.serializeDate : et.serializeDate,
- skipNulls: typeof t.skipNulls == "boolean" ? t.skipNulls : et.skipNulls,
+ serializeDate: typeof t.serializeDate == "function" ? t.serializeDate : ot.serializeDate,
+ skipNulls: typeof t.skipNulls == "boolean" ? t.skipNulls : ot.skipNulls,
sort: typeof t.sort == "function" ? t.sort : null,
- strictNullHandling: typeof t.strictNullHandling == "boolean" ? t.strictNullHandling : et.strictNullHandling
+ strictNullHandling: typeof t.strictNullHandling == "boolean" ? t.strictNullHandling : ot.strictNullHandling
}
},
- wd = function(e, t) {
- var n = e,
- o = xd(t),
+ wp = function(e, t) {
+ var r = e,
+ i = bp(t),
s, a;
- typeof o.filter == "function" ? (a = o.filter, n = a("", n)) : rr(o.filter) && (a = o.filter, s = a);
+ typeof i.filter == "function" ? (a = i.filter, r = a("", r)) : ur(i.filter) && (a = i.filter, s = a);
var c = [];
- if (typeof n != "object" || n === null) return "";
+ if (typeof r != "object" || r === null) return "";
var h;
- t && t.arrayFormat in Ga ? h = t.arrayFormat : t && "indices" in t ? h = t.indices ? "indices" : "repeat" : h = "indices";
- var y = Ga[h];
+ t && t.arrayFormat in ku ? h = t.arrayFormat : t && "indices" in t ? h = t.indices ? "indices" : "repeat" : h = "indices";
+ var y = ku[h];
if (t && "commaRoundTrip" in t && typeof t.commaRoundTrip != "boolean") throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
- var b = y === "comma" && t && t.commaRoundTrip;
- s || (s = Object.keys(n)), o.sort && s.sort(o.sort);
- for (var w = Xa(), N = 0; N < s.length; ++N) {
- var $ = s[N];
- o.skipNulls && n[$] === null || Ya(c, _d(n[$], $, y, b, o.strictNullHandling, o.skipNulls, o.encode ? o.encoder : null, o.filter, o.sort, o.allowDots, o.serializeDate, o.format, o.formatter, o.encodeValuesOnly, o.charset, w))
- }
- var W = c.join(o.delimiter),
- q = o.addQueryPrefix === !0 ? "?" : "";
- return o.charsetSentinel && (o.charset === "iso-8859-1" ? q += "utf8=%26%2310003%3B&" : q += "utf8=%E2%9C%93&"), W.length > 0 ? q + W : ""
- },
- en = Qa,
- Bo = Object.prototype.hasOwnProperty,
- Sd = Array.isArray,
- ze = {
+ var v = y === "comma" && t && t.commaRoundTrip;
+ s || (s = Object.keys(r)), i.sort && s.sort(i.sort);
+ for (var _ = Mu(), E = 0; E < s.length; ++E) {
+ var P = s[E];
+ i.skipNulls && r[P] === null || ju(c, vp(r[P], P, y, v, i.strictNullHandling, i.skipNulls, i.encode ? i.encoder : null, i.filter, i.sort, i.allowDots, i.serializeDate, i.format, i.formatter, i.encodeValuesOnly, i.charset, _))
+ }
+ var q = c.join(i.delimiter),
+ j = i.addQueryPrefix === !0 ? "?" : "";
+ return i.charsetSentinel && (i.charset === "iso-8859-1" ? j += "utf8=%26%2310003%3B&" : j += "utf8=%E2%9C%93&"), q.length > 0 ? j + q : ""
+ },
+ vn = Iu,
+ hs = Object.prototype.hasOwnProperty,
+ _p = Array.isArray,
+ Je = {
allowDots: !1,
allowPrototypes: !1,
allowSparse: !1,
arrayLimit: 20,
charset: "utf-8",
charsetSentinel: !1,
comma: !1,
- decoder: en.decode,
+ decoder: vn.decode,
delimiter: "&",
depth: 5,
ignoreQueryPrefix: !1,
interpretNumericEntities: !1,
parameterLimit: 1e3,
parseArrays: !0,
plainObjects: !1,
strictNullHandling: !1
},
- Ed = function(e) {
- return e.replace(/&#(\d+);/g, function(t, n) {
- return String.fromCharCode(parseInt(n, 10))
+ xp = function(e) {
+ return e.replace(/&#(\d+);/g, function(t, r) {
+ return String.fromCharCode(parseInt(r, 10))
})
},
- eu = function(e, t) {
+ Fu = function(e, t) {
return e && typeof e == "string" && t.comma && e.indexOf(",") > -1 ? e.split(",") : e
},
- Td = "utf8=%26%2310003%3B",
- Ad = "utf8=%E2%9C%93",
- Cd = function(t, n) {
- var o = {
+ Sp = "utf8=%26%2310003%3B",
+ Ep = "utf8=%E2%9C%93",
+ Tp = function(t, r) {
+ var i = {
__proto__: null
},
- s = n.ignoreQueryPrefix ? t.replace(/^\?/, "") : t,
- a = n.parameterLimit === 1 / 0 ? void 0 : n.parameterLimit,
- c = s.split(n.delimiter, a),
+ s = r.ignoreQueryPrefix ? t.replace(/^\?/, "") : t,
+ a = r.parameterLimit === 1 / 0 ? void 0 : r.parameterLimit,
+ c = s.split(r.delimiter, a),
h = -1,
- y, b = n.charset;
- if (n.charsetSentinel)
- for (y = 0; y < c.length; ++y) c[y].indexOf("utf8=") === 0 && (c[y] === Ad ? b = "utf-8" : c[y] === Td && (b = "iso-8859-1"), h = y, y = c.length);
+ y, v = r.charset;
+ if (r.charsetSentinel)
+ for (y = 0; y < c.length; ++y) c[y].indexOf("utf8=") === 0 && (c[y] === Ep ? v = "utf-8" : c[y] === Sp && (v = "iso-8859-1"), h = y, y = c.length);
for (y = 0; y < c.length; ++y)
if (y !== h) {
- var w = c[y],
- N = w.indexOf("]="),
- $ = N === -1 ? w.indexOf("=") : N + 1,
- W, q;
- $ === -1 ? (W = n.decoder(w, ze.decoder, b, "key"), q = n.strictNullHandling ? null : "") : (W = n.decoder(w.slice(0, $), ze.decoder, b, "key"), q = en.maybeMap(eu(w.slice($ + 1), n), function(U) {
- return n.decoder(U, ze.decoder, b, "value")
- })), q && n.interpretNumericEntities && b === "iso-8859-1" && (q = Ed(q)), w.indexOf("[]=") > -1 && (q = Sd(q) ? [q] : q), Bo.call(o, W) ? o[W] = en.combine(o[W], q) : o[W] = q
- } return o
+ var _ = c[y],
+ E = _.indexOf("]="),
+ P = E === -1 ? _.indexOf("=") : E + 1,
+ q, j;
+ P === -1 ? (q = r.decoder(_, Je.decoder, v, "key"), j = r.strictNullHandling ? null : "") : (q = r.decoder(_.slice(0, P), Je.decoder, v, "key"), j = vn.maybeMap(Fu(_.slice(P + 1), r), function(B) {
+ return r.decoder(B, Je.decoder, v, "value")
+ })), j && r.interpretNumericEntities && v === "iso-8859-1" && (j = xp(j)), _.indexOf("[]=") > -1 && (j = _p(j) ? [j] : j), hs.call(i, q) ? i[q] = vn.combine(i[q], j) : i[q] = j
+ } return i
},
- Od = function(e, t, n, o) {
- for (var s = o ? t : eu(t, n), a = e.length - 1; a >= 0; --a) {
+ Op = function(e, t, r, i) {
+ for (var s = i ? t : Fu(t, r), a = e.length - 1; a >= 0; --a) {
var c, h = e[a];
- if (h === "[]" && n.parseArrays) c = [].concat(s);
+ if (h === "[]" && r.parseArrays) c = [].concat(s);
else {
- c = n.plainObjects ? Object.create(null) : {};
+ c = r.plainObjects ? Object.create(null) : {};
var y = h.charAt(0) === "[" && h.charAt(h.length - 1) === "]" ? h.slice(1, -1) : h,
- b = parseInt(y, 10);
- !n.parseArrays && y === "" ? c = {
+ v = parseInt(y, 10);
+ !r.parseArrays && y === "" ? c = {
0: s
- } : !isNaN(b) && h !== y && String(b) === y && b >= 0 && n.parseArrays && b <= n.arrayLimit ? (c = [], c[b] = s) : y !== "__proto__" && (c[y] = s)
+ } : !isNaN(v) && h !== y && String(v) === y && v >= 0 && r.parseArrays && v <= r.arrayLimit ? (c = [], c[v] = s) : y !== "__proto__" && (c[y] = s)
}
s = c
}
return s
},
- Pd = function(t, n, o, s) {
+ Cp = function(t, r, i, s) {
if (!!t) {
- var a = o.allowDots ? t.replace(/\.([^.[]+)/g, "[$1]") : t,
+ var a = i.allowDots ? t.replace(/\.([^.[]+)/g, "[$1]") : t,
c = /(\[[^[\]]*])/,
h = /(\[[^[\]]*])/g,
- y = o.depth > 0 && c.exec(a),
- b = y ? a.slice(0, y.index) : a,
- w = [];
- if (b) {
- if (!o.plainObjects && Bo.call(Object.prototype, b) && !o.allowPrototypes) return;
- w.push(b)
- }
- for (var N = 0; o.depth > 0 && (y = h.exec(a)) !== null && N < o.depth;) {
- if (N += 1, !o.plainObjects && Bo.call(Object.prototype, y[1].slice(1, -1)) && !o.allowPrototypes) return;
- w.push(y[1])
+ y = i.depth > 0 && c.exec(a),
+ v = y ? a.slice(0, y.index) : a,
+ _ = [];
+ if (v) {
+ if (!i.plainObjects && hs.call(Object.prototype, v) && !i.allowPrototypes) return;
+ _.push(v)
+ }
+ for (var E = 0; i.depth > 0 && (y = h.exec(a)) !== null && E < i.depth;) {
+ if (E += 1, !i.plainObjects && hs.call(Object.prototype, y[1].slice(1, -1)) && !i.allowPrototypes) return;
+ _.push(y[1])
}
- return y && w.push("[" + a.slice(y.index) + "]"), Od(w, n, o, s)
+ return y && _.push("[" + a.slice(y.index) + "]"), Op(_, r, i, s)
}
},
- Nd = function(t) {
- if (!t) return ze;
+ Ap = function(t) {
+ if (!t) return Je;
if (t.decoder !== null && t.decoder !== void 0 && typeof t.decoder != "function") throw new TypeError("Decoder has to be a function.");
if (typeof t.charset != "undefined" && t.charset !== "utf-8" && t.charset !== "iso-8859-1") throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
- var n = typeof t.charset == "undefined" ? ze.charset : t.charset;
+ var r = typeof t.charset == "undefined" ? Je.charset : t.charset;
return {
- allowDots: typeof t.allowDots == "undefined" ? ze.allowDots : !!t.allowDots,
- allowPrototypes: typeof t.allowPrototypes == "boolean" ? t.allowPrototypes : ze.allowPrototypes,
- allowSparse: typeof t.allowSparse == "boolean" ? t.allowSparse : ze.allowSparse,
- arrayLimit: typeof t.arrayLimit == "number" ? t.arrayLimit : ze.arrayLimit,
- charset: n,
- charsetSentinel: typeof t.charsetSentinel == "boolean" ? t.charsetSentinel : ze.charsetSentinel,
- comma: typeof t.comma == "boolean" ? t.comma : ze.comma,
- decoder: typeof t.decoder == "function" ? t.decoder : ze.decoder,
- delimiter: typeof t.delimiter == "string" || en.isRegExp(t.delimiter) ? t.delimiter : ze.delimiter,
- depth: typeof t.depth == "number" || t.depth === !1 ? +t.depth : ze.depth,
+ allowDots: typeof t.allowDots == "undefined" ? Je.allowDots : !!t.allowDots,
+ allowPrototypes: typeof t.allowPrototypes == "boolean" ? t.allowPrototypes : Je.allowPrototypes,
+ allowSparse: typeof t.allowSparse == "boolean" ? t.allowSparse : Je.allowSparse,
+ arrayLimit: typeof t.arrayLimit == "number" ? t.arrayLimit : Je.arrayLimit,
+ charset: r,
+ charsetSentinel: typeof t.charsetSentinel == "boolean" ? t.charsetSentinel : Je.charsetSentinel,
+ comma: typeof t.comma == "boolean" ? t.comma : Je.comma,
+ decoder: typeof t.decoder == "function" ? t.decoder : Je.decoder,
+ delimiter: typeof t.delimiter == "string" || vn.isRegExp(t.delimiter) ? t.delimiter : Je.delimiter,
+ depth: typeof t.depth == "number" || t.depth === !1 ? +t.depth : Je.depth,
ignoreQueryPrefix: t.ignoreQueryPrefix === !0,
- interpretNumericEntities: typeof t.interpretNumericEntities == "boolean" ? t.interpretNumericEntities : ze.interpretNumericEntities,
- parameterLimit: typeof t.parameterLimit == "number" ? t.parameterLimit : ze.parameterLimit,
+ interpretNumericEntities: typeof t.interpretNumericEntities == "boolean" ? t.interpretNumericEntities : Je.interpretNumericEntities,
+ parameterLimit: typeof t.parameterLimit == "number" ? t.parameterLimit : Je.parameterLimit,
parseArrays: t.parseArrays !== !1,
- plainObjects: typeof t.plainObjects == "boolean" ? t.plainObjects : ze.plainObjects,
- strictNullHandling: typeof t.strictNullHandling == "boolean" ? t.strictNullHandling : ze.strictNullHandling
+ plainObjects: typeof t.plainObjects == "boolean" ? t.plainObjects : Je.plainObjects,
+ strictNullHandling: typeof t.strictNullHandling == "boolean" ? t.strictNullHandling : Je.strictNullHandling
}
},
- Rd = function(e, t) {
- var n = Nd(t);
- if (e === "" || e === null || typeof e == "undefined") return n.plainObjects ? Object.create(null) : {};
- for (var o = typeof e == "string" ? Cd(e, n) : e, s = n.plainObjects ? Object.create(null) : {}, a = Object.keys(o), c = 0; c < a.length; ++c) {
+ Pp = function(e, t) {
+ var r = Ap(t);
+ if (e === "" || e === null || typeof e == "undefined") return r.plainObjects ? Object.create(null) : {};
+ for (var i = typeof e == "string" ? Tp(e, r) : e, s = r.plainObjects ? Object.create(null) : {}, a = Object.keys(i), c = 0; c < a.length; ++c) {
var h = a[c],
- y = Pd(h, o[h], n, typeof e == "string");
- s = en.merge(s, y, n)
+ y = Cp(h, i[h], r, typeof e == "string");
+ s = vn.merge(s, y, r)
}
- return n.allowSparse === !0 ? s : en.compact(s)
+ return r.allowSparse === !0 ? s : vn.compact(s)
},
- Dd = wd,
- Id = Rd,
- $d = ko,
- Uo = {
- formats: $d,
- parse: Id,
- stringify: Dd
+ $p = wp,
+ Rp = Pp,
+ Np = cs,
+ gs = {
+ formats: Np,
+ parse: Rp,
+ stringify: $p
};
- function Ho(e, t) {
- const n = Object.create(null),
- o = e.split(",");
- for (let s = 0; s < o.length; s++) n[o[s]] = !0;
- return t ? s => !!n[s.toLowerCase()] : s => !!n[s]
- }
- const De = {},
- tn = [],
- Dt = () => {},
- Md = () => !1,
- Ld = /^on[^a-z]/,
- yi = e => Ld.test(e),
- Wo = e => e.startsWith("onUpdate:"),
- Ke = Object.assign,
- Vo = (e, t) => {
- const n = e.indexOf(t);
- n > -1 && e.splice(n, 1)
- },
- Fd = Object.prototype.hasOwnProperty,
- xe = (e, t) => Fd.call(e, t),
- ne = Array.isArray,
- rn = e => kn(e) === "[object Map]",
- nn = e => kn(e) === "[object Set]",
- tu = e => kn(e) === "[object Date]",
- fe = e => typeof e == "function",
+ function xr(e, t) {
+ const r = Object.create(null),
+ i = e.split(",");
+ for (let s = 0; s < i.length; s++) r[i[s]] = !0;
+ return t ? s => !!r[s.toLowerCase()] : s => !!r[s]
+ }
+ const Ne = Object.freeze({}),
+ bn = Object.freeze([]),
+ mt = () => {},
+ Uu = () => !1,
+ Dp = /^on[^a-z]/,
+ Xn = e => Dp.test(e),
+ ji = e => e.startsWith("onUpdate:"),
+ Le = Object.assign,
+ ys = (e, t) => {
+ const r = e.indexOf(t);
+ r > -1 && e.splice(r, 1)
+ },
+ Ip = Object.prototype.hasOwnProperty,
+ ve = (e, t) => Ip.call(e, t),
+ re = Array.isArray,
+ Ur = e => Zn(e) === "[object Map]",
+ wn = e => Zn(e) === "[object Set]",
+ qu = e => Zn(e) === "[object Date]",
+ le = e => typeof e == "function",
He = e => typeof e == "string",
- Fn = e => typeof e == "symbol",
- Ie = e => e !== null && typeof e == "object",
- ru = e => Ie(e) && fe(e.then) && fe(e.catch),
- nu = Object.prototype.toString,
- kn = e => nu.call(e),
- kd = e => kn(e).slice(8, -1),
- iu = e => kn(e) === "[object Object]",
- zo = e => He(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e,
- mi = Ho(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),
- vi = e => {
+ Yn = e => typeof e == "symbol",
+ Oe = e => e !== null && typeof e == "object",
+ ms = e => Oe(e) && le(e.then) && le(e.catch),
+ Hu = Object.prototype.toString,
+ Zn = e => Hu.call(e),
+ vs = e => Zn(e).slice(8, -1),
+ Bu = e => Zn(e) === "[object Object]",
+ bs = e => He(e) && e !== "NaN" && e[0] !== "-" && "" + parseInt(e, 10) === e,
+ Li = xr(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),
+ Mp = xr("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),
+ Fi = e => {
const t = Object.create(null);
- return n => t[n] || (t[n] = e(n))
+ return r => t[r] || (t[r] = e(r))
},
- jd = /-(\w)/g,
- Ht = vi(e => e.replace(jd, (t, n) => n ? n.toUpperCase() : "")),
- qd = /\B([A-Z])/g,
- on = vi(e => e.replace(qd, "-$1").toLowerCase()),
- bi = vi(e => e.charAt(0).toUpperCase() + e.slice(1)),
- Ko = vi(e => e ? `on${bi(e)}` : ""),
- _i = (e, t) => !Object.is(e, t),
- xi = (e, t) => {
- for (let n = 0; n < e.length; n++) e[n](t)
+ kp = /-(\w)/g,
+ Jt = Fi(e => e.replace(kp, (t, r) => r ? r.toUpperCase() : "")),
+ jp = /\B([A-Z])/g,
+ Sr = Fi(e => e.replace(jp, "-$1").toLowerCase()),
+ qr = Fi(e => e.charAt(0).toUpperCase() + e.slice(1)),
+ Hr = Fi(e => e ? `on${qr(e)}` : ""),
+ Ui = (e, t) => !Object.is(e, t),
+ _n = (e, t) => {
+ for (let r = 0; r < e.length; r++) e[r](t)
},
- wi = (e, t, n) => {
+ qi = (e, t, r) => {
Object.defineProperty(e, t, {
configurable: !0,
enumerable: !1,
- value: n
+ value: r
})
},
- Si = e => {
+ Hi = e => {
const t = parseFloat(e);
return isNaN(t) ? e : t
};
- let ou;
- const Jo = () => ou || (ou = typeof globalThis != "undefined" ? globalThis : typeof self != "undefined" ? self : typeof window != "undefined" ? window : typeof global != "undefined" ? global : {});
+ let Wu;
+ const Bi = () => Wu || (Wu = typeof globalThis != "undefined" ? globalThis : typeof self != "undefined" ? self : typeof window != "undefined" ? window : typeof global != "undefined" ? global : {});
- function Qo(e) {
- if (ne(e)) {
+ function ws(e) {
+ if (re(e)) {
const t = {};
- for (let n = 0; n < e.length; n++) {
- const o = e[n],
- s = He(o) ? Wd(o) : Qo(o);
+ for (let r = 0; r < e.length; r++) {
+ const i = e[r],
+ s = He(i) ? qp(i) : ws(i);
if (s)
for (const a in s) t[a] = s[a]
}
return t
} else {
if (He(e)) return e;
- if (Ie(e)) return e
+ if (Oe(e)) return e
}
}
- const Bd = /;(?![^(]*\))/g,
- Ud = /:([^]+)/,
- Hd = /\/\*[^]*?\*\//g;
+ const Lp = /;(?![^(]*\))/g,
+ Fp = /:([^]+)/,
+ Up = /\/\*[^]*?\*\//g;
- function Wd(e) {
+ function qp(e) {
const t = {};
- return e.replace(Hd, "").split(Bd).forEach(n => {
- if (n) {
- const o = n.split(Ud);
- o.length > 1 && (t[o[0].trim()] = o[1].trim())
+ return e.replace(Up, "").split(Lp).forEach(r => {
+ if (r) {
+ const i = r.split(Fp);
+ i.length > 1 && (t[i[0].trim()] = i[1].trim())
}
}), t
}
- function Wt(e) {
+ function Qt(e) {
let t = "";
if (He(e)) t = e;
- else if (ne(e))
- for (let n = 0; n < e.length; n++) {
- const o = Wt(e[n]);
- o && (t += o + " ")
- } else if (Ie(e))
- for (const n in e) e[n] && (t += n + " ");
+ else if (re(e))
+ for (let r = 0; r < e.length; r++) {
+ const i = Qt(e[r]);
+ i && (t += i + " ")
+ } else if (Oe(e))
+ for (const r in e) e[r] && (t += r + " ");
return t.trim()
}
- const Vd = Ho("itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly");
+ const Hp = "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",
+ Bp = "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",
+ Wp = xr(Hp),
+ Vp = xr(Bp),
+ zp = xr("itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly");
- function su(e) {
+ function Vu(e) {
return !!e || e === ""
}
- function zd(e, t) {
+ function Kp(e, t) {
if (e.length !== t.length) return !1;
- let n = !0;
- for (let o = 0; n && o < e.length; o++) n = Nr(e[o], t[o]);
- return n
+ let r = !0;
+ for (let i = 0; r && i < e.length; i++) r = Br(e[i], t[i]);
+ return r
}
- function Nr(e, t) {
+ function Br(e, t) {
if (e === t) return !0;
- let n = tu(e),
- o = tu(t);
- if (n || o) return n && o ? e.getTime() === t.getTime() : !1;
- if (n = Fn(e), o = Fn(t), n || o) return e === t;
- if (n = ne(e), o = ne(t), n || o) return n && o ? zd(e, t) : !1;
- if (n = Ie(e), o = Ie(t), n || o) {
- if (!n || !o) return !1;
+ let r = qu(e),
+ i = qu(t);
+ if (r || i) return r && i ? e.getTime() === t.getTime() : !1;
+ if (r = Yn(e), i = Yn(t), r || i) return e === t;
+ if (r = re(e), i = re(t), r || i) return r && i ? Kp(e, t) : !1;
+ if (r = Oe(e), i = Oe(t), r || i) {
+ if (!r || !i) return !1;
const s = Object.keys(e).length,
a = Object.keys(t).length;
if (s !== a) return !1;
for (const c in e) {
const h = e.hasOwnProperty(c),
y = t.hasOwnProperty(c);
- if (h && !y || !h && y || !Nr(e[c], t[c])) return !1
+ if (h && !y || !h && y || !Br(e[c], t[c])) return !1
}
}
return String(e) === String(t)
}
- function Xo(e, t) {
- return e.findIndex(n => Nr(n, t))
+ function _s(e, t) {
+ return e.findIndex(r => Br(r, t))
}
- const Ee = e => He(e) ? e : e == null ? "" : ne(e) || Ie(e) && (e.toString === nu || !fe(e.toString)) ? JSON.stringify(e, au, 2) : String(e),
- au = (e, t) => t && t.__v_isRef ? au(e, t.value) : rn(t) ? {
- [`Map(${t.size})`]: [...t.entries()].reduce((n, [o, s]) => (n[`${o} =>`] = s, n), {})
- } : nn(t) ? {
+ const Ce = e => He(e) ? e : e == null ? "" : re(e) || Oe(e) && (e.toString === Hu || !le(e.toString)) ? JSON.stringify(e, zu, 2) : String(e),
+ zu = (e, t) => t && t.__v_isRef ? zu(e, t.value) : Ur(t) ? {
+ [`Map(${t.size})`]: [...t.entries()].reduce((r, [i, s]) => (r[`${i} =>`] = s, r), {})
+ } : wn(t) ? {
[`Set(${t.size})`]: [...t.values()]
- } : Ie(t) && !ne(t) && !iu(t) ? String(t) : t;
- let It;
- class Kd {
+ } : Oe(t) && !re(t) && !Bu(t) ? String(t) : t;
+
+ function xs(e, ...t) {
+ console.warn(`[Vue warn] ${e}`, ...t)
+ }
+ let Lt;
+ class Jp {
constructor(t = !1) {
- this.detached = t, this._active = !0, this.effects = [], this.cleanups = [], this.parent = It, !t && It && (this.index = (It.scopes || (It.scopes = [])).push(this) - 1)
+ this.detached = t, this._active = !0, this.effects = [], this.cleanups = [], this.parent = Lt, !t && Lt && (this.index = (Lt.scopes || (Lt.scopes = [])).push(this) - 1)
}
get active() {
return this._active
}
run(t) {
if (this._active) {
- const n = It;
+ const r = Lt;
try {
- return It = this, t()
+ return Lt = this, t()
} finally {
- It = n
+ Lt = r
}
- }
+ } else xs("cannot run an inactive effect scope.")
}
on() {
- It = this
+ Lt = this
}
off() {
- It = this.parent
+ Lt = this.parent
}
stop(t) {
if (this._active) {
- let n, o;
- for (n = 0, o = this.effects.length; n < o; n++) this.effects[n].stop();
- for (n = 0, o = this.cleanups.length; n < o; n++) this.cleanups[n]();
+ let r, i;
+ for (r = 0, i = this.effects.length; r < i; r++) this.effects[r].stop();
+ for (r = 0, i = this.cleanups.length; r < i; r++) this.cleanups[r]();
if (this.scopes)
- for (n = 0, o = this.scopes.length; n < o; n++) this.scopes[n].stop(!0);
+ for (r = 0, i = this.scopes.length; r < i; r++) this.scopes[r].stop(!0);
if (!this.detached && this.parent && !t) {
const s = this.parent.scopes.pop();
s && s !== this && (this.parent.scopes[this.index] = s, s.index = this.index)
}
this.parent = void 0, this._active = !1
}
}
}
- function Jd(e, t = It) {
+ function Qp(e, t = Lt) {
t && t.active && t.effects.push(e)
}
- function Qd() {
- return It
+ function Gp() {
+ return Lt
}
- const Go = e => {
+ const Ss = e => {
const t = new Set(e);
return t.w = 0, t.n = 0, t
},
- uu = e => (e.w & yr) > 0,
- lu = e => (e.n & yr) > 0,
- Xd = ({
+ Ku = e => (e.w & Er) > 0,
+ Ju = e => (e.n & Er) > 0,
+ Xp = ({
deps: e
}) => {
if (e.length)
- for (let t = 0; t < e.length; t++) e[t].w |= yr
+ for (let t = 0; t < e.length; t++) e[t].w |= Er
},
- Gd = e => {
+ Yp = e => {
const {
deps: t
} = e;
if (t.length) {
- let n = 0;
- for (let o = 0; o < t.length; o++) {
- const s = t[o];
- uu(s) && !lu(s) ? s.delete(e) : t[n++] = s, s.w &= ~yr, s.n &= ~yr
- }
- t.length = n
- }
- },
- Yo = new WeakMap;
- let jn = 0,
- yr = 1;
- const Zo = 30;
- let $t;
- const Rr = Symbol(""),
- es = Symbol("");
- class ts {
- constructor(t, n = null, o) {
- this.fn = t, this.scheduler = n, this.active = !0, this.deps = [], this.parent = void 0, Jd(this, o)
+ let r = 0;
+ for (let i = 0; i < t.length; i++) {
+ const s = t[i];
+ Ku(s) && !Ju(s) ? s.delete(e) : t[r++] = s, s.w &= ~Er, s.n &= ~Er
+ }
+ t.length = r
+ }
+ },
+ Es = new WeakMap;
+ let ei = 0,
+ Er = 1;
+ const Ts = 30;
+ let ft;
+ const Wr = Symbol("iterate"),
+ Os = Symbol("Map key iterate");
+ class Cs {
+ constructor(t, r = null, i) {
+ this.fn = t, this.scheduler = r, this.active = !0, this.deps = [], this.parent = void 0, Qp(this, i)
}
run() {
if (!this.active) return this.fn();
- let t = $t,
- n = mr;
+ let t = ft,
+ r = Tr;
for (; t;) {
if (t === this) return;
t = t.parent
}
try {
- return this.parent = $t, $t = this, mr = !0, yr = 1 << ++jn, jn <= Zo ? Xd(this) : fu(this), this.fn()
+ return this.parent = ft, ft = this, Tr = !0, Er = 1 << ++ei, ei <= Ts ? Xp(this) : Qu(this), this.fn()
} finally {
- jn <= Zo && Gd(this), yr = 1 << --jn, $t = this.parent, mr = n, this.parent = void 0, this.deferStop && this.stop()
+ ei <= Ts && Yp(this), Er = 1 << --ei, ft = this.parent, Tr = r, this.parent = void 0, this.deferStop && this.stop()
}
}
stop() {
- $t === this ? this.deferStop = !0 : this.active && (fu(this), this.onStop && this.onStop(), this.active = !1)
+ ft === this ? this.deferStop = !0 : this.active && (Qu(this), this.onStop && this.onStop(), this.active = !1)
}
}
- function fu(e) {
+ function Qu(e) {
const {
deps: t
} = e;
if (t.length) {
- for (let n = 0; n < t.length; n++) t[n].delete(e);
+ for (let r = 0; r < t.length; r++) t[r].delete(e);
t.length = 0
}
}
- let mr = !0;
- const cu = [];
+ let Tr = !0;
+ const Gu = [];
- function sn() {
- cu.push(mr), mr = !1
+ function Vr() {
+ Gu.push(Tr), Tr = !1
}
- function an() {
- const e = cu.pop();
- mr = e === void 0 ? !0 : e
- }
-
- function lt(e, t, n) {
- if (mr && $t) {
- let o = Yo.get(e);
- o || Yo.set(e, o = new Map);
- let s = o.get(n);
- s || o.set(n, s = Go()), du(s)
+ function zr() {
+ const e = Gu.pop();
+ Tr = e === void 0 ? !0 : e
+ }
+
+ function st(e, t, r) {
+ if (Tr && ft) {
+ let i = Es.get(e);
+ i || Es.set(e, i = new Map);
+ let s = i.get(r);
+ s || i.set(r, s = Ss()), Xu(s, {
+ effect: ft,
+ target: e,
+ type: t,
+ key: r
+ })
}
}
- function du(e, t) {
- let n = !1;
- jn <= Zo ? lu(e) || (e.n |= yr, n = !uu(e)) : n = !e.has($t), n && (e.add($t), $t.deps.push(e))
+ function Xu(e, t) {
+ let r = !1;
+ ei <= Ts ? Ju(e) || (e.n |= Er, r = !Ku(e)) : r = !e.has(ft), r && (e.add(ft), ft.deps.push(e), ft.onTrack && ft.onTrack(Le({
+ effect: ft
+ }, t)))
}
- function nr(e, t, n, o, s, a) {
- const c = Yo.get(e);
+ function Gt(e, t, r, i, s, a) {
+ const c = Es.get(e);
if (!c) return;
let h = [];
if (t === "clear") h = [...c.values()];
- else if (n === "length" && ne(e)) {
- const y = Number(o);
- c.forEach((b, w) => {
- (w === "length" || w >= y) && h.push(b)
+ else if (r === "length" && re(e)) {
+ const v = Number(i);
+ c.forEach((_, E) => {
+ (E === "length" || E >= v) && h.push(_)
})
- } else switch (n !== void 0 && h.push(c.get(n)), t) {
+ } else switch (r !== void 0 && h.push(c.get(r)), t) {
case "add":
- ne(e) ? zo(n) && h.push(c.get("length")) : (h.push(c.get(Rr)), rn(e) && h.push(c.get(es)));
+ re(e) ? bs(r) && h.push(c.get("length")) : (h.push(c.get(Wr)), Ur(e) && h.push(c.get(Os)));
break;
case "delete":
- ne(e) || (h.push(c.get(Rr)), rn(e) && h.push(c.get(es)));
+ re(e) || (h.push(c.get(Wr)), Ur(e) && h.push(c.get(Os)));
break;
case "set":
- rn(e) && h.push(c.get(Rr));
+ Ur(e) && h.push(c.get(Wr));
break
}
- if (h.length === 1) h[0] && rs(h[0]);
+ const y = {
+ target: e,
+ type: t,
+ key: r,
+ newValue: i,
+ oldValue: s,
+ oldTarget: a
+ };
+ if (h.length === 1) h[0] && As(h[0], y);
else {
- const y = [];
- for (const b of h) b && y.push(...b);
- rs(Go(y))
+ const v = [];
+ for (const _ of h) _ && v.push(..._);
+ As(Ss(v), y)
}
}
- function rs(e, t) {
- const n = ne(e) ? e : [...e];
- for (const o of n) o.computed && pu(o);
- for (const o of n) o.computed || pu(o)
- }
-
- function pu(e, t) {
- (e !== $t || e.allowRecurse) && (e.scheduler ? e.scheduler() : e.run())
- }
- const Yd = Ho("__proto__,__v_isRef,__isVue"),
- hu = new Set(Object.getOwnPropertyNames(Symbol).filter(e => e !== "arguments" && e !== "caller").map(e => Symbol[e]).filter(Fn)),
- Zd = ns(),
- ep = ns(!1, !0),
- tp = ns(!0),
- gu = rp();
+ function As(e, t) {
+ const r = re(e) ? e : [...e];
+ for (const i of r) i.computed && Yu(i, t);
+ for (const i of r) i.computed || Yu(i, t)
+ }
+
+ function Yu(e, t) {
+ (e !== ft || e.allowRecurse) && (e.onTrigger && e.onTrigger(Le({
+ effect: e
+ }, t)), e.scheduler ? e.scheduler() : e.run())
+ }
+ const Zp = xr("__proto__,__v_isRef,__isVue"),
+ Zu = new Set(Object.getOwnPropertyNames(Symbol).filter(e => e !== "arguments" && e !== "caller").map(e => Symbol[e]).filter(Yn)),
+ eh = Wi(),
+ th = Wi(!1, !0),
+ rh = Wi(!0),
+ nh = Wi(!0, !0),
+ el = ih();
- function rp() {
+ function ih() {
const e = {};
return ["includes", "indexOf", "lastIndexOf"].forEach(t => {
- e[t] = function(...n) {
- const o = Oe(this);
- for (let a = 0, c = this.length; a < c; a++) lt(o, "get", a + "");
- const s = o[t](...n);
- return s === -1 || s === !1 ? o[t](...n.map(Oe)) : s
+ e[t] = function(...r) {
+ const i = ye(this);
+ for (let a = 0, c = this.length; a < c; a++) st(i, "get", a + "");
+ const s = i[t](...r);
+ return s === -1 || s === !1 ? i[t](...r.map(ye)) : s
}
}), ["push", "pop", "shift", "unshift", "splice"].forEach(t => {
- e[t] = function(...n) {
- sn();
- const o = Oe(this)[t].apply(this, n);
- return an(), o
+ e[t] = function(...r) {
+ Vr();
+ const i = ye(this)[t].apply(this, r);
+ return zr(), i
}
}), e
}
- function np(e) {
- const t = Oe(this);
- return lt(t, "has", e), t.hasOwnProperty(e)
+ function oh(e) {
+ const t = ye(this);
+ return st(t, "has", e), t.hasOwnProperty(e)
}
- function ns(e = !1, t = !1) {
- return function(o, s, a) {
+ function Wi(e = !1, t = !1) {
+ return function(i, s, a) {
if (s === "__v_isReactive") return !e;
if (s === "__v_isReadonly") return e;
if (s === "__v_isShallow") return t;
- if (s === "__v_raw" && a === (e ? t ? bp : Eu : t ? Su : wu).get(o)) return o;
- const c = ne(o);
+ if (s === "__v_raw" && a === (e ? t ? dl : cl : t ? fl : ll).get(i)) return i;
+ const c = re(i);
if (!e) {
- if (c && xe(gu, s)) return Reflect.get(gu, s, a);
- if (s === "hasOwnProperty") return np
+ if (c && ve(el, s)) return Reflect.get(el, s, a);
+ if (s === "hasOwnProperty") return oh
}
- const h = Reflect.get(o, s, a);
- return (Fn(s) ? hu.has(s) : Yd(s)) || (e || lt(o, "get", s), t) ? h : ot(h) ? c && zo(s) ? h : h.value : Ie(h) ? e ? Tu(h) : ss(h) : h
+ const h = Reflect.get(i, s, a);
+ return (Yn(s) ? Zu.has(s) : Zp(s)) || (e || st(i, "get", s), t) ? h : Qe(h) ? c && bs(s) ? h : h.value : Oe(h) ? e ? pl(h) : $s(h) : h
}
}
- const ip = yu(),
- op = yu(!0);
+ const sh = tl(),
+ ah = tl(!0);
- function yu(e = !1) {
- return function(n, o, s, a) {
- let c = n[o];
- if (qn(c) && ot(c) && !ot(s)) return !1;
- if (!e && (!us(s) && !qn(s) && (c = Oe(c), s = Oe(s)), !ne(n) && ot(c) && !ot(s))) return c.value = s, !0;
- const h = ne(n) && zo(o) ? Number(o) < n.length : xe(n, o),
- y = Reflect.set(n, o, s, a);
- return n === Oe(a) && (h ? _i(s, c) && nr(n, "set", o, s) : nr(n, "add", o, s)), y
+ function tl(e = !1) {
+ return function(r, i, s, a) {
+ let c = r[i];
+ if (Jr(c) && Qe(c) && !Qe(s)) return !1;
+ if (!e && (!Rs(s) && !Jr(s) && (c = ye(c), s = ye(s)), !re(r) && Qe(c) && !Qe(s))) return c.value = s, !0;
+ const h = re(r) && bs(i) ? Number(i) < r.length : ve(r, i),
+ y = Reflect.set(r, i, s, a);
+ return r === ye(a) && (h ? Ui(s, c) && Gt(r, "set", i, s, c) : Gt(r, "add", i, s)), y
}
}
- function sp(e, t) {
- const n = xe(e, t);
- e[t];
- const o = Reflect.deleteProperty(e, t);
- return o && n && nr(e, "delete", t, void 0), o
+ function uh(e, t) {
+ const r = ve(e, t),
+ i = e[t],
+ s = Reflect.deleteProperty(e, t);
+ return s && r && Gt(e, "delete", t, void 0, i), s
}
- function ap(e, t) {
- const n = Reflect.has(e, t);
- return (!Fn(t) || !hu.has(t)) && lt(e, "has", t), n
+ function lh(e, t) {
+ const r = Reflect.has(e, t);
+ return (!Yn(t) || !Zu.has(t)) && st(e, "has", t), r
}
- function up(e) {
- return lt(e, "iterate", ne(e) ? "length" : Rr), Reflect.ownKeys(e)
+ function fh(e) {
+ return st(e, "iterate", re(e) ? "length" : Wr), Reflect.ownKeys(e)
}
- const mu = {
- get: Zd,
- set: ip,
- deleteProperty: sp,
- has: ap,
- ownKeys: up
+ const rl = {
+ get: eh,
+ set: sh,
+ deleteProperty: uh,
+ has: lh,
+ ownKeys: fh
},
- lp = {
- get: tp,
+ nl = {
+ get: rh,
set(e, t) {
- return !0
+ return xs(`Set operation on key "${String(t)}" failed: target is readonly.`, e), !0
},
deleteProperty(e, t) {
- return !0
+ return xs(`Delete operation on key "${String(t)}" failed: target is readonly.`, e), !0
}
},
- fp = Ke({}, mu, {
- get: ep,
- set: op
+ ch = Le({}, rl, {
+ get: th,
+ set: ah
+ }),
+ dh = Le({}, nl, {
+ get: nh
}),
- is = e => e,
- Ei = e => Reflect.getPrototypeOf(e);
+ Ps = e => e,
+ Vi = e => Reflect.getPrototypeOf(e);
- function Ti(e, t, n = !1, o = !1) {
+ function zi(e, t, r = !1, i = !1) {
e = e.__v_raw;
- const s = Oe(e),
- a = Oe(t);
- n || (t !== a && lt(s, "get", t), lt(s, "get", a));
+ const s = ye(e),
+ a = ye(t);
+ r || (t !== a && st(s, "get", t), st(s, "get", a));
const {
has: c
- } = Ei(s), h = o ? is : n ? fs : ls;
+ } = Vi(s), h = i ? Ps : r ? Is : Ds;
if (c.call(s, t)) return h(e.get(t));
if (c.call(s, a)) return h(e.get(a));
e !== s && e.get(t)
}
- function Ai(e, t = !1) {
- const n = this.__v_raw,
- o = Oe(n),
- s = Oe(e);
- return t || (e !== s && lt(o, "has", e), lt(o, "has", s)), e === s ? n.has(e) : n.has(e) || n.has(s)
+ function Ki(e, t = !1) {
+ const r = this.__v_raw,
+ i = ye(r),
+ s = ye(e);
+ return t || (e !== s && st(i, "has", e), st(i, "has", s)), e === s ? r.has(e) : r.has(e) || r.has(s)
}
- function Ci(e, t = !1) {
- return e = e.__v_raw, !t && lt(Oe(e), "iterate", Rr), Reflect.get(e, "size", e)
+ function Ji(e, t = !1) {
+ return e = e.__v_raw, !t && st(ye(e), "iterate", Wr), Reflect.get(e, "size", e)
}
- function vu(e) {
- e = Oe(e);
- const t = Oe(this);
- return Ei(t).has.call(t, e) || (t.add(e), nr(t, "add", e, e)), this
+ function il(e) {
+ e = ye(e);
+ const t = ye(this);
+ return Vi(t).has.call(t, e) || (t.add(e), Gt(t, "add", e, e)), this
}
- function bu(e, t) {
- t = Oe(t);
- const n = Oe(this),
+ function ol(e, t) {
+ t = ye(t);
+ const r = ye(this),
{
- has: o,
+ has: i,
get: s
- } = Ei(n);
- let a = o.call(n, e);
- a || (e = Oe(e), a = o.call(n, e));
- const c = s.call(n, e);
- return n.set(e, t), a ? _i(t, c) && nr(n, "set", e, t) : nr(n, "add", e, t), this
+ } = Vi(r);
+ let a = i.call(r, e);
+ a ? ul(r, i, e) : (e = ye(e), a = i.call(r, e));
+ const c = s.call(r, e);
+ return r.set(e, t), a ? Ui(t, c) && Gt(r, "set", e, t, c) : Gt(r, "add", e, t), this
}
- function _u(e) {
- const t = Oe(this),
+ function sl(e) {
+ const t = ye(this),
{
- has: n,
- get: o
- } = Ei(t);
- let s = n.call(t, e);
- s || (e = Oe(e), s = n.call(t, e)), o && o.call(t, e);
- const a = t.delete(e);
- return s && nr(t, "delete", e, void 0), a
+ has: r,
+ get: i
+ } = Vi(t);
+ let s = r.call(t, e);
+ s ? ul(t, r, e) : (e = ye(e), s = r.call(t, e));
+ const a = i ? i.call(t, e) : void 0,
+ c = t.delete(e);
+ return s && Gt(t, "delete", e, void 0, a), c
}
- function xu() {
- const e = Oe(this),
+ function al() {
+ const e = ye(this),
t = e.size !== 0,
- n = e.clear();
- return t && nr(e, "clear", void 0, void 0), n
+ r = Ur(e) ? new Map(e) : new Set(e),
+ i = e.clear();
+ return t && Gt(e, "clear", void 0, void 0, r), i
}
- function Oi(e, t) {
- return function(o, s) {
+ function Qi(e, t) {
+ return function(i, s) {
const a = this,
c = a.__v_raw,
- h = Oe(c),
- y = t ? is : e ? fs : ls;
- return !e && lt(h, "iterate", Rr), c.forEach((b, w) => o.call(s, y(b), y(w), a))
+ h = ye(c),
+ y = t ? Ps : e ? Is : Ds;
+ return !e && st(h, "iterate", Wr), c.forEach((v, _) => i.call(s, y(v), y(_), a))
}
}
- function Pi(e, t, n) {
- return function(...o) {
+ function Gi(e, t, r) {
+ return function(...i) {
const s = this.__v_raw,
- a = Oe(s),
- c = rn(a),
+ a = ye(s),
+ c = Ur(a),
h = e === "entries" || e === Symbol.iterator && c,
y = e === "keys" && c,
- b = s[e](...o),
- w = n ? is : t ? fs : ls;
- return !t && lt(a, "iterate", y ? es : Rr), {
+ v = s[e](...i),
+ _ = r ? Ps : t ? Is : Ds;
+ return !t && st(a, "iterate", y ? Os : Wr), {
next() {
const {
- value: N,
- done: $
- } = b.next();
- return $ ? {
- value: N,
- done: $
+ value: E,
+ done: P
+ } = v.next();
+ return P ? {
+ value: E,
+ done: P
} : {
- value: h ? [w(N[0]), w(N[1])] : w(N),
- done: $
+ value: h ? [_(E[0]), _(E[1])] : _(E),
+ done: P
}
},
[Symbol.iterator]() {
return this
}
}
}
}
- function vr(e) {
+ function Or(e) {
return function(...t) {
+ {
+ const r = t[0] ? `on key "${t[0]}" ` : "";
+ console.warn(`${qr(e)} operation ${r}failed: target is readonly.`, ye(this))
+ }
return e === "delete" ? !1 : this
}
}
- function cp() {
+ function ph() {
const e = {
get(a) {
- return Ti(this, a)
+ return zi(this, a)
},
get size() {
- return Ci(this)
+ return Ji(this)
},
- has: Ai,
- add: vu,
- set: bu,
- delete: _u,
- clear: xu,
- forEach: Oi(!1, !1)
+ has: Ki,
+ add: il,
+ set: ol,
+ delete: sl,
+ clear: al,
+ forEach: Qi(!1, !1)
},
t = {
get(a) {
- return Ti(this, a, !1, !0)
+ return zi(this, a, !1, !0)
},
get size() {
- return Ci(this)
+ return Ji(this)
},
- has: Ai,
- add: vu,
- set: bu,
- delete: _u,
- clear: xu,
- forEach: Oi(!1, !0)
+ has: Ki,
+ add: il,
+ set: ol,
+ delete: sl,
+ clear: al,
+ forEach: Qi(!1, !0)
},
- n = {
+ r = {
get(a) {
- return Ti(this, a, !0)
+ return zi(this, a, !0)
},
get size() {
- return Ci(this, !0)
+ return Ji(this, !0)
},
has(a) {
- return Ai.call(this, a, !0)
+ return Ki.call(this, a, !0)
},
- add: vr("add"),
- set: vr("set"),
- delete: vr("delete"),
- clear: vr("clear"),
- forEach: Oi(!0, !1)
+ add: Or("add"),
+ set: Or("set"),
+ delete: Or("delete"),
+ clear: Or("clear"),
+ forEach: Qi(!0, !1)
},
- o = {
+ i = {
get(a) {
- return Ti(this, a, !0, !0)
+ return zi(this, a, !0, !0)
},
get size() {
- return Ci(this, !0)
+ return Ji(this, !0)
},
has(a) {
- return Ai.call(this, a, !0)
+ return Ki.call(this, a, !0)
},
- add: vr("add"),
- set: vr("set"),
- delete: vr("delete"),
- clear: vr("clear"),
- forEach: Oi(!0, !0)
+ add: Or("add"),
+ set: Or("set"),
+ delete: Or("delete"),
+ clear: Or("clear"),
+ forEach: Qi(!0, !0)
};
return ["keys", "values", "entries", Symbol.iterator].forEach(a => {
- e[a] = Pi(a, !1, !1), n[a] = Pi(a, !0, !1), t[a] = Pi(a, !1, !0), o[a] = Pi(a, !0, !0)
- }), [e, n, t, o]
+ e[a] = Gi(a, !1, !1), r[a] = Gi(a, !0, !1), t[a] = Gi(a, !1, !0), i[a] = Gi(a, !0, !0)
+ }), [e, r, t, i]
}
- const [dp, pp, hp, gp] = cp();
+ const [hh, gh, yh, mh] = ph();
- function os(e, t) {
- const n = t ? e ? gp : hp : e ? pp : dp;
- return (o, s, a) => s === "__v_isReactive" ? !e : s === "__v_isReadonly" ? e : s === "__v_raw" ? o : Reflect.get(xe(n, s) && s in o ? n : o, s, a)
+ function Xi(e, t) {
+ const r = t ? e ? mh : yh : e ? gh : hh;
+ return (i, s, a) => s === "__v_isReactive" ? !e : s === "__v_isReadonly" ? e : s === "__v_raw" ? i : Reflect.get(ve(r, s) && s in i ? r : i, s, a)
}
- const yp = {
- get: os(!1, !1)
+ const vh = {
+ get: Xi(!1, !1)
},
- mp = {
- get: os(!1, !0)
+ bh = {
+ get: Xi(!1, !0)
},
- vp = {
- get: os(!0, !1)
+ wh = {
+ get: Xi(!0, !1)
},
- wu = new WeakMap,
- Su = new WeakMap,
- Eu = new WeakMap,
- bp = new WeakMap;
+ _h = {
+ get: Xi(!0, !0)
+ };
+
+ function ul(e, t, r) {
+ const i = ye(r);
+ if (i !== r && t.call(e, i)) {
+ const s = vs(e);
+ console.warn(`Reactive ${s} contains both the raw and reactive versions of the same object${s==="Map"?" as keys":""}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`)
+ }
+ }
+ const ll = new WeakMap,
+ fl = new WeakMap,
+ cl = new WeakMap,
+ dl = new WeakMap;
- function _p(e) {
+ function xh(e) {
switch (e) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0
}
}
- function xp(e) {
- return e.__v_skip || !Object.isExtensible(e) ? 0 : _p(kd(e))
+ function Sh(e) {
+ return e.__v_skip || !Object.isExtensible(e) ? 0 : xh(vs(e))
}
- function ss(e) {
- return qn(e) ? e : as(e, !1, mu, yp, wu)
+ function $s(e) {
+ return Jr(e) ? e : Yi(e, !1, rl, vh, ll)
+ }
+
+ function Eh(e) {
+ return Yi(e, !1, ch, bh, fl)
}
- function wp(e) {
- return as(e, !1, fp, mp, Su)
+ function pl(e) {
+ return Yi(e, !0, nl, wh, cl)
}
- function Tu(e) {
- return as(e, !0, lp, vp, Eu)
+ function ti(e) {
+ return Yi(e, !0, dh, _h, dl)
}
- function as(e, t, n, o, s) {
- if (!Ie(e) || e.__v_raw && !(t && e.__v_isReactive)) return e;
+ function Yi(e, t, r, i, s) {
+ if (!Oe(e)) return console.warn(`value cannot be made reactive: ${String(e)}`), e;
+ if (e.__v_raw && !(t && e.__v_isReactive)) return e;
const a = s.get(e);
if (a) return a;
- const c = xp(e);
+ const c = Sh(e);
if (c === 0) return e;
- const h = new Proxy(e, c === 2 ? o : n);
+ const h = new Proxy(e, c === 2 ? i : r);
return s.set(e, h), h
}
- function un(e) {
- return qn(e) ? un(e.__v_raw) : !!(e && e.__v_isReactive)
+ function Kr(e) {
+ return Jr(e) ? Kr(e.__v_raw) : !!(e && e.__v_isReactive)
}
- function qn(e) {
+ function Jr(e) {
return !!(e && e.__v_isReadonly)
}
- function us(e) {
+ function Rs(e) {
return !!(e && e.__v_isShallow)
}
- function Au(e) {
- return un(e) || qn(e)
+ function Ns(e) {
+ return Kr(e) || Jr(e)
}
- function Oe(e) {
+ function ye(e) {
const t = e && e.__v_raw;
- return t ? Oe(t) : e
+ return t ? ye(t) : e
}
- function Cu(e) {
- return wi(e, "__v_skip", !0), e
+ function hl(e) {
+ return qi(e, "__v_skip", !0), e
}
- const ls = e => Ie(e) ? ss(e) : e,
- fs = e => Ie(e) ? Tu(e) : e;
+ const Ds = e => Oe(e) ? $s(e) : e,
+ Is = e => Oe(e) ? pl(e) : e;
- function Sp(e) {
- mr && $t && (e = Oe(e), du(e.dep || (e.dep = Go())))
+ function Th(e) {
+ Tr && ft && (e = ye(e), Xu(e.dep || (e.dep = Ss()), {
+ target: e,
+ type: "get",
+ key: "value"
+ }))
}
- function Ep(e, t) {
- e = Oe(e);
- const n = e.dep;
- n && rs(n)
+ function Oh(e, t) {
+ e = ye(e);
+ const r = e.dep;
+ r && As(r, {
+ target: e,
+ type: "set",
+ key: "value",
+ newValue: t
+ })
}
- function ot(e) {
+ function Qe(e) {
return !!(e && e.__v_isRef === !0)
}
- function Tp(e) {
- return ot(e) ? e.value : e
+ function Ch(e) {
+ return Qe(e) ? e.value : e
}
- const Ap = {
- get: (e, t, n) => Tp(Reflect.get(e, t, n)),
- set: (e, t, n, o) => {
+ const Ah = {
+ get: (e, t, r) => Ch(Reflect.get(e, t, r)),
+ set: (e, t, r, i) => {
const s = e[t];
- return ot(s) && !ot(n) ? (s.value = n, !0) : Reflect.set(e, t, n, o)
+ return Qe(s) && !Qe(r) ? (s.value = r, !0) : Reflect.set(e, t, r, i)
}
};
- function Ou(e) {
- return un(e) ? e : new Proxy(e, Ap)
+ function gl(e) {
+ return Kr(e) ? e : new Proxy(e, Ah)
}
- class Cp {
- constructor(t, n, o, s) {
- this._setter = n, this.dep = void 0, this.__v_isRef = !0, this.__v_isReadonly = !1, this._dirty = !0, this.effect = new ts(t, () => {
- this._dirty || (this._dirty = !0, Ep(this))
- }), this.effect.computed = this, this.effect.active = this._cacheable = !s, this.__v_isReadonly = o
+ class Ph {
+ constructor(t, r, i, s) {
+ this._setter = r, this.dep = void 0, this.__v_isRef = !0, this.__v_isReadonly = !1, this._dirty = !0, this.effect = new Cs(t, () => {
+ this._dirty || (this._dirty = !0, Oh(this))
+ }), this.effect.computed = this, this.effect.active = this._cacheable = !s, this.__v_isReadonly = i
}
get value() {
- const t = Oe(this);
- return Sp(t), (t._dirty || !t._cacheable) && (t._dirty = !1, t._value = t.effect.run()), t._value
+ const t = ye(this);
+ return Th(t), (t._dirty || !t._cacheable) && (t._dirty = !1, t._value = t.effect.run()), t._value
}
set value(t) {
this._setter(t)
}
}
- function Op(e, t, n = !1) {
- let o, s;
- const a = fe(e);
- return a ? (o = e, s = Dt) : (o = e.get, s = e.set), new Cp(o, s, a || !s, n)
+ function $h(e, t, r = !1) {
+ let i, s;
+ const a = le(e);
+ a ? (i = e, s = () => {
+ console.warn("Write operation failed: computed value is readonly")
+ }) : (i = e.get, s = e.set);
+ const c = new Ph(i, s, a || !s, r);
+ return t && !r && (c.effect.onTrack = t.onTrack, c.effect.onTrigger = t.onTrigger), c
+ }
+ const Qr = [];
+
+ function Zi(e) {
+ Qr.push(e)
+ }
+
+ function eo() {
+ Qr.pop()
+ }
+
+ function z(e, ...t) {
+ Vr();
+ const r = Qr.length ? Qr[Qr.length - 1].component : null,
+ i = r && r.appContext.config.warnHandler,
+ s = Rh();
+ if (i) lr(i, r, 11, [e + t.join(""), r && r.proxy, s.map(({
+ vnode: a
+ }) => `at <${wo(r,a.type)}>`).join(`
+`), s]);
+ else {
+ const a = [`[Vue warn]: ${e}`, ...t];
+ s.length && a.push(`
+`, ...Nh(s)), console.warn(...a)
+ }
+ zr()
}
- function Pb(e, ...t) {}
+ function Rh() {
+ let e = Qr[Qr.length - 1];
+ if (!e) return [];
+ const t = [];
+ for (; e;) {
+ const r = t[0];
+ r && r.vnode === e ? r.recurseCount++ : t.push({
+ vnode: e,
+ recurseCount: 0
+ });
+ const i = e.component && e.component.parent;
+ e = i && i.vnode
+ }
+ return t
+ }
+
+ function Nh(e) {
+ const t = [];
+ return e.forEach((r, i) => {
+ t.push(...i === 0 ? [] : [`
+`], ...Dh(r))
+ }), t
+ }
- function br(e, t, n, o) {
+ function Dh({
+ vnode: e,
+ recurseCount: t
+ }) {
+ const r = t > 0 ? `... (${t} recursive calls)` : "",
+ i = e.component ? e.component.parent == null : !1,
+ s = ` at <${wo(e.component,e.type,i)}`,
+ a = ">" + r;
+ return e.props ? [s, ...Ih(e.props), a] : [s + a]
+ }
+
+ function Ih(e) {
+ const t = [],
+ r = Object.keys(e);
+ return r.slice(0, 3).forEach(i => {
+ t.push(...yl(i, e[i]))
+ }), r.length > 3 && t.push(" ..."), t
+ }
+
+ function yl(e, t, r) {
+ return He(t) ? (t = JSON.stringify(t), r ? t : [`${e}=${t}`]) : typeof t == "number" || typeof t == "boolean" || t == null ? r ? t : [`${e}=${t}`] : Qe(t) ? (t = yl(e, ye(t.value), !0), r ? t : [`${e}=Ref<`, t, ">"]) : le(t) ? [`${e}=fn${t.name?`<${t.name}>`:""}`] : (t = ye(t), r ? t : [`${e}=`, t])
+ }
+ const Ms = {
+ sp: "serverPrefetch hook",
+ bc: "beforeCreate hook",
+ c: "created hook",
+ bm: "beforeMount hook",
+ m: "mounted hook",
+ bu: "beforeUpdate hook",
+ u: "updated",
+ bum: "beforeUnmount hook",
+ um: "unmounted hook",
+ a: "activated hook",
+ da: "deactivated hook",
+ ec: "errorCaptured hook",
+ rtc: "renderTracked hook",
+ rtg: "renderTriggered hook",
+ [0]: "setup function",
+ [1]: "render function",
+ [2]: "watcher getter",
+ [3]: "watcher callback",
+ [4]: "watcher cleanup function",
+ [5]: "native event handler",
+ [6]: "component event handler",
+ [7]: "vnode hook",
+ [8]: "directive hook",
+ [9]: "transition hook",
+ [10]: "app errorHandler",
+ [11]: "app warnHandler",
+ [12]: "ref function",
+ [13]: "async component loader",
+ [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+ };
+
+ function lr(e, t, r, i) {
let s;
try {
- s = o ? e(...o) : e()
+ s = i ? e(...i) : e()
} catch (a) {
- Ni(a, t, n)
+ to(a, t, r)
}
return s
}
- function Mt(e, t, n, o) {
- if (fe(e)) {
- const a = br(e, t, n, o);
- return a && ru(a) && a.catch(c => {
- Ni(c, t, n)
+ function Ft(e, t, r, i) {
+ if (le(e)) {
+ const a = lr(e, t, r, i);
+ return a && ms(a) && a.catch(c => {
+ to(c, t, r)
}), a
}
const s = [];
- for (let a = 0; a < e.length; a++) s.push(Mt(e[a], t, n, o));
+ for (let a = 0; a < e.length; a++) s.push(Ft(e[a], t, r, i));
return s
}
- function Ni(e, t, n, o = !0) {
+ function to(e, t, r, i = !0) {
const s = t ? t.vnode : null;
if (t) {
let a = t.parent;
const c = t.proxy,
- h = n;
+ h = Ms[r];
for (; a;) {
- const b = a.ec;
- if (b) {
- for (let w = 0; w < b.length; w++)
- if (b[w](e, c, h) === !1) return
+ const v = a.ec;
+ if (v) {
+ for (let _ = 0; _ < v.length; _++)
+ if (v[_](e, c, h) === !1) return
}
a = a.parent
}
const y = t.appContext.config.errorHandler;
if (y) {
- br(y, null, 10, [e, c, h]);
+ lr(y, null, 10, [e, c, h]);
return
}
}
- Pp(e, n, s, o)
+ Mh(e, r, s, i)
}
- function Pp(e, t, n, o = !0) {
- console.error(e)
- }
- let Bn = !1,
- cs = !1;
- const tt = [];
- let Vt = 0;
- const ln = [];
- let ir = null,
- Dr = 0;
- const Pu = Promise.resolve();
- let ds = null;
+ function Mh(e, t, r, i = !0) {
+ {
+ const s = Ms[t];
+ if (r && Zi(r), z(`Unhandled error${s?` during execution of ${s}`:""}`), r && eo(), i) throw e;
+ console.error(e)
+ }
+ }
+ let ri = !1,
+ ks = !1;
+ const at = [];
+ let Xt = 0;
+ const xn = [];
+ let Yt = null,
+ Cr = 0;
+ const ml = Promise.resolve();
+ let js = null;
+ const kh = 100;
- function Np(e) {
- const t = ds || Pu;
+ function jh(e) {
+ const t = js || ml;
return e ? t.then(this ? e.bind(this) : e) : t
}
- function Rp(e) {
- let t = Vt + 1,
- n = tt.length;
- for (; t < n;) {
- const o = t + n >>> 1;
- Un(tt[o]) < e ? t = o + 1 : n = o
+ function Lh(e) {
+ let t = Xt + 1,
+ r = at.length;
+ for (; t < r;) {
+ const i = t + r >>> 1;
+ ni(at[i]) < e ? t = i + 1 : r = i
}
return t
}
- function ps(e) {
- (!tt.length || !tt.includes(e, Bn && e.allowRecurse ? Vt + 1 : Vt)) && (e.id == null ? tt.push(e) : tt.splice(Rp(e.id), 0, e), Nu())
+ function ro(e) {
+ (!at.length || !at.includes(e, ri && e.allowRecurse ? Xt + 1 : Xt)) && (e.id == null ? at.push(e) : at.splice(Lh(e.id), 0, e), vl())
}
- function Nu() {
- !Bn && !cs && (cs = !0, ds = Pu.then(Iu))
+ function vl() {
+ !ri && !ks && (ks = !0, js = ml.then(xl))
}
- function Dp(e) {
- const t = tt.indexOf(e);
- t > Vt && tt.splice(t, 1)
+ function Fh(e) {
+ const t = at.indexOf(e);
+ t > Xt && at.splice(t, 1)
}
- function Ip(e) {
- ne(e) ? ln.push(...e) : (!ir || !ir.includes(e, e.allowRecurse ? Dr + 1 : Dr)) && ln.push(e), Nu()
+ function bl(e) {
+ re(e) ? xn.push(...e) : (!Yt || !Yt.includes(e, e.allowRecurse ? Cr + 1 : Cr)) && xn.push(e), vl()
}
- function Ru(e, t = Bn ? Vt + 1 : 0) {
- for (; t < tt.length; t++) {
- const n = tt[t];
- n && n.pre && (tt.splice(t, 1), t--, n())
+ function wl(e, t = ri ? Xt + 1 : 0) {
+ for (e = e || new Map; t < at.length; t++) {
+ const r = at[t];
+ if (r && r.pre) {
+ if (Ls(e, r)) continue;
+ at.splice(t, 1), t--, r()
+ }
}
}
- function Du(e) {
- if (ln.length) {
- const t = [...new Set(ln)];
- if (ln.length = 0, ir) {
- ir.push(...t);
+ function _l(e) {
+ if (xn.length) {
+ const t = [...new Set(xn)];
+ if (xn.length = 0, Yt) {
+ Yt.push(...t);
return
}
- for (ir = t, ir.sort((n, o) => Un(n) - Un(o)), Dr = 0; Dr < ir.length; Dr++) ir[Dr]();
- ir = null, Dr = 0
+ for (Yt = t, e = e || new Map, Yt.sort((r, i) => ni(r) - ni(i)), Cr = 0; Cr < Yt.length; Cr++) Ls(e, Yt[Cr]) || Yt[Cr]();
+ Yt = null, Cr = 0
}
}
- const Un = e => e.id == null ? 1 / 0 : e.id,
- $p = (e, t) => {
- const n = Un(e) - Un(t);
- if (n === 0) {
+ const ni = e => e.id == null ? 1 / 0 : e.id,
+ Uh = (e, t) => {
+ const r = ni(e) - ni(t);
+ if (r === 0) {
if (e.pre && !t.pre) return -1;
if (t.pre && !e.pre) return 1
}
- return n
+ return r
};
- function Iu(e) {
- cs = !1, Bn = !0, tt.sort($p);
- const t = Dt;
+ function xl(e) {
+ ks = !1, ri = !0, e = e || new Map, at.sort(Uh);
+ const t = r => Ls(e, r);
try {
- for (Vt = 0; Vt < tt.length; Vt++) {
- const n = tt[Vt];
- n && n.active !== !1 && br(n, null, 14)
+ for (Xt = 0; Xt < at.length; Xt++) {
+ const r = at[Xt];
+ if (r && r.active !== !1) {
+ if (t(r)) continue;
+ lr(r, null, 14)
+ }
}
} finally {
- Vt = 0, tt.length = 0, Du(), Bn = !1, ds = null, (tt.length || ln.length) && Iu()
+ Xt = 0, at.length = 0, _l(e), ri = !1, js = null, (at.length || xn.length) && xl(e)
+ }
+ }
+
+ function Ls(e, t) {
+ if (!e.has(t)) e.set(t, 1);
+ else {
+ const r = e.get(t);
+ if (r > kh) {
+ const i = t.ownerInstance,
+ s = i && fa(i.type);
+ return z(`Maximum recursive updates exceeded${s?` in component <${s}>`:""}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`), !0
+ } else e.set(t, r + 1)
+ }
+ }
+ let Gr = !1;
+ const Sn = new Set;
+ Bi().__VUE_HMR_RUNTIME__ = {
+ createRecord: Fs(Sl),
+ rerender: Fs(Bh),
+ reload: Fs(Wh)
+ };
+ const Xr = new Map;
+
+ function qh(e) {
+ const t = e.type.__hmrId;
+ let r = Xr.get(t);
+ r || (Sl(t, e.type), r = Xr.get(t)), r.instances.add(e)
+ }
+
+ function Hh(e) {
+ Xr.get(e.type.__hmrId).instances.delete(e)
+ }
+
+ function Sl(e, t) {
+ return Xr.has(e) ? !1 : (Xr.set(e, {
+ initialDef: ii(t),
+ instances: new Set
+ }), !0)
+ }
+
+ function ii(e) {
+ return pf(e) ? e.__vccOpts : e
+ }
+
+ function Bh(e, t) {
+ const r = Xr.get(e);
+ !r || (r.initialDef.render = t, [...r.instances].forEach(i => {
+ t && (i.render = t, ii(i.type).render = t), i.renderCache = [], Gr = !0, i.update(), Gr = !1
+ }))
+ }
+
+ function Wh(e, t) {
+ const r = Xr.get(e);
+ if (!r) return;
+ t = ii(t), El(r.initialDef, t);
+ const i = [...r.instances];
+ for (const s of i) {
+ const a = ii(s.type);
+ Sn.has(a) || (a !== r.initialDef && El(a, t), Sn.add(a)), s.appContext.propsCache.delete(s.type), s.appContext.emitsCache.delete(s.type), s.appContext.optionsCache.delete(s.type), s.ceReload ? (Sn.add(a), s.ceReload(t.styles), Sn.delete(a)) : s.parent ? ro(s.parent.update) : s.appContext.reload ? s.appContext.reload() : typeof window != "undefined" ? window.location.reload() : console.warn("[HMR] Root or manually mounted instance modified. Full reload required.")
}
+ bl(() => {
+ for (const s of i) Sn.delete(ii(s.type))
+ })
+ }
+
+ function El(e, t) {
+ Le(e, t);
+ for (const r in e) r !== "__file" && !(r in t) && delete e[r]
+ }
+
+ function Fs(e) {
+ return (t, r) => {
+ try {
+ return e(t, r)
+ } catch (i) {
+ console.error(i), console.warn("[HMR] Something went wrong during Vue component hot-reload. Full reload required.")
+ }
+ }
+ }
+ let Zt, oi = [],
+ Us = !1;
+
+ function si(e, ...t) {
+ Zt ? Zt.emit(e, ...t) : Us || oi.push({
+ event: e,
+ args: t
+ })
+ }
+
+ function Tl(e, t) {
+ var r, i;
+ Zt = e, Zt ? (Zt.enabled = !0, oi.forEach(({
+ event: s,
+ args: a
+ }) => Zt.emit(s, ...a)), oi = []) : typeof window != "undefined" && window.HTMLElement && !((i = (r = window.navigator) == null ? void 0 : r.userAgent) != null && i.includes("jsdom")) ? ((t.__VUE_DEVTOOLS_HOOK_REPLAY__ = t.__VUE_DEVTOOLS_HOOK_REPLAY__ || []).push(a => {
+ Tl(a, t)
+ }), setTimeout(() => {
+ Zt || (t.__VUE_DEVTOOLS_HOOK_REPLAY__ = null, Us = !0, oi = [])
+ }, 3e3)) : (Us = !0, oi = [])
}
- function Mp(e, t, ...n) {
+ function Vh(e, t) {
+ si("app:init", e, t, {
+ Fragment: dt,
+ Text: fi,
+ Comment: Ct,
+ Static: yo
+ })
+ }
+
+ function zh(e) {
+ si("app:unmount", e)
+ }
+ const Kh = qs("component:added"),
+ Ol = qs("component:updated"),
+ Jh = qs("component:removed"),
+ Qh = e => {
+ Zt && typeof Zt.cleanupBuffer == "function" && !Zt.cleanupBuffer(e) && Jh(e)
+ };
+
+ function qs(e) {
+ return t => {
+ si(e, t.appContext.app, t.uid, t.parent ? t.parent.uid : void 0, t)
+ }
+ }
+ const Gh = Cl("perf:start"),
+ Xh = Cl("perf:end");
+
+ function Cl(e) {
+ return (t, r, i) => {
+ si(e, t.appContext.app, t.uid, t, r, i)
+ }
+ }
+
+ function Yh(e, t, r) {
+ si("component:emit", e.appContext.app, e, t, r)
+ }
+
+ function Zh(e, t, ...r) {
if (e.isUnmounted) return;
- const o = e.vnode.props || De;
- let s = n;
+ const i = e.vnode.props || Ne;
+ {
+ const {
+ emitsOptions: _,
+ propsOptions: [E]
+ } = e;
+ if (_)
+ if (!(t in _))(!E || !(Hr(t) in E)) && z(`Component emitted event "${t}" but it is neither declared in the emits option nor as an "${Hr(t)}" prop.`);
+ else {
+ const P = _[t];
+ le(P) && (P(...r) || z(`Invalid event arguments: event validation failed for event "${t}".`))
+ }
+ }
+ let s = r;
const a = t.startsWith("update:"),
c = a && t.slice(7);
- if (c && c in o) {
- const w = `${c==="modelValue"?"model":c}Modifiers`,
+ if (c && c in i) {
+ const _ = `${c==="modelValue"?"model":c}Modifiers`,
{
- number: N,
- trim: $
- } = o[w] || De;
- $ && (s = n.map(W => He(W) ? W.trim() : W)), N && (s = n.map(Si))
- }
- let h, y = o[h = Ko(t)] || o[h = Ko(Ht(t))];
- !y && a && (y = o[h = Ko(on(t))]), y && Mt(y, e, 6, s);
- const b = o[h + "Once"];
- if (b) {
+ number: E,
+ trim: P
+ } = i[_] || Ne;
+ P && (s = r.map(q => He(q) ? q.trim() : q)), E && (s = r.map(Hi))
+ }
+ Yh(e, t, s);
+ {
+ const _ = t.toLowerCase();
+ _ !== t && i[Hr(_)] && z(`Event "${_}" is emitted in component ${wo(e,e.type)} but the handler is registered for "${t}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${Sr(t)}" instead of "${t}".`)
+ }
+ let h, y = i[h = Hr(t)] || i[h = Hr(Jt(t))];
+ !y && a && (y = i[h = Hr(Sr(t))]), y && Ft(y, e, 6, s);
+ const v = i[h + "Once"];
+ if (v) {
if (!e.emitted) e.emitted = {};
else if (e.emitted[h]) return;
- e.emitted[h] = !0, Mt(b, e, 6, s)
+ e.emitted[h] = !0, Ft(v, e, 6, s)
}
}
- function $u(e, t, n = !1) {
- const o = t.emitsCache,
- s = o.get(e);
+ function Al(e, t, r = !1) {
+ const i = t.emitsCache,
+ s = i.get(e);
if (s !== void 0) return s;
const a = e.emits;
let c = {},
h = !1;
- if (!fe(e)) {
- const y = b => {
- const w = $u(b, t, !0);
- w && (h = !0, Ke(c, w))
+ if (!le(e)) {
+ const y = v => {
+ const _ = Al(v, t, !0);
+ _ && (h = !0, Le(c, _))
};
- !n && t.mixins.length && t.mixins.forEach(y), e.extends && y(e.extends), e.mixins && e.mixins.forEach(y)
+ !r && t.mixins.length && t.mixins.forEach(y), e.extends && y(e.extends), e.mixins && e.mixins.forEach(y)
}
- return !a && !h ? (Ie(e) && o.set(e, null), null) : (ne(a) ? a.forEach(y => c[y] = null) : Ke(c, a), Ie(e) && o.set(e, c), c)
+ return !a && !h ? (Oe(e) && i.set(e, null), null) : (re(a) ? a.forEach(y => c[y] = null) : Le(c, a), Oe(e) && i.set(e, c), c)
}
- function Ri(e, t) {
- return !e || !yi(t) ? !1 : (t = t.slice(2).replace(/Once$/, ""), xe(e, t[0].toLowerCase() + t.slice(1)) || xe(e, on(t)) || xe(e, t))
+ function no(e, t) {
+ return !e || !Xn(t) ? !1 : (t = t.slice(2).replace(/Once$/, ""), ve(e, t[0].toLowerCase() + t.slice(1)) || ve(e, Sr(t)) || ve(e, t))
}
- let Et = null,
- Mu = null;
+ let vt = null,
+ Pl = null;
- function Di(e) {
- const t = Et;
- return Et = e, Mu = e && e.type.__scopeId || null, t
+ function io(e) {
+ const t = vt;
+ return vt = e, Pl = e && e.type.__scopeId || null, t
}
- function Lp(e, t = Et, n) {
+ function eg(e, t = vt, r) {
if (!t || e._n) return e;
- const o = (...s) => {
- o._d && sl(-1);
- const a = Di(t);
+ const i = (...s) => {
+ i._d && nf(-1);
+ const a = io(t);
let c;
try {
c = e(...s)
} finally {
- Di(a), o._d && sl(1)
+ io(a), i._d && nf(1)
}
- return c
+ return Ol(t), c
};
- return o._n = !0, o._c = !0, o._d = !0, o
+ return i._n = !0, i._c = !0, i._d = !0, i
}
+ let Hs = !1;
- function Nb() {}
+ function oo() {
+ Hs = !0
+ }
- function hs(e) {
+ function Bs(e) {
const {
type: t,
- vnode: n,
- proxy: o,
+ vnode: r,
+ proxy: i,
withProxy: s,
props: a,
propsOptions: [c],
slots: h,
attrs: y,
- emit: b,
- render: w,
- renderCache: N,
- data: $,
- setupState: W,
- ctx: q,
- inheritAttrs: U
+ emit: v,
+ render: _,
+ renderCache: E,
+ data: P,
+ setupState: q,
+ ctx: j,
+ inheritAttrs: B
} = e;
- let de, L;
- const be = Di(e);
+ let he, U;
+ const $e = io(e);
+ Hs = !1;
try {
- if (n.shapeFlag & 4) {
- const te = s || o;
- de = zt(w.call(te, te, N, a, W, $, q)), L = y
+ if (r.shapeFlag & 4) {
+ const ne = s || i;
+ he = qt(_.call(ne, ne, E, a, q, P, j)), U = y
} else {
- const te = t;
- de = zt(te.length > 1 ? te(a, {
- attrs: y,
+ const ne = t;
+ y === a && oo(), he = qt(ne.length > 1 ? ne(a, {
+ get attrs() {
+ return oo(), y
+ },
slots: h,
- emit: b
- }) : te(a, null)), L = t.props ? y : Fp(y)
+ emit: v
+ }) : ne(a, null)), U = t.props ? y : rg(y)
}
- } catch (te) {
- zn.length = 0, Ni(te, e, 1), de = _t(Lr)
+ } catch (ne) {
+ ci.length = 0, to(ne, e, 1), he = At(Ct)
}
- let ye = de;
- if (L && U !== !1) {
- const te = Object.keys(L),
+ let oe = he,
+ Ie;
+ if (he.patchFlag > 0 && he.patchFlag & 2048 && ([oe, Ie] = tg(he)), U && B !== !1) {
+ const ne = Object.keys(U),
{
- shapeFlag: qe
- } = ye;
- te.length && qe & 7 && (c && te.some(Wo) && (L = kp(L, c)), ye = fn(ye, L))
+ shapeFlag: xt
+ } = oe;
+ if (ne.length) {
+ if (xt & 7) c && ne.some(ji) && (U = ng(U, c)), oe = Pr(oe, U);
+ else if (!Hs && oe.type !== Ct) {
+ const f = Object.keys(y),
+ Ve = [],
+ ce = [];
+ for (let Ye = 0, ut = f.length; Ye < ut; Ye++) {
+ const ke = f[Ye];
+ Xn(ke) ? ji(ke) || Ve.push(ke[2].toLowerCase() + ke.slice(3)) : ce.push(ke)
+ }
+ ce.length && z(`Extraneous non-props attributes (${ce.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes.`), Ve.length && z(`Extraneous non-emits event listeners (${Ve.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`)
+ }
+ }
+ }
+ return r.dirs && (Rl(oe) || z("Runtime directive used on component with non-element root node. The directives will not function as intended."), oe = Pr(oe), oe.dirs = oe.dirs ? oe.dirs.concat(r.dirs) : r.dirs), r.transition && (Rl(oe) || z("Component inside <Transition> renders non-element root node that cannot be animated."), oe.transition = r.transition), Ie ? Ie(oe) : he = oe, io($e), he
+ }
+ const tg = e => {
+ const t = e.children,
+ r = e.dynamicChildren,
+ i = $l(t);
+ if (!i) return [e, void 0];
+ const s = t.indexOf(i),
+ a = r ? r.indexOf(i) : -1,
+ c = h => {
+ t[s] = h, r && (a > -1 ? r[a] = h : h.patchFlag > 0 && (e.dynamicChildren = [...r, h]))
+ };
+ return [qt(i), c]
+ };
+
+ function $l(e) {
+ let t;
+ for (let r = 0; r < e.length; r++) {
+ const i = e[r];
+ if (ia(i)) {
+ if (i.type !== Ct || i.children === "v-if") {
+ if (t) return;
+ t = i
+ }
+ } else return
}
- return n.dirs && (ye = fn(ye), ye.dirs = ye.dirs ? ye.dirs.concat(n.dirs) : n.dirs), n.transition && (ye.transition = n.transition), de = ye, Di(be), de
+ return t
}
- const Fp = e => {
+ const rg = e => {
let t;
- for (const n in e)(n === "class" || n === "style" || yi(n)) && ((t || (t = {}))[n] = e[n]);
+ for (const r in e)(r === "class" || r === "style" || Xn(r)) && ((t || (t = {}))[r] = e[r]);
return t
},
- kp = (e, t) => {
- const n = {};
- for (const o in e)(!Wo(o) || !(o.slice(9) in t)) && (n[o] = e[o]);
- return n
- };
+ ng = (e, t) => {
+ const r = {};
+ for (const i in e)(!ji(i) || !(i.slice(9) in t)) && (r[i] = e[i]);
+ return r
+ },
+ Rl = e => e.shapeFlag & 7 || e.type === Ct;
- function jp(e, t, n) {
+ function ig(e, t, r) {
const {
- props: o,
+ props: i,
children: s,
component: a
} = e, {
props: c,
children: h,
patchFlag: y
- } = t, b = a.emitsOptions;
- if (t.dirs || t.transition) return !0;
- if (n && y >= 0) {
+ } = t, v = a.emitsOptions;
+ if ((s || h) && Gr || t.dirs || t.transition) return !0;
+ if (r && y >= 0) {
if (y & 1024) return !0;
- if (y & 16) return o ? Lu(o, c, b) : !!c;
+ if (y & 16) return i ? Nl(i, c, v) : !!c;
if (y & 8) {
- const w = t.dynamicProps;
- for (let N = 0; N < w.length; N++) {
- const $ = w[N];
- if (c[$] !== o[$] && !Ri(b, $)) return !0
+ const _ = t.dynamicProps;
+ for (let E = 0; E < _.length; E++) {
+ const P = _[E];
+ if (c[P] !== i[P] && !no(v, P)) return !0
}
}
- } else return (s || h) && (!h || !h.$stable) ? !0 : o === c ? !1 : o ? c ? Lu(o, c, b) : !0 : !!c;
+ } else return (s || h) && (!h || !h.$stable) ? !0 : i === c ? !1 : i ? c ? Nl(i, c, v) : !0 : !!c;
return !1
}
- function Lu(e, t, n) {
- const o = Object.keys(t);
- if (o.length !== Object.keys(e).length) return !0;
- for (let s = 0; s < o.length; s++) {
- const a = o[s];
- if (t[a] !== e[a] && !Ri(n, a)) return !0
+ function Nl(e, t, r) {
+ const i = Object.keys(t);
+ if (i.length !== Object.keys(e).length) return !0;
+ for (let s = 0; s < i.length; s++) {
+ const a = i[s];
+ if (t[a] !== e[a] && !no(r, a)) return !0
}
return !1
}
- function qp({
+ function og({
vnode: e,
parent: t
- }, n) {
- for (; t && t.subTree === e;)(e = t.vnode).el = n, t = t.parent
+ }, r) {
+ for (; t && t.subTree === e;)(e = t.vnode).el = r, t = t.parent
}
- const Bp = e => e.__isSuspense;
+ const sg = e => e.__isSuspense;
- function Up(e, t) {
- t && t.pendingBranch ? ne(e) ? t.effects.push(...e) : t.effects.push(e) : Ip(e)
+ function ag(e, t) {
+ t && t.pendingBranch ? re(e) ? t.effects.push(...e) : t.effects.push(e) : bl(e)
}
- const Ii = {};
+ const so = {};
- function gs(e, t, n) {
- return Fu(e, t, n)
+ function Ws(e, t, r) {
+ return le(t) || z("`watch(fn, options?)` signature has been moved to a separate API. Use `watchEffect(fn, options?)` instead. `watch` now only supports `watch(source, cb, options?) signature."), Dl(e, t, r)
}
- function Fu(e, t, {
- immediate: n,
- deep: o,
+ function Dl(e, t, {
+ immediate: r,
+ deep: i,
flush: s,
onTrack: a,
onTrigger: c
- } = De) {
+ } = Ne) {
var h;
- const y = Qd() === ((h = Xe) == null ? void 0 : h.scope) ? Xe : null;
- let b, w = !1,
- N = !1;
- if (ot(e) ? (b = () => e.value, w = us(e)) : un(e) ? (b = () => e, o = !0) : ne(e) ? (N = !0, w = e.some(te => un(te) || us(te)), b = () => e.map(te => {
- if (ot(te)) return te.value;
- if (un(te)) return Ir(te);
- if (fe(te)) return br(te, y, 2)
- })) : fe(e) ? t ? b = () => br(e, y, 2) : b = () => {
- if (!(y && y.isUnmounted)) return $ && $(), Mt(e, y, 3, [W])
- } : b = Dt, t && o) {
- const te = b;
- b = () => Ir(te())
- }
- let $, W = te => {
- $ = be.onStop = () => {
- br(te, y, 4)
- }
- },
- q;
- if (Qn)
- if (W = Dt, t ? n && Mt(t, y, 3, [b(), N ? [] : void 0, W]) : b(), s === "sync") {
- const te = jh();
- q = te.__watcherHandles || (te.__watcherHandles = [])
- } else return Dt;
- let U = N ? new Array(e.length).fill(Ii) : Ii;
- const de = () => {
- if (!!be.active)
+ t || (r !== void 0 && z('watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.'), i !== void 0 && z('watch() "deep" option is only respected when using the watch(source, callback, options?) signature.'));
+ const y = ne => {
+ z("Invalid watch source: ", ne, "A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.")
+ },
+ v = Gp() === ((h = Ge) == null ? void 0 : h.scope) ? Ge : null;
+ let _, E = !1,
+ P = !1;
+ if (Qe(e) ? (_ = () => e.value, E = Rs(e)) : Kr(e) ? (_ = () => e, i = !0) : re(e) ? (P = !0, E = e.some(ne => Kr(ne) || Rs(ne)), _ = () => e.map(ne => {
+ if (Qe(ne)) return ne.value;
+ if (Kr(ne)) return Yr(ne);
+ if (le(ne)) return lr(ne, v, 2);
+ y(ne)
+ })) : le(e) ? t ? _ = () => lr(e, v, 2) : _ = () => {
+ if (!(v && v.isUnmounted)) return q && q(), Ft(e, v, 3, [j])
+ } : (_ = mt, y(e)), t && i) {
+ const ne = _;
+ _ = () => Yr(ne())
+ }
+ let q, j = ne => {
+ q = oe.onStop = () => {
+ lr(ne, v, 4)
+ }
+ },
+ B;
+ if (hi)
+ if (j = mt, t ? r && Ft(t, v, 3, [_(), P ? [] : void 0, j]) : _(), s === "sync") {
+ const ne = yy();
+ B = ne.__watcherHandles || (ne.__watcherHandles = [])
+ } else return mt;
+ let he = P ? new Array(e.length).fill(so) : so;
+ const U = () => {
+ if (!!oe.active)
if (t) {
- const te = be.run();
- (o || w || (N ? te.some((qe, Ct) => _i(qe, U[Ct])) : _i(te, U))) && ($ && $(), Mt(t, y, 3, [te, U === Ii ? void 0 : N && U[0] === Ii ? [] : U, W]), U = te)
- } else be.run()
+ const ne = oe.run();
+ (i || E || (P ? ne.some((xt, f) => Ui(xt, he[f])) : Ui(ne, he))) && (q && q(), Ft(t, v, 3, [ne, he === so ? void 0 : P && he[0] === so ? [] : he, j]), he = ne)
+ } else oe.run()
};
- de.allowRecurse = !!t;
- let L;
- s === "sync" ? L = de : s === "post" ? L = () => ft(de, y && y.suspense) : (de.pre = !0, y && (de.id = y.uid), L = () => ps(de));
- const be = new ts(b, L);
- t ? n ? de() : U = be.run() : s === "post" ? ft(be.run.bind(be), y && y.suspense) : be.run();
- const ye = () => {
- be.stop(), y && y.scope && Vo(y.scope.effects, be)
+ U.allowRecurse = !!t;
+ let $e;
+ s === "sync" ? $e = U : s === "post" ? $e = () => bt(U, v && v.suspense) : (U.pre = !0, v && (U.id = v.uid), $e = () => ro(U));
+ const oe = new Cs(_, $e);
+ oe.onTrack = a, oe.onTrigger = c, t ? r ? U() : he = oe.run() : s === "post" ? bt(oe.run.bind(oe), v && v.suspense) : oe.run();
+ const Ie = () => {
+ oe.stop(), v && v.scope && ys(v.scope.effects, oe)
};
- return q && q.push(ye), ye
+ return B && B.push(Ie), Ie
}
- function Hp(e, t, n) {
- const o = this.proxy,
- s = He(e) ? e.includes(".") ? ku(o, e) : () => o[e] : e.bind(o, o);
+ function ug(e, t, r) {
+ const i = this.proxy,
+ s = He(e) ? e.includes(".") ? Il(i, e) : () => i[e] : e.bind(i, i);
let a;
- fe(t) ? a = t : (a = t.handler, n = t);
- const c = Xe;
- dn(this);
- const h = Fu(s, a.bind(o), n);
- return c ? dn(c) : kr(), h
+ le(t) ? a = t : (a = t.handler, r = t);
+ const c = Ge;
+ Tn(this);
+ const h = Dl(s, a.bind(i), r);
+ return c ? Tn(c) : nn(), h
}
- function ku(e, t) {
- const n = t.split(".");
+ function Il(e, t) {
+ const r = t.split(".");
return () => {
- let o = e;
- for (let s = 0; s < n.length && o; s++) o = o[n[s]];
- return o
+ let i = e;
+ for (let s = 0; s < r.length && i; s++) i = i[r[s]];
+ return i
}
}
- function Ir(e, t) {
- if (!Ie(e) || e.__v_skip || (t = t || new Set, t.has(e))) return e;
- if (t.add(e), ot(e)) Ir(e.value, t);
- else if (ne(e))
- for (let n = 0; n < e.length; n++) Ir(e[n], t);
- else if (nn(e) || rn(e)) e.forEach(n => {
- Ir(n, t)
+ function Yr(e, t) {
+ if (!Oe(e) || e.__v_skip || (t = t || new Set, t.has(e))) return e;
+ if (t.add(e), Qe(e)) Yr(e.value, t);
+ else if (re(e))
+ for (let r = 0; r < e.length; r++) Yr(e[r], t);
+ else if (wn(e) || Ur(e)) e.forEach(r => {
+ Yr(r, t)
});
- else if (iu(e))
- for (const n in e) Ir(e[n], t);
+ else if (Bu(e))
+ for (const r in e) Yr(e[r], t);
return e
}
- function $i(e, t) {
- const n = Et;
- if (n === null) return e;
- const o = Wi(n) || n.proxy,
+ function Ml(e) {
+ Mp(e) && z("Do not use built-in directive ids as custom directive id: " + e)
+ }
+
+ function ao(e, t) {
+ const r = vt;
+ if (r === null) return z("withDirectives can only be used inside render functions."), e;
+ const i = bo(r) || r.proxy,
s = e.dirs || (e.dirs = []);
for (let a = 0; a < t.length; a++) {
- let [c, h, y, b = De] = t[a];
- c && (fe(c) && (c = {
+ let [c, h, y, v = Ne] = t[a];
+ c && (le(c) && (c = {
mounted: c,
updated: c
- }), c.deep && Ir(h), s.push({
+ }), c.deep && Yr(h), s.push({
dir: c,
- instance: o,
+ instance: i,
value: h,
oldValue: void 0,
arg: y,
- modifiers: b
+ modifiers: v
}))
}
return e
}
- function $r(e, t, n, o) {
+ function Zr(e, t, r, i) {
const s = e.dirs,
a = t && t.dirs;
for (let c = 0; c < s.length; c++) {
const h = s[c];
a && (h.oldValue = a[c].value);
- let y = h.dir[o];
- y && (sn(), Mt(y, n, 8, [e.el, h, e, t]), an())
+ let y = h.dir[i];
+ y && (Vr(), Ft(y, r, 8, [e.el, h, e, t]), zr())
}
}
- const Tt = [Function, Array],
- Wp = {
- mode: String,
- appear: Boolean,
- persisted: Boolean,
- onBeforeEnter: Tt,
- onEnter: Tt,
- onAfterEnter: Tt,
- onEnterCancelled: Tt,
- onBeforeLeave: Tt,
- onLeave: Tt,
- onAfterLeave: Tt,
- onLeaveCancelled: Tt,
- onBeforeAppear: Tt,
- onAppear: Tt,
- onAfterAppear: Tt,
- onAppearCancelled: Tt
- },
- Mi = e => !!e.type.__asyncLoader,
- ju = e => e.type.__isKeepAlive;
-
- function Vp(e, t) {
- qu(e, "a", t)
- }
-
- function zp(e, t) {
- qu(e, "da", t)
- }
-
- function qu(e, t, n = Xe) {
- const o = e.__wdc || (e.__wdc = () => {
- let s = n;
+ const uo = e => !!e.type.__asyncLoader,
+ Vs = e => e.type.__isKeepAlive;
+
+ function lg(e, t) {
+ kl(e, "a", t)
+ }
+
+ function fg(e, t) {
+ kl(e, "da", t)
+ }
+
+ function kl(e, t, r = Ge) {
+ const i = e.__wdc || (e.__wdc = () => {
+ let s = r;
for (; s;) {
if (s.isDeactivated) return;
s = s.parent
}
return e()
});
- if (Li(t, o, n), n) {
- let s = n.parent;
- for (; s && s.parent;) ju(s.parent.vnode) && Kp(o, t, n, s), s = s.parent
+ if (lo(t, i, r), r) {
+ let s = r.parent;
+ for (; s && s.parent;) Vs(s.parent.vnode) && cg(i, t, r, s), s = s.parent
}
}
- function Kp(e, t, n, o) {
- const s = Li(t, e, o, !0);
- Bu(() => {
- Vo(o[t], s)
- }, n)
+ function cg(e, t, r, i) {
+ const s = lo(t, e, i, !0);
+ jl(() => {
+ ys(i[t], s)
+ }, r)
}
- function Li(e, t, n = Xe, o = !1) {
- if (n) {
- const s = n[e] || (n[e] = []),
+ function lo(e, t, r = Ge, i = !1) {
+ if (r) {
+ const s = r[e] || (r[e] = []),
a = t.__weh || (t.__weh = (...c) => {
- if (n.isUnmounted) return;
- sn(), dn(n);
- const h = Mt(t, n, e, c);
- return kr(), an(), h
+ if (r.isUnmounted) return;
+ Vr(), Tn(r);
+ const h = Ft(t, r, e, c);
+ return nn(), zr(), h
});
- return o ? s.unshift(a) : s.push(a), a
+ return i ? s.unshift(a) : s.push(a), a
+ } else {
+ const s = Hr(Ms[e].replace(/ hook$/, ""));
+ z(`${s} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup(). If you are using async setup(), make sure to register lifecycle hooks before the first await statement.`)
}
}
- const or = e => (t, n = Xe) => (!Qn || e === "sp") && Li(e, (...o) => t(...o), n),
- Jp = or("bm"),
- Qp = or("m"),
- Xp = or("bu"),
- Gp = or("u"),
- Yp = or("bum"),
- Bu = or("um"),
- Zp = or("sp"),
- eh = or("rtg"),
- th = or("rtc");
+ const fr = e => (t, r = Ge) => (!hi || e === "sp") && lo(e, (...i) => t(...i), r),
+ dg = fr("bm"),
+ pg = fr("m"),
+ hg = fr("bu"),
+ gg = fr("u"),
+ yg = fr("bum"),
+ jl = fr("um"),
+ mg = fr("sp"),
+ vg = fr("rtg"),
+ bg = fr("rtc");
- function rh(e, t = Xe) {
- Li("ec", e, t)
+ function wg(e, t = Ge) {
+ lo("ec", e, t)
}
- const Uu = "components";
+ const zs = "components";
- function Hn(e, t) {
- return ih(Uu, e, !0, t) || e
+ function ai(e, t) {
+ return xg(zs, e, !0, t) || e
}
- const nh = Symbol.for("v-ndc");
+ const _g = Symbol.for("v-ndc");
- function ih(e, t, n = !0, o = !1) {
- const s = Et || Xe;
+ function xg(e, t, r = !0, i = !1) {
+ const s = vt || Ge;
if (s) {
const a = s.type;
- if (e === Uu) {
- const h = Mh(a, !1);
- if (h && (h === t || h === Ht(t) || h === bi(Ht(t)))) return a
+ if (e === zs) {
+ const h = fa(a, !1);
+ if (h && (h === t || h === Jt(t) || h === qr(Jt(t)))) return a
+ }
+ const c = Ll(s[e] || a[e], t) || Ll(s.appContext[e], t);
+ if (!c && i) return a;
+ if (r && !c) {
+ const h = e === zs ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : "";
+ z(`Failed to resolve ${e.slice(0,-1)}: ${t}${h}`)
}
- const c = Hu(s[e] || a[e], t) || Hu(s.appContext[e], t);
- return !c && o ? a : c
- }
+ return c
+ } else z(`resolve${qr(e.slice(0,-1))} can only be used in render() or setup().`)
}
- function Hu(e, t) {
- return e && (e[t] || e[Ht(t)] || e[bi(Ht(t))])
+ function Ll(e, t) {
+ return e && (e[t] || e[Jt(t)] || e[qr(Jt(t))])
}
- function Fi(e, t, n, o) {
+ function fo(e, t, r, i) {
let s;
- const a = n && n[o];
- if (ne(e) || He(e)) {
+ const a = r && r[i];
+ if (re(e) || He(e)) {
s = new Array(e.length);
for (let c = 0, h = e.length; c < h; c++) s[c] = t(e[c], c, void 0, a && a[c])
} else if (typeof e == "number") {
- s = new Array(e);
+ Number.isInteger(e) || z(`The v-for range expect an integer value but got ${e}.`), s = new Array(e);
for (let c = 0; c < e; c++) s[c] = t(c + 1, c, void 0, a && a[c])
- } else if (Ie(e))
+ } else if (Oe(e))
if (e[Symbol.iterator]) s = Array.from(e, (c, h) => t(c, h, void 0, a && a[h]));
else {
const c = Object.keys(e);
s = new Array(c.length);
for (let h = 0, y = c.length; h < y; h++) {
- const b = c[h];
- s[h] = t(e[b], b, h, a && a[h])
+ const v = c[h];
+ s[h] = t(e[v], v, h, a && a[h])
}
}
else s = [];
- return n && (n[o] = s), s
+ return r && (r[i] = s), s
}
- const ys = e => e ? cl(e) ? Wi(e) || e.proxy : ys(e.parent) : null,
- Wn = Ke(Object.create(null), {
+ const Ks = e => e ? ff(e) ? bo(e) || e.proxy : Ks(e.parent) : null,
+ en = Le(Object.create(null), {
$: e => e,
$el: e => e.vnode.el,
$data: e => e.data,
- $props: e => e.props,
- $attrs: e => e.attrs,
- $slots: e => e.slots,
- $refs: e => e.refs,
- $parent: e => ys(e.parent),
- $root: e => ys(e.root),
+ $props: e => ti(e.props),
+ $attrs: e => ti(e.attrs),
+ $slots: e => ti(e.slots),
+ $refs: e => ti(e.refs),
+ $parent: e => Ks(e.parent),
+ $root: e => Ks(e.root),
$emit: e => e.emit,
- $options: e => bs(e),
- $forceUpdate: e => e.f || (e.f = () => ps(e.update)),
- $nextTick: e => e.n || (e.n = Np.bind(e.proxy)),
- $watch: e => Hp.bind(e)
+ $options: e => Xs(e),
+ $forceUpdate: e => e.f || (e.f = () => ro(e.update)),
+ $nextTick: e => e.n || (e.n = jh.bind(e.proxy)),
+ $watch: e => ug.bind(e)
}),
- ms = (e, t) => e !== De && !e.__isScriptSetup && xe(e, t),
- oh = {
+ Js = e => e === "_" || e === "$",
+ Qs = (e, t) => e !== Ne && !e.__isScriptSetup && ve(e, t),
+ Fl = {
get({
_: e
}, t) {
const {
- ctx: n,
- setupState: o,
+ ctx: r,
+ setupState: i,
data: s,
props: a,
accessCache: c,
type: h,
appContext: y
} = e;
- let b;
+ if (t === "__isVue") return !0;
+ let v;
if (t[0] !== "$") {
- const W = c[t];
- if (W !== void 0) switch (W) {
+ const q = c[t];
+ if (q !== void 0) switch (q) {
case 1:
- return o[t];
+ return i[t];
case 2:
return s[t];
case 4:
- return n[t];
+ return r[t];
case 3:
return a[t]
} else {
- if (ms(o, t)) return c[t] = 1, o[t];
- if (s !== De && xe(s, t)) return c[t] = 2, s[t];
- if ((b = e.propsOptions[0]) && xe(b, t)) return c[t] = 3, a[t];
- if (n !== De && xe(n, t)) return c[t] = 4, n[t];
- vs && (c[t] = 0)
+ if (Qs(i, t)) return c[t] = 1, i[t];
+ if (s !== Ne && ve(s, t)) return c[t] = 2, s[t];
+ if ((v = e.propsOptions[0]) && ve(v, t)) return c[t] = 3, a[t];
+ if (r !== Ne && ve(r, t)) return c[t] = 4, r[t];
+ Gs && (c[t] = 0)
}
}
- const w = Wn[t];
- let N, $;
- if (w) return t === "$attrs" && lt(e, "get", t), w(e);
- if ((N = h.__cssModules) && (N = N[t])) return N;
- if (n !== De && xe(n, t)) return c[t] = 4, n[t];
- if ($ = y.config.globalProperties, xe($, t)) return $[t]
+ const _ = en[t];
+ let E, P;
+ if (_) return t === "$attrs" ? (st(e, "get", t), oo()) : t === "$slots" && st(e, "get", t), _(e);
+ if ((E = h.__cssModules) && (E = E[t])) return E;
+ if (r !== Ne && ve(r, t)) return c[t] = 4, r[t];
+ if (P = y.config.globalProperties, ve(P, t)) return P[t];
+ vt && (!He(t) || t.indexOf("__v") !== 0) && (s !== Ne && Js(t[0]) && ve(s, t) ? z(`Property ${JSON.stringify(t)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`) : e === vt && z(`Property ${JSON.stringify(t)} was accessed during render but is not defined on instance.`))
},
set({
_: e
- }, t, n) {
+ }, t, r) {
const {
- data: o,
+ data: i,
setupState: s,
ctx: a
} = e;
- return ms(s, t) ? (s[t] = n, !0) : o !== De && xe(o, t) ? (o[t] = n, !0) : xe(e.props, t) || t[0] === "$" && t.slice(1) in e ? !1 : (a[t] = n, !0)
+ return Qs(s, t) ? (s[t] = r, !0) : s.__isScriptSetup && ve(s, t) ? (z(`Cannot mutate <script setup> binding "${t}" from Options API.`), !1) : i !== Ne && ve(i, t) ? (i[t] = r, !0) : ve(e.props, t) ? (z(`Attempting to mutate prop "${t}". Props are readonly.`), !1) : t[0] === "$" && t.slice(1) in e ? (z(`Attempting to mutate public property "${t}". Properties starting with $ are reserved and readonly.`), !1) : (t in e.appContext.config.globalProperties ? Object.defineProperty(a, t, {
+ enumerable: !0,
+ configurable: !0,
+ value: r
+ }) : a[t] = r, !0)
},
has({
_: {
data: e,
setupState: t,
- accessCache: n,
- ctx: o,
+ accessCache: r,
+ ctx: i,
appContext: s,
propsOptions: a
}
}, c) {
let h;
- return !!n[c] || e !== De && xe(e, c) || ms(t, c) || (h = a[0]) && xe(h, c) || xe(o, c) || xe(Wn, c) || xe(s.config.globalProperties, c)
+ return !!r[c] || e !== Ne && ve(e, c) || Qs(t, c) || (h = a[0]) && ve(h, c) || ve(i, c) || ve(en, c) || ve(s.config.globalProperties, c)
},
- defineProperty(e, t, n) {
- return n.get != null ? e._.accessCache[t] = 0 : xe(n, "value") && this.set(e, t, n.value, null), Reflect.defineProperty(e, t, n)
+ defineProperty(e, t, r) {
+ return r.get != null ? e._.accessCache[t] = 0 : ve(r, "value") && this.set(e, t, r.value, null), Reflect.defineProperty(e, t, r)
}
};
+ Fl.ownKeys = e => (z("Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead."), Reflect.ownKeys(e));
+
+ function Sg(e) {
+ const t = {};
+ return Object.defineProperty(t, "_", {
+ configurable: !0,
+ enumerable: !1,
+ get: () => e
+ }), Object.keys(en).forEach(r => {
+ Object.defineProperty(t, r, {
+ configurable: !0,
+ enumerable: !1,
+ get: () => en[r](e),
+ set: mt
+ })
+ }), t
+ }
+
+ function Eg(e) {
+ const {
+ ctx: t,
+ propsOptions: [r]
+ } = e;
+ r && Object.keys(r).forEach(i => {
+ Object.defineProperty(t, i, {
+ enumerable: !0,
+ configurable: !0,
+ get: () => e.props[i],
+ set: mt
+ })
+ })
+ }
+
+ function Tg(e) {
+ const {
+ ctx: t,
+ setupState: r
+ } = e;
+ Object.keys(ye(r)).forEach(i => {
+ if (!r.__isScriptSetup) {
+ if (Js(i[0])) {
+ z(`setup() return property ${JSON.stringify(i)} should not start with "$" or "_" which are reserved prefixes for Vue internals.`);
+ return
+ }
+ Object.defineProperty(t, i, {
+ enumerable: !0,
+ configurable: !0,
+ get: () => r[i],
+ set: mt
+ })
+ }
+ })
+ }
+
+ function Ul(e) {
+ return re(e) ? e.reduce((t, r) => (t[r] = null, t), {}) : e
+ }
- function Wu(e) {
- return ne(e) ? e.reduce((t, n) => (t[n] = null, t), {}) : e
+ function Og() {
+ const e = Object.create(null);
+ return (t, r) => {
+ e[r] ? z(`${t} property "${r}" is already defined in ${e[r]}.`) : e[r] = t
+ }
}
- let vs = !0;
+ let Gs = !0;
- function sh(e) {
- const t = bs(e),
- n = e.proxy,
- o = e.ctx;
- vs = !1, t.beforeCreate && Vu(t.beforeCreate, e, "bc");
+ function Cg(e) {
+ const t = Xs(e),
+ r = e.proxy,
+ i = e.ctx;
+ Gs = !1, t.beforeCreate && ql(t.beforeCreate, e, "bc");
const {
data: s,
computed: a,
methods: c,
watch: h,
provide: y,
- inject: b,
- created: w,
- beforeMount: N,
- mounted: $,
- beforeUpdate: W,
- updated: q,
- activated: U,
- deactivated: de,
- beforeDestroy: L,
- beforeUnmount: be,
- destroyed: ye,
- unmounted: te,
- render: qe,
- renderTracked: Ct,
+ inject: v,
+ created: _,
+ beforeMount: E,
+ mounted: P,
+ beforeUpdate: q,
+ updated: j,
+ activated: B,
+ deactivated: he,
+ beforeDestroy: U,
+ beforeUnmount: $e,
+ destroyed: oe,
+ unmounted: Ie,
+ render: ne,
+ renderTracked: xt,
renderTriggered: f,
- errorCaptured: Be,
- serverPrefetch: me,
- expose: rt,
- inheritAttrs: wt,
- components: Qe,
- directives: le,
- filters: nt
- } = t;
- if (b && ah(b, o, null), c)
- for (const Se in c) {
- const Ae = c[Se];
- fe(Ae) && (o[Se] = Ae.bind(n))
+ errorCaptured: Ve,
+ serverPrefetch: ce,
+ expose: Ye,
+ inheritAttrs: ut,
+ components: ke,
+ directives: de,
+ filters: pt
+ } = t, ht = Og();
+ {
+ const [pe] = e.propsOptions;
+ if (pe)
+ for (const be in pe) ht("Props", be)
+ }
+ if (v && Ag(v, i, ht), c)
+ for (const pe in c) {
+ const be = c[pe];
+ le(be) ? (Object.defineProperty(i, pe, {
+ value: be.bind(r),
+ configurable: !0,
+ enumerable: !0,
+ writable: !0
+ }), ht("Methods", pe)) : z(`Method "${pe}" has type "${typeof be}" in the component definition. Did you reference the function correctly?`)
}
if (s) {
- const Se = s.call(n, n);
- Ie(Se) && (e.data = ss(Se))
+ le(s) || z("The data option must be a function. Plain object usage is no longer supported.");
+ const pe = s.call(r, r);
+ if (ms(pe) && z("data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>."), !Oe(pe)) z("data() should return an object.");
+ else {
+ e.data = $s(pe);
+ for (const be in pe) ht("Data", be), Js(be[0]) || Object.defineProperty(i, be, {
+ configurable: !0,
+ enumerable: !0,
+ get: () => pe[be],
+ set: mt
+ })
+ }
}
- if (vs = !0, a)
- for (const Se in a) {
- const Ae = a[Se],
- ht = fe(Ae) ? Ae.bind(n, n) : fe(Ae.get) ? Ae.get.bind(n, n) : Dt,
- Ur = !fe(Ae) && fe(Ae.set) ? Ae.set.bind(n) : Dt,
- Qt = Fh({
- get: ht,
- set: Ur
+ if (Gs = !0, a)
+ for (const pe in a) {
+ const be = a[pe],
+ et = le(be) ? be.bind(r, r) : le(be.get) ? be.get.bind(r, r) : mt;
+ et === mt && z(`Computed property "${pe}" has no getter.`);
+ const In = !le(be) && le(be.set) ? be.set.bind(r) : () => {
+ z(`Write operation failed: computed property "${pe}" is readonly.`)
+ },
+ Dr = hy({
+ get: et,
+ set: In
});
- Object.defineProperty(o, Se, {
+ Object.defineProperty(i, pe, {
enumerable: !0,
configurable: !0,
- get: () => Qt.value,
- set: St => Qt.value = St
- })
+ get: () => Dr.value,
+ set: gr => Dr.value = gr
+ }), ht("Computed", pe)
}
if (h)
- for (const Se in h) zu(h[Se], o, n, Se);
+ for (const pe in h) Hl(h[pe], i, r, pe);
if (y) {
- const Se = fe(y) ? y.call(n) : y;
- Reflect.ownKeys(Se).forEach(Ae => {
- ph(Ae, Se[Ae])
+ const pe = le(y) ? y.call(r) : y;
+ Reflect.ownKeys(pe).forEach(be => {
+ Ig(be, pe[be])
})
}
- w && Vu(w, e, "c");
+ _ && ql(_, e, "c");
- function Me(Se, Ae) {
- ne(Ae) ? Ae.forEach(ht => Se(ht.bind(n))) : Ae && Se(Ae.bind(n))
+ function Ue(pe, be) {
+ re(be) ? be.forEach(et => pe(et.bind(r))) : be && pe(be.bind(r))
}
- if (Me(Jp, N), Me(Qp, $), Me(Xp, W), Me(Gp, q), Me(Vp, U), Me(zp, de), Me(rh, Be), Me(th, Ct), Me(eh, f), Me(Yp, be), Me(Bu, te), Me(Zp, me), ne(rt))
- if (rt.length) {
- const Se = e.exposed || (e.exposed = {});
- rt.forEach(Ae => {
- Object.defineProperty(Se, Ae, {
- get: () => n[Ae],
- set: ht => n[Ae] = ht
+ if (Ue(dg, E), Ue(pg, P), Ue(hg, q), Ue(gg, j), Ue(lg, B), Ue(fg, he), Ue(wg, Ve), Ue(bg, xt), Ue(vg, f), Ue(yg, $e), Ue(jl, Ie), Ue(mg, ce), re(Ye))
+ if (Ye.length) {
+ const pe = e.exposed || (e.exposed = {});
+ Ye.forEach(be => {
+ Object.defineProperty(pe, be, {
+ get: () => r[be],
+ set: et => r[be] = et
})
})
} else e.exposed || (e.exposed = {});
- qe && e.render === Dt && (e.render = qe), wt != null && (e.inheritAttrs = wt), Qe && (e.components = Qe), le && (e.directives = le)
+ ne && e.render === mt && (e.render = ne), ut != null && (e.inheritAttrs = ut), ke && (e.components = ke), de && (e.directives = de)
}
- function ah(e, t, n = Dt) {
- ne(e) && (e = _s(e));
- for (const o in e) {
- const s = e[o];
+ function Ag(e, t, r = mt) {
+ re(e) && (e = Ys(e));
+ for (const i in e) {
+ const s = e[i];
let a;
- Ie(s) ? "default" in s ? a = qi(s.from || o, s.default, !0) : a = qi(s.from || o) : a = qi(s), ot(a) ? Object.defineProperty(t, o, {
+ Oe(s) ? "default" in s ? a = ho(s.from || i, s.default, !0) : a = ho(s.from || i) : a = ho(s), Qe(a) ? Object.defineProperty(t, i, {
enumerable: !0,
configurable: !0,
get: () => a.value,
set: c => a.value = c
- }) : t[o] = a
+ }) : t[i] = a, r("Inject", i)
}
}
- function Vu(e, t, n) {
- Mt(ne(e) ? e.map(o => o.bind(t.proxy)) : e.bind(t.proxy), t, n)
+ function ql(e, t, r) {
+ Ft(re(e) ? e.map(i => i.bind(t.proxy)) : e.bind(t.proxy), t, r)
}
- function zu(e, t, n, o) {
- const s = o.includes(".") ? ku(n, o) : () => n[o];
+ function Hl(e, t, r, i) {
+ const s = i.includes(".") ? Il(r, i) : () => r[i];
if (He(e)) {
const a = t[e];
- fe(a) && gs(s, a)
- } else if (fe(e)) gs(s, e.bind(n));
- else if (Ie(e))
- if (ne(e)) e.forEach(a => zu(a, t, n, o));
+ le(a) ? Ws(s, a) : z(`Invalid watch handler specified by key "${e}"`, a)
+ } else if (le(e)) Ws(s, e.bind(r));
+ else if (Oe(e))
+ if (re(e)) e.forEach(a => Hl(a, t, r, i));
else {
- const a = fe(e.handler) ? e.handler.bind(n) : t[e.handler];
- fe(a) && gs(s, a, e)
+ const a = le(e.handler) ? e.handler.bind(r) : t[e.handler];
+ le(a) ? Ws(s, a, e) : z(`Invalid watch handler specified by key "${e.handler}"`, a)
}
+ else z(`Invalid watch option: "${i}"`, e)
}
- function bs(e) {
+ function Xs(e) {
const t = e.type,
{
- mixins: n,
- extends: o
+ mixins: r,
+ extends: i
} = t,
{
mixins: s,
optionsCache: a,
config: {
optionMergeStrategies: c
}
} = e.appContext,
h = a.get(t);
let y;
- return h ? y = h : !s.length && !n && !o ? y = t : (y = {}, s.length && s.forEach(b => ki(y, b, c, !0)), ki(y, t, c)), Ie(t) && a.set(t, y), y
+ return h ? y = h : !s.length && !r && !i ? y = t : (y = {}, s.length && s.forEach(v => co(y, v, c, !0)), co(y, t, c)), Oe(t) && a.set(t, y), y
}
- function ki(e, t, n, o = !1) {
+ function co(e, t, r, i = !1) {
const {
mixins: s,
extends: a
} = t;
- a && ki(e, a, n, !0), s && s.forEach(c => ki(e, c, n, !0));
+ a && co(e, a, r, !0), s && s.forEach(c => co(e, c, r, !0));
for (const c in t)
- if (!(o && c === "expose")) {
- const h = uh[c] || n && n[c];
+ if (i && c === "expose") z('"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.');
+ else {
+ const h = Pg[c] || r && r[c];
e[c] = h ? h(e[c], t[c]) : t[c]
} return e
}
- const uh = {
- data: Ku,
- props: Ju,
- emits: Ju,
- methods: Vn,
- computed: Vn,
- beforeCreate: st,
- created: st,
- beforeMount: st,
- mounted: st,
- beforeUpdate: st,
- updated: st,
- beforeDestroy: st,
- beforeUnmount: st,
- destroyed: st,
- unmounted: st,
- activated: st,
- deactivated: st,
- errorCaptured: st,
- serverPrefetch: st,
- components: Vn,
- directives: Vn,
- watch: fh,
- provide: Ku,
- inject: lh
+ const Pg = {
+ data: Bl,
+ props: Wl,
+ emits: Wl,
+ methods: ui,
+ computed: ui,
+ beforeCreate: ct,
+ created: ct,
+ beforeMount: ct,
+ mounted: ct,
+ beforeUpdate: ct,
+ updated: ct,
+ beforeDestroy: ct,
+ beforeUnmount: ct,
+ destroyed: ct,
+ unmounted: ct,
+ activated: ct,
+ deactivated: ct,
+ errorCaptured: ct,
+ serverPrefetch: ct,
+ components: ui,
+ directives: ui,
+ watch: Rg,
+ provide: Bl,
+ inject: $g
};
- function Ku(e, t) {
+ function Bl(e, t) {
return t ? e ? function() {
- return Ke(fe(e) ? e.call(this, this) : e, fe(t) ? t.call(this, this) : t)
+ return Le(le(e) ? e.call(this, this) : e, le(t) ? t.call(this, this) : t)
} : t : e
}
- function lh(e, t) {
- return Vn(_s(e), _s(t))
+ function $g(e, t) {
+ return ui(Ys(e), Ys(t))
}
- function _s(e) {
- if (ne(e)) {
+ function Ys(e) {
+ if (re(e)) {
const t = {};
- for (let n = 0; n < e.length; n++) t[e[n]] = e[n];
+ for (let r = 0; r < e.length; r++) t[e[r]] = e[r];
return t
}
return e
}
- function st(e, t) {
+ function ct(e, t) {
return e ? [...new Set([].concat(e, t))] : t
}
- function Vn(e, t) {
- return e ? Ke(Object.create(null), e, t) : t
+ function ui(e, t) {
+ return e ? Le(Object.create(null), e, t) : t
}
- function Ju(e, t) {
- return e ? ne(e) && ne(t) ? [...new Set([...e, ...t])] : Ke(Object.create(null), Wu(e), Wu(t != null ? t : {})) : t
+ function Wl(e, t) {
+ return e ? re(e) && re(t) ? [...new Set([...e, ...t])] : Le(Object.create(null), Ul(e), Ul(t != null ? t : {})) : t
}
- function fh(e, t) {
+ function Rg(e, t) {
if (!e) return t;
if (!t) return e;
- const n = Ke(Object.create(null), e);
- for (const o in t) n[o] = st(e[o], t[o]);
- return n
+ const r = Le(Object.create(null), e);
+ for (const i in t) r[i] = ct(e[i], t[i]);
+ return r
}
- function Qu() {
+ function Vl() {
return {
app: null,
config: {
- isNativeTag: Md,
+ isNativeTag: Uu,
performance: !1,
globalProperties: {},
optionMergeStrategies: {},
errorHandler: void 0,
warnHandler: void 0,
compilerOptions: {}
},
@@ -2825,1053 +3297,1212 @@
directives: {},
provides: Object.create(null),
optionsCache: new WeakMap,
propsCache: new WeakMap,
emitsCache: new WeakMap
}
}
- let ch = 0;
+ let Ng = 0;
- function dh(e, t) {
- return function(o, s = null) {
- fe(o) || (o = Ke({}, o)), s != null && !Ie(s) && (s = null);
- const a = Qu(),
- c = new Set;
+ function Dg(e, t) {
+ return function(i, s = null) {
+ le(i) || (i = Le({}, i)), s != null && !Oe(s) && (z("root props passed to app.mount() must be an object."), s = null);
+ const a = Vl();
+ Object.defineProperty(a.config, "unwrapInjectedRef", {
+ get() {
+ return !0
+ },
+ set() {
+ z("app.config.unwrapInjectedRef has been deprecated. 3.3 now alawys unwraps injected refs in Options API.")
+ }
+ });
+ const c = new Set;
let h = !1;
const y = a.app = {
- _uid: ch++,
- _component: o,
+ _uid: Ng++,
+ _component: i,
_props: s,
_container: null,
_context: a,
_instance: null,
- version: qh,
+ version: hf,
get config() {
return a.config
},
- set config(b) {},
- use(b, ...w) {
- return c.has(b) || (b && fe(b.install) ? (c.add(b), b.install(y, ...w)) : fe(b) && (c.add(b), b(y, ...w))), y
- },
- mixin(b) {
- return a.mixins.includes(b) || a.mixins.push(b), y
- },
- component(b, w) {
- return w ? (a.components[b] = w, y) : a.components[b]
- },
- directive(b, w) {
- return w ? (a.directives[b] = w, y) : a.directives[b]
- },
- mount(b, w, N) {
- if (!h) {
- const $ = _t(o, s);
- return $.appContext = a, w && t ? t($, b) : e($, b, N), h = !0, y._container = b, b.__vue_app__ = y, Wi($.component) || $.component.proxy
+ set config(v) {
+ z("app.config cannot be replaced. Modify individual options instead.")
+ },
+ use(v, ..._) {
+ return c.has(v) ? z("Plugin has already been applied to target app.") : v && le(v.install) ? (c.add(v), v.install(y, ..._)) : le(v) ? (c.add(v), v(y, ..._)) : z('A plugin must either be a function or an object with an "install" function.'), y
+ },
+ mixin(v) {
+ return a.mixins.includes(v) ? z("Mixin has already been applied to target app" + (v.name ? `: ${v.name}` : "")) : a.mixins.push(v), y
+ },
+ component(v, _) {
+ return ua(v, a.config), _ ? (a.components[v] && z(`Component "${v}" has already been registered in target app.`), a.components[v] = _, y) : a.components[v]
+ },
+ directive(v, _) {
+ return Ml(v), _ ? (a.directives[v] && z(`Directive "${v}" has already been registered in target app.`), a.directives[v] = _, y) : a.directives[v]
+ },
+ mount(v, _, E) {
+ if (h) z("App has already been mounted.\nIf you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. `const createMyApp = () => createApp(App)`");
+ else {
+ v.__vue_app__ && z("There is already an app instance mounted on the host container.\n If you want to mount another app on the same host container, you need to unmount the previous app by calling `app.unmount()` first.");
+ const P = At(i, s);
+ return P.appContext = a, a.reload = () => {
+ e(Pr(P), v, E)
+ }, _ && t ? t(P, v) : e(P, v, E), h = !0, y._container = v, v.__vue_app__ = y, y._instance = P.component, Vh(y, hf), bo(P.component) || P.component.proxy
}
},
unmount() {
- h && (e(null, y._container), delete y._container.__vue_app__)
+ h ? (e(null, y._container), y._instance = null, zh(y), delete y._container.__vue_app__) : z("Cannot unmount an app that is not mounted.")
},
- provide(b, w) {
- return a.provides[b] = w, y
+ provide(v, _) {
+ return v in a.provides && z(`App already provides property with key "${String(v)}". It will be overwritten with the new value.`), a.provides[v] = _, y
},
- runWithContext(b) {
- ji = y;
+ runWithContext(v) {
+ po = y;
try {
- return b()
+ return v()
} finally {
- ji = null
+ po = null
}
}
};
return y
}
}
- let ji = null;
+ let po = null;
- function ph(e, t) {
- if (Xe) {
- let n = Xe.provides;
- const o = Xe.parent && Xe.parent.provides;
- o === n && (n = Xe.provides = Object.create(o)), n[e] = t
+ function Ig(e, t) {
+ if (!Ge) z("provide() can only be used inside setup().");
+ else {
+ let r = Ge.provides;
+ const i = Ge.parent && Ge.parent.provides;
+ i === r && (r = Ge.provides = Object.create(i)), r[e] = t
}
}
- function qi(e, t, n = !1) {
- const o = Xe || Et;
- if (o || ji) {
- const s = o ? o.parent == null ? o.vnode.appContext && o.vnode.appContext.provides : o.parent.provides : ji._context.provides;
+ function ho(e, t, r = !1) {
+ const i = Ge || vt;
+ if (i || po) {
+ const s = i ? i.parent == null ? i.vnode.appContext && i.vnode.appContext.provides : i.parent.provides : po._context.provides;
if (s && e in s) return s[e];
- if (arguments.length > 1) return n && fe(t) ? t.call(o && o.proxy) : t
- }
+ if (arguments.length > 1) return r && le(t) ? t.call(i && i.proxy) : t;
+ z(`injection "${String(e)}" not found.`)
+ } else z("inject() can only be used inside setup() or functional components.")
}
- function hh(e, t, n, o = !1) {
+ function Mg(e, t, r, i = !1) {
const s = {},
a = {};
- wi(a, Ui, 1), e.propsDefaults = Object.create(null), Xu(e, t, s, a);
+ qi(a, mo, 1), e.propsDefaults = Object.create(null), zl(e, t, s, a);
for (const c in e.propsOptions[0]) c in s || (s[c] = void 0);
- n ? e.props = o ? s : wp(s) : e.type.props ? e.props = s : e.props = a, e.attrs = a
+ Xl(t || {}, s, e), r ? e.props = i ? s : Eh(s) : e.type.props ? e.props = s : e.props = a, e.attrs = a
+ }
+
+ function kg(e) {
+ for (; e;) {
+ if (e.type.__hmrId) return !0;
+ e = e.parent
+ }
}
- function gh(e, t, n, o) {
+ function jg(e, t, r, i) {
const {
props: s,
attrs: a,
vnode: {
patchFlag: c
}
- } = e, h = Oe(s), [y] = e.propsOptions;
- let b = !1;
- if ((o || c > 0) && !(c & 16)) {
+ } = e, h = ye(s), [y] = e.propsOptions;
+ let v = !1;
+ if (!kg(e) && (i || c > 0) && !(c & 16)) {
if (c & 8) {
- const w = e.vnode.dynamicProps;
- for (let N = 0; N < w.length; N++) {
- let $ = w[N];
- if (Ri(e.emitsOptions, $)) continue;
- const W = t[$];
+ const _ = e.vnode.dynamicProps;
+ for (let E = 0; E < _.length; E++) {
+ let P = _[E];
+ if (no(e.emitsOptions, P)) continue;
+ const q = t[P];
if (y)
- if (xe(a, $)) W !== a[$] && (a[$] = W, b = !0);
+ if (ve(a, P)) q !== a[P] && (a[P] = q, v = !0);
else {
- const q = Ht($);
- s[q] = xs(y, h, q, W, e, !1)
+ const j = Jt(P);
+ s[j] = Zs(y, h, j, q, e, !1)
}
- else W !== a[$] && (a[$] = W, b = !0)
+ else q !== a[P] && (a[P] = q, v = !0)
}
}
} else {
- Xu(e, t, s, a) && (b = !0);
- let w;
- for (const N in h)(!t || !xe(t, N) && ((w = on(N)) === N || !xe(t, w))) && (y ? n && (n[N] !== void 0 || n[w] !== void 0) && (s[N] = xs(y, h, N, void 0, e, !0)) : delete s[N]);
+ zl(e, t, s, a) && (v = !0);
+ let _;
+ for (const E in h)(!t || !ve(t, E) && ((_ = Sr(E)) === E || !ve(t, _))) && (y ? r && (r[E] !== void 0 || r[_] !== void 0) && (s[E] = Zs(y, h, E, void 0, e, !0)) : delete s[E]);
if (a !== h)
- for (const N in a)(!t || !xe(t, N) && !0) && (delete a[N], b = !0)
+ for (const E in a)(!t || !ve(t, E) && !0) && (delete a[E], v = !0)
}
- b && nr(e, "set", "$attrs")
+ v && Gt(e, "set", "$attrs"), Xl(t || {}, s, e)
}
- function Xu(e, t, n, o) {
+ function zl(e, t, r, i) {
const [s, a] = e.propsOptions;
let c = !1,
h;
if (t)
for (let y in t) {
- if (mi(y)) continue;
- const b = t[y];
- let w;
- s && xe(s, w = Ht(y)) ? !a || !a.includes(w) ? n[w] = b : (h || (h = {}))[w] = b : Ri(e.emitsOptions, y) || (!(y in o) || b !== o[y]) && (o[y] = b, c = !0)
+ if (Li(y)) continue;
+ const v = t[y];
+ let _;
+ s && ve(s, _ = Jt(y)) ? !a || !a.includes(_) ? r[_] = v : (h || (h = {}))[_] = v : no(e.emitsOptions, y) || (!(y in i) || v !== i[y]) && (i[y] = v, c = !0)
}
if (a) {
- const y = Oe(n),
- b = h || De;
- for (let w = 0; w < a.length; w++) {
- const N = a[w];
- n[N] = xs(s, y, N, b[N], e, !xe(b, N))
+ const y = ye(r),
+ v = h || Ne;
+ for (let _ = 0; _ < a.length; _++) {
+ const E = a[_];
+ r[E] = Zs(s, y, E, v[E], e, !ve(v, E))
}
}
return c
}
- function xs(e, t, n, o, s, a) {
- const c = e[n];
+ function Zs(e, t, r, i, s, a) {
+ const c = e[r];
if (c != null) {
- const h = xe(c, "default");
- if (h && o === void 0) {
+ const h = ve(c, "default");
+ if (h && i === void 0) {
const y = c.default;
- if (c.type !== Function && !c.skipFactory && fe(y)) {
+ if (c.type !== Function && !c.skipFactory && le(y)) {
const {
- propsDefaults: b
+ propsDefaults: v
} = s;
- n in b ? o = b[n] : (dn(s), o = b[n] = y.call(null, t), kr())
- } else o = y
+ r in v ? i = v[r] : (Tn(s), i = v[r] = y.call(null, t), nn())
+ } else i = y
}
- c[0] && (a && !h ? o = !1 : c[1] && (o === "" || o === on(n)) && (o = !0))
+ c[0] && (a && !h ? i = !1 : c[1] && (i === "" || i === Sr(r)) && (i = !0))
}
- return o
+ return i
}
- function Gu(e, t, n = !1) {
- const o = t.propsCache,
- s = o.get(e);
+ function Kl(e, t, r = !1) {
+ const i = t.propsCache,
+ s = i.get(e);
if (s) return s;
const a = e.props,
c = {},
h = [];
let y = !1;
- if (!fe(e)) {
- const w = N => {
+ if (!le(e)) {
+ const _ = E => {
y = !0;
- const [$, W] = Gu(N, t, !0);
- Ke(c, $), W && h.push(...W)
+ const [P, q] = Kl(E, t, !0);
+ Le(c, P), q && h.push(...q)
};
- !n && t.mixins.length && t.mixins.forEach(w), e.extends && w(e.extends), e.mixins && e.mixins.forEach(w)
+ !r && t.mixins.length && t.mixins.forEach(_), e.extends && _(e.extends), e.mixins && e.mixins.forEach(_)
}
- if (!a && !y) return Ie(e) && o.set(e, tn), tn;
- if (ne(a))
- for (let w = 0; w < a.length; w++) {
- const N = Ht(a[w]);
- Yu(N) && (c[N] = De)
- } else if (a)
- for (const w in a) {
- const N = Ht(w);
- if (Yu(N)) {
- const $ = a[w],
- W = c[N] = ne($) || fe($) ? {
- type: $
- } : Ke({}, $);
- if (W) {
- const q = tl(Boolean, W.type),
- U = tl(String, W.type);
- W[0] = q > -1, W[1] = U < 0 || q < U, (q > -1 || xe(W, "default")) && h.push(N)
+ if (!a && !y) return Oe(e) && i.set(e, bn), bn;
+ if (re(a))
+ for (let _ = 0; _ < a.length; _++) {
+ He(a[_]) || z("props must be strings when using array syntax.", a[_]);
+ const E = Jt(a[_]);
+ Jl(E) && (c[E] = Ne)
+ } else if (a) {
+ Oe(a) || z("invalid props options", a);
+ for (const _ in a) {
+ const E = Jt(_);
+ if (Jl(E)) {
+ const P = a[_],
+ q = c[E] = re(P) || le(P) ? {
+ type: P
+ } : Le({}, P);
+ if (q) {
+ const j = Gl(Boolean, q.type),
+ B = Gl(String, q.type);
+ q[0] = j > -1, q[1] = B < 0 || j < B, (j > -1 || ve(q, "default")) && h.push(E)
}
}
}
- const b = [c, h];
- return Ie(e) && o.set(e, b), b
+ } const v = [c, h];
+ return Oe(e) && i.set(e, v), v
}
- function Yu(e) {
- return e[0] !== "$"
+ function Jl(e) {
+ return e[0] !== "$" ? !0 : (z(`Invalid prop name: "${e}" is a reserved property.`), !1)
}
- function Zu(e) {
+ function ea(e) {
const t = e && e.toString().match(/^\s*(function|class) (\w+)/);
return t ? t[2] : e === null ? "null" : ""
}
- function el(e, t) {
- return Zu(e) === Zu(t)
+ function Ql(e, t) {
+ return ea(e) === ea(t)
+ }
+
+ function Gl(e, t) {
+ return re(t) ? t.findIndex(r => Ql(r, e)) : le(t) && Ql(t, e) ? 0 : -1
}
- function tl(e, t) {
- return ne(t) ? t.findIndex(n => el(n, e)) : fe(t) && el(t, e) ? 0 : -1
+ function Xl(e, t, r) {
+ const i = ye(t),
+ s = r.propsOptions[0];
+ for (const a in s) {
+ let c = s[a];
+ c != null && Lg(a, i[a], c, !ve(e, a) && !ve(e, Sr(a)))
+ }
+ }
+
+ function Lg(e, t, r, i) {
+ const {
+ type: s,
+ required: a,
+ validator: c,
+ skipCheck: h
+ } = r;
+ if (a && i) {
+ z('Missing required prop: "' + e + '"');
+ return
+ }
+ if (!(t == null && !a)) {
+ if (s != null && s !== !0 && !h) {
+ let y = !1;
+ const v = re(s) ? s : [s],
+ _ = [];
+ for (let E = 0; E < v.length && !y; E++) {
+ const {
+ valid: P,
+ expectedType: q
+ } = Ug(t, v[E]);
+ _.push(q || ""), y = P
+ }
+ if (!y) {
+ z(qg(e, t, _));
+ return
+ }
+ }
+ c && !c(t) && z('Invalid prop: custom validator check failed for prop "' + e + '".')
+ }
}
- const rl = e => e[0] === "_" || e === "$stable",
- ws = e => ne(e) ? e.map(zt) : [zt(e)],
- yh = (e, t, n) => {
+ const Fg = xr("String,Number,Boolean,Function,Symbol,BigInt");
+
+ function Ug(e, t) {
+ let r;
+ const i = ea(t);
+ if (Fg(i)) {
+ const s = typeof e;
+ r = s === i.toLowerCase(), !r && s === "object" && (r = e instanceof t)
+ } else i === "Object" ? r = Oe(e) : i === "Array" ? r = re(e) : i === "null" ? r = e === null : r = e instanceof t;
+ return {
+ valid: r,
+ expectedType: i
+ }
+ }
+
+ function qg(e, t, r) {
+ let i = `Invalid prop: type check failed for prop "${e}". Expected ${r.map(qr).join(" | ")}`;
+ const s = r[0],
+ a = vs(t),
+ c = Yl(t, s),
+ h = Yl(t, a);
+ return r.length === 1 && Zl(s) && !Hg(s, a) && (i += ` with value ${c}`), i += `, got ${a} `, Zl(a) && (i += `with value ${h}.`), i
+ }
+
+ function Yl(e, t) {
+ return t === "String" ? `"${e}"` : t === "Number" ? `${Number(e)}` : `${e}`
+ }
+
+ function Zl(e) {
+ return ["string", "number", "boolean"].some(r => e.toLowerCase() === r)
+ }
+
+ function Hg(...e) {
+ return e.some(t => t.toLowerCase() === "boolean")
+ }
+ const ef = e => e[0] === "_" || e === "$stable",
+ ta = e => re(e) ? e.map(qt) : [qt(e)],
+ Bg = (e, t, r) => {
if (t._n) return t;
- const o = Lp((...s) => ws(t(...s)), n);
- return o._c = !1, o
+ const i = eg((...s) => (Ge && z(`Slot "${e}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`), ta(t(...s))), r);
+ return i._c = !1, i
},
- nl = (e, t, n) => {
- const o = e._ctx;
+ tf = (e, t, r) => {
+ const i = e._ctx;
for (const s in e) {
- if (rl(s)) continue;
+ if (ef(s)) continue;
const a = e[s];
- if (fe(a)) t[s] = yh(s, a, o);
+ if (le(a)) t[s] = Bg(s, a, i);
else if (a != null) {
- const c = ws(a);
+ z(`Non-function value encountered for slot "${s}". Prefer function slots for better performance.`);
+ const c = ta(a);
t[s] = () => c
}
}
},
- il = (e, t) => {
- const n = ws(t);
- e.slots.default = () => n
+ rf = (e, t) => {
+ Vs(e.vnode) || z("Non-function value encountered for default slot. Prefer function slots for better performance.");
+ const r = ta(t);
+ e.slots.default = () => r
},
- mh = (e, t) => {
+ Wg = (e, t) => {
if (e.vnode.shapeFlag & 32) {
- const n = t._;
- n ? (e.slots = Oe(t), wi(t, "_", n)) : nl(t, e.slots = {})
- } else e.slots = {}, t && il(e, t);
- wi(e.slots, Ui, 1)
+ const r = t._;
+ r ? (e.slots = ye(t), qi(t, "_", r)) : tf(t, e.slots = {})
+ } else e.slots = {}, t && rf(e, t);
+ qi(e.slots, mo, 1)
},
- vh = (e, t, n) => {
+ Vg = (e, t, r) => {
const {
- vnode: o,
+ vnode: i,
slots: s
} = e;
let a = !0,
- c = De;
- if (o.shapeFlag & 32) {
+ c = Ne;
+ if (i.shapeFlag & 32) {
const h = t._;
- h ? n && h === 1 ? a = !1 : (Ke(s, t), !n && h === 1 && delete s._) : (a = !t.$stable, nl(t, s)), c = t
- } else t && (il(e, t), c = {
+ h ? Gr ? (Le(s, t), Gt(e, "set", "$slots")) : r && h === 1 ? a = !1 : (Le(s, t), !r && h === 1 && delete s._) : (a = !t.$stable, tf(t, s)), c = t
+ } else t && (rf(e, t), c = {
default: 1
});
if (a)
- for (const h in s) !rl(h) && !(h in c) && delete s[h]
+ for (const h in s) !ef(h) && !(h in c) && delete s[h]
};
- function Ss(e, t, n, o, s = !1) {
- if (ne(e)) {
- e.forEach(($, W) => Ss($, t && (ne(t) ? t[W] : t), n, o, s));
+ function ra(e, t, r, i, s = !1) {
+ if (re(e)) {
+ e.forEach((P, q) => ra(P, t && (re(t) ? t[q] : t), r, i, s));
return
}
- if (Mi(o) && !s) return;
- const a = o.shapeFlag & 4 ? Wi(o.component) || o.component.proxy : o.el,
+ if (uo(i) && !s) return;
+ const a = i.shapeFlag & 4 ? bo(i.component) || i.component.proxy : i.el,
c = s ? null : a,
{
i: h,
r: y
- } = e,
- b = t && t.r,
- w = h.refs === De ? h.refs = {} : h.refs,
- N = h.setupState;
- if (b != null && b !== y && (He(b) ? (w[b] = null, xe(N, b) && (N[b] = null)) : ot(b) && (b.value = null)), fe(y)) br(y, h, 12, [c, w]);
+ } = e;
+ if (!h) {
+ z("Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.");
+ return
+ }
+ const v = t && t.r,
+ _ = h.refs === Ne ? h.refs = {} : h.refs,
+ E = h.setupState;
+ if (v != null && v !== y && (He(v) ? (_[v] = null, ve(E, v) && (E[v] = null)) : Qe(v) && (v.value = null)), le(y)) lr(y, h, 12, [c, _]);
else {
- const $ = He(y),
- W = ot(y);
- if ($ || W) {
- const q = () => {
+ const P = He(y),
+ q = Qe(y);
+ if (P || q) {
+ const j = () => {
if (e.f) {
- const U = $ ? xe(N, y) ? N[y] : w[y] : y.value;
- s ? ne(U) && Vo(U, a) : ne(U) ? U.includes(a) || U.push(a) : $ ? (w[y] = [a], xe(N, y) && (N[y] = w[y])) : (y.value = [a], e.k && (w[e.k] = y.value))
- } else $ ? (w[y] = c, xe(N, y) && (N[y] = c)) : W && (y.value = c, e.k && (w[e.k] = c))
+ const B = P ? ve(E, y) ? E[y] : _[y] : y.value;
+ s ? re(B) && ys(B, a) : re(B) ? B.includes(a) || B.push(a) : P ? (_[y] = [a], ve(E, y) && (E[y] = _[y])) : (y.value = [a], e.k && (_[e.k] = y.value))
+ } else P ? (_[y] = c, ve(E, y) && (E[y] = c)) : q ? (y.value = c, e.k && (_[e.k] = c)) : z("Invalid template ref type:", y, `(${typeof y})`)
};
- c ? (q.id = -1, ft(q, n)) : q()
- }
+ c ? (j.id = -1, bt(j, r)) : j()
+ } else z("Invalid template ref type:", y, `(${typeof y})`)
}
}
- const ft = Up;
+ let li, Ar;
- function bh(e) {
- return _h(e)
+ function cr(e, t) {
+ e.appContext.config.performance && go() && Ar.mark(`vue-${t}-${e.uid}`), Gh(e, t, go() ? Ar.now() : Date.now())
}
- function _h(e, t) {
- const n = Jo();
- n.__VUE__ = !0;
+ function dr(e, t) {
+ if (e.appContext.config.performance && go()) {
+ const r = `vue-${t}-${e.uid}`,
+ i = r + ":end";
+ Ar.mark(i), Ar.measure(`<${wo(e,e.type)}> ${t}`, r, i), Ar.clearMarks(r), Ar.clearMarks(i)
+ }
+ Xh(e, t, go() ? Ar.now() : Date.now())
+ }
+
+ function go() {
+ return li !== void 0 || (typeof window != "undefined" && window.performance ? (li = !0, Ar = window.performance) : li = !1), li
+ }
+
+ function zg() {
+ const e = [];
+ if (e.length) {
+ const t = e.length > 1;
+ console.warn(`Feature flag${t?"s":""} ${e.join(", ")} ${t?"are":"is"} not explicitly defined. You are running the esm-bundler build of Vue, which expects these compile-time feature flags to be globally injected via the bundler config in order to get better tree-shaking in the production bundle.
+
+For more details, see https://link.vuejs.org/feature-flags.`)
+ }
+ }
+ const bt = ag;
+
+ function Kg(e) {
+ return Jg(e)
+ }
+
+ function Jg(e, t) {
+ zg();
+ const r = Bi();
+ r.__VUE__ = !0, Tl(r.__VUE_DEVTOOLS_GLOBAL_HOOK__, r);
const {
- insert: o,
+ insert: i,
remove: s,
patchProp: a,
createElement: c,
createText: h,
createComment: y,
- setText: b,
- setElementText: w,
- parentNode: N,
- nextSibling: $,
- setScopeId: W = Dt,
- insertStaticContent: q
- } = e, U = (x, T, R, F = null, M = null, H = null, K = !1, V = null, J = !!T.dynamicChildren) => {
- if (x === T) return;
- x && !Jn(x, T) && (F = wn(x), St(x, M, H, !0), x = null), T.patchFlag === -2 && (J = !1, T.dynamicChildren = null);
+ setText: v,
+ setElementText: _,
+ parentNode: E,
+ nextSibling: P,
+ setScopeId: q = mt,
+ insertStaticContent: j
+ } = e, B = (b, T, N, F = null, L = null, H = null, Q = !1, V = null, K = Gr ? !1 : !!T.dynamicChildren) => {
+ if (b === T) return;
+ b && !pi(b, T) && (F = kn(b), Nt(b, L, H, !0), b = null), T.patchFlag === -2 && (K = !1, T.dynamicChildren = null);
const {
- type: j,
- ref: Y,
- shapeFlag: G
+ type: k,
+ ref: Z,
+ shapeFlag: Y
} = T;
- switch (j) {
- case Bi:
- de(x, T, R, F);
+ switch (k) {
+ case fi:
+ he(b, T, N, F);
break;
- case Lr:
- L(x, T, R, F);
+ case Ct:
+ U(b, T, N, F);
break;
- case Es:
- x == null && be(T, R, F, K);
+ case yo:
+ b == null ? $e(T, N, F, Q) : oe(b, T, N, Q);
break;
- case ct:
- Qe(x, T, R, F, M, H, K, V, J);
+ case dt:
+ de(b, T, N, F, L, H, Q, V, K);
break;
default:
- G & 1 ? qe(x, T, R, F, M, H, K, V, J) : G & 6 ? le(x, T, R, F, M, H, K, V, J) : (G & 64 || G & 128) && j.process(x, T, R, F, M, H, K, V, J, lr)
+ Y & 1 ? xt(b, T, N, F, L, H, Q, V, K) : Y & 6 ? pt(b, T, N, F, L, H, Q, V, K) : Y & 64 || Y & 128 ? k.process(b, T, N, F, L, H, Q, V, K, tt) : z("Invalid VNode type:", k, `(${typeof k})`)
}
- Y != null && M && Ss(Y, x && x.ref, H, T || x, !T)
- }, de = (x, T, R, F) => {
- if (x == null) o(T.el = h(T.children), R, F);
+ Z != null && L && ra(Z, b && b.ref, H, T || b, !T)
+ }, he = (b, T, N, F) => {
+ if (b == null) i(T.el = h(T.children), N, F);
else {
- const M = T.el = x.el;
- T.children !== x.children && b(M, T.children)
+ const L = T.el = b.el;
+ T.children !== b.children && v(L, T.children)
}
- }, L = (x, T, R, F) => {
- x == null ? o(T.el = y(T.children || ""), R, F) : T.el = x.el
- }, be = (x, T, R, F) => {
- [x.el, x.anchor] = q(x.children, T, R, F, x.el, x.anchor)
- }, ye = ({
- el: x,
+ }, U = (b, T, N, F) => {
+ b == null ? i(T.el = y(T.children || ""), N, F) : T.el = b.el
+ }, $e = (b, T, N, F) => {
+ [b.el, b.anchor] = j(b.children, T, N, F, b.el, b.anchor)
+ }, oe = (b, T, N, F) => {
+ if (T.children !== b.children) {
+ const L = P(b.anchor);
+ ne(b), [T.el, T.anchor] = j(T.children, N, L, F)
+ } else T.el = b.el, T.anchor = b.anchor
+ }, Ie = ({
+ el: b,
anchor: T
- }, R, F) => {
- let M;
- for (; x && x !== T;) M = $(x), o(x, R, F), x = M;
- o(T, R, F)
- }, te = ({
- el: x,
+ }, N, F) => {
+ let L;
+ for (; b && b !== T;) L = P(b), i(b, N, F), b = L;
+ i(T, N, F)
+ }, ne = ({
+ el: b,
anchor: T
}) => {
- let R;
- for (; x && x !== T;) R = $(x), s(x), x = R;
+ let N;
+ for (; b && b !== T;) N = P(b), s(b), b = N;
s(T)
- }, qe = (x, T, R, F, M, H, K, V, J) => {
- K = K || T.type === "svg", x == null ? Ct(T, R, F, M, H, K, V, J) : me(x, T, M, H, K, V, J)
- }, Ct = (x, T, R, F, M, H, K, V) => {
- let J, j;
+ }, xt = (b, T, N, F, L, H, Q, V, K) => {
+ Q = Q || T.type === "svg", b == null ? f(T, N, F, L, H, Q, V, K) : Ye(b, T, L, H, Q, V, K)
+ }, f = (b, T, N, F, L, H, Q, V) => {
+ let K, k;
const {
- type: Y,
- props: G,
- shapeFlag: ee,
- transition: k,
- dirs: ie
- } = x;
- if (J = x.el = c(x.type, H, G && G.is, G), ee & 8 ? w(J, x.children) : ee & 16 && Be(x.children, J, null, F, M, H && Y !== "foreignObject", K, V), ie && $r(x, null, F, "created"), f(J, x, x.scopeId, K, F), G) {
- for (const Ce in G) Ce !== "value" && !mi(Ce) && a(J, Ce, null, G[Ce], H, x.children, F, M, kt);
- "value" in G && a(J, "value", null, G.value), (j = G.onVnodeBeforeMount) && Kt(j, F, x)
- }
- ie && $r(x, null, F, "beforeMount");
- const Pe = (!M || M && !M.pendingBranch) && k && !k.persisted;
- Pe && k.beforeEnter(J), o(J, T, R), ((j = G && G.onVnodeMounted) || Pe || ie) && ft(() => {
- j && Kt(j, F, x), Pe && k.enter(J), ie && $r(x, null, F, "mounted")
- }, M)
- }, f = (x, T, R, F, M) => {
- if (R && W(x, R), F)
- for (let H = 0; H < F.length; H++) W(x, F[H]);
- if (M) {
- let H = M.subTree;
- if (T === H) {
- const K = M.vnode;
- f(x, K, K.scopeId, K.slotScopeIds, M.parent)
- }
- }
- }, Be = (x, T, R, F, M, H, K, V, J = 0) => {
- for (let j = J; j < x.length; j++) {
- const Y = x[j] = V ? _r(x[j]) : zt(x[j]);
- U(null, Y, T, R, F, M, H, K, V)
+ type: Z,
+ props: Y,
+ shapeFlag: M,
+ transition: te,
+ dirs: me
+ } = b;
+ if (K = b.el = c(b.type, H, Y && Y.is, Y), M & 8 ? _(K, b.children) : M & 16 && ce(b.children, K, null, F, L, H && Z !== "foreignObject", Q, V), me && Zr(b, null, F, "created"), Ve(K, b, b.scopeId, Q, F), Y) {
+ for (const Pe in Y) Pe !== "value" && !Li(Pe) && a(K, Pe, null, Y[Pe], H, b.children, F, L, Bt);
+ "value" in Y && a(K, "value", null, Y.value), (k = Y.onVnodeBeforeMount) && er(k, F, b)
+ }
+ Object.defineProperty(K, "__vnode", {
+ value: b,
+ enumerable: !1
+ }), Object.defineProperty(K, "__vueParentComponent", {
+ value: F,
+ enumerable: !1
+ }), me && Zr(b, null, F, "beforeMount");
+ const Re = (!L || L && !L.pendingBranch) && te && !te.persisted;
+ Re && te.beforeEnter(K), i(K, T, N), ((k = Y && Y.onVnodeMounted) || Re || me) && bt(() => {
+ k && er(k, F, b), Re && te.enter(K), me && Zr(b, null, F, "mounted")
+ }, L)
+ }, Ve = (b, T, N, F, L) => {
+ if (N && q(b, N), F)
+ for (let H = 0; H < F.length; H++) q(b, F[H]);
+ if (L) {
+ let H = L.subTree;
+ if (H.patchFlag > 0 && H.patchFlag & 2048 && (H = $l(H.children) || H), T === H) {
+ const Q = L.vnode;
+ Ve(b, Q, Q.scopeId, Q.slotScopeIds, L.parent)
+ }
+ }
+ }, ce = (b, T, N, F, L, H, Q, V, K = 0) => {
+ for (let k = K; k < b.length; k++) {
+ const Z = b[k] = V ? $r(b[k]) : qt(b[k]);
+ B(null, Z, T, N, F, L, H, Q, V)
}
- }, me = (x, T, R, F, M, H, K) => {
- const V = T.el = x.el;
+ }, Ye = (b, T, N, F, L, H, Q) => {
+ const V = T.el = b.el;
let {
- patchFlag: J,
- dynamicChildren: j,
- dirs: Y
+ patchFlag: K,
+ dynamicChildren: k,
+ dirs: Z
} = T;
- J |= x.patchFlag & 16;
- const G = x.props || De,
- ee = T.props || De;
- let k;
- R && Mr(R, !1), (k = ee.onVnodeBeforeUpdate) && Kt(k, R, T, x), Y && $r(T, x, R, "beforeUpdate"), R && Mr(R, !0);
- const ie = M && T.type !== "foreignObject";
- if (j ? rt(x.dynamicChildren, j, V, R, F, ie, H) : K || Ae(x, T, V, null, R, F, ie, H, !1), J > 0) {
- if (J & 16) wt(V, T, G, ee, R, F, M);
- else if (J & 2 && G.class !== ee.class && a(V, "class", null, ee.class, M), J & 4 && a(V, "style", G.style, ee.style, M), J & 8) {
- const Pe = T.dynamicProps;
- for (let Ce = 0; Ce < Pe.length; Ce++) {
- const ke = Pe[Ce],
- yt = G[ke],
- fr = ee[ke];
- (fr !== yt || ke === "value") && a(V, ke, yt, fr, M, x.children, R, F, kt)
- }
- }
- J & 1 && x.children !== T.children && w(V, T.children)
- } else !K && j == null && wt(V, T, G, ee, R, F, M);
- ((k = ee.onVnodeUpdated) || Y) && ft(() => {
- k && Kt(k, R, T, x), Y && $r(T, x, R, "updated")
+ K |= b.patchFlag & 16;
+ const Y = b.props || Ne,
+ M = T.props || Ne;
+ let te;
+ N && tn(N, !1), (te = M.onVnodeBeforeUpdate) && er(te, N, T, b), Z && Zr(T, b, N, "beforeUpdate"), N && tn(N, !0), Gr && (K = 0, Q = !1, k = null);
+ const me = L && T.type !== "foreignObject";
+ if (k ? (ut(b.dynamicChildren, k, V, N, F, me, H), na(b, T)) : Q || et(b, T, V, null, N, F, me, H, !1), K > 0) {
+ if (K & 16) ke(V, T, Y, M, N, F, L);
+ else if (K & 2 && Y.class !== M.class && a(V, "class", null, M.class, L), K & 4 && a(V, "style", Y.style, M.style, L), K & 8) {
+ const Re = T.dynamicProps;
+ for (let Pe = 0; Pe < Re.length; Pe++) {
+ const qe = Re[Pe],
+ St = Y[qe],
+ Dt = M[qe];
+ (Dt !== St || qe === "value") && a(V, qe, St, Dt, L, b.children, N, F, Bt)
+ }
+ }
+ K & 1 && b.children !== T.children && _(V, T.children)
+ } else !Q && k == null && ke(V, T, Y, M, N, F, L);
+ ((te = M.onVnodeUpdated) || Z) && bt(() => {
+ te && er(te, N, T, b), Z && Zr(T, b, N, "updated")
}, F)
- }, rt = (x, T, R, F, M, H, K) => {
+ }, ut = (b, T, N, F, L, H, Q) => {
for (let V = 0; V < T.length; V++) {
- const J = x[V],
- j = T[V],
- Y = J.el && (J.type === ct || !Jn(J, j) || J.shapeFlag & 70) ? N(J.el) : R;
- U(J, j, Y, null, F, M, H, K, !0)
- }
- }, wt = (x, T, R, F, M, H, K) => {
- if (R !== F) {
- if (R !== De)
- for (const V in R) !mi(V) && !(V in F) && a(x, V, R[V], null, K, T.children, M, H, kt);
+ const K = b[V],
+ k = T[V],
+ Z = K.el && (K.type === dt || !pi(K, k) || K.shapeFlag & 70) ? E(K.el) : N;
+ B(K, k, Z, null, F, L, H, Q, !0)
+ }
+ }, ke = (b, T, N, F, L, H, Q) => {
+ if (N !== F) {
+ if (N !== Ne)
+ for (const V in N) !Li(V) && !(V in F) && a(b, V, N[V], null, Q, T.children, L, H, Bt);
for (const V in F) {
- if (mi(V)) continue;
- const J = F[V],
- j = R[V];
- J !== j && V !== "value" && a(x, V, j, J, K, T.children, M, H, kt)
- }
- "value" in F && a(x, "value", R.value, F.value)
- }
- }, Qe = (x, T, R, F, M, H, K, V, J) => {
- const j = T.el = x ? x.el : h(""),
- Y = T.anchor = x ? x.anchor : h("");
+ if (Li(V)) continue;
+ const K = F[V],
+ k = N[V];
+ K !== k && V !== "value" && a(b, V, k, K, Q, T.children, L, H, Bt)
+ }
+ "value" in F && a(b, "value", N.value, F.value)
+ }
+ }, de = (b, T, N, F, L, H, Q, V, K) => {
+ const k = T.el = b ? b.el : h(""),
+ Z = T.anchor = b ? b.anchor : h("");
let {
- patchFlag: G,
- dynamicChildren: ee,
- slotScopeIds: k
+ patchFlag: Y,
+ dynamicChildren: M,
+ slotScopeIds: te
} = T;
- k && (V = V ? V.concat(k) : k), x == null ? (o(j, R, F), o(Y, R, F), Be(T.children, R, Y, M, H, K, V, J)) : G > 0 && G & 64 && ee && x.dynamicChildren ? (rt(x.dynamicChildren, ee, R, M, H, K, V), (T.key != null || M && T === M.subTree) && ol(x, T, !0)) : Ae(x, T, R, Y, M, H, K, V, J)
- }, le = (x, T, R, F, M, H, K, V, J) => {
- T.slotScopeIds = V, x == null ? T.shapeFlag & 512 ? M.ctx.activate(T, R, F, K, J) : nt(T, R, F, M, H, K, J) : ur(x, T, J)
- }, nt = (x, T, R, F, M, H, K) => {
- const V = x.component = Nh(x, F, M);
- if (ju(x) && (V.ctx.renderer = lr), Rh(V), V.asyncDep) {
- if (M && M.registerDep(V, Me), !x.el) {
- const J = V.subTree = _t(Lr);
- L(null, J, T, R)
+ (Gr || Y & 2048) && (Y = 0, K = !1, M = null), te && (V = V ? V.concat(te) : te), b == null ? (i(k, N, F), i(Z, N, F), ce(T.children, N, Z, L, H, Q, V, K)) : Y > 0 && Y & 64 && M && b.dynamicChildren ? (ut(b.dynamicChildren, M, N, L, H, Q, V), na(b, T)) : et(b, T, N, Z, L, H, Q, V, K)
+ }, pt = (b, T, N, F, L, H, Q, V, K) => {
+ T.slotScopeIds = V, b == null ? T.shapeFlag & 512 ? L.ctx.activate(T, N, F, Q, K) : ht(T, N, F, L, H, Q, K) : Ue(b, T, K)
+ }, ht = (b, T, N, F, L, H, Q) => {
+ const V = b.component = iy(b, F, L);
+ if (V.type.__hmrId && qh(V), Zi(b), cr(V, "mount"), Vs(b) && (V.ctx.renderer = tt), cr(V, "init"), sy(V), dr(V, "init"), V.asyncDep) {
+ if (L && L.registerDep(V, pe), !b.el) {
+ const K = V.subTree = At(Ct);
+ U(null, K, T, N)
}
return
}
- Me(V, x, T, R, M, H, K)
- }, ur = (x, T, R) => {
- const F = T.component = x.component;
- if (jp(x, T, R))
+ pe(V, b, T, N, L, H, Q), eo(), dr(V, "mount")
+ }, Ue = (b, T, N) => {
+ const F = T.component = b.component;
+ if (ig(b, T, N))
if (F.asyncDep && !F.asyncResolved) {
- Se(F, T, R);
+ Zi(T), be(F, T, N), eo();
return
- } else F.next = T, Dp(F.update), F.update();
- else T.el = x.el, F.vnode = T
- }, Me = (x, T, R, F, M, H, K) => {
+ } else F.next = T, Fh(F.update), F.update();
+ else T.el = b.el, F.vnode = T
+ }, pe = (b, T, N, F, L, H, Q) => {
const V = () => {
- if (x.isMounted) {
+ if (b.isMounted) {
let {
- next: Y,
- bu: G,
- u: ee,
- parent: k,
- vnode: ie
- } = x, Pe = Y, Ce;
- Mr(x, !1), Y ? (Y.el = ie.el, Se(x, Y, K)) : Y = ie, G && xi(G), (Ce = Y.props && Y.props.onVnodeBeforeUpdate) && Kt(Ce, k, Y, ie), Mr(x, !0);
- const ke = hs(x),
- yt = x.subTree;
- x.subTree = ke, U(yt, ke, N(yt.el), wn(yt), x, M, H), Y.el = ke.el, Pe === null && qp(x, ke.el), ee && ft(ee, M), (Ce = Y.props && Y.props.onVnodeUpdated) && ft(() => Kt(Ce, k, Y, ie), M)
+ next: Z,
+ bu: Y,
+ u: M,
+ parent: te,
+ vnode: me
+ } = b, Re = Z, Pe;
+ Zi(Z || b.vnode), tn(b, !1), Z ? (Z.el = me.el, be(b, Z, Q)) : Z = me, Y && _n(Y), (Pe = Z.props && Z.props.onVnodeBeforeUpdate) && er(Pe, te, Z, me), tn(b, !0), cr(b, "render");
+ const qe = Bs(b);
+ dr(b, "render");
+ const St = b.subTree;
+ b.subTree = qe, cr(b, "patch"), B(St, qe, E(St.el), kn(St), b, L, H), dr(b, "patch"), Z.el = qe.el, Re === null && og(b, qe.el), M && bt(M, L), (Pe = Z.props && Z.props.onVnodeUpdated) && bt(() => er(Pe, te, Z, me), L), Ol(b), eo()
} else {
- let Y;
+ let Z;
const {
- el: G,
- props: ee
+ el: Y,
+ props: M
} = T, {
- bm: k,
- m: ie,
- parent: Pe
- } = x, Ce = Mi(T);
- if (Mr(x, !1), k && xi(k), !Ce && (Y = ee && ee.onVnodeBeforeMount) && Kt(Y, Pe, T), Mr(x, !0), G && ei) {
- const ke = () => {
- x.subTree = hs(x), ei(G, x.subTree, x, M, null)
+ bm: te,
+ m: me,
+ parent: Re
+ } = b, Pe = uo(T);
+ if (tn(b, !1), te && _n(te), !Pe && (Z = M && M.onVnodeBeforeMount) && er(Z, Re, T), tn(b, !0), Y && rr) {
+ const qe = () => {
+ cr(b, "render"), b.subTree = Bs(b), dr(b, "render"), cr(b, "hydrate"), rr(Y, b.subTree, b, L, null), dr(b, "hydrate")
};
- Ce ? T.type.__asyncLoader().then(() => !x.isUnmounted && ke()) : ke()
+ Pe ? T.type.__asyncLoader().then(() => !b.isUnmounted && qe()) : qe()
} else {
- const ke = x.subTree = hs(x);
- U(null, ke, R, F, x, M, H), T.el = ke.el
- }
- if (ie && ft(ie, M), !Ce && (Y = ee && ee.onVnodeMounted)) {
- const ke = T;
- ft(() => Kt(Y, Pe, ke), M)
- }(T.shapeFlag & 256 || Pe && Mi(Pe.vnode) && Pe.vnode.shapeFlag & 256) && x.a && ft(x.a, M), x.isMounted = !0, T = R = F = null
- }
- },
- J = x.effect = new ts(V, () => ps(j), x.scope),
- j = x.update = () => J.run();
- j.id = x.uid, Mr(x, !0), j()
- }, Se = (x, T, R) => {
- T.component = x;
- const F = x.vnode.props;
- x.vnode = T, x.next = null, gh(x, T.props, F, R), vh(x, T.children, R), sn(), Ru(), an()
- }, Ae = (x, T, R, F, M, H, K, V, J = !1) => {
- const j = x && x.children,
- Y = x ? x.shapeFlag : 0,
- G = T.children,
+ cr(b, "render");
+ const qe = b.subTree = Bs(b);
+ dr(b, "render"), cr(b, "patch"), B(null, qe, N, F, b, L, H), dr(b, "patch"), T.el = qe.el
+ }
+ if (me && bt(me, L), !Pe && (Z = M && M.onVnodeMounted)) {
+ const qe = T;
+ bt(() => er(Z, Re, qe), L)
+ }(T.shapeFlag & 256 || Re && uo(Re.vnode) && Re.vnode.shapeFlag & 256) && b.a && bt(b.a, L), b.isMounted = !0, Kh(b), T = N = F = null
+ }
+ },
+ K = b.effect = new Cs(V, () => ro(k), b.scope),
+ k = b.update = () => K.run();
+ k.id = b.uid, tn(b, !0), K.onTrack = b.rtc ? Z => _n(b.rtc, Z) : void 0, K.onTrigger = b.rtg ? Z => _n(b.rtg, Z) : void 0, k.ownerInstance = b, k()
+ }, be = (b, T, N) => {
+ T.component = b;
+ const F = b.vnode.props;
+ b.vnode = T, b.next = null, jg(b, T.props, F, N), Vg(b, T.children, N), Vr(), wl(), zr()
+ }, et = (b, T, N, F, L, H, Q, V, K = !1) => {
+ const k = b && b.children,
+ Z = b ? b.shapeFlag : 0,
+ Y = T.children,
{
- patchFlag: ee,
- shapeFlag: k
+ patchFlag: M,
+ shapeFlag: te
} = T;
- if (ee > 0) {
- if (ee & 128) {
- Ur(j, G, R, F, M, H, K, V, J);
+ if (M > 0) {
+ if (M & 128) {
+ Dr(k, Y, N, F, L, H, Q, V, K);
return
- } else if (ee & 256) {
- ht(j, G, R, F, M, H, K, V, J);
+ } else if (M & 256) {
+ In(k, Y, N, F, L, H, Q, V, K);
return
}
}
- k & 8 ? (Y & 16 && kt(j, M, H), G !== j && w(R, G)) : Y & 16 ? k & 16 ? Ur(j, G, R, F, M, H, K, V, J) : kt(j, M, H, !0) : (Y & 8 && w(R, ""), k & 16 && Be(G, R, F, M, H, K, V, J))
- }, ht = (x, T, R, F, M, H, K, V, J) => {
- x = x || tn, T = T || tn;
- const j = x.length,
- Y = T.length,
- G = Math.min(j, Y);
- let ee;
- for (ee = 0; ee < G; ee++) {
- const k = T[ee] = J ? _r(T[ee]) : zt(T[ee]);
- U(x[ee], k, R, null, M, H, K, V, J)
- }
- j > Y ? kt(x, M, H, !0, !1, G) : Be(T, R, F, M, H, K, V, J, G)
- }, Ur = (x, T, R, F, M, H, K, V, J) => {
- let j = 0;
- const Y = T.length;
- let G = x.length - 1,
- ee = Y - 1;
- for (; j <= G && j <= ee;) {
- const k = x[j],
- ie = T[j] = J ? _r(T[j]) : zt(T[j]);
- if (Jn(k, ie)) U(k, ie, R, null, M, H, K, V, J);
+ te & 8 ? (Z & 16 && Bt(k, L, H), Y !== k && _(N, Y)) : Z & 16 ? te & 16 ? Dr(k, Y, N, F, L, H, Q, V, K) : Bt(k, L, H, !0) : (Z & 8 && _(N, ""), te & 16 && ce(Y, N, F, L, H, Q, V, K))
+ }, In = (b, T, N, F, L, H, Q, V, K) => {
+ b = b || bn, T = T || bn;
+ const k = b.length,
+ Z = T.length,
+ Y = Math.min(k, Z);
+ let M;
+ for (M = 0; M < Y; M++) {
+ const te = T[M] = K ? $r(T[M]) : qt(T[M]);
+ B(b[M], te, N, null, L, H, Q, V, K)
+ }
+ k > Z ? Bt(b, L, H, !0, !1, Y) : ce(T, N, F, L, H, Q, V, K, Y)
+ }, Dr = (b, T, N, F, L, H, Q, V, K) => {
+ let k = 0;
+ const Z = T.length;
+ let Y = b.length - 1,
+ M = Z - 1;
+ for (; k <= Y && k <= M;) {
+ const te = b[k],
+ me = T[k] = K ? $r(T[k]) : qt(T[k]);
+ if (pi(te, me)) B(te, me, N, null, L, H, Q, V, K);
else break;
- j++
+ k++
}
- for (; j <= G && j <= ee;) {
- const k = x[G],
- ie = T[ee] = J ? _r(T[ee]) : zt(T[ee]);
- if (Jn(k, ie)) U(k, ie, R, null, M, H, K, V, J);
+ for (; k <= Y && k <= M;) {
+ const te = b[Y],
+ me = T[M] = K ? $r(T[M]) : qt(T[M]);
+ if (pi(te, me)) B(te, me, N, null, L, H, Q, V, K);
else break;
- G--, ee--
+ Y--, M--
}
- if (j > G) {
- if (j <= ee) {
- const k = ee + 1,
- ie = k < Y ? T[k].el : F;
- for (; j <= ee;) U(null, T[j] = J ? _r(T[j]) : zt(T[j]), R, ie, M, H, K, V, J), j++
+ if (k > Y) {
+ if (k <= M) {
+ const te = M + 1,
+ me = te < Z ? T[te].el : F;
+ for (; k <= M;) B(null, T[k] = K ? $r(T[k]) : qt(T[k]), N, me, L, H, Q, V, K), k++
}
- } else if (j > ee)
- for (; j <= G;) St(x[j], M, H, !0), j++;
+ } else if (k > M)
+ for (; k <= Y;) Nt(b[k], L, H, !0), k++;
else {
- const k = j,
- ie = j,
- Pe = new Map;
- for (j = ie; j <= ee; j++) {
- const Ue = T[j] = J ? _r(T[j]) : zt(T[j]);
- Ue.key != null && Pe.set(Ue.key, j)
- }
- let Ce, ke = 0;
- const yt = ee - ie + 1;
- let fr = !1,
- Sr = 0;
- const at = new Array(yt);
- for (j = 0; j < yt; j++) at[j] = 0;
- for (j = k; j <= G; j++) {
- const Ue = x[j];
- if (ke >= yt) {
- St(Ue, M, H, !0);
+ const te = k,
+ me = k,
+ Re = new Map;
+ for (k = me; k <= M; k++) {
+ const rt = T[k] = K ? $r(T[k]) : qt(T[k]);
+ rt.key != null && (Re.has(rt.key) && z("Duplicate keys found during update:", JSON.stringify(rt.key), "Make sure keys are unique."), Re.set(rt.key, k))
+ }
+ let Pe, qe = 0;
+ const St = M - me + 1;
+ let Dt = !1,
+ It = 0;
+ const $t = new Array(St);
+ for (k = 0; k < St; k++) $t[k] = 0;
+ for (k = te; k <= Y; k++) {
+ const rt = b[k];
+ if (qe >= St) {
+ Nt(rt, L, H, !0);
continue
}
- let Ot;
- if (Ue.key != null) Ot = Pe.get(Ue.key);
+ let gt;
+ if (rt.key != null) gt = Re.get(rt.key);
else
- for (Ce = ie; Ce <= ee; Ce++)
- if (at[Ce - ie] === 0 && Jn(Ue, T[Ce])) {
- Ot = Ce;
+ for (Pe = me; Pe <= M; Pe++)
+ if ($t[Pe - me] === 0 && pi(rt, T[Pe])) {
+ gt = Pe;
break
- } Ot === void 0 ? St(Ue, M, H, !0) : (at[Ot - ie] = j + 1, Ot >= Sr ? Sr = Ot : fr = !0, U(Ue, T[Ot], R, null, M, H, K, V, J), ke++)
+ } gt === void 0 ? Nt(rt, L, H, !0) : ($t[gt - me] = k + 1, gt >= It ? It = gt : Dt = !0, B(rt, T[gt], N, null, L, H, Q, V, K), qe++)
}
- const Xt = fr ? xh(at) : tn;
- for (Ce = Xt.length - 1, j = yt - 1; j >= 0; j--) {
- const Ue = ie + j,
- Ot = T[Ue],
- Hr = Ue + 1 < Y ? T[Ue + 1].el : F;
- at[j] === 0 ? U(null, Ot, R, Hr, M, H, K, V, J) : fr && (Ce < 0 || j !== Xt[Ce] ? Qt(Ot, R, Hr, 2) : Ce--)
+ const yr = Dt ? Qg($t) : bn;
+ for (Pe = yr.length - 1, k = St - 1; k >= 0; k--) {
+ const rt = me + k,
+ gt = T[rt],
+ _i = rt + 1 < Z ? T[rt + 1].el : F;
+ $t[k] === 0 ? B(null, gt, N, _i, L, H, Q, V, K) : Dt && (Pe < 0 || k !== yr[Pe] ? gr(gt, N, _i, 2) : Pe--)
}
}
- }, Qt = (x, T, R, F, M = null) => {
+ }, gr = (b, T, N, F, L = null) => {
const {
el: H,
- type: K,
+ type: Q,
transition: V,
- children: J,
- shapeFlag: j
- } = x;
- if (j & 6) {
- Qt(x.component.subTree, T, R, F);
+ children: K,
+ shapeFlag: k
+ } = b;
+ if (k & 6) {
+ gr(b.component.subTree, T, N, F);
return
}
- if (j & 128) {
- x.suspense.move(T, R, F);
+ if (k & 128) {
+ b.suspense.move(T, N, F);
return
}
- if (j & 64) {
- K.move(x, T, R, lr);
+ if (k & 64) {
+ Q.move(b, T, N, tt);
return
}
- if (K === ct) {
- o(H, T, R);
- for (let G = 0; G < J.length; G++) Qt(J[G], T, R, F);
- o(x.anchor, T, R);
+ if (Q === dt) {
+ i(H, T, N);
+ for (let Y = 0; Y < K.length; Y++) gr(K[Y], T, N, F);
+ i(b.anchor, T, N);
return
}
- if (K === Es) {
- ye(x, T, R);
+ if (Q === yo) {
+ Ie(b, T, N);
return
}
- if (F !== 2 && j & 1 && V)
- if (F === 0) V.beforeEnter(H), o(H, T, R), ft(() => V.enter(H), M);
+ if (F !== 2 && k & 1 && V)
+ if (F === 0) V.beforeEnter(H), i(H, T, N), bt(() => V.enter(H), L);
else {
const {
- leave: G,
- delayLeave: ee,
- afterLeave: k
- } = V, ie = () => o(H, T, R), Pe = () => {
- G(H, () => {
- ie(), k && k()
+ leave: Y,
+ delayLeave: M,
+ afterLeave: te
+ } = V, me = () => i(H, T, N), Re = () => {
+ Y(H, () => {
+ me(), te && te()
})
};
- ee ? ee(H, ie, Pe) : Pe()
+ M ? M(H, me, Re) : Re()
}
- else o(H, T, R)
- }, St = (x, T, R, F = !1, M = !1) => {
+ else i(H, T, N)
+ }, Nt = (b, T, N, F = !1, L = !1) => {
const {
type: H,
- props: K,
+ props: Q,
ref: V,
- children: J,
- dynamicChildren: j,
- shapeFlag: Y,
- patchFlag: G,
- dirs: ee
- } = x;
- if (V != null && Ss(V, null, R, x, !0), Y & 256) {
- T.ctx.deactivate(x);
+ children: K,
+ dynamicChildren: k,
+ shapeFlag: Z,
+ patchFlag: Y,
+ dirs: M
+ } = b;
+ if (V != null && ra(V, null, N, b, !0), Z & 256) {
+ T.ctx.deactivate(b);
return
}
- const k = Y & 1 && ee,
- ie = !Mi(x);
- let Pe;
- if (ie && (Pe = K && K.onVnodeBeforeUnmount) && Kt(Pe, T, x), Y & 6) ea(x.component, R, F);
+ const te = Z & 1 && M,
+ me = !uo(b);
+ let Re;
+ if (me && (Re = Q && Q.onVnodeBeforeUnmount) && er(Re, T, b), Z & 6) Fa(b.component, N, F);
else {
- if (Y & 128) {
- x.suspense.unmount(R, F);
+ if (Z & 128) {
+ b.suspense.unmount(N, F);
return
}
- k && $r(x, null, T, "beforeUnmount"), Y & 64 ? x.type.remove(x, T, R, M, lr, F) : j && (H !== ct || G > 0 && G & 64) ? kt(j, T, R, !1, !0) : (H === ct && G & 384 || !M && Y & 16) && kt(J, T, R), F && xn(x)
- }(ie && (Pe = K && K.onVnodeUnmounted) || k) && ft(() => {
- Pe && Kt(Pe, T, x), k && $r(x, null, T, "unmounted")
- }, R)
- }, xn = x => {
+ te && Zr(b, null, T, "beforeUnmount"), Z & 64 ? b.type.remove(b, T, N, L, tt, F) : k && (H !== dt || Y > 0 && Y & 64) ? Bt(k, T, N, !1, !0) : (H === dt && Y & 384 || !L && Z & 16) && Bt(K, T, N), F && Mn(b)
+ }(me && (Re = Q && Q.onVnodeUnmounted) || te) && bt(() => {
+ Re && er(Re, T, b), te && Zr(b, null, T, "unmounted")
+ }, N)
+ }, Mn = b => {
const {
type: T,
- el: R,
+ el: N,
anchor: F,
- transition: M
- } = x;
- if (T === ct) {
- so(R, F);
+ transition: L
+ } = b;
+ if (T === dt) {
+ b.patchFlag > 0 && b.patchFlag & 2048 && L && !L.persisted ? b.children.forEach(Q => {
+ Q.type === Ct ? s(Q.el) : Mn(Q)
+ }) : La(N, F);
return
}
- if (T === Es) {
- te(x);
+ if (T === yo) {
+ ne(b);
return
}
const H = () => {
- s(R), M && !M.persisted && M.afterLeave && M.afterLeave()
+ s(N), L && !L.persisted && L.afterLeave && L.afterLeave()
};
- if (x.shapeFlag & 1 && M && !M.persisted) {
+ if (b.shapeFlag & 1 && L && !L.persisted) {
const {
- leave: K,
+ leave: Q,
delayLeave: V
- } = M, J = () => K(R, H);
- V ? V(x.el, H, J) : J()
+ } = L, K = () => Q(N, H);
+ V ? V(b.el, H, K) : K()
} else H()
- }, so = (x, T) => {
- let R;
- for (; x !== T;) R = $(x), s(x), x = R;
+ }, La = (b, T) => {
+ let N;
+ for (; b !== T;) N = P(b), s(b), b = N;
s(T)
- }, ea = (x, T, R) => {
+ }, Fa = (b, T, N) => {
+ b.type.__hmrId && Hh(b);
const {
bum: F,
- scope: M,
+ scope: L,
update: H,
- subTree: K,
+ subTree: Q,
um: V
- } = x;
- F && xi(F), M.stop(), H && (H.active = !1, St(K, x, T, R)), V && ft(V, T), ft(() => {
- x.isUnmounted = !0
- }, T), T && T.pendingBranch && !T.isUnmounted && x.asyncDep && !x.asyncResolved && x.suspenseId === T.pendingId && (T.deps--, T.deps === 0 && T.resolve())
- }, kt = (x, T, R, F = !1, M = !1, H = 0) => {
- for (let K = H; K < x.length; K++) St(x[K], T, R, F, M)
- }, wn = x => x.shapeFlag & 6 ? wn(x.component.subTree) : x.shapeFlag & 128 ? x.suspense.next() : $(x.anchor || x.el), ao = (x, T, R) => {
- x == null ? T._vnode && St(T._vnode, null, null, !0) : U(T._vnode || null, x, T, null, null, null, R), Ru(), Du(), T._vnode = x
- }, lr = {
- p: U,
- um: St,
- m: Qt,
- r: xn,
- mt: nt,
- mc: Be,
- pc: Ae,
- pbc: rt,
- n: wn,
+ } = b;
+ F && _n(F), L.stop(), H && (H.active = !1, Nt(Q, b, T, N)), V && bt(V, T), bt(() => {
+ b.isUnmounted = !0
+ }, T), T && T.pendingBranch && !T.isUnmounted && b.asyncDep && !b.asyncResolved && b.suspenseId === T.pendingId && (T.deps--, T.deps === 0 && T.resolve()), Qh(b)
+ }, Bt = (b, T, N, F = !1, L = !1, H = 0) => {
+ for (let Q = H; Q < b.length; Q++) Nt(b[Q], T, N, F, L)
+ }, kn = b => b.shapeFlag & 6 ? kn(b.component.subTree) : b.shapeFlag & 128 ? b.suspense.next() : P(b.anchor || b.el), bi = (b, T, N) => {
+ b == null ? T._vnode && Nt(T._vnode, null, null, !0) : B(T._vnode || null, b, T, null, null, null, N), wl(), _l(), T._vnode = b
+ }, tt = {
+ p: B,
+ um: Nt,
+ m: gr,
+ r: Mn,
+ mt: ht,
+ mc: ce,
+ pc: et,
+ pbc: ut,
+ n: kn,
o: e
};
- let gt, ei;
- return t && ([gt, ei] = t(lr)), {
- render: ao,
- hydrate: gt,
- createApp: dh(ao, gt)
+ let wi, rr;
+ return t && ([wi, rr] = t(tt)), {
+ render: bi,
+ hydrate: wi,
+ createApp: Dg(bi, wi)
}
}
- function Mr({
+ function tn({
effect: e,
update: t
- }, n) {
- e.allowRecurse = t.allowRecurse = n
+ }, r) {
+ e.allowRecurse = t.allowRecurse = r
}
- function ol(e, t, n = !1) {
- const o = e.children,
+ function na(e, t, r = !1) {
+ const i = e.children,
s = t.children;
- if (ne(o) && ne(s))
- for (let a = 0; a < o.length; a++) {
- const c = o[a];
+ if (re(i) && re(s))
+ for (let a = 0; a < i.length; a++) {
+ const c = i[a];
let h = s[a];
- h.shapeFlag & 1 && !h.dynamicChildren && ((h.patchFlag <= 0 || h.patchFlag === 32) && (h = s[a] = _r(s[a]), h.el = c.el), n || ol(c, h)), h.type === Bi && (h.el = c.el)
+ h.shapeFlag & 1 && !h.dynamicChildren && ((h.patchFlag <= 0 || h.patchFlag === 32) && (h = s[a] = $r(s[a]), h.el = c.el), r || na(c, h)), h.type === fi && (h.el = c.el), h.type === Ct && !h.el && (h.el = c.el)
}
}
- function xh(e) {
+ function Qg(e) {
const t = e.slice(),
- n = [0];
- let o, s, a, c, h;
+ r = [0];
+ let i, s, a, c, h;
const y = e.length;
- for (o = 0; o < y; o++) {
- const b = e[o];
- if (b !== 0) {
- if (s = n[n.length - 1], e[s] < b) {
- t[o] = s, n.push(o);
+ for (i = 0; i < y; i++) {
+ const v = e[i];
+ if (v !== 0) {
+ if (s = r[r.length - 1], e[s] < v) {
+ t[i] = s, r.push(i);
continue
}
- for (a = 0, c = n.length - 1; a < c;) h = a + c >> 1, e[n[h]] < b ? a = h + 1 : c = h;
- b < e[n[a]] && (a > 0 && (t[o] = n[a - 1]), n[a] = o)
+ for (a = 0, c = r.length - 1; a < c;) h = a + c >> 1, e[r[h]] < v ? a = h + 1 : c = h;
+ v < e[r[a]] && (a > 0 && (t[i] = r[a - 1]), r[a] = i)
}
}
- for (a = n.length, c = n[a - 1]; a-- > 0;) n[a] = c, c = t[c];
- return n
+ for (a = r.length, c = r[a - 1]; a-- > 0;) r[a] = c, c = t[c];
+ return r
}
- const wh = e => e.__isTeleport,
- ct = Symbol.for("v-fgt"),
- Bi = Symbol.for("v-txt"),
- Lr = Symbol.for("v-cmt"),
- Es = Symbol.for("v-stc"),
- zn = [];
- let Lt = null;
+ const Gg = e => e.__isTeleport,
+ dt = Symbol.for("v-fgt"),
+ fi = Symbol.for("v-txt"),
+ Ct = Symbol.for("v-cmt"),
+ yo = Symbol.for("v-stc"),
+ ci = [];
+ let Ut = null;
- function $e(e = !1) {
- zn.push(Lt = e ? null : [])
+ function je(e = !1) {
+ ci.push(Ut = e ? null : [])
}
- function Sh() {
- zn.pop(), Lt = zn[zn.length - 1] || null
+ function Xg() {
+ ci.pop(), Ut = ci[ci.length - 1] || null
}
- let Kn = 1;
+ let di = 1;
- function sl(e) {
- Kn += e
+ function nf(e) {
+ di += e
}
- function al(e) {
- return e.dynamicChildren = Kn > 0 ? Lt || tn : null, Sh(), Kn > 0 && Lt && Lt.push(e), e
+ function of(e) {
+ return e.dynamicChildren = di > 0 ? Ut || bn : null, Xg(), di > 0 && Ut && Ut.push(e), e
}
- function Fe(e, t, n, o, s, a) {
- return al(se(e, t, n, o, s, a, !0))
+ function Be(e, t, r, i, s, a) {
+ return of(ae(e, t, r, i, s, a, !0))
}
- function ul(e, t, n, o, s) {
- return al(_t(e, t, n, o, s, !0))
+ function sf(e, t, r, i, s) {
+ return of(At(e, t, r, i, s, !0))
}
- function Eh(e) {
+ function ia(e) {
return e ? e.__v_isVNode === !0 : !1
}
- function Jn(e, t) {
- return e.type === t.type && e.key === t.key
+ function pi(e, t) {
+ return t.shapeFlag & 6 && Sn.has(t.type) ? (e.shapeFlag &= -257, t.shapeFlag &= -513, !1) : e.type === t.type && e.key === t.key
}
- const Ui = "__vInternal",
- ll = ({
+ const Yg = (...e) => Zg(...e),
+ mo = "__vInternal",
+ af = ({
key: e
}) => e != null ? e : null,
- Hi = ({
+ vo = ({
ref: e,
ref_key: t,
- ref_for: n
- }) => (typeof e == "number" && (e = "" + e), e != null ? He(e) || ot(e) || fe(e) ? {
- i: Et,
+ ref_for: r
+ }) => (typeof e == "number" && (e = "" + e), e != null ? He(e) || Qe(e) || le(e) ? {
+ i: vt,
r: e,
k: t,
- f: !!n
+ f: !!r
} : e : null);
- function se(e, t = null, n = null, o = 0, s = null, a = e === ct ? 0 : 1, c = !1, h = !1) {
+ function ae(e, t = null, r = null, i = 0, s = null, a = e === dt ? 0 : 1, c = !1, h = !1) {
const y = {
__v_isVNode: !0,
__v_skip: !0,
type: e,
props: t,
- key: t && ll(t),
- ref: t && Hi(t),
- scopeId: Mu,
+ key: t && af(t),
+ ref: t && vo(t),
+ scopeId: Pl,
slotScopeIds: null,
- children: n,
+ children: r,
component: null,
suspense: null,
ssContent: null,
ssFallback: null,
dirs: null,
transition: null,
el: null,
anchor: null,
target: null,
targetAnchor: null,
staticCount: 0,
shapeFlag: a,
- patchFlag: o,
+ patchFlag: i,
dynamicProps: s,
dynamicChildren: null,
appContext: null,
- ctx: Et
+ ctx: vt
};
- return h ? (As(y, n), a & 128 && e.normalize(y)) : n && (y.shapeFlag |= He(n) ? 8 : 16), Kn > 0 && !c && Lt && (y.patchFlag > 0 || a & 6) && y.patchFlag !== 32 && Lt.push(y), y
+ return h ? (sa(y, r), a & 128 && e.normalize(y)) : r && (y.shapeFlag |= He(r) ? 8 : 16), y.key !== y.key && z("VNode created with invalid key (NaN). VNode type:", y.type), di > 0 && !c && Ut && (y.patchFlag > 0 || a & 6) && y.patchFlag !== 32 && Ut.push(y), y
}
- const _t = Th;
+ const At = Yg;
- function Th(e, t = null, n = null, o = 0, s = null, a = !1) {
- if ((!e || e === nh) && (e = Lr), Eh(e)) {
- const h = fn(e, t, !0);
- return n && As(h, n), Kn > 0 && !a && Lt && (h.shapeFlag & 6 ? Lt[Lt.indexOf(e)] = h : Lt.push(h)), h.patchFlag |= -2, h
+ function Zg(e, t = null, r = null, i = 0, s = null, a = !1) {
+ if ((!e || e === _g) && (e || z(`Invalid vnode type when creating vnode: ${e}.`), e = Ct), ia(e)) {
+ const h = Pr(e, t, !0);
+ return r && sa(h, r), di > 0 && !a && Ut && (h.shapeFlag & 6 ? Ut[Ut.indexOf(e)] = h : Ut.push(h)), h.patchFlag |= -2, h
}
- if (Lh(e) && (e = e.__vccOpts), t) {
- t = Ah(t);
+ if (pf(e) && (e = e.__vccOpts), t) {
+ t = ey(t);
let {
class: h,
style: y
} = t;
- h && !He(h) && (t.class = Wt(h)), Ie(y) && (Au(y) && !ne(y) && (y = Ke({}, y)), t.style = Qo(y))
+ h && !He(h) && (t.class = Qt(h)), Oe(y) && (Ns(y) && !re(y) && (y = Le({}, y)), t.style = ws(y))
}
- const c = He(e) ? 1 : Bp(e) ? 128 : wh(e) ? 64 : Ie(e) ? 4 : fe(e) ? 2 : 0;
- return se(e, t, n, o, s, c, a, !0)
+ const c = He(e) ? 1 : sg(e) ? 128 : Gg(e) ? 64 : Oe(e) ? 4 : le(e) ? 2 : 0;
+ return c & 4 && Ns(e) && (e = ye(e), z("Vue received a Component which was made a reactive object. This can lead to unnecessary performance overhead, and should be avoided by marking the component with `markRaw` or using `shallowRef` instead of `ref`.", `
+Component that was made reactive: `, e)), ae(e, t, r, i, s, c, a, !0)
}
- function Ah(e) {
- return e ? Au(e) || Ui in e ? Ke({}, e) : e : null
+ function ey(e) {
+ return e ? Ns(e) || mo in e ? Le({}, e) : e : null
}
- function fn(e, t, n = !1) {
+ function Pr(e, t, r = !1) {
const {
- props: o,
+ props: i,
ref: s,
patchFlag: a,
children: c
- } = e, h = t ? Ch(o || {}, t) : o;
+ } = e, h = t ? ty(i || {}, t) : i;
return {
__v_isVNode: !0,
__v_skip: !0,
type: e.type,
props: h,
- key: h && ll(h),
- ref: t && t.ref ? n && s ? ne(s) ? s.concat(Hi(t)) : [s, Hi(t)] : Hi(t) : s,
+ key: h && af(h),
+ ref: t && t.ref ? r && s ? re(s) ? s.concat(vo(t)) : [s, vo(t)] : vo(t) : s,
scopeId: e.scopeId,
slotScopeIds: e.slotScopeIds,
- children: c,
+ children: a === -1 && re(c) ? c.map(uf) : c,
target: e.target,
targetAnchor: e.targetAnchor,
staticCount: e.staticCount,
shapeFlag: e.shapeFlag,
- patchFlag: t && e.type !== ct ? a === -1 ? 16 : a | 16 : a,
+ patchFlag: t && e.type !== dt ? a === -1 ? 16 : a | 16 : a,
dynamicProps: e.dynamicProps,
dynamicChildren: e.dynamicChildren,
appContext: e.appContext,
dirs: e.dirs,
transition: e.transition,
component: e.component,
suspense: e.suspense,
- ssContent: e.ssContent && fn(e.ssContent),
- ssFallback: e.ssFallback && fn(e.ssFallback),
+ ssContent: e.ssContent && Pr(e.ssContent),
+ ssFallback: e.ssFallback && Pr(e.ssFallback),
el: e.el,
anchor: e.anchor,
ctx: e.ctx,
ce: e.ce
}
}
- function Fr(e = " ", t = 0) {
- return _t(Bi, null, e, t)
+ function uf(e) {
+ const t = Pr(e);
+ return re(e.children) && (t.children = e.children.map(uf)), t
}
- function Ts(e = "", t = !1) {
- return t ? ($e(), ul(Lr, null, e)) : _t(Lr, null, e)
+ function rn(e = " ", t = 0) {
+ return At(fi, null, e, t)
}
- function zt(e) {
- return e == null || typeof e == "boolean" ? _t(Lr) : ne(e) ? _t(ct, null, e.slice()) : typeof e == "object" ? _r(e) : _t(Bi, null, String(e))
+ function oa(e = "", t = !1) {
+ return t ? (je(), sf(Ct, null, e)) : At(Ct, null, e)
}
- function _r(e) {
- return e.el === null && e.patchFlag !== -1 || e.memo ? e : fn(e)
+ function qt(e) {
+ return e == null || typeof e == "boolean" ? At(Ct) : re(e) ? At(dt, null, e.slice()) : typeof e == "object" ? $r(e) : At(fi, null, String(e))
}
- function As(e, t) {
- let n = 0;
+ function $r(e) {
+ return e.el === null && e.patchFlag !== -1 || e.memo ? e : Pr(e)
+ }
+
+ function sa(e, t) {
+ let r = 0;
const {
- shapeFlag: o
+ shapeFlag: i
} = e;
if (t == null) t = null;
- else if (ne(t)) n = 16;
+ else if (re(t)) r = 16;
else if (typeof t == "object")
- if (o & 65) {
+ if (i & 65) {
const s = t.default;
- s && (s._c && (s._d = !1), As(e, s()), s._c && (s._d = !0));
+ s && (s._c && (s._d = !1), sa(e, s()), s._c && (s._d = !0));
return
} else {
- n = 32;
+ r = 32;
const s = t._;
- !s && !(Ui in t) ? t._ctx = Et : s === 3 && Et && (Et.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024))
+ !s && !(mo in t) ? t._ctx = vt : s === 3 && vt && (vt.slots._ === 1 ? t._ = 1 : (t._ = 2, e.patchFlag |= 1024))
}
- else fe(t) ? (t = {
+ else le(t) ? (t = {
default: t,
- _ctx: Et
- }, n = 32) : (t = String(t), o & 64 ? (n = 16, t = [Fr(t)]) : n = 8);
- e.children = t, e.shapeFlag |= n
+ _ctx: vt
+ }, r = 32) : (t = String(t), i & 64 ? (r = 16, t = [rn(t)]) : r = 8);
+ e.children = t, e.shapeFlag |= r
}
- function Ch(...e) {
+ function ty(...e) {
const t = {};
- for (let n = 0; n < e.length; n++) {
- const o = e[n];
- for (const s in o)
- if (s === "class") t.class !== o.class && (t.class = Wt([t.class, o.class]));
- else if (s === "style") t.style = Qo([t.style, o.style]);
- else if (yi(s)) {
+ for (let r = 0; r < e.length; r++) {
+ const i = e[r];
+ for (const s in i)
+ if (s === "class") t.class !== i.class && (t.class = Qt([t.class, i.class]));
+ else if (s === "style") t.style = ws([t.style, i.style]);
+ else if (Xn(s)) {
const a = t[s],
- c = o[s];
- c && a !== c && !(ne(a) && a.includes(c)) && (t[s] = a ? [].concat(a, c) : c)
- } else s !== "" && (t[s] = o[s])
+ c = i[s];
+ c && a !== c && !(re(a) && a.includes(c)) && (t[s] = a ? [].concat(a, c) : c)
+ } else s !== "" && (t[s] = i[s])
}
return t
}
- function Kt(e, t, n, o = null) {
- Mt(e, t, 7, [n, o])
+ function er(e, t, r, i = null) {
+ Ft(e, t, 7, [r, i])
}
- const Oh = Qu();
- let Ph = 0;
+ const ry = Vl();
+ let ny = 0;
- function Nh(e, t, n) {
- const o = e.type,
- s = (t ? t.appContext : e.appContext) || Oh,
+ function iy(e, t, r) {
+ const i = e.type,
+ s = (t ? t.appContext : e.appContext) || ry,
a = {
- uid: Ph++,
+ uid: ny++,
vnode: e,
- type: o,
+ type: i,
parent: t,
appContext: s,
root: null,
next: null,
subTree: null,
effect: null,
update: null,
- scope: new Kd(!0),
+ scope: new Jp(!0),
render: null,
proxy: null,
exposed: null,
exposeProxy: null,
withProxy: null,
provides: t ? t.provides : Object.create(s.provides),
accessCache: null,
renderCache: [],
components: null,
directives: null,
- propsOptions: Gu(o, s),
- emitsOptions: $u(o, s),
+ propsOptions: Kl(i, s),
+ emitsOptions: Al(i, s),
emit: null,
emitted: null,
- propsDefaults: De,
- inheritAttrs: o.inheritAttrs,
- ctx: De,
- data: De,
- props: De,
- attrs: De,
- slots: De,
- refs: De,
- setupState: De,
+ propsDefaults: Ne,
+ inheritAttrs: i.inheritAttrs,
+ ctx: Ne,
+ data: Ne,
+ props: Ne,
+ attrs: Ne,
+ slots: Ne,
+ refs: Ne,
+ setupState: Ne,
setupContext: null,
attrsProxy: null,
slotsProxy: null,
- suspense: n,
- suspenseId: n ? n.pendingId : 0,
+ suspense: r,
+ suspenseId: r ? r.pendingId : 0,
asyncDep: null,
asyncResolved: !1,
isMounted: !1,
isUnmounted: !1,
isDeactivated: !1,
bc: null,
c: null,
@@ -3884,584 +4515,769 @@
da: null,
a: null,
rtg: null,
rtc: null,
ec: null,
sp: null
};
- return a.ctx = {
- _: a
- }, a.root = t ? t.root : a, a.emit = Mp.bind(null, a), e.ce && e.ce(a), a
- }
- let Xe = null,
- Cs, cn, fl = "__VUE_INSTANCE_SETTERS__";
- (cn = Jo()[fl]) || (cn = Jo()[fl] = []), cn.push(e => Xe = e), Cs = e => {
- cn.length > 1 ? cn.forEach(t => t(e)) : cn[0](e)
+ return a.ctx = Sg(a), a.root = t ? t.root : a, a.emit = Zh.bind(null, a), e.ce && e.ce(a), a
+ }
+ let Ge = null,
+ aa, En, lf = "__VUE_INSTANCE_SETTERS__";
+ (En = Bi()[lf]) || (En = Bi()[lf] = []), En.push(e => Ge = e), aa = e => {
+ En.length > 1 ? En.forEach(t => t(e)) : En[0](e)
};
- const dn = e => {
- Cs(e), e.scope.on()
+ const Tn = e => {
+ aa(e), e.scope.on()
},
- kr = () => {
- Xe && Xe.scope.off(), Cs(null)
- };
+ nn = () => {
+ Ge && Ge.scope.off(), aa(null)
+ },
+ oy = xr("slot,component");
- function cl(e) {
- return e.vnode.shapeFlag & 4
+ function ua(e, t) {
+ const r = t.isNativeTag || Uu;
+ (oy(e) || r(e)) && z("Do not use built-in or reserved HTML elements as component id: " + e)
}
- let Qn = !1;
- function Rh(e, t = !1) {
- Qn = t;
- const {
- props: n,
- children: o
- } = e.vnode, s = cl(e);
- hh(e, n, s, t), mh(e, o);
- const a = s ? Dh(e, t) : void 0;
- return Qn = !1, a
+ function ff(e) {
+ return e.vnode.shapeFlag & 4
}
+ let hi = !1;
- function Dh(e, t) {
- const n = e.type;
- e.accessCache = Object.create(null), e.proxy = Cu(new Proxy(e.ctx, oh));
+ function sy(e, t = !1) {
+ hi = t;
+ const {
+ props: r,
+ children: i
+ } = e.vnode, s = ff(e);
+ Mg(e, r, s, t), Wg(e, i);
+ const a = s ? ay(e, t) : void 0;
+ return hi = !1, a
+ }
+
+ function ay(e, t) {
+ var r;
+ const i = e.type;
+ {
+ if (i.name && ua(i.name, e.appContext.config), i.components) {
+ const a = Object.keys(i.components);
+ for (let c = 0; c < a.length; c++) ua(a[c], e.appContext.config)
+ }
+ if (i.directives) {
+ const a = Object.keys(i.directives);
+ for (let c = 0; c < a.length; c++) Ml(a[c])
+ }
+ i.compilerOptions && uy() && z('"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.')
+ }
+ e.accessCache = Object.create(null), e.proxy = hl(new Proxy(e.ctx, Fl)), Eg(e);
const {
- setup: o
- } = n;
- if (o) {
- const s = e.setupContext = o.length > 1 ? $h(e) : null;
- dn(e), sn();
- const a = br(o, e, 0, [e.props, s]);
- if (an(), kr(), ru(a)) {
- if (a.then(kr, kr), t) return a.then(c => {
- dl(e, c, t)
- }).catch(c => {
- Ni(c, e, 0)
+ setup: s
+ } = i;
+ if (s) {
+ const a = e.setupContext = s.length > 1 ? cy(e) : null;
+ Tn(e), Vr();
+ const c = lr(s, e, 0, [ti(e.props), a]);
+ if (zr(), nn(), ms(c)) {
+ if (c.then(nn, nn), t) return c.then(h => {
+ cf(e, h, t)
+ }).catch(h => {
+ to(h, e, 0)
});
- e.asyncDep = a
- } else dl(e, a, t)
- } else hl(e, t)
+ if (e.asyncDep = c, !e.suspense) {
+ const h = (r = i.name) != null ? r : "Anonymous";
+ z(`Component <${h}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`)
+ }
+ } else cf(e, c, t)
+ } else df(e, t)
}
- function dl(e, t, n) {
- fe(t) ? e.type.__ssrInlineRender ? e.ssrRender = t : e.render = t : Ie(t) && (e.setupState = Ou(t)), hl(e, n)
+ function cf(e, t, r) {
+ le(t) ? e.type.__ssrInlineRender ? e.ssrRender = t : e.render = t : Oe(t) ? (ia(t) && z("setup() should not return VNodes directly - return a render function instead."), e.devtoolsRawSetupState = t, e.setupState = gl(t), Tg(e)) : t !== void 0 && z(`setup() should return an object. Received: ${t===null?"null":typeof t}`), df(e, r)
}
- let pl;
+ let la;
+ const uy = () => !la;
- function hl(e, t, n) {
- const o = e.type;
+ function df(e, t, r) {
+ const i = e.type;
if (!e.render) {
- if (!t && pl && !o.render) {
- const s = o.template || bs(e).template;
+ if (!t && la && !i.render) {
+ const s = i.template || Xs(e).template;
if (s) {
+ cr(e, "compile");
const {
isCustomElement: a,
compilerOptions: c
} = e.appContext.config, {
delimiters: h,
compilerOptions: y
- } = o, b = Ke(Ke({
+ } = i, v = Le(Le({
isCustomElement: a,
delimiters: h
}, c), y);
- o.render = pl(s, b)
+ i.render = la(s, v), dr(e, "compile")
}
}
- e.render = o.render || Dt
+ e.render = i.render || mt
}
- dn(e), sn(), sh(e), an(), kr()
+ Tn(e), Vr(), Cg(e), zr(), nn(), !i.render && e.render === mt && !t && (i.template ? z('Component provided template option but runtime compilation is not supported in this build of Vue. Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".') : z("Component is missing template or render function."))
}
- function Ih(e) {
+ function ly(e) {
return e.attrsProxy || (e.attrsProxy = new Proxy(e.attrs, {
- get(t, n) {
- return lt(e, "get", "$attrs"), t[n]
+ get(t, r) {
+ return oo(), st(e, "get", "$attrs"), t[r]
+ },
+ set() {
+ return z("setupContext.attrs is readonly."), !1
+ },
+ deleteProperty() {
+ return z("setupContext.attrs is readonly."), !1
}
}))
}
- function $h(e) {
- const t = n => {
- e.exposed = n || {}
- };
- return {
+ function fy(e) {
+ return e.slotsProxy || (e.slotsProxy = new Proxy(e.slots, {
+ get(t, r) {
+ return st(e, "get", "$slots"), t[r]
+ }
+ }))
+ }
+
+ function cy(e) {
+ return Object.freeze({
get attrs() {
- return Ih(e)
+ return ly(e)
},
- slots: e.slots,
- emit: e.emit,
- expose: t
- }
+ get slots() {
+ return fy(e)
+ },
+ get emit() {
+ return (r, ...i) => e.emit(r, ...i)
+ },
+ expose: r => {
+ if (e.exposed && z("expose() should be called only once per setup()."), r != null) {
+ let i = typeof r;
+ i === "object" && (re(r) ? i = "array" : Qe(r) && (i = "ref")), i !== "object" && z(`expose() should be passed a plain object, received ${i}.`)
+ }
+ e.exposed = r || {}
+ }
+ })
}
- function Wi(e) {
- if (e.exposed) return e.exposeProxy || (e.exposeProxy = new Proxy(Ou(Cu(e.exposed)), {
- get(t, n) {
- if (n in t) return t[n];
- if (n in Wn) return Wn[n](e)
+ function bo(e) {
+ if (e.exposed) return e.exposeProxy || (e.exposeProxy = new Proxy(gl(hl(e.exposed)), {
+ get(t, r) {
+ if (r in t) return t[r];
+ if (r in en) return en[r](e)
},
- has(t, n) {
- return n in t || n in Wn
+ has(t, r) {
+ return r in t || r in en
}
}))
}
+ const dy = /(?:^|[-_])(\w)/g,
+ py = e => e.replace(dy, t => t.toUpperCase()).replace(/[-_]/g, "");
- function Mh(e, t = !0) {
- return fe(e) ? e.displayName || e.name : e.name || t && e.__name
+ function fa(e, t = !0) {
+ return le(e) ? e.displayName || e.name : e.name || t && e.__name
}
- function Lh(e) {
- return fe(e) && "__vccOpts" in e
+ function wo(e, t, r = !1) {
+ let i = fa(t);
+ if (!i && t.__file) {
+ const s = t.__file.match(/([^/\\]+)\.\w+$/);
+ s && (i = s[1])
+ }
+ if (!i && e && e.parent) {
+ const s = a => {
+ for (const c in a)
+ if (a[c] === t) return c
+ };
+ i = s(e.components || e.parent.type.components) || s(e.appContext.components)
+ }
+ return i ? py(i) : r ? "App" : "Anonymous"
+ }
+
+ function pf(e) {
+ return le(e) && "__vccOpts" in e
}
- const Fh = (e, t) => Op(e, t, Qn),
- kh = Symbol.for("v-scx"),
- jh = () => qi(kh),
- qh = "3.3.4",
- Bh = "http://www.w3.org/2000/svg",
- jr = typeof document != "undefined" ? document : null,
- gl = jr && jr.createElement("template"),
- Uh = {
- insert: (e, t, n) => {
- t.insertBefore(e, n || null)
+ const hy = (e, t) => $h(e, t, hi),
+ gy = Symbol.for("v-scx"),
+ yy = () => {
+ {
+ const e = ho(gy);
+ return e || z("Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build."), e
+ }
+ };
+
+ function ca(e) {
+ return !!(e && e.__v_isShallow)
+ }
+
+ function my() {
+ if (typeof window == "undefined") return;
+ const e = {
+ style: "color:#3ba776"
+ },
+ t = {
+ style: "color:#0b1bc9"
+ },
+ r = {
+ style: "color:#b62e24"
+ },
+ i = {
+ style: "color:#9d288c"
+ },
+ s = {
+ header(E) {
+ return Oe(E) ? E.__isVue ? ["div", e, "VueInstance"] : Qe(E) ? ["div", {},
+ ["span", e, _(E)], "<", h(E.value), ">"
+ ] : Kr(E) ? ["div", {},
+ ["span", e, ca(E) ? "ShallowReactive" : "Reactive"], "<", h(E), `>${Jr(E)?" (readonly)":""}`
+ ] : Jr(E) ? ["div", {},
+ ["span", e, ca(E) ? "ShallowReadonly" : "Readonly"], "<", h(E), ">"
+ ] : null : null
+ },
+ hasBody(E) {
+ return E && E.__isVue
+ },
+ body(E) {
+ if (E && E.__isVue) return ["div", {}, ...a(E.$)]
+ }
+ };
+
+ function a(E) {
+ const P = [];
+ E.type.props && E.props && P.push(c("props", ye(E.props))), E.setupState !== Ne && P.push(c("setup", E.setupState)), E.data !== Ne && P.push(c("data", ye(E.data)));
+ const q = y(E, "computed");
+ q && P.push(c("computed", q));
+ const j = y(E, "inject");
+ return j && P.push(c("injected", j)), P.push(["div", {},
+ ["span", {
+ style: i.style + ";opacity:0.66"
+ }, "$ (internal): "],
+ ["object", {
+ object: E
+ }]
+ ]), P
+ }
+
+ function c(E, P) {
+ return P = Le({}, P), Object.keys(P).length ? ["div", {
+ style: "line-height:1.25em;margin-bottom:0.6em"
+ },
+ ["div", {
+ style: "color:#476582"
+ }, E],
+ ["div", {
+ style: "padding-left:1.25em"
+ }, ...Object.keys(P).map(q => ["div", {},
+ ["span", i, q + ": "], h(P[q], !1)
+ ])]
+ ] : ["span", {}]
+ }
+
+ function h(E, P = !0) {
+ return typeof E == "number" ? ["span", t, E] : typeof E == "string" ? ["span", r, JSON.stringify(E)] : typeof E == "boolean" ? ["span", i, E] : Oe(E) ? ["object", {
+ object: P ? ye(E) : E
+ }] : ["span", r, String(E)]
+ }
+
+ function y(E, P) {
+ const q = E.type;
+ if (le(q)) return;
+ const j = {};
+ for (const B in E.ctx) v(q, B, P) && (j[B] = E.ctx[B]);
+ return j
+ }
+
+ function v(E, P, q) {
+ const j = E[q];
+ if (re(j) && j.includes(P) || Oe(j) && P in j || E.extends && v(E.extends, P, q) || E.mixins && E.mixins.some(B => v(B, P, q))) return !0
+ }
+
+ function _(E) {
+ return ca(E) ? "ShallowRef" : E.effect ? "ComputedRef" : "Ref"
+ }
+ window.devtoolsFormatters ? window.devtoolsFormatters.push(s) : window.devtoolsFormatters = [s]
+ }
+ const hf = "3.3.4",
+ vy = "http://www.w3.org/2000/svg",
+ on = typeof document != "undefined" ? document : null,
+ gf = on && on.createElement("template"),
+ by = {
+ insert: (e, t, r) => {
+ t.insertBefore(e, r || null)
},
remove: e => {
const t = e.parentNode;
t && t.removeChild(e)
},
- createElement: (e, t, n, o) => {
- const s = t ? jr.createElementNS(Bh, e) : jr.createElement(e, n ? {
- is: n
+ createElement: (e, t, r, i) => {
+ const s = t ? on.createElementNS(vy, e) : on.createElement(e, r ? {
+ is: r
} : void 0);
- return e === "select" && o && o.multiple != null && s.setAttribute("multiple", o.multiple), s
+ return e === "select" && i && i.multiple != null && s.setAttribute("multiple", i.multiple), s
},
- createText: e => jr.createTextNode(e),
- createComment: e => jr.createComment(e),
+ createText: e => on.createTextNode(e),
+ createComment: e => on.createComment(e),
setText: (e, t) => {
e.nodeValue = t
},
setElementText: (e, t) => {
e.textContent = t
},
parentNode: e => e.parentNode,
nextSibling: e => e.nextSibling,
- querySelector: e => jr.querySelector(e),
+ querySelector: e => on.querySelector(e),
setScopeId(e, t) {
e.setAttribute(t, "")
},
- insertStaticContent(e, t, n, o, s, a) {
- const c = n ? n.previousSibling : t.lastChild;
+ insertStaticContent(e, t, r, i, s, a) {
+ const c = r ? r.previousSibling : t.lastChild;
if (s && (s === a || s.nextSibling))
- for (; t.insertBefore(s.cloneNode(!0), n), !(s === a || !(s = s.nextSibling)););
+ for (; t.insertBefore(s.cloneNode(!0), r), !(s === a || !(s = s.nextSibling)););
else {
- gl.innerHTML = o ? `<svg>${e}</svg>` : e;
- const h = gl.content;
- if (o) {
+ gf.innerHTML = i ? `<svg>${e}</svg>` : e;
+ const h = gf.content;
+ if (i) {
const y = h.firstChild;
for (; y.firstChild;) h.appendChild(y.firstChild);
h.removeChild(y)
}
- t.insertBefore(h, n)
+ t.insertBefore(h, r)
}
- return [c ? c.nextSibling : t.firstChild, n ? n.previousSibling : t.lastChild]
+ return [c ? c.nextSibling : t.firstChild, r ? r.previousSibling : t.lastChild]
}
};
- function Hh(e, t, n) {
- const o = e._vtc;
- o && (t = (t ? [t, ...o] : [...o]).join(" ")), t == null ? e.removeAttribute("class") : n ? e.setAttribute("class", t) : e.className = t
+ function wy(e, t, r) {
+ const i = e._vtc;
+ i && (t = (t ? [t, ...i] : [...i]).join(" ")), t == null ? e.removeAttribute("class") : r ? e.setAttribute("class", t) : e.className = t
}
- function Wh(e, t, n) {
- const o = e.style,
- s = He(n);
- if (n && !s) {
+ function _y(e, t, r) {
+ const i = e.style,
+ s = He(r);
+ if (r && !s) {
if (t && !He(t))
- for (const a in t) n[a] == null && Os(o, a, "");
- for (const a in n) Os(o, a, n[a])
+ for (const a in t) r[a] == null && da(i, a, "");
+ for (const a in r) da(i, a, r[a])
} else {
- const a = o.display;
- s ? t !== n && (o.cssText = n) : t && e.removeAttribute("style"), "_vod" in e && (o.display = a)
+ const a = i.display;
+ s ? t !== r && (i.cssText = r) : t && e.removeAttribute("style"), "_vod" in e && (i.display = a)
}
}
- const yl = /\s*!important$/;
+ const xy = /[^\\];\s*$/,
+ yf = /\s*!important$/;
- function Os(e, t, n) {
- if (ne(n)) n.forEach(o => Os(e, t, o));
- else if (n == null && (n = ""), t.startsWith("--")) e.setProperty(t, n);
+ function da(e, t, r) {
+ if (re(r)) r.forEach(i => da(e, t, i));
+ else if (r == null && (r = ""), xy.test(r) && z(`Unexpected semicolon at the end of '${t}' style value: '${r}'`), t.startsWith("--")) e.setProperty(t, r);
else {
- const o = Vh(e, t);
- yl.test(n) ? e.setProperty(on(o), n.replace(yl, ""), "important") : e[o] = n
+ const i = Sy(e, t);
+ yf.test(r) ? e.setProperty(Sr(i), r.replace(yf, ""), "important") : e[i] = r
}
}
- const ml = ["Webkit", "Moz", "ms"],
- Ps = {};
+ const mf = ["Webkit", "Moz", "ms"],
+ pa = {};
- function Vh(e, t) {
- const n = Ps[t];
- if (n) return n;
- let o = Ht(t);
- if (o !== "filter" && o in e) return Ps[t] = o;
- o = bi(o);
- for (let s = 0; s < ml.length; s++) {
- const a = ml[s] + o;
- if (a in e) return Ps[t] = a
+ function Sy(e, t) {
+ const r = pa[t];
+ if (r) return r;
+ let i = Jt(t);
+ if (i !== "filter" && i in e) return pa[t] = i;
+ i = qr(i);
+ for (let s = 0; s < mf.length; s++) {
+ const a = mf[s] + i;
+ if (a in e) return pa[t] = a
}
return t
}
- const vl = "http://www.w3.org/1999/xlink";
+ const vf = "http://www.w3.org/1999/xlink";
- function zh(e, t, n, o, s) {
- if (o && t.startsWith("xlink:")) n == null ? e.removeAttributeNS(vl, t.slice(6, t.length)) : e.setAttributeNS(vl, t, n);
+ function Ey(e, t, r, i, s) {
+ if (i && t.startsWith("xlink:")) r == null ? e.removeAttributeNS(vf, t.slice(6, t.length)) : e.setAttributeNS(vf, t, r);
else {
- const a = Vd(t);
- n == null || a && !su(n) ? e.removeAttribute(t) : e.setAttribute(t, a ? "" : n)
+ const a = zp(t);
+ r == null || a && !Vu(r) ? e.removeAttribute(t) : e.setAttribute(t, a ? "" : r)
}
}
- function Kh(e, t, n, o, s, a, c) {
+ function Ty(e, t, r, i, s, a, c) {
if (t === "innerHTML" || t === "textContent") {
- o && c(o, s, a), e[t] = n == null ? "" : n;
+ i && c(i, s, a), e[t] = r == null ? "" : r;
return
}
const h = e.tagName;
if (t === "value" && h !== "PROGRESS" && !h.includes("-")) {
- e._value = n;
- const b = h === "OPTION" ? e.getAttribute("value") : e.value,
- w = n == null ? "" : n;
- b !== w && (e.value = w), n == null && e.removeAttribute(t);
+ e._value = r;
+ const v = h === "OPTION" ? e.getAttribute("value") : e.value,
+ _ = r == null ? "" : r;
+ v !== _ && (e.value = _), r == null && e.removeAttribute(t);
return
}
let y = !1;
- if (n === "" || n == null) {
- const b = typeof e[t];
- b === "boolean" ? n = su(n) : n == null && b === "string" ? (n = "", y = !0) : b === "number" && (n = 0, y = !0)
+ if (r === "" || r == null) {
+ const v = typeof e[t];
+ v === "boolean" ? r = Vu(r) : r == null && v === "string" ? (r = "", y = !0) : v === "number" && (r = 0, y = !0)
}
try {
- e[t] = n
- } catch {}
+ e[t] = r
+ } catch (v) {
+ y || z(`Failed setting prop "${t}" on <${h.toLowerCase()}>: value ${r} is invalid.`, v)
+ }
y && e.removeAttribute(t)
}
- function sr(e, t, n, o) {
- e.addEventListener(t, n, o)
+ function pr(e, t, r, i) {
+ e.addEventListener(t, r, i)
}
- function Jh(e, t, n, o) {
- e.removeEventListener(t, n, o)
+ function Oy(e, t, r, i) {
+ e.removeEventListener(t, r, i)
}
- function Qh(e, t, n, o, s = null) {
+ function Cy(e, t, r, i, s = null) {
const a = e._vei || (e._vei = {}),
c = a[t];
- if (o && c) c.value = o;
+ if (i && c) c.value = i;
else {
- const [h, y] = Xh(t);
- if (o) {
- const b = a[t] = Zh(o, s);
- sr(e, h, b, y)
- } else c && (Jh(e, h, c, y), a[t] = void 0)
+ const [h, y] = Ay(t);
+ if (i) {
+ const v = a[t] = Ry(i, s);
+ pr(e, h, v, y)
+ } else c && (Oy(e, h, c, y), a[t] = void 0)
}
}
- const bl = /(?:Once|Passive|Capture)$/;
+ const bf = /(?:Once|Passive|Capture)$/;
- function Xh(e) {
+ function Ay(e) {
let t;
- if (bl.test(e)) {
+ if (bf.test(e)) {
t = {};
- let o;
- for (; o = e.match(bl);) e = e.slice(0, e.length - o[0].length), t[o[0].toLowerCase()] = !0
+ let i;
+ for (; i = e.match(bf);) e = e.slice(0, e.length - i[0].length), t[i[0].toLowerCase()] = !0
}
- return [e[2] === ":" ? e.slice(3) : on(e.slice(2)), t]
+ return [e[2] === ":" ? e.slice(3) : Sr(e.slice(2)), t]
}
- let Ns = 0;
- const Gh = Promise.resolve(),
- Yh = () => Ns || (Gh.then(() => Ns = 0), Ns = Date.now());
-
- function Zh(e, t) {
- const n = o => {
- if (!o._vts) o._vts = Date.now();
- else if (o._vts <= n.attached) return;
- Mt(eg(o, n.value), t, 5, [o])
+ let ha = 0;
+ const Py = Promise.resolve(),
+ $y = () => ha || (Py.then(() => ha = 0), ha = Date.now());
+
+ function Ry(e, t) {
+ const r = i => {
+ if (!i._vts) i._vts = Date.now();
+ else if (i._vts <= r.attached) return;
+ Ft(Ny(i, r.value), t, 5, [i])
};
- return n.value = e, n.attached = Yh(), n
+ return r.value = e, r.attached = $y(), r
}
- function eg(e, t) {
- if (ne(t)) {
- const n = e.stopImmediatePropagation;
+ function Ny(e, t) {
+ if (re(t)) {
+ const r = e.stopImmediatePropagation;
return e.stopImmediatePropagation = () => {
- n.call(e), e._stopped = !0
- }, t.map(o => s => !s._stopped && o && o(s))
+ r.call(e), e._stopped = !0
+ }, t.map(i => s => !s._stopped && i && i(s))
} else return t
}
- const _l = /^on[a-z]/,
- tg = (e, t, n, o, s = !1, a, c, h, y) => {
- t === "class" ? Hh(e, o, s) : t === "style" ? Wh(e, n, o) : yi(t) ? Wo(t) || Qh(e, t, n, o, c) : (t[0] === "." ? (t = t.slice(1), !0) : t[0] === "^" ? (t = t.slice(1), !1) : rg(e, t, o, s)) ? Kh(e, t, o, a, c, h, y) : (t === "true-value" ? e._trueValue = o : t === "false-value" && (e._falseValue = o), zh(e, t, o, s))
+ const wf = /^on[a-z]/,
+ Dy = (e, t, r, i, s = !1, a, c, h, y) => {
+ t === "class" ? wy(e, i, s) : t === "style" ? _y(e, r, i) : Xn(t) ? ji(t) || Cy(e, t, r, i, c) : (t[0] === "." ? (t = t.slice(1), !0) : t[0] === "^" ? (t = t.slice(1), !1) : Iy(e, t, i, s)) ? Ty(e, t, i, a, c, h, y) : (t === "true-value" ? e._trueValue = i : t === "false-value" && (e._falseValue = i), Ey(e, t, i, s))
};
- function rg(e, t, n, o) {
- return o ? !!(t === "innerHTML" || t === "textContent" || t in e && _l.test(t) && fe(n)) : t === "spellcheck" || t === "draggable" || t === "translate" || t === "form" || t === "list" && e.tagName === "INPUT" || t === "type" && e.tagName === "TEXTAREA" || _l.test(t) && He(n) ? !1 : t in e
+ function Iy(e, t, r, i) {
+ return i ? !!(t === "innerHTML" || t === "textContent" || t in e && wf.test(t) && le(r)) : t === "spellcheck" || t === "draggable" || t === "translate" || t === "form" || t === "list" && e.tagName === "INPUT" || t === "type" && e.tagName === "TEXTAREA" || wf.test(t) && He(r) ? !1 : t in e
}
- const ng = {
- name: String,
- type: String,
- css: {
- type: Boolean,
- default: !0
- },
- duration: [String, Number, Object],
- enterFromClass: String,
- enterActiveClass: String,
- enterToClass: String,
- appearFromClass: String,
- appearActiveClass: String,
- appearToClass: String,
- leaveFromClass: String,
- leaveActiveClass: String,
- leaveToClass: String
- },
- xr = e => {
- const t = e.props["onUpdate:modelValue"] || !1;
- return ne(t) ? n => xi(t, n) : t
- };
+ const Rr = e => {
+ const t = e.props["onUpdate:modelValue"] || !1;
+ return re(t) ? r => _n(t, r) : t
+ };
- function ig(e) {
+ function My(e) {
e.target.composing = !0
}
- function xl(e) {
+ function _f(e) {
const t = e.target;
t.composing && (t.composing = !1, t.dispatchEvent(new Event("input")))
}
- const Rs = {
+ const ga = {
created(e, {
modifiers: {
lazy: t,
- trim: n,
- number: o
+ trim: r,
+ number: i
}
}, s) {
- e._assign = xr(s);
- const a = o || s.props && s.props.type === "number";
- sr(e, t ? "change" : "input", c => {
+ e._assign = Rr(s);
+ const a = i || s.props && s.props.type === "number";
+ pr(e, t ? "change" : "input", c => {
if (c.target.composing) return;
let h = e.value;
- n && (h = h.trim()), a && (h = Si(h)), e._assign(h)
- }), n && sr(e, "change", () => {
+ r && (h = h.trim()), a && (h = Hi(h)), e._assign(h)
+ }), r && pr(e, "change", () => {
e.value = e.value.trim()
- }), t || (sr(e, "compositionstart", ig), sr(e, "compositionend", xl), sr(e, "change", xl))
+ }), t || (pr(e, "compositionstart", My), pr(e, "compositionend", _f), pr(e, "change", _f))
},
mounted(e, {
value: t
}) {
e.value = t == null ? "" : t
},
beforeUpdate(e, {
value: t,
modifiers: {
- lazy: n,
- trim: o,
+ lazy: r,
+ trim: i,
number: s
}
}, a) {
- if (e._assign = xr(a), e.composing || document.activeElement === e && e.type !== "range" && (n || o && e.value.trim() === t || (s || e.type === "number") && Si(e.value) === t)) return;
+ if (e._assign = Rr(a), e.composing || document.activeElement === e && e.type !== "range" && (r || i && e.value.trim() === t || (s || e.type === "number") && Hi(e.value) === t)) return;
const c = t == null ? "" : t;
e.value !== c && (e.value = c)
}
},
- og = {
+ ky = {
deep: !0,
- created(e, t, n) {
- e._assign = xr(n), sr(e, "change", () => {
- const o = e._modelValue,
- s = pn(e),
+ created(e, t, r) {
+ e._assign = Rr(r), pr(e, "change", () => {
+ const i = e._modelValue,
+ s = On(e),
a = e.checked,
c = e._assign;
- if (ne(o)) {
- const h = Xo(o, s),
+ if (re(i)) {
+ const h = _s(i, s),
y = h !== -1;
- if (a && !y) c(o.concat(s));
+ if (a && !y) c(i.concat(s));
else if (!a && y) {
- const b = [...o];
- b.splice(h, 1), c(b)
+ const v = [...i];
+ v.splice(h, 1), c(v)
}
- } else if (nn(o)) {
- const h = new Set(o);
+ } else if (wn(i)) {
+ const h = new Set(i);
a ? h.add(s) : h.delete(s), c(h)
- } else c(El(e, a))
+ } else c(Ef(e, a))
})
},
- mounted: wl,
- beforeUpdate(e, t, n) {
- e._assign = xr(n), wl(e, t, n)
+ mounted: xf,
+ beforeUpdate(e, t, r) {
+ e._assign = Rr(r), xf(e, t, r)
}
};
- function wl(e, {
+ function xf(e, {
value: t,
- oldValue: n
- }, o) {
- e._modelValue = t, ne(t) ? e.checked = Xo(t, o.props.value) > -1 : nn(t) ? e.checked = t.has(o.props.value) : t !== n && (e.checked = Nr(t, El(e, !0)))
+ oldValue: r
+ }, i) {
+ e._modelValue = t, re(t) ? e.checked = _s(t, i.props.value) > -1 : wn(t) ? e.checked = t.has(i.props.value) : t !== r && (e.checked = Br(t, Ef(e, !0)))
}
- const sg = {
+ const jy = {
created(e, {
value: t
- }, n) {
- e.checked = Nr(t, n.props.value), e._assign = xr(n), sr(e, "change", () => {
- e._assign(pn(e))
+ }, r) {
+ e.checked = Br(t, r.props.value), e._assign = Rr(r), pr(e, "change", () => {
+ e._assign(On(e))
})
},
beforeUpdate(e, {
value: t,
- oldValue: n
- }, o) {
- e._assign = xr(o), t !== n && (e.checked = Nr(t, o.props.value))
+ oldValue: r
+ }, i) {
+ e._assign = Rr(i), t !== r && (e.checked = Br(t, i.props.value))
}
},
- Ds = {
+ ya = {
deep: !0,
created(e, {
value: t,
modifiers: {
- number: n
+ number: r
}
- }, o) {
- const s = nn(t);
- sr(e, "change", () => {
- const a = Array.prototype.filter.call(e.options, c => c.selected).map(c => n ? Si(pn(c)) : pn(c));
+ }, i) {
+ const s = wn(t);
+ pr(e, "change", () => {
+ const a = Array.prototype.filter.call(e.options, c => c.selected).map(c => r ? Hi(On(c)) : On(c));
e._assign(e.multiple ? s ? new Set(a) : a : a[0])
- }), e._assign = xr(o)
+ }), e._assign = Rr(i)
},
mounted(e, {
value: t
}) {
- Sl(e, t)
+ Sf(e, t)
},
- beforeUpdate(e, t, n) {
- e._assign = xr(n)
+ beforeUpdate(e, t, r) {
+ e._assign = Rr(r)
},
updated(e, {
value: t
}) {
- Sl(e, t)
+ Sf(e, t)
}
};
- function Sl(e, t) {
- const n = e.multiple;
- if (!(n && !ne(t) && !nn(t))) {
- for (let o = 0, s = e.options.length; o < s; o++) {
- const a = e.options[o],
- c = pn(a);
- if (n) ne(t) ? a.selected = Xo(t, c) > -1 : a.selected = t.has(c);
- else if (Nr(pn(a), t)) {
- e.selectedIndex !== o && (e.selectedIndex = o);
- return
- }
- }!n && e.selectedIndex !== -1 && (e.selectedIndex = -1)
+ function Sf(e, t) {
+ const r = e.multiple;
+ if (r && !re(t) && !wn(t)) {
+ z(`<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(t).slice(8,-1)}.`);
+ return
}
+ for (let i = 0, s = e.options.length; i < s; i++) {
+ const a = e.options[i],
+ c = On(a);
+ if (r) re(t) ? a.selected = _s(t, c) > -1 : a.selected = t.has(c);
+ else if (Br(On(a), t)) {
+ e.selectedIndex !== i && (e.selectedIndex = i);
+ return
+ }
+ }!r && e.selectedIndex !== -1 && (e.selectedIndex = -1)
}
- function pn(e) {
+ function On(e) {
return "_value" in e ? e._value : e.value
}
- function El(e, t) {
- const n = t ? "_trueValue" : "_falseValue";
- return n in e ? e[n] : t
- }
- const ag = {
- created(e, t, n) {
- Vi(e, t, n, null, "created")
+ function Ef(e, t) {
+ const r = t ? "_trueValue" : "_falseValue";
+ return r in e ? e[r] : t
+ }
+ const Ly = {
+ created(e, t, r) {
+ _o(e, t, r, null, "created")
},
- mounted(e, t, n) {
- Vi(e, t, n, null, "mounted")
+ mounted(e, t, r) {
+ _o(e, t, r, null, "mounted")
},
- beforeUpdate(e, t, n, o) {
- Vi(e, t, n, o, "beforeUpdate")
+ beforeUpdate(e, t, r, i) {
+ _o(e, t, r, i, "beforeUpdate")
},
- updated(e, t, n, o) {
- Vi(e, t, n, o, "updated")
+ updated(e, t, r, i) {
+ _o(e, t, r, i, "updated")
}
};
- function ug(e, t) {
+ function Fy(e, t) {
switch (e) {
case "SELECT":
- return Ds;
+ return ya;
case "TEXTAREA":
- return Rs;
+ return ga;
default:
switch (t) {
case "checkbox":
- return og;
+