@vue/runtime-core
Version:
@vue/runtime-core
1,708 lines (1,690 loc) • 200 kB
JavaScript
/**
* @vue/runtime-core v3.5.26
* (c) 2018-present Yuxi (Evan) You and Vue contributors
* @license MIT
**/
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var reactivity = require('@vue/reactivity');
var shared = require('@vue/shared');
function pushWarningContext(vnode) {
}
function popWarningContext() {
}
function assertNumber(val, type) {
return;
}
const ErrorCodes = {
"SETUP_FUNCTION": 0,
"0": "SETUP_FUNCTION",
"RENDER_FUNCTION": 1,
"1": "RENDER_FUNCTION",
"NATIVE_EVENT_HANDLER": 5,
"5": "NATIVE_EVENT_HANDLER",
"COMPONENT_EVENT_HANDLER": 6,
"6": "COMPONENT_EVENT_HANDLER",
"VNODE_HOOK": 7,
"7": "VNODE_HOOK",
"DIRECTIVE_HOOK": 8,
"8": "DIRECTIVE_HOOK",
"TRANSITION_HOOK": 9,
"9": "TRANSITION_HOOK",
"APP_ERROR_HANDLER": 10,
"10": "APP_ERROR_HANDLER",
"APP_WARN_HANDLER": 11,
"11": "APP_WARN_HANDLER",
"FUNCTION_REF": 12,
"12": "FUNCTION_REF",
"ASYNC_COMPONENT_LOADER": 13,
"13": "ASYNC_COMPONENT_LOADER",
"SCHEDULER": 14,
"14": "SCHEDULER",
"COMPONENT_UPDATE": 15,
"15": "COMPONENT_UPDATE",
"APP_UNMOUNT_CLEANUP": 16,
"16": "APP_UNMOUNT_CLEANUP"
};
const ErrorTypeStrings$1 = {
["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",
[15]: "component update",
[16]: "app unmount cleanup function"
};
function callWithErrorHandling(fn, instance, type, args) {
try {
return args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance, type);
}
}
function callWithAsyncErrorHandling(fn, instance, type, args) {
if (shared.isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args);
if (res && shared.isPromise(res)) {
res.catch((err) => {
handleError(err, instance, type);
});
}
return res;
}
if (shared.isArray(fn)) {
const values = [];
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
}
return values;
}
}
function handleError(err, instance, type, throwInDev = true) {
const contextVNode = instance ? instance.vnode : null;
const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
if (instance) {
let cur = instance.parent;
const exposedInstance = instance.proxy;
const errorInfo = `https://vuejs.org/error-reference/#runtime-${type}`;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
return;
}
}
}
cur = cur.parent;
}
if (errorHandler) {
reactivity.pauseTracking();
callWithErrorHandling(errorHandler, null, 10, [
err,
exposedInstance,
errorInfo
]);
reactivity.resetTracking();
return;
}
}
logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
}
function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
if (throwInProd) {
throw err;
} else {
console.error(err);
}
}
const queue = [];
let flushIndex = -1;
const pendingPostFlushCbs = [];
let activePostFlushCbs = null;
let postFlushIndex = 0;
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
let currentFlushPromise = null;
function nextTick(fn) {
const p = currentFlushPromise || resolvedPromise;
return fn ? p.then(this ? fn.bind(this) : fn) : p;
}
function findInsertionIndex(id) {
let start = flushIndex + 1;
let end = queue.length;
while (start < end) {
const middle = start + end >>> 1;
const middleJob = queue[middle];
const middleJobId = getId(middleJob);
if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
start = middle + 1;
} else {
end = middle;
}
}
return start;
}
function queueJob(job) {
if (!(job.flags & 1)) {
const jobId = getId(job);
const lastJob = queue[queue.length - 1];
if (!lastJob || // fast path when the job id is larger than the tail
!(job.flags & 2) && jobId >= getId(lastJob)) {
queue.push(job);
} else {
queue.splice(findInsertionIndex(jobId), 0, job);
}
job.flags |= 1;
queueFlush();
}
}
function queueFlush() {
if (!currentFlushPromise) {
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function queuePostFlushCb(cb) {
if (!shared.isArray(cb)) {
if (activePostFlushCbs && cb.id === -1) {
activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
} else if (!(cb.flags & 1)) {
pendingPostFlushCbs.push(cb);
cb.flags |= 1;
}
} else {
pendingPostFlushCbs.push(...cb);
}
queueFlush();
}
function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
for (; i < queue.length; i++) {
const cb = queue[i];
if (cb && cb.flags & 2) {
if (instance && cb.id !== instance.uid) {
continue;
}
queue.splice(i, 1);
i--;
if (cb.flags & 4) {
cb.flags &= -2;
}
cb();
if (!(cb.flags & 4)) {
cb.flags &= -2;
}
}
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)].sort(
(a, b) => getId(a) - getId(b)
);
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
const cb = activePostFlushCbs[postFlushIndex];
if (cb.flags & 4) {
cb.flags &= -2;
}
if (!(cb.flags & 8)) cb();
cb.flags &= -2;
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
function flushJobs(seen) {
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job && !(job.flags & 8)) {
if (false) ;
if (job.flags & 4) {
job.flags &= ~1;
}
callWithErrorHandling(
job,
job.i,
job.i ? 15 : 14
);
if (!(job.flags & 4)) {
job.flags &= ~1;
}
}
}
} finally {
for (; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job) {
job.flags &= -2;
}
}
flushIndex = -1;
queue.length = 0;
flushPostFlushCbs();
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs();
}
}
}
let currentRenderingInstance = null;
let currentScopeId = null;
function setCurrentRenderingInstance(instance) {
const prev = currentRenderingInstance;
currentRenderingInstance = instance;
currentScopeId = instance && instance.type.__scopeId || null;
return prev;
}
function pushScopeId(id) {
currentScopeId = id;
}
function popScopeId() {
currentScopeId = null;
}
const withScopeId = (_id) => withCtx;
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
if (!ctx) return fn;
if (fn._n) {
return fn;
}
const renderFnWithContext = (...args) => {
if (renderFnWithContext._d) {
setBlockTracking(-1);
}
const prevInstance = setCurrentRenderingInstance(ctx);
let res;
try {
res = fn(...args);
} finally {
setCurrentRenderingInstance(prevInstance);
if (renderFnWithContext._d) {
setBlockTracking(1);
}
}
return res;
};
renderFnWithContext._n = true;
renderFnWithContext._c = true;
renderFnWithContext._d = true;
return renderFnWithContext;
}
function withDirectives(vnode, directives) {
if (currentRenderingInstance === null) {
return vnode;
}
const instance = getComponentPublicInstance(currentRenderingInstance);
const bindings = vnode.dirs || (vnode.dirs = []);
for (let i = 0; i < directives.length; i++) {
let [dir, value, arg, modifiers = shared.EMPTY_OBJ] = directives[i];
if (dir) {
if (shared.isFunction(dir)) {
dir = {
mounted: dir,
updated: dir
};
}
if (dir.deep) {
reactivity.traverse(value);
}
bindings.push({
dir,
instance,
value,
oldValue: void 0,
arg,
modifiers
});
}
}
return vnode;
}
function invokeDirectiveHook(vnode, prevVNode, instance, name) {
const bindings = vnode.dirs;
const oldBindings = prevVNode && prevVNode.dirs;
for (let i = 0; i < bindings.length; i++) {
const binding = bindings[i];
if (oldBindings) {
binding.oldValue = oldBindings[i].value;
}
let hook = binding.dir[name];
if (hook) {
reactivity.pauseTracking();
callWithAsyncErrorHandling(hook, instance, 8, [
vnode.el,
binding,
vnode,
prevVNode
]);
reactivity.resetTracking();
}
}
}
function provide(key, value) {
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 && shared.isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
} else ;
}
}
function hasInjectionContext() {
return !!(getCurrentInstance() || currentApp);
}
const ssrContextKey = /* @__PURE__ */ Symbol.for("v-scx");
const useSSRContext = () => {
{
const ctx = inject(ssrContextKey);
return ctx;
}
};
function watchEffect(effect, options) {
return doWatch(effect, null, options);
}
function watchPostEffect(effect, options) {
return doWatch(
effect,
null,
{ flush: "post" }
);
}
function watchSyncEffect(effect, options) {
return doWatch(
effect,
null,
{ flush: "sync" }
);
}
function watch(source, cb, options) {
return doWatch(source, cb, options);
}
function doWatch(source, cb, options = shared.EMPTY_OBJ) {
const { immediate, deep, flush, once } = options;
const baseWatchOptions = shared.extend({}, options);
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 = shared.NOOP;
watchStopHandle.resume = shared.NOOP;
watchStopHandle.pause = shared.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 = reactivity.watch(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 = shared.isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
let cb;
if (shared.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 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 === "");
const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
const resolveTarget = (props, select) => {
const targetSelector = props && props.to;
if (shared.isString(targetSelector)) {
if (!select) {
return null;
} else {
const target = select(targetSelector);
return target;
}
} else {
return targetSelector;
}
};
const TeleportImpl = {
name: "Teleport",
__isTeleport: true,
process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
const {
mc: mountChildren,
pc: patchChildren,
pbc: patchBlockChildren,
o: { insert, querySelector, createText, createComment }
} = internals;
const disabled = isTeleportDisabled(n2.props);
let { shapeFlag, children, dynamicChildren } = n2;
if (n1 == null) {
const placeholder = n2.el = createText("");
const mainAnchor = n2.anchor = createText("");
insert(placeholder, container, anchor);
insert(mainAnchor, container, anchor);
const 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);
}
}
};
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);
return;
}
n2.el = n1.el;
n2.targetStart = n1.targetStart;
const mainAnchor = n2.anchor = n1.anchor;
const target = n2.target = n1.target;
const targetAnchor = n2.targetAnchor = n1.targetAnchor;
const wasDisabled = isTeleportDisabled(n1.props);
const currentContainer = wasDisabled ? container : target;
const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
if (namespace === "svg" || isTargetSVG(target)) {
namespace = "svg";
} else if (namespace === "mathml" || isTargetMathML(target)) {
namespace = "mathml";
}
if (dynamicChildren) {
patchBlockChildren(
n1.dynamicChildren,
dynamicChildren,
currentContainer,
parentComponent,
parentSuspense,
namespace,
slotScopeIds
);
traverseStaticChildren(n1, n2, true);
} else if (!optimized) {
patchChildren(
n1,
n2,
currentContainer,
currentAnchor,
parentComponent,
parentSuspense,
namespace,
slotScopeIds,
false
);
}
if (disabled) {
if (!wasDisabled) {
moveTeleport(
n2,
container,
mainAnchor,
internals,
1
);
} else {
if (n2.props && n1.props && n2.props.to !== n1.props.to) {
n2.props.to = n1.props.to;
}
}
} else {
if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
const nextTarget = n2.target = resolveTarget(
n2.props,
querySelector
);
if (nextTarget) {
moveTeleport(
n2,
nextTarget,
null,
internals,
0
);
}
} else if (wasDisabled) {
moveTeleport(
n2,
target,
targetAnchor,
internals,
1
);
}
}
updateCssVars(n2, disabled);
}
},
remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
const {
shapeFlag,
children,
anchor,
targetStart,
targetAnchor,
target,
props
} = vnode;
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(
child,
parentComponent,
parentSuspense,
shouldRemove,
!!child.dynamicChildren
);
}
}
},
move: moveTeleport,
hydrate: hydrateTeleport
};
function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
if (moveType === 0) {
insert(vnode.targetAnchor, container, parentAnchor);
}
const { el, anchor, shapeFlag, children, props } = vnode;
const isReorder = moveType === 2;
if (isReorder) {
insert(el, container, parentAnchor);
}
if (!isReorder || isTeleportDisabled(props)) {
if (shapeFlag & 16) {
for (let i = 0; i < children.length; i++) {
move(
children[i],
container,
parentAnchor,
2
);
}
}
}
if (isReorder) {
insert(anchor, container, parentAnchor);
}
}
function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
o: { nextSibling, parentNode, querySelector, insert, createText }
}, hydrateChildren) {
function hydrateDisabledTeleport(node2, vnode2, targetStart, targetAnchor) {
vnode2.anchor = hydrateChildren(
nextSibling(node2),
vnode2,
parentNode(node2),
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
vnode2.targetStart = targetStart;
vnode2.targetAnchor = targetAnchor;
}
const target = vnode.target = resolveTarget(
vnode.props,
querySelector
);
const disabled = isTeleportDisabled(vnode.props);
if (target) {
const targetNode = target._lpa || target.firstChild;
if (vnode.shapeFlag & 16) {
if (disabled) {
hydrateDisabledTeleport(
node,
vnode,
targetNode,
targetNode && nextSibling(targetNode)
);
} 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);
}
if (!vnode.targetAnchor) {
prepareAnchor(target, vnode, createText, insert);
}
hydrateChildren(
targetNode && nextSibling(targetNode),
vnode,
target,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
}
updateCssVars(vnode, disabled);
} else if (disabled) {
if (vnode.shapeFlag & 16) {
hydrateDisabledTeleport(node, vnode, node, nextSibling(node));
}
}
return vnode.anchor && nextSibling(vnode.anchor);
}
const Teleport = TeleportImpl;
function updateCssVars(vnode, isDisabled) {
const ctx = vnode.ctx;
if (ctx && ctx.ut) {
let node, anchor;
if (isDisabled) {
node = vnode.el;
anchor = vnode.anchor;
} else {
node = vnode.targetStart;
anchor = vnode.targetAnchor;
}
while (node && node !== anchor) {
if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
node = node.nextSibling;
}
ctx.ut();
}
}
function prepareAnchor(target, vnode, createText, insert) {
const targetStart = vnode.targetStart = createText("");
const targetAnchor = vnode.targetAnchor = createText("");
targetStart[TeleportEndKey] = targetAnchor;
if (target) {
insert(targetStart, target);
insert(targetAnchor, target);
}
return targetAnchor;
}
const leaveCbKey = /* @__PURE__ */ Symbol("_leaveCb");
const enterCbKey = /* @__PURE__ */ Symbol("_enterCb");
function useTransitionState() {
const state = {
isMounted: false,
isLeaving: false,
isUnmounting: false,
leavingVNodes: /* @__PURE__ */ new Map()
};
onMounted(() => {
state.isMounted = true;
});
onBeforeUnmount(() => {
state.isUnmounting = true;
});
return state;
}
const TransitionHookValidator = [Function, Array];
const BaseTransitionPropsValidators = {
mode: String,
appear: Boolean,
persisted: Boolean,
// enter
onBeforeEnter: TransitionHookValidator,
onEnter: TransitionHookValidator,
onAfterEnter: TransitionHookValidator,
onEnterCancelled: TransitionHookValidator,
// leave
onBeforeLeave: TransitionHookValidator,
onLeave: TransitionHookValidator,
onAfterLeave: TransitionHookValidator,
onLeaveCancelled: TransitionHookValidator,
// appear
onBeforeAppear: TransitionHookValidator,
onAppear: TransitionHookValidator,
onAfterAppear: TransitionHookValidator,
onAppearCancelled: TransitionHookValidator
};
const recursiveGetSubtree = (instance) => {
const subTree = instance.subTree;
return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
};
const BaseTransitionImpl = {
name: `BaseTransition`,
props: BaseTransitionPropsValidators,
setup(props, { slots }) {
const instance = getCurrentInstance();
const state = useTransitionState();
return () => {
const children = slots.default && getTransitionRawChildren(slots.default(), true);
if (!children || !children.length) {
return;
}
const child = findNonCommentChild(children);
const rawProps = reactivity.toRaw(props);
const { mode } = rawProps;
if (state.isLeaving) {
return emptyPlaceholder(child);
}
const innerChild = getInnerChild$1(child);
if (!innerChild) {
return emptyPlaceholder(child);
}
let enterHooks = resolveTransitionHooks(
innerChild,
rawProps,
state,
instance,
// #11061, ensure enterHooks is fresh after clone
(hooks) => enterHooks = hooks
);
if (innerChild.type !== Comment) {
setTransitionHooks(innerChild, enterHooks);
}
let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(oldInnerChild, innerChild) && recursiveGetSubtree(instance).type !== Comment) {
let leavingHooks = resolveTransitionHooks(
oldInnerChild,
rawProps,
state,
instance
);
setTransitionHooks(oldInnerChild, leavingHooks);
if (mode === "out-in" && innerChild.type !== Comment) {
state.isLeaving = true;
leavingHooks.afterLeave = () => {
state.isLeaving = false;
if (!(instance.job.flags & 8)) {
instance.update();
}
delete leavingHooks.afterLeave;
oldInnerChild = void 0;
};
return emptyPlaceholder(child);
} else if (mode === "in-out" && innerChild.type !== Comment) {
leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
const leavingVNodesCache = getLeavingNodesForType(
state,
oldInnerChild
);
leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
el[leaveCbKey] = () => {
earlyRemove();
el[leaveCbKey] = void 0;
delete enterHooks.delayedLeave;
oldInnerChild = void 0;
};
enterHooks.delayedLeave = () => {
delayedLeave();
delete enterHooks.delayedLeave;
oldInnerChild = void 0;
};
};
} else {
oldInnerChild = void 0;
}
} else if (oldInnerChild) {
oldInnerChild = void 0;
}
return child;
};
}
};
function findNonCommentChild(children) {
let child = children[0];
if (children.length > 1) {
for (const c of children) {
if (c.type !== Comment) {
child = c;
break;
}
}
}
return child;
}
const BaseTransition = BaseTransitionImpl;
function getLeavingNodesForType(state, vnode) {
const { leavingVNodes } = state;
let leavingVNodesCache = leavingVNodes.get(vnode.type);
if (!leavingVNodesCache) {
leavingVNodesCache = /* @__PURE__ */ Object.create(null);
leavingVNodes.set(vnode.type, leavingVNodesCache);
}
return leavingVNodesCache;
}
function resolveTransitionHooks(vnode, props, state, instance, postClone) {
const {
appear,
mode,
persisted = false,
onBeforeEnter,
onEnter,
onAfterEnter,
onEnterCancelled,
onBeforeLeave,
onLeave,
onAfterLeave,
onLeaveCancelled,
onBeforeAppear,
onAppear,
onAfterAppear,
onAppearCancelled
} = props;
const key = String(vnode.key);
const leavingVNodesCache = getLeavingNodesForType(state, vnode);
const callHook = (hook, args) => {
hook && callWithAsyncErrorHandling(
hook,
instance,
9,
args
);
};
const callAsyncHook = (hook, args) => {
const done = args[1];
callHook(hook, args);
if (shared.isArray(hook)) {
if (hook.every((hook2) => hook2.length <= 1)) done();
} else if (hook.length <= 1) {
done();
}
};
const hooks = {
mode,
persisted,
beforeEnter(el) {
let hook = onBeforeEnter;
if (!state.isMounted) {
if (appear) {
hook = onBeforeAppear || onBeforeEnter;
} else {
return;
}
}
if (el[leaveCbKey]) {
el[leaveCbKey](
true
/* cancelled */
);
}
const leavingVNode = leavingVNodesCache[key];
if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
leavingVNode.el[leaveCbKey]();
}
callHook(hook, [el]);
},
enter(el) {
let hook = onEnter;
let afterHook = onAfterEnter;
let cancelHook = onEnterCancelled;
if (!state.isMounted) {
if (appear) {
hook = onAppear || onEnter;
afterHook = onAfterAppear || onAfterEnter;
cancelHook = onAppearCancelled || onEnterCancelled;
} else {
return;
}
}
let called = false;
const done = el[enterCbKey] = (cancelled) => {
if (called) return;
called = true;
if (cancelled) {
callHook(cancelHook, [el]);
} else {
callHook(afterHook, [el]);
}
if (hooks.delayedLeave) {
hooks.delayedLeave();
}
el[enterCbKey] = void 0;
};
if (hook) {
callAsyncHook(hook, [el, done]);
} else {
done();
}
},
leave(el, remove) {
const key2 = String(vnode.key);
if (el[enterCbKey]) {
el[enterCbKey](
true
/* cancelled */
);
}
if (state.isUnmounting) {
return remove();
}
callHook(onBeforeLeave, [el]);
let called = false;
const done = el[leaveCbKey] = (cancelled) => {
if (called) return;
called = true;
remove();
if (cancelled) {
callHook(onLeaveCancelled, [el]);
} else {
callHook(onAfterLeave, [el]);
}
el[leaveCbKey] = void 0;
if (leavingVNodesCache[key2] === vnode) {
delete leavingVNodesCache[key2];
}
};
leavingVNodesCache[key2] = vnode;
if (onLeave) {
callAsyncHook(onLeave, [el, done]);
} else {
done();
}
},
clone(vnode2) {
const hooks2 = resolveTransitionHooks(
vnode2,
props,
state,
instance,
postClone
);
if (postClone) postClone(hooks2);
return hooks2;
}
};
return hooks;
}
function emptyPlaceholder(vnode) {
if (isKeepAlive(vnode)) {
vnode = cloneVNode(vnode);
vnode.children = null;
return vnode;
}
}
function getInnerChild$1(vnode) {
if (!isKeepAlive(vnode)) {
if (isTeleport(vnode.type) && vnode.children) {
return findNonCommentChild(vnode.children);
}
return vnode;
}
if (vnode.component) {
return vnode.component.subTree;
}
const { shapeFlag, children } = vnode;
if (children) {
if (shapeFlag & 16) {
return children[0];
}
if (shapeFlag & 32 && shared.isFunction(children.default)) {
return children.default();
}
}
}
function setTransitionHooks(vnode, hooks) {
if (vnode.shapeFlag & 6 && vnode.component) {
vnode.transition = hooks;
setTransitionHooks(vnode.component.subTree, hooks);
} else if (vnode.shapeFlag & 128) {
vnode.ssContent.transition = hooks.clone(vnode.ssContent);
vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
} else {
vnode.transition = hooks;
}
}
function getTransitionRawChildren(children, keepComment = false, parentKey) {
let ret = [];
let keyedFragmentCount = 0;
for (let i = 0; i < children.length; i++) {
let child = children[i];
const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
if (child.type === Fragment) {
if (child.patchFlag & 128) keyedFragmentCount++;
ret = ret.concat(
getTransitionRawChildren(child.children, keepComment, key)
);
} else if (keepComment || child.type !== Comment) {
ret.push(key != null ? cloneVNode(child, { key }) : child);
}
}
if (keyedFragmentCount > 1) {
for (let i = 0; i < ret.length; i++) {
ret[i].patchFlag = -2;
}
}
return ret;
}
// @__NO_SIDE_EFFECTS__
function defineComponent(options, extraOptions) {
return shared.isFunction(options) ? (
// #8236: extend call and options.name access are considered side-effects
// by Rollup, so we have to wrap it in a pure-annotated IIFE.
/* @__PURE__ */ (() => shared.extend({ name: options.name }, extraOptions, { setup: options }))()
) : options;
}
function useId() {
const i = getCurrentInstance();
if (i) {
return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
}
return "";
}
function markAsyncBoundary(instance) {
instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
}
function useTemplateRef(key) {
const i = getCurrentInstance();
const r = reactivity.shallowRef(null);
if (i) {
const refs = i.refs === shared.EMPTY_OBJ ? i.refs = {} : i.refs;
{
Object.defineProperty(refs, key, {
enumerable: true,
get: () => r.value,
set: (val) => r.value = val
});
}
}
const ret = r;
return ret;
}
const pendingSetRefMap = /* @__PURE__ */ new WeakMap();
function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
if (shared.isArray(rawRef)) {
rawRef.forEach(
(r, i) => setRef(
r,
oldRawRef && (shared.isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
parentSuspense,
vnode,
isUnmount
)
);
return;
}
if (isAsyncWrapper(vnode) && !isUnmount) {
if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) {
setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
}
return;
}
const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
const value = isUnmount ? null : refValue;
const { i: owner, r: ref } = rawRef;
const oldRef = oldRawRef && oldRawRef.r;
const refs = owner.refs === shared.EMPTY_OBJ ? owner.refs = {} : owner.refs;
const setupState = owner.setupState;
const rawSetupState = reactivity.toRaw(setupState);
const canSetSetupRef = setupState === shared.EMPTY_OBJ ? shared.NO : (key) => {
return shared.hasOwn(rawSetupState, key);
};
if (oldRef != null && oldRef !== ref) {
invalidatePendingSetRef(oldRawRef);
if (shared.isString(oldRef)) {
refs[oldRef] = null;
if (canSetSetupRef(oldRef)) {
setupState[oldRef] = null;
}
} else if (reactivity.isRef(oldRef)) {
{
oldRef.value = null;
}
const oldRawRefAtom = oldRawRef;
if (oldRawRefAtom.k) refs[oldRawRefAtom.k] = null;
}
}
if (shared.isFunction(ref)) {
callWithErrorHandling(ref, owner, 12, [value, refs]);
} else {
const _isString = shared.isString(ref);
const _isRef = reactivity.isRef(ref);
if (_isString || _isRef) {
const doSet = () => {
if (rawRef.f) {
const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value ;
if (isUnmount) {
shared.isArray(existing) && shared.remove(existing, refValue);
} else {
if (!shared.isArray(existing)) {
if (_isString) {
refs[ref] = [refValue];
if (canSetSetupRef(ref)) {
setupState[ref] = refs[ref];
}
} else {
const newVal = [refValue];
{
ref.value = newVal;
}
if (rawRef.k) refs[rawRef.k] = newVal;
}
} else if (!existing.includes(refValue)) {
existing.push(refValue);
}
}
} else if (_isString) {
refs[ref] = value;
if (canSetSetupRef(ref)) {
setupState[ref] = value;
}
} else if (_isRef) {
{
ref.value = value;
}
if (rawRef.k) refs[rawRef.k] = value;
} else ;
};
if (value) {
const job = () => {
doSet();
pendingSetRefMap.delete(rawRef);
};
job.id = -1;
pendingSetRefMap.set(rawRef, job);
queuePostRenderEffect(job, parentSuspense);
} else {
invalidatePendingSetRef(rawRef);
doSet();
}
}
}
}
function invalidatePendingSetRef(rawRef) {
const pendingSetRef = pendingSetRefMap.get(rawRef);
if (pendingSetRef) {
pendingSetRef.flags |= 8;
pendingSetRefMap.delete(rawRef);
}
}
let hasLoggedMismatchError = false;
const logMismatchError = () => {
if (hasLoggedMismatchError) {
return;
}
console.error("Hydration completed but contains mismatches.");
hasLoggedMismatchError = true;
};
const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
const getContainerType = (container) => {
if (container.nodeType !== 1) return void 0;
if (isSVGContainer(container)) return "svg";
if (isMathMLContainer(container)) return "mathml";
return void 0;
};
const isComment = (node) => node.nodeType === 8;
function createHydrationFunctions(rendererInternals) {
const {
mt: mountComponent,
p: patch,
o: {
patchProp,
createText,
nextSibling,
parentNode,
remove,
insert,
createComment
}
} = rendererInternals;
const hydrate = (vnode, container) => {
if (!container.hasChildNodes()) {
patch(null, vnode, container);
flushPostFlushCbs();
container._vnode = vnode;
return;
}
hydrateNode(container.firstChild, vnode, null, null, null);
flushPostFlushCbs();
container._vnode = vnode;
};
const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
optimized = optimized || !!vnode.dynamicChildren;
const isFragmentStart = isComment(node) && node.data === "[";
const onMismatch = () => handleMismatch(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
isFragmentStart
);
const { type, ref, shapeFlag, patchFlag } = vnode;
let domType = node.nodeType;
vnode.el = node;
if (patchFlag === -2) {
optimized = false;
vnode.dynamicChildren = null;
}
let nextNode = null;
switch (type) {
case Text:
if (domType !== 3) {
if (vnode.children === "") {
insert(vnode.el = createText(""), parentNode(node), node);
nextNode = node;
} else {
nextNode = onMismatch();
}
} else {
if (node.data !== vnode.children) {
logMismatchError();
node.data = vnode.children;
}
nextNode = nextSibling(node);
}
break;
case Comment:
if (isTemplateNode(node)) {
nextNode = nextSibling(node);
replaceNode(
vnode.el = node.content.firstChild,
node,
parentComponent
);
} else if (domType !== 8 || isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = nextSibling(node);
}
break;
case Static:
if (isFragmentStart) {
node = nextSibling(node);
domType = node.nodeType;
}
if (domType === 1 || domType === 3) {
nextNode = node;
const needToAdoptContent = !vnode.children.length;
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode;
}
nextNode = nextSibling(nextNode);
}
return isFragmentStart ? nextSibling(nextNode) : nextNode;
} else {
onMismatch();
}
break;
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch();
} else {
nextNode = hydrateFragment(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
break;
default:
if (shapeFlag & 1) {
if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
nextNode = onMismatch();
} else {
nextNode = hydrateElement(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
}
} else if (shapeFlag & 6) {
vnode.slotScopeIds = slotScopeIds;
const container = parentNode(node);
if (isFragmentStart) {
nextNode = locateClosingAnchor(node);
} else if (isComment(node) && node.data === "teleport start") {
nextNode = locateClosingAnchor(node, node.data, "teleport end");
} else {
nextNode = nextSibling(node);
}
mountComponent(
vnode,
container,
null,
parentComponent,
parentSuspense,
getContainerType(container),
optimized
);
if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
let subTree;
if (isFragmentStart) {
subTree = createVNode(Fragment);
subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
} else {
subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
}
subTree.el = node;
vnode.component.subTree = subTree;
}
} else if (shapeFlag & 64) {
if (domType !== 8) {
nextNode = onMismatch();
} else {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized,
rendererInternals,
hydrateChildren
);
}
} else if (shapeFlag & 128) {
nextNode = vnode.type.hydrate(
node,
vnode,
parentComponent,
parentSuspense,
getContainerType(parentNode(node)),
slotScopeIds,
optimized,
rendererInternals,
hydrateNode
);
} else ;
}
if (ref != null) {
setRef(ref, null, parentSuspense, vnode);
}
return nextNode;
};
const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!vnode.dynamicChildren;
const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
const forcePatch = type === "input" || type === "option";
if (forcePatch || patchFlag !== -1) {
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "created");
}
let needCallTransitionHooks = false;
if (isTemplateNode(el)) {
needCallTransitionHooks = needTransition(
null,
// no need check parentSuspense in hydration
transition
) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
const content = el.content.firstChild;
if (needCallTransitionHooks) {
const cls = content.getAttribute("class");
if (cls) content.$cls = cls;
transition.beforeEnter(content);
}
replaceNode(content, el, parentComponent);
vnode.el = el = content;
}
if (shapeFlag & 16 && // skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))) {
let next = hydrateChildren(
el.firstChild,
vnode,
el,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
while (next) {
if (!isMismatchAllowed(el, 1 /* CHILDREN */)) {
logMismatchError();
}
const cur = next;
next = next.nextSibling;
remove(cur);
}
} else if (shapeFlag & 8) {
let clientText = vnode.children;
if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
clientText = clientText.slice(1);
}
const { textContent } = el;
if (textContent !== clientText && // innerHTML normalize \r\n or \r into a single \n in the DOM
textContent !== clientText.replace(/\r\n|\r/g, "\n")) {
if (!isMismatchAllowed(el, 0 /* TEXT */)) {
logMismatchError();
}
el.textContent = vnode.children;
}
}
if (props) {
if (forcePatch || !optimized || patchFlag & (16 | 32)) {
const isCustomElement = el.tagName.includes("-");
for (const key in props) {
if (forcePatch && (key.endsWith("value") || key === "indeterminate") || shared.isOn(key) && !shared.isReservedProp(key) || // force hydrate v-bind with .prop modifiers
key[0] === "." || isCustomElement) {
patchProp(el, key, null, props[key], void 0, parentComponent);
}
}
} else if (props.onClick) {
patchProp(
el,
"onClick",
null,
props.onClick,
void 0,
parentComponent
);
} else if (patchFlag & 4 && reactivity.isReactive(props.style)) {
for (const key in props.style) props.style[key];
}
}
let vnodeHooks;
if (vnodeHooks = props && props.onVnodeBeforeMount) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode);
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
needCallTransitionHooks && transition.enter(el);
dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
}, parentSuspense);
}
}
return el.nextSibling;
};
const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
optimized = optimized || !!parentVNode.dynamicChildren;
const children = parentVNode.children;
const l = children.length;
for (let i = 0; i < l; i++) {
const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
const isText = vnode.type === Text;
if (node) {
if (isText && !optimized) {
if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
insert(
createText(
node.data.slice(vnode.children.length)
),
container,
nextSibling(node)
);
node.data = vnode.children;
}
}
node = hydrateNode(
node,
vnode,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
} else if (isText && !vnode.children) {
insert(vnode.el = createText(""), container);
} else {
if (!isMismatchAllowed(container, 1 /* CHILDREN */)) {
logMismatchError();
}
patch(
null,
vnode,
container,
null,
parentComponent,
parentSuspense,
getContainerType(container),
slotScopeIds
);
}
}
return node;
};
const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
const { slotScopeIds: fragmentSlotScopeIds } = vnode;
if (fragmentSlotScopeIds) {
slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
}
const container = parentNode(node);
const next = hydrateChildren(
nextSibling(node),
vnode,
container,
parentComponent,
parentSuspense,
slotScopeIds,
optimized
);
if (next && isComment(next) && next.data === "]") {
return nextSibling(vnode.anchor = next);