From 2cc85c64f1c64a2dbaeae276a3e2ca8420de76b7 Mon Sep 17 00:00:00 2001
From: WXL <wl_5969728@163.com>
Date: 星期三, 22 四月 2026 18:09:58 +0800
Subject: [PATCH] 上报转运调试
---
node_modules/vue/dist/vue.runtime.esm-browser.js | 978 ++++++++++++++++++++++++++++++++++----------------------
1 files changed, 591 insertions(+), 387 deletions(-)
diff --git a/node_modules/vue/dist/vue.runtime.esm-browser.js b/node_modules/vue/dist/vue.runtime.esm-browser.js
index b78b866..41e887e 100644
--- a/node_modules/vue/dist/vue.runtime.esm-browser.js
+++ b/node_modules/vue/dist/vue.runtime.esm-browser.js
@@ -1,5 +1,5 @@
/**
-* vue v3.5.25
+* vue v3.5.32
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
@@ -334,6 +334,7 @@
let activeEffectScope;
class EffectScope {
+ // TODO isolatedDeclarations "__v_skip"
constructor(detached = false) {
this.detached = detached;
/**
@@ -353,6 +354,7 @@
*/
this.cleanups = [];
this._isPaused = false;
+ this.__v_skip = true;
this.parent = activeEffectScope;
if (!detached && activeEffectScope) {
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
@@ -929,13 +931,13 @@
}
}
const targetMap = /* @__PURE__ */ new WeakMap();
-const ITERATE_KEY = Symbol(
+const ITERATE_KEY = /* @__PURE__ */ Symbol(
"Object iterate"
);
-const MAP_KEY_ITERATE_KEY = Symbol(
+const MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol(
"Map keys iterate"
);
-const ARRAY_ITERATE_KEY = Symbol(
+const ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol(
"Array iterate"
);
function track(target, type, key) {
@@ -1203,10 +1205,17 @@
}
function reduce(self, method, fn, args) {
const arr = shallowReadArray(self);
+ const needsWrap = arr !== self && !isShallow(self);
let wrappedFn = fn;
+ let wrapInitialAccumulator = false;
if (arr !== self) {
- if (!isShallow(self)) {
+ if (needsWrap) {
+ wrapInitialAccumulator = args.length === 0;
wrappedFn = function(acc, item, index) {
+ if (wrapInitialAccumulator) {
+ wrapInitialAccumulator = false;
+ acc = toWrapped(self, acc);
+ }
return fn.call(this, acc, toWrapped(self, item), index, self);
};
} else if (fn.length > 3) {
@@ -1215,7 +1224,8 @@
};
}
}
- return arr[method](wrappedFn, ...args);
+ const result = arr[method](wrappedFn, ...args);
+ return wrapInitialAccumulator ? toWrapped(self, result) : result;
}
function searchProxy(self, method, args) {
const arr = toRaw(self);
@@ -1418,20 +1428,20 @@
"iterate",
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
);
- return {
- // iterator protocol
- next() {
- const { value, done } = innerIterator.next();
- return done ? { value, done } : {
- value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
- done
- };
- },
- // iterable protocol
- [Symbol.iterator]() {
- return this;
+ return extend(
+ // inheriting all iterator properties
+ Object.create(innerIterator),
+ {
+ // iterator protocol
+ next() {
+ const { value, done } = innerIterator.next();
+ return done ? { value, done } : {
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+ done
+ };
+ }
}
- };
+ );
};
}
function createReadonlyMethod(type) {
@@ -1505,15 +1515,14 @@
clear: createReadonlyMethod("clear")
} : {
add(value) {
- if (!shallow && !isShallow(value) && !isReadonly(value)) {
- value = toRaw(value);
- }
const target = toRaw(this);
const proto = getProto(target);
- const hadKey = proto.has.call(target, value);
+ const rawValue = toRaw(value);
+ const valueToAdd = !shallow && !isShallow(value) && !isReadonly(value) ? rawValue : value;
+ const hadKey = proto.has.call(target, valueToAdd) || hasChanged(value, valueToAdd) && proto.has.call(target, value) || hasChanged(rawValue, valueToAdd) && proto.has.call(target, rawValue);
if (!hadKey) {
- target.add(value);
- trigger(target, "add", value, value);
+ target.add(valueToAdd);
+ trigger(target, "add", valueToAdd, valueToAdd);
}
return this;
},
@@ -1645,8 +1654,9 @@
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
}
+// @__NO_SIDE_EFFECTS__
function reactive(target) {
- if (isReadonly(target)) {
+ if (/* @__PURE__ */ isReadonly(target)) {
return target;
}
return createReactiveObject(
@@ -1657,6 +1667,7 @@
reactiveMap
);
}
+// @__NO_SIDE_EFFECTS__
function shallowReactive(target) {
return createReactiveObject(
target,
@@ -1666,6 +1677,7 @@
shallowReactiveMap
);
}
+// @__NO_SIDE_EFFECTS__
function readonly(target) {
return createReactiveObject(
target,
@@ -1675,6 +1687,7 @@
readonlyMap
);
}
+// @__NO_SIDE_EFFECTS__
function shallowReadonly(target) {
return createReactiveObject(
target,
@@ -1713,24 +1726,29 @@
proxyMap.set(target, proxy);
return proxy;
}
+// @__NO_SIDE_EFFECTS__
function isReactive(value) {
- if (isReadonly(value)) {
- return isReactive(value["__v_raw"]);
+ if (/* @__PURE__ */ isReadonly(value)) {
+ return /* @__PURE__ */ isReactive(value["__v_raw"]);
}
return !!(value && value["__v_isReactive"]);
}
+// @__NO_SIDE_EFFECTS__
function isReadonly(value) {
return !!(value && value["__v_isReadonly"]);
}
+// @__NO_SIDE_EFFECTS__
function isShallow(value) {
return !!(value && value["__v_isShallow"]);
}
+// @__NO_SIDE_EFFECTS__
function isProxy(value) {
return value ? !!value["__v_raw"] : false;
}
+// @__NO_SIDE_EFFECTS__
function toRaw(observed) {
const raw = observed && observed["__v_raw"];
- return raw ? toRaw(raw) : observed;
+ return raw ? /* @__PURE__ */ toRaw(raw) : observed;
}
function markRaw(value) {
if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
@@ -1738,20 +1756,23 @@
}
return value;
}
-const toReactive = (value) => isObject(value) ? reactive(value) : value;
-const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+const toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+// @__NO_SIDE_EFFECTS__
function isRef(r) {
return r ? r["__v_isRef"] === true : false;
}
+// @__NO_SIDE_EFFECTS__
function ref(value) {
return createRef(value, false);
}
+// @__NO_SIDE_EFFECTS__
function shallowRef(value) {
return createRef(value, true);
}
function createRef(rawValue, shallow) {
- if (isRef(rawValue)) {
+ if (/* @__PURE__ */ isRef(rawValue)) {
return rawValue;
}
return new RefImpl(rawValue, shallow);
@@ -1807,7 +1828,7 @@
}
}
function unref(ref2) {
- return isRef(ref2) ? ref2.value : ref2;
+ return /* @__PURE__ */ isRef(ref2) ? ref2.value : ref2;
}
function toValue(source) {
return isFunction(source) ? source() : unref(source);
@@ -1816,7 +1837,7 @@
get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
set: (target, key, value, receiver) => {
const oldValue = target[key];
- if (isRef(oldValue) && !isRef(value)) {
+ if (/* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
oldValue.value = value;
return true;
} else {
@@ -1846,6 +1867,7 @@
function customRef(factory) {
return new CustomRefImpl(factory);
}
+// @__NO_SIDE_EFFECTS__
function toRefs(object) {
if (!isProxy(object)) {
warn$2(`toRefs() expects a reactive object but received a plain one.`);
@@ -1857,16 +1879,16 @@
return ret;
}
class ObjectRefImpl {
- constructor(_object, _key, _defaultValue) {
+ constructor(_object, key, _defaultValue) {
this._object = _object;
- this._key = _key;
this._defaultValue = _defaultValue;
this["__v_isRef"] = true;
this._value = void 0;
+ this._key = isSymbol(key) ? key : String(key);
this._raw = toRaw(_object);
let shallow = true;
let obj = _object;
- if (!isArray(_object) || !isIntegerKey(String(_key))) {
+ if (!isArray(_object) || isSymbol(this._key) || !isIntegerKey(this._key)) {
do {
shallow = !isProxy(obj) || isShallow(obj);
} while (shallow && (obj = obj["__v_raw"]));
@@ -1881,9 +1903,9 @@
return this._value = val === void 0 ? this._defaultValue : val;
}
set value(newVal) {
- if (this._shallow && isRef(this._raw[this._key])) {
+ if (this._shallow && /* @__PURE__ */ isRef(this._raw[this._key])) {
const nestedRef = this._object[this._key];
- if (isRef(nestedRef)) {
+ if (/* @__PURE__ */ isRef(nestedRef)) {
nestedRef.value = newVal;
return;
}
@@ -1905,15 +1927,16 @@
return this._value = this._getter();
}
}
+// @__NO_SIDE_EFFECTS__
function toRef(source, key, defaultValue) {
- if (isRef(source)) {
+ if (/* @__PURE__ */ isRef(source)) {
return source;
} else if (isFunction(source)) {
return new GetterRefImpl(source);
} else if (isObject(source) && arguments.length > 1) {
return propertyToRef(source, key, defaultValue);
} else {
- return ref(source);
+ return /* @__PURE__ */ ref(source);
}
}
function propertyToRef(source, key, defaultValue) {
@@ -1994,6 +2017,7 @@
}
}
}
+// @__NO_SIDE_EFFECTS__
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
let getter;
let setter;
@@ -2664,6 +2688,13 @@
}
let isHmrUpdating = false;
+const setHmrUpdating = (v) => {
+ try {
+ return isHmrUpdating;
+ } finally {
+ isHmrUpdating = v;
+ }
+};
const hmrDirtyComponents = /* @__PURE__ */ new Map();
{
getGlobalThis().__VUE_HMR_RUNTIME__ = {
@@ -2984,7 +3015,181 @@
}
}
-const TeleportEndKey = Symbol("_vte");
+function provide(key, value) {
+ {
+ if (!currentInstance || currentInstance.isMounted) {
+ warn$1(`provide() can only be used inside setup().`);
+ }
+ }
+ if (currentInstance) {
+ let provides = currentInstance.provides;
+ const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+ if (parentProvides === provides) {
+ provides = currentInstance.provides = Object.create(parentProvides);
+ }
+ provides[key] = value;
+ }
+}
+function inject(key, defaultValue, treatDefaultAsFactory = false) {
+ const instance = getCurrentInstance();
+ if (instance || currentApp) {
+ let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+ if (provides && key in provides) {
+ return provides[key];
+ } else if (arguments.length > 1) {
+ return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+ } else {
+ warn$1(`injection "${String(key)}" not found.`);
+ }
+ } else {
+ warn$1(`inject() can only be used inside setup() or functional components.`);
+ }
+}
+function hasInjectionContext() {
+ return !!(getCurrentInstance() || currentApp);
+}
+
+const ssrContextKey = /* @__PURE__ */ Symbol.for("v-scx");
+const useSSRContext = () => {
+ {
+ const ctx = inject(ssrContextKey);
+ if (!ctx) {
+ warn$1(
+ `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
+ );
+ }
+ return ctx;
+ }
+};
+
+function watchEffect(effect, options) {
+ return doWatch(effect, null, options);
+}
+function watchPostEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ extend({}, options, { flush: "post" })
+ );
+}
+function watchSyncEffect(effect, options) {
+ return doWatch(
+ effect,
+ null,
+ extend({}, options, { flush: "sync" })
+ );
+}
+function watch(source, cb, options) {
+ if (!isFunction(cb)) {
+ warn$1(
+ `\`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(source, cb, options);
+}
+function doWatch(source, cb, options = EMPTY_OBJ) {
+ const { immediate, deep, flush, once } = options;
+ if (!cb) {
+ if (immediate !== void 0) {
+ warn$1(
+ `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ if (deep !== void 0) {
+ warn$1(
+ `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ if (once !== void 0) {
+ warn$1(
+ `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
+ );
+ }
+ }
+ const baseWatchOptions = extend({}, options);
+ baseWatchOptions.onWarn = warn$1;
+ const runsImmediately = cb && immediate || !cb && flush !== "post";
+ let ssrCleanup;
+ if (isInSSRComponentSetup) {
+ if (flush === "sync") {
+ const ctx = useSSRContext();
+ ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+ } else if (!runsImmediately) {
+ const watchStopHandle = () => {
+ };
+ watchStopHandle.stop = NOOP;
+ watchStopHandle.resume = NOOP;
+ watchStopHandle.pause = NOOP;
+ return watchStopHandle;
+ }
+ }
+ const instance = currentInstance;
+ baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+ let isPre = false;
+ if (flush === "post") {
+ baseWatchOptions.scheduler = (job) => {
+ queuePostRenderEffect(job, instance && instance.suspense);
+ };
+ } else if (flush !== "sync") {
+ isPre = true;
+ baseWatchOptions.scheduler = (job, isFirstRun) => {
+ if (isFirstRun) {
+ job();
+ } else {
+ queueJob(job);
+ }
+ };
+ }
+ baseWatchOptions.augmentJob = (job) => {
+ if (cb) {
+ job.flags |= 4;
+ }
+ if (isPre) {
+ job.flags |= 2;
+ if (instance) {
+ job.id = instance.uid;
+ job.i = instance;
+ }
+ }
+ };
+ const watchHandle = watch$1(source, cb, baseWatchOptions);
+ if (isInSSRComponentSetup) {
+ if (ssrCleanup) {
+ ssrCleanup.push(watchHandle);
+ } else if (runsImmediately) {
+ watchHandle();
+ }
+ }
+ return watchHandle;
+}
+function instanceWatch(source, value, options) {
+ const publicThis = this.proxy;
+ const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+ let cb;
+ if (isFunction(value)) {
+ cb = value;
+ } else {
+ cb = value.handler;
+ options = value;
+ }
+ const reset = setCurrentInstance(this);
+ const res = doWatch(getter, cb.bind(publicThis), options);
+ reset();
+ return res;
+}
+function createPathGetter(ctx, path) {
+ const segments = path.split(".");
+ return () => {
+ let cur = ctx;
+ for (let i = 0; i < segments.length && cur; i++) {
+ cur = cur[segments[i]];
+ }
+ return cur;
+ };
+}
+
+const pendingMounts = /* @__PURE__ */ new WeakMap();
+const TeleportEndKey = /* @__PURE__ */ Symbol("_vte");
const isTeleport = (type) => type.__isTeleport;
const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
@@ -3025,88 +3230,84 @@
o: { insert, querySelector, createText, createComment }
} = internals;
const disabled = isTeleportDisabled(n2.props);
- let { shapeFlag, children, dynamicChildren } = n2;
+ let { dynamicChildren } = n2;
if (isHmrUpdating) {
optimized = false;
dynamicChildren = null;
}
+ const mount = (vnode, container2, anchor2) => {
+ if (vnode.shapeFlag & 16) {
+ mountChildren(
+ vnode.children,
+ container2,
+ anchor2,
+ parentComponent,
+ parentSuspense,
+ namespace,
+ slotScopeIds,
+ optimized
+ );
+ }
+ };
+ const mountToTarget = (vnode = n2) => {
+ const disabled2 = isTeleportDisabled(vnode.props);
+ const target = vnode.target = resolveTarget(vnode.props, querySelector);
+ const targetAnchor = prepareAnchor(target, vnode, createText, insert);
+ if (target) {
+ if (namespace !== "svg" && isTargetSVG(target)) {
+ namespace = "svg";
+ } else if (namespace !== "mathml" && isTargetMathML(target)) {
+ namespace = "mathml";
+ }
+ if (parentComponent && parentComponent.isCE) {
+ (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
+ }
+ if (!disabled2) {
+ mount(vnode, target, targetAnchor);
+ updateCssVars(vnode, false);
+ }
+ } else if (!disabled2) {
+ warn$1("Invalid Teleport target on mount:", target, `(${typeof target})`);
+ }
+ };
+ const queuePendingMount = (vnode) => {
+ const mountJob = () => {
+ if (pendingMounts.get(vnode) !== mountJob) return;
+ pendingMounts.delete(vnode);
+ if (isTeleportDisabled(vnode.props)) {
+ mount(vnode, container, vnode.anchor);
+ updateCssVars(vnode, true);
+ }
+ mountToTarget(vnode);
+ };
+ pendingMounts.set(vnode, mountJob);
+ queuePostRenderEffect(mountJob, parentSuspense);
+ };
if (n1 == null) {
const placeholder = n2.el = createComment("teleport start") ;
const mainAnchor = n2.anchor = createComment("teleport end") ;
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
- const mount = (container2, anchor2) => {
- if (shapeFlag & 16) {
- mountChildren(
- children,
- container2,
- anchor2,
- parentComponent,
- parentSuspense,
- namespace,
- slotScopeIds,
- optimized
- );
- }
- };
- const mountToTarget = () => {
- const target = n2.target = resolveTarget(n2.props, querySelector);
- const targetAnchor = prepareAnchor(target, n2, createText, insert);
- if (target) {
- if (namespace !== "svg" && isTargetSVG(target)) {
- namespace = "svg";
- } else if (namespace !== "mathml" && isTargetMathML(target)) {
- namespace = "mathml";
- }
- if (parentComponent && parentComponent.isCE) {
- (parentComponent.ce._teleportTargets || (parentComponent.ce._teleportTargets = /* @__PURE__ */ new Set())).add(target);
- }
- if (!disabled) {
- mount(target, targetAnchor);
- updateCssVars(n2, false);
- }
- } else if (!disabled) {
- warn$1(
- "Invalid Teleport target on mount:",
- target,
- `(${typeof target})`
- );
- }
- };
- if (disabled) {
- mount(container, mainAnchor);
- updateCssVars(n2, true);
- }
- if (isTeleportDeferred(n2.props)) {
- n2.el.__isMounted = false;
- queuePostRenderEffect(() => {
- mountToTarget();
- delete n2.el.__isMounted;
- }, parentSuspense);
- } else {
- mountToTarget();
- }
- } else {
- if (isTeleportDeferred(n2.props) && n1.el.__isMounted === false) {
- queuePostRenderEffect(() => {
- TeleportImpl.process(
- n1,
- n2,
- container,
- anchor,
- parentComponent,
- parentSuspense,
- namespace,
- slotScopeIds,
- optimized,
- internals
- );
- }, parentSuspense);
+ if (isTeleportDeferred(n2.props) || parentSuspense && parentSuspense.pendingBranch) {
+ queuePendingMount(n2);
return;
}
+ if (disabled) {
+ mount(n2, container, mainAnchor);
+ updateCssVars(n2, true);
+ }
+ mountToTarget();
+ } else {
n2.el = n1.el;
- n2.targetStart = n1.targetStart;
const mainAnchor = n2.anchor = n1.anchor;
+ const pendingMount = pendingMounts.get(n1);
+ if (pendingMount) {
+ pendingMount.flags |= 8;
+ pendingMounts.delete(n1);
+ queuePendingMount(n2);
+ return;
+ }
+ n2.targetStart = n1.targetStart;
const target = n2.target = n1.target;
const targetAnchor = n2.targetAnchor = n1.targetAnchor;
const wasDisabled = isTeleportDisabled(n1.props);
@@ -3199,13 +3400,19 @@
target,
props
} = vnode;
+ let shouldRemove = doRemove || !isTeleportDisabled(props);
+ const pendingMount = pendingMounts.get(vnode);
+ if (pendingMount) {
+ pendingMount.flags |= 8;
+ pendingMounts.delete(vnode);
+ shouldRemove = false;
+ }
if (target) {
hostRemove(targetStart);
hostRemove(targetAnchor);
}
doRemove && hostRemove(anchor);
if (shapeFlag & 16) {
- const shouldRemove = doRemove || !isTeleportDisabled(props);
for (let i = 0; i < children.length; i++) {
const child = children[i];
unmount(
@@ -3249,7 +3456,22 @@
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
o: { nextSibling, parentNode, querySelector, insert, createText }
}, hydrateChildren) {
- function hydrateDisabledTeleport(node2, vnode2, targetStart, targetAnchor) {
+ function hydrateAnchor(target2, targetNode) {
+ let targetAnchor = targetNode;
+ while (targetAnchor) {
+ if (targetAnchor && targetAnchor.nodeType === 8) {
+ if (targetAnchor.data === "teleport start anchor") {
+ vnode.targetStart = targetAnchor;
+ } else if (targetAnchor.data === "teleport anchor") {
+ vnode.targetAnchor = targetAnchor;
+ target2._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+ break;
+ }
+ }
+ targetAnchor = nextSibling(targetAnchor);
+ }
+ }
+ function hydrateDisabledTeleport(node2, vnode2) {
vnode2.anchor = hydrateChildren(
nextSibling(node2),
vnode2,
@@ -3259,8 +3481,6 @@
slotScopeIds,
optimized
);
- vnode2.targetStart = targetStart;
- vnode2.targetAnchor = targetAnchor;
}
const target = vnode.target = resolveTarget(
vnode.props,
@@ -3271,27 +3491,22 @@
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16) {
if (disabled) {
- hydrateDisabledTeleport(
- node,
- vnode,
- targetNode,
- targetNode && nextSibling(targetNode)
- );
+ hydrateDisabledTeleport(node, vnode);
+ hydrateAnchor(target, targetNode);
+ if (!vnode.targetAnchor) {
+ prepareAnchor(
+ target,
+ vnode,
+ createText,
+ insert,
+ // if target is the same as the main view, insert anchors before current node
+ // to avoid hydrating mismatch
+ parentNode(node) === target ? node : null
+ );
+ }
} else {
vnode.anchor = nextSibling(node);
- let targetAnchor = targetNode;
- while (targetAnchor) {
- if (targetAnchor && targetAnchor.nodeType === 8) {
- if (targetAnchor.data === "teleport start anchor") {
- vnode.targetStart = targetAnchor;
- } else if (targetAnchor.data === "teleport anchor") {
- vnode.targetAnchor = targetAnchor;
- target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
- break;
- }
- }
- targetAnchor = nextSibling(targetAnchor);
- }
+ hydrateAnchor(target, targetNode);
if (!vnode.targetAnchor) {
prepareAnchor(target, vnode, createText, insert);
}
@@ -3309,7 +3524,9 @@
updateCssVars(vnode, disabled);
} else if (disabled) {
if (vnode.shapeFlag & 16) {
- hydrateDisabledTeleport(node, vnode, node, nextSibling(node));
+ hydrateDisabledTeleport(node, vnode);
+ vnode.targetStart = node;
+ vnode.targetAnchor = nextSibling(node);
}
}
return vnode.anchor && nextSibling(vnode.anchor);
@@ -3333,19 +3550,19 @@
ctx.ut();
}
}
-function prepareAnchor(target, vnode, createText, insert) {
+function prepareAnchor(target, vnode, createText, insert, anchor = null) {
const targetStart = vnode.targetStart = createText("");
const targetAnchor = vnode.targetAnchor = createText("");
targetStart[TeleportEndKey] = targetAnchor;
if (target) {
- insert(targetStart, target);
- insert(targetAnchor, target);
+ insert(targetStart, target, anchor);
+ insert(targetAnchor, target, anchor);
}
return targetAnchor;
}
-const leaveCbKey = Symbol("_leaveCb");
-const enterCbKey$1 = Symbol("_enterCb");
+const leaveCbKey = /* @__PURE__ */ Symbol("_leaveCb");
+const enterCbKey$1 = /* @__PURE__ */ Symbol("_enterCb");
function useTransitionState() {
const state = {
isMounted: false,
@@ -3561,6 +3778,7 @@
callHook(hook, [el]);
},
enter(el) {
+ if (!isHmrUpdating && leavingVNodesCache[key] === vnode) return;
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
@@ -3574,7 +3792,7 @@
}
}
let called = false;
- const done = el[enterCbKey$1] = (cancelled) => {
+ el[enterCbKey$1] = (cancelled) => {
if (called) return;
called = true;
if (cancelled) {
@@ -3587,6 +3805,7 @@
}
el[enterCbKey$1] = void 0;
};
+ const done = el[enterCbKey$1].bind(null, false);
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
@@ -3606,7 +3825,7 @@
}
callHook(onBeforeLeave, [el]);
let called = false;
- const done = el[leaveCbKey] = (cancelled) => {
+ el[leaveCbKey] = (cancelled) => {
if (called) return;
called = true;
remove();
@@ -3620,6 +3839,7 @@
delete leavingVNodesCache[key2];
}
};
+ const done = el[leaveCbKey].bind(null, false);
leavingVNodesCache[key2] = vnode;
if (onLeave) {
callAsyncHook(onLeave, [el, done]);
@@ -3732,8 +3952,7 @@
const r = shallowRef(null);
if (i) {
const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
- let desc;
- if ((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable) {
+ if (isTemplateRefKey(refs, key)) {
warn$1(`useTemplateRef('${key}') already exists.`);
} else {
Object.defineProperty(refs, key, {
@@ -3752,6 +3971,10 @@
knownTemplateRefs.add(ret);
}
return ret;
+}
+function isTemplateRefKey(refs, key) {
+ let desc;
+ return !!((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable);
}
const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
@@ -3798,10 +4021,19 @@
return false;
}
}
+ if (isTemplateRefKey(refs, key)) {
+ return false;
+ }
return hasOwn(rawSetupState, key);
};
- const canSetRef = (ref2) => {
- return !knownTemplateRefs.has(ref2);
+ const canSetRef = (ref2, key) => {
+ if (knownTemplateRefs.has(ref2)) {
+ return false;
+ }
+ if (key && isTemplateRefKey(refs, key)) {
+ return false;
+ }
+ return true;
};
if (oldRef != null && oldRef !== ref) {
invalidatePendingSetRef(oldRawRef);
@@ -3811,10 +4043,10 @@
setupState[oldRef] = null;
}
} else if (isRef(oldRef)) {
- if (canSetRef(oldRef)) {
+ const oldRawRefAtom = oldRawRef;
+ if (canSetRef(oldRef, oldRawRefAtom.k)) {
oldRef.value = null;
}
- const oldRawRefAtom = oldRawRef;
if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
}
}
@@ -3838,7 +4070,7 @@
}
} else {
const newVal = [refValue];
- if (canSetRef(ref)) {
+ if (canSetRef(ref, rawRef.k)) {
ref.value = newVal;
}
if (rawRef.k) refs[rawRef.k] = newVal;
@@ -3853,7 +4085,7 @@
setupState[ref] = value;
}
} else if (_isRef) {
- if (canSetRef(ref)) {
+ if (canSetRef(ref, rawRef.k)) {
ref.value = value;
}
if (rawRef.k) refs[rawRef.k] = value;
@@ -4193,7 +4425,7 @@
logMismatchError();
}
if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers
- key[0] === "." || isCustomElement) {
+ key[0] === "." || isCustomElement && !isReservedProp(key)) {
patchProp(el, key, null, props[key], void 0, parentComponent);
}
}
@@ -4882,7 +5114,9 @@
}
function pruneCache(filter) {
cache.forEach((vnode, key) => {
- const name = getComponentName(vnode.type);
+ const name = getComponentName(
+ isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : vnode.type
+ );
if (name && !filter(name)) {
pruneCacheEntry(key);
}
@@ -5109,7 +5343,7 @@
function resolveComponent(name, maybeSelfReference) {
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
}
-const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
function resolveDynamicComponent(component) {
if (isString(component)) {
return resolveAsset(COMPONENTS, component, false) || component;
@@ -5181,12 +5415,16 @@
);
}
} else if (typeof source === "number") {
- if (!Number.isInteger(source)) {
- warn$1(`The v-for range expect an integer value but got ${source}.`);
- }
- ret = new Array(source);
- for (let i = 0; i < source; i++) {
- ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+ if (!Number.isInteger(source) || source < 0) {
+ warn$1(
+ `The v-for range expects a positive integer value but got ${source}.`
+ );
+ ret = [];
+ } else {
+ ret = new Array(source);
+ for (let i = 0; i < source; i++) {
+ ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+ }
}
} else if (isObject(source)) {
if (source[Symbol.iterator]) {
@@ -5637,6 +5875,7 @@
}
function withAsyncContext(getAwaitable) {
const ctx = getCurrentInstance();
+ const inSSRSetup = isInSSRComponentSetup;
if (!ctx) {
warn$1(
`withAsyncContext called without active current instance. This is likely a bug.`
@@ -5644,13 +5883,36 @@
}
let awaitable = getAwaitable();
unsetCurrentInstance();
+ if (inSSRSetup) {
+ setInSSRSetupState(false);
+ }
+ const restore = () => {
+ setCurrentInstance(ctx);
+ if (inSSRSetup) {
+ setInSSRSetupState(true);
+ }
+ };
+ const cleanup = () => {
+ if (getCurrentInstance() !== ctx) ctx.scope.off();
+ unsetCurrentInstance();
+ if (inSSRSetup) {
+ setInSSRSetupState(false);
+ }
+ };
if (isPromise(awaitable)) {
awaitable = awaitable.catch((e) => {
- setCurrentInstance(ctx);
+ restore();
+ Promise.resolve().then(() => Promise.resolve().then(cleanup));
throw e;
});
}
- return [awaitable, () => setCurrentInstance(ctx)];
+ return [
+ awaitable,
+ () => {
+ restore();
+ Promise.resolve().then(cleanup);
+ }
+ ];
}
function createDuplicateChecker() {
@@ -6273,179 +6535,6 @@
}
let currentApp = null;
-function provide(key, value) {
- {
- if (!currentInstance || currentInstance.isMounted) {
- warn$1(`provide() can only be used inside setup().`);
- }
- }
- if (currentInstance) {
- let provides = currentInstance.provides;
- const parentProvides = currentInstance.parent && currentInstance.parent.provides;
- if (parentProvides === provides) {
- provides = currentInstance.provides = Object.create(parentProvides);
- }
- provides[key] = value;
- }
-}
-function inject(key, defaultValue, treatDefaultAsFactory = false) {
- const instance = getCurrentInstance();
- if (instance || currentApp) {
- let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
- if (provides && key in provides) {
- return provides[key];
- } else if (arguments.length > 1) {
- return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
- } else {
- warn$1(`injection "${String(key)}" not found.`);
- }
- } else {
- warn$1(`inject() can only be used inside setup() or functional components.`);
- }
-}
-function hasInjectionContext() {
- return !!(getCurrentInstance() || currentApp);
-}
-
-const ssrContextKey = Symbol.for("v-scx");
-const useSSRContext = () => {
- {
- const ctx = inject(ssrContextKey);
- if (!ctx) {
- warn$1(
- `Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
- );
- }
- return ctx;
- }
-};
-
-function watchEffect(effect, options) {
- return doWatch(effect, null, options);
-}
-function watchPostEffect(effect, options) {
- return doWatch(
- effect,
- null,
- extend({}, options, { flush: "post" })
- );
-}
-function watchSyncEffect(effect, options) {
- return doWatch(
- effect,
- null,
- extend({}, options, { flush: "sync" })
- );
-}
-function watch(source, cb, options) {
- if (!isFunction(cb)) {
- warn$1(
- `\`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(source, cb, options);
-}
-function doWatch(source, cb, options = EMPTY_OBJ) {
- const { immediate, deep, flush, once } = options;
- if (!cb) {
- if (immediate !== void 0) {
- warn$1(
- `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
- );
- }
- if (deep !== void 0) {
- warn$1(
- `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
- );
- }
- if (once !== void 0) {
- warn$1(
- `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
- );
- }
- }
- const baseWatchOptions = extend({}, options);
- baseWatchOptions.onWarn = warn$1;
- const runsImmediately = cb && immediate || !cb && flush !== "post";
- let ssrCleanup;
- if (isInSSRComponentSetup) {
- if (flush === "sync") {
- const ctx = useSSRContext();
- ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
- } else if (!runsImmediately) {
- const watchStopHandle = () => {
- };
- watchStopHandle.stop = NOOP;
- watchStopHandle.resume = NOOP;
- watchStopHandle.pause = NOOP;
- return watchStopHandle;
- }
- }
- const instance = currentInstance;
- baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
- let isPre = false;
- if (flush === "post") {
- baseWatchOptions.scheduler = (job) => {
- queuePostRenderEffect(job, instance && instance.suspense);
- };
- } else if (flush !== "sync") {
- isPre = true;
- baseWatchOptions.scheduler = (job, isFirstRun) => {
- if (isFirstRun) {
- job();
- } else {
- queueJob(job);
- }
- };
- }
- baseWatchOptions.augmentJob = (job) => {
- if (cb) {
- job.flags |= 4;
- }
- if (isPre) {
- job.flags |= 2;
- if (instance) {
- job.id = instance.uid;
- job.i = instance;
- }
- }
- };
- const watchHandle = watch$1(source, cb, baseWatchOptions);
- if (isInSSRComponentSetup) {
- if (ssrCleanup) {
- ssrCleanup.push(watchHandle);
- } else if (runsImmediately) {
- watchHandle();
- }
- }
- return watchHandle;
-}
-function instanceWatch(source, value, options) {
- const publicThis = this.proxy;
- const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
- let cb;
- if (isFunction(value)) {
- cb = value;
- } else {
- cb = value.handler;
- options = value;
- }
- const reset = setCurrentInstance(this);
- const res = doWatch(getter, cb.bind(publicThis), options);
- reset();
- return res;
-}
-function createPathGetter(ctx, path) {
- const segments = path.split(".");
- return () => {
- let cur = ctx;
- for (let i = 0; i < segments.length && cur; i++) {
- cur = cur[segments[i]];
- }
- return cur;
- };
-}
-
function useModel(props, name, options = EMPTY_OBJ) {
const i = getCurrentInstance();
if (!i) {
@@ -6888,7 +6977,7 @@
const dynamicProps = nextVNode.dynamicProps;
for (let i = 0; i < dynamicProps.length; i++) {
const key = dynamicProps[i];
- if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
+ if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emits, key)) {
return true;
}
}
@@ -6919,17 +7008,26 @@
}
for (let i = 0; i < nextKeys.length; i++) {
const key = nextKeys[i];
- if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
+ if (hasPropValueChanged(nextProps, prevProps, key) && !isEmitListener(emitsOptions, key)) {
return true;
}
}
return false;
}
-function updateHOCHostEl({ vnode, parent }, el) {
+function hasPropValueChanged(nextProps, prevProps, key) {
+ const nextProp = nextProps[key];
+ const prevProp = prevProps[key];
+ if (key === "style" && isObject(nextProp) && isObject(prevProp)) {
+ return !looseEqual(nextProp, prevProp);
+ }
+ return nextProp !== prevProp;
+}
+function updateHOCHostEl({ vnode, parent, suspense }, el) {
while (parent) {
const root = parent.subTree;
if (root.suspense && root.suspense.activeBranch === vnode) {
- root.el = vnode.el;
+ root.suspense.vnode.el = root.el = el;
+ vnode = root;
}
if (root === vnode) {
(vnode = parent.vnode).el = el;
@@ -6937,6 +7035,9 @@
} else {
break;
}
+ }
+ if (suspense && suspense.activeBranch === vnode) {
+ suspense.vnode.el = el;
}
}
@@ -7704,7 +7805,7 @@
optimized
);
} else {
- const customElement = !!(n1.el && n1.el._isVueCE) ? n1.el : null;
+ const customElement = n1.el && n1.el._isVueCE ? n1.el : null;
try {
if (customElement) {
customElement._beginPatch();
@@ -7779,10 +7880,17 @@
}
hostInsert(el, container, anchor);
if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+ const isHmr = isHmrUpdating;
queuePostRenderEffect(() => {
- vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
- needCallTransitionHooks && transition.enter(el);
- dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ let prev;
+ prev = setHmrUpdating(isHmr);
+ try {
+ vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+ needCallTransitionHooks && transition.enter(el);
+ dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+ } finally {
+ setHmrUpdating(prev);
+ }
}, parentSuspense);
}
};
@@ -8014,7 +8122,7 @@
} else {
if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
// of renderSlot() with no valid children
- n1.dynamicChildren) {
+ n1.dynamicChildren && n1.dynamicChildren.length === dynamicChildren.length) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
@@ -8186,9 +8294,11 @@
hydrateSubTree();
}
} else {
- if (root.ce && // @ts-expect-error _def is private
- root.ce._def.shadowRoot !== false) {
- root.ce._injectChildStyle(type);
+ if (root.ce && root.ce._hasShadowRoot()) {
+ root.ce._injectChildStyle(
+ type,
+ instance.parent ? instance.parent.type : void 0
+ );
}
{
startMeasure(instance, `render`);
@@ -8242,9 +8352,9 @@
updateComponentPreRender(instance, next, optimized);
}
nonHydratedAsyncRoot.asyncDep.then(() => {
- if (!instance.isUnmounted) {
- componentUpdateFn();
- }
+ queuePostRenderEffect(() => {
+ if (!instance.isUnmounted) update();
+ }, parentSuspense);
});
return;
}
@@ -8603,8 +8713,8 @@
const nextChild = c2[nextIndex];
const anchorVNode = c2[nextIndex + 1];
const anchor = nextIndex + 1 < l2 ? (
- // #13559, fallback to el placeholder for unresolved async component
- anchorVNode.el || anchorVNode.placeholder
+ // #13559, #14173 fallback to el placeholder for unresolved async component
+ anchorVNode.el || resolveAsyncComponentPlaceholder(anchorVNode)
) : parentAnchor;
if (newIndexToOldIndexMap[i] === 0) {
patch(
@@ -8701,7 +8811,8 @@
shapeFlag,
patchFlag,
dirs,
- cacheIndex
+ cacheIndex,
+ memo
} = vnode;
if (patchFlag === -2) {
optimized = false;
@@ -8763,10 +8874,14 @@
remove(vnode);
}
}
- if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
+ const shouldInvalidateMemo = memo != null && cacheIndex == null;
+ if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs || shouldInvalidateMemo) {
queuePostRenderEffect(() => {
vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+ if (shouldInvalidateMemo) {
+ vnode.el = null;
+ }
}, parentSuspense);
}
};
@@ -8860,9 +8975,11 @@
};
let isFlushing = false;
const render = (vnode, container, namespace) => {
+ let instance;
if (vnode == null) {
if (container._vnode) {
unmount(container._vnode, null, null, true);
+ instance = container._vnode.component;
}
} else {
patch(
@@ -8878,7 +8995,7 @@
container._vnode = vnode;
if (!isFlushing) {
isFlushing = true;
- flushPreFlushCbs();
+ flushPreFlushCbs(instance);
flushPostFlushCbs();
isFlushing = false;
}
@@ -8938,8 +9055,10 @@
if (!shallow && c2.patchFlag !== -2)
traverseStaticChildren(c1, c2);
}
- if (c2.type === Text && // avoid cached text nodes retaining detached dom nodes
- c2.patchFlag !== -1) {
+ if (c2.type === Text) {
+ if (c2.patchFlag === -1) {
+ c2 = ch2[i] = cloneIfMounted(c2);
+ }
c2.el = c1.el;
}
if (c2.type === Comment && !c2.el) {
@@ -9006,6 +9125,16 @@
for (let i = 0; i < hooks.length; i++)
hooks[i].flags |= 8;
}
+}
+function resolveAsyncComponentPlaceholder(anchorVnode) {
+ if (anchorVnode.placeholder) {
+ return anchorVnode.placeholder;
+ }
+ const instance = anchorVnode.component;
+ if (instance) {
+ return resolveAsyncComponentPlaceholder(instance.subTree);
+ }
+ return null;
}
const isSuspense = (type) => type.__isSuspense;
@@ -9306,6 +9435,7 @@
pendingId: suspenseId++,
timeout: typeof timeout === "number" ? timeout : -1,
activeBranch: null,
+ isFallbackMountPending: false,
pendingBranch: null,
isInFallback: !isHydrating,
isHydrating,
@@ -9355,7 +9485,7 @@
}
};
}
- if (activeBranch) {
+ if (activeBranch && !suspense.isFallbackMountPending) {
if (parentNode(activeBranch.el) === container2) {
anchor = next(activeBranch);
}
@@ -9368,6 +9498,7 @@
move(pendingBranch, container2, anchor, 0);
}
}
+ suspense.isFallbackMountPending = false;
setActiveBranch(suspense, pendingBranch);
suspense.pendingBranch = null;
suspense.isInFallback = false;
@@ -9403,6 +9534,7 @@
triggerEvent(vnode2, "onFallback");
const anchor2 = next(activeBranch);
const mountFallback = () => {
+ suspense.isFallbackMountPending = false;
if (!suspense.isInFallback) {
return;
}
@@ -9422,6 +9554,7 @@
};
const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
if (delayEnter) {
+ suspense.isFallbackMountPending = true;
activeBranch.transition.afterLeave = mountFallback;
}
suspense.isInFallback = true;
@@ -9456,6 +9589,7 @@
if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
return;
}
+ unsetCurrentInstance();
instance.asyncResolved = true;
const { vnode: vnode2 } = instance;
{
@@ -9609,10 +9743,10 @@
return suspensible != null && suspensible !== false;
}
-const Fragment = Symbol.for("v-fgt");
-const Text = Symbol.for("v-txt");
-const Comment = Symbol.for("v-cmt");
-const Static = Symbol.for("v-stc");
+const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
+const Text = /* @__PURE__ */ Symbol.for("v-txt");
+const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
+const Static = /* @__PURE__ */ Symbol.for("v-stc");
const blockStack = [];
let currentBlock = null;
function openBlock(disableTracking = false) {
@@ -9972,6 +10106,10 @@
const incoming = toMerge[key];
if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
ret[key] = existing ? [].concat(existing, incoming) : incoming;
+ } else if (incoming == null && existing == null && // mergeProps({ 'onUpdate:modelValue': undefined }) should not retain
+ // the model listener.
+ !isModelListener(key)) {
+ ret[key] = incoming;
}
} else if (key !== "") {
ret[key] = toMerge[key];
@@ -10656,7 +10794,7 @@
return true;
}
-const version = "3.5.25";
+const version = "3.5.32";
const warn = warn$1 ;
const ErrorTypeStrings = ErrorTypeStrings$1 ;
const devtools = devtools$1 ;
@@ -10761,7 +10899,7 @@
const TRANSITION = "transition";
const ANIMATION = "animation";
-const vtcKey = Symbol("_vtc");
+const vtcKey = /* @__PURE__ */ Symbol("_vtc");
const DOMTransitionPropsValidators = {
name: String,
type: String,
@@ -11054,8 +11192,8 @@
}
}
-const vShowOriginalDisplay = Symbol("_vod");
-const vShowHidden = Symbol("_vsh");
+const vShowOriginalDisplay = /* @__PURE__ */ Symbol("_vod");
+const vShowHidden = /* @__PURE__ */ Symbol("_vsh");
const vShow = {
// used for prop mismatch check during hydration
name: "show",
@@ -11104,7 +11242,7 @@
};
}
-const CSS_VAR_TEXT = Symbol("CSS_VAR_TEXT" );
+const CSS_VAR_TEXT = /* @__PURE__ */ Symbol("CSS_VAR_TEXT" );
function useCssVars(getter) {
const instance = getCurrentInstance();
if (!instance) {
@@ -11354,7 +11492,7 @@
function removeEventListener(el, event, handler, options) {
el.removeEventListener(event, handler, options);
}
-const veiKey = Symbol("_vei");
+const veiKey = /* @__PURE__ */ Symbol("_vei");
function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
const invokers = el[veiKey] || (el[veiKey] = {});
const existingInvoker = invokers[rawName];
@@ -11453,7 +11591,9 @@
}
} else if (
// #11081 force set props for possible async custom element
- el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))
+ el._isVueCE && // #12408 check if it's declared prop or it's async custom element
+ (shouldSetAsPropForVueCE(el, key) || // @ts-expect-error _def is private
+ el._def.__asyncLoader && (/[A-Z]/.test(key) || !isString(nextValue)))
) {
patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
} else {
@@ -11501,6 +11641,17 @@
}
return key in el;
}
+function shouldSetAsPropForVueCE(el, key) {
+ const props = (
+ // @ts-expect-error _def is private
+ el._def.props
+ );
+ if (!props) {
+ return false;
+ }
+ const camelKey = camelize(key);
+ return Array.isArray(props) ? props.some((prop) => camelize(prop) === camelKey) : Object.keys(props).some((prop) => camelize(prop) === camelKey);
+}
const REMOVAL = {};
// @__NO_SIDE_EFFECTS__
@@ -11545,6 +11696,7 @@
this._dirty = false;
this._numberProps = null;
this._styleChildren = /* @__PURE__ */ new WeakSet();
+ this._styleAnchors = /* @__PURE__ */ new WeakMap();
this._ob = null;
if (this.shadowRoot && _createApp !== createApp) {
this._root = this.shadowRoot;
@@ -11573,7 +11725,8 @@
}
this._connected = true;
let parent = this;
- while (parent = parent && (parent.parentNode || parent.host)) {
+ while (parent = parent && // #12479 should check assignedSlot first to get correct parent
+ (parent.assignedSlot || parent.parentNode || parent.host)) {
if (parent instanceof VueElement) {
this._parent = parent;
break;
@@ -11795,6 +11948,7 @@
this._styles.forEach((s) => this._root.removeChild(s));
this._styles.length = 0;
}
+ this._styleAnchors.delete(this._def);
this._applyStyles(newStyles);
this._instance = null;
this._update();
@@ -11819,7 +11973,7 @@
}
return vnode;
}
- _applyStyles(styles, owner) {
+ _applyStyles(styles, owner, parentComp) {
if (!styles) return;
if (owner) {
if (owner === this._def || this._styleChildren.has(owner)) {
@@ -11828,11 +11982,19 @@
this._styleChildren.add(owner);
}
const nonce = this._nonce;
+ const root = this.shadowRoot;
+ const insertionAnchor = parentComp ? this._getStyleAnchor(parentComp) || this._getStyleAnchor(this._def) : this._getRootStyleInsertionAnchor(root);
+ let last = null;
for (let i = styles.length - 1; i >= 0; i--) {
const s = document.createElement("style");
if (nonce) s.setAttribute("nonce", nonce);
s.textContent = styles[i];
- this.shadowRoot.prepend(s);
+ root.insertBefore(s, last || insertionAnchor);
+ last = s;
+ if (i === 0) {
+ if (!parentComp) this._styleAnchors.set(this._def, s);
+ if (owner) this._styleAnchors.set(owner, s);
+ }
{
if (owner) {
if (owner.__hmrId) {
@@ -11848,6 +12010,28 @@
}
}
}
+ }
+ _getStyleAnchor(comp) {
+ if (!comp) {
+ return null;
+ }
+ const anchor = this._styleAnchors.get(comp);
+ if (anchor && anchor.parentNode === this.shadowRoot) {
+ return anchor;
+ }
+ if (anchor) {
+ this._styleAnchors.delete(comp);
+ }
+ return null;
+ }
+ _getRootStyleInsertionAnchor(root) {
+ for (let i = 0; i < root.childNodes.length; i++) {
+ const node = root.childNodes[i];
+ if (!(node instanceof HTMLStyleElement)) {
+ return node;
+ }
+ }
+ return null;
}
/**
* Only called when shadowRoot is false
@@ -11911,8 +12095,8 @@
/**
* @internal
*/
- _injectChildStyle(comp) {
- this._applyStyles(comp.styles, comp);
+ _injectChildStyle(comp, parentComp) {
+ this._applyStyles(comp.styles, comp, parentComp);
}
/**
* @internal
@@ -11933,9 +12117,16 @@
/**
* @internal
*/
+ _hasShadowRoot() {
+ return this._def.shadowRoot !== false;
+ }
+ /**
+ * @internal
+ */
_removeChildStyle(comp) {
{
this._styleChildren.delete(comp);
+ this._styleAnchors.delete(comp);
if (this._childStyles && comp.__hmrId) {
const oldStyles = this._childStyles.get(comp.__hmrId);
if (oldStyles) {
@@ -11992,8 +12183,8 @@
const positionMap = /* @__PURE__ */ new WeakMap();
const newPositionMap = /* @__PURE__ */ new WeakMap();
-const moveCbKey = Symbol("_moveCb");
-const enterCbKey = Symbol("_enterCb");
+const moveCbKey = /* @__PURE__ */ Symbol("_moveCb");
+const enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
const decorate = (t) => {
delete t.props.mode;
return t;
@@ -12064,10 +12255,7 @@
instance
)
);
- positionMap.set(child, {
- left: child.el.offsetLeft,
- top: child.el.offsetTop
- });
+ positionMap.set(child, getPosition(child.el));
}
}
}
@@ -12098,10 +12286,7 @@
}
}
function recordPosition(c) {
- newPositionMap.set(c, {
- left: c.el.offsetLeft,
- top: c.el.offsetTop
- });
+ newPositionMap.set(c, getPosition(c.el));
}
function applyTranslation(c) {
const oldPos = positionMap.get(c);
@@ -12109,11 +12294,28 @@
const dx = oldPos.left - newPos.left;
const dy = oldPos.top - newPos.top;
if (dx || dy) {
- const s = c.el.style;
- s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+ const el = c.el;
+ const s = el.style;
+ const rect = el.getBoundingClientRect();
+ let scaleX = 1;
+ let scaleY = 1;
+ if (el.offsetWidth) scaleX = rect.width / el.offsetWidth;
+ if (el.offsetHeight) scaleY = rect.height / el.offsetHeight;
+ if (!Number.isFinite(scaleX) || scaleX === 0) scaleX = 1;
+ if (!Number.isFinite(scaleY) || scaleY === 0) scaleY = 1;
+ if (Math.abs(scaleX - 1) < 0.01) scaleX = 1;
+ if (Math.abs(scaleY - 1) < 0.01) scaleY = 1;
+ s.transform = s.webkitTransform = `translate(${dx / scaleX}px,${dy / scaleY}px)`;
s.transitionDuration = "0s";
return c;
}
+}
+function getPosition(el) {
+ const rect = el.getBoundingClientRect();
+ return {
+ left: rect.left,
+ top: rect.top
+ };
}
function hasCSSTransform(el, root, moveClass) {
const clone = el.cloneNode();
@@ -12146,7 +12348,7 @@
target.dispatchEvent(new Event("input"));
}
}
-const assignKey = Symbol("_assign");
+const assignKey = /* @__PURE__ */ Symbol("_assign");
function castValue(value, trim, number) {
if (trim) value = value.trim();
if (number) value = looseToNumber(value);
@@ -12183,7 +12385,8 @@
if (elValue === newValue) {
return;
}
- if (document.activeElement === el && el.type !== "range") {
+ const rootNode = el.getRootNode();
+ if ((rootNode instanceof Document || rootNode instanceof ShadowRoot) && rootNode.activeElement === el && el.type !== "range") {
if (lazy && value === oldValue) {
return;
}
@@ -12425,6 +12628,7 @@
exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
};
const withModifiers = (fn, modifiers) => {
+ if (!fn) return fn;
const cache = fn._withMods || (fn._withMods = {});
const cacheKey = modifiers.join(".");
return cache[cacheKey] || (cache[cacheKey] = ((event, ...args) => {
--
Gitblit v1.9.3