From b47d8e2e6c58f51946a601b58ace53b7564edaed Mon Sep 17 00:00:00 2001 From: fxy060608 Date: Fri, 4 Mar 2022 21:00:44 +0800 Subject: [PATCH] chore: remove unused --- .../uni-mp-vue/lib/vue.runtime.esm.legacy.js | 4753 ----------------- 1 file changed, 4753 deletions(-) delete mode 100644 packages/uni-mp-vue/lib/vue.runtime.esm.legacy.js diff --git a/packages/uni-mp-vue/lib/vue.runtime.esm.legacy.js b/packages/uni-mp-vue/lib/vue.runtime.esm.legacy.js deleted file mode 100644 index 21f2588ae..000000000 --- a/packages/uni-mp-vue/lib/vue.runtime.esm.legacy.js +++ /dev/null @@ -1,4753 +0,0 @@ -import { extend, isArray, isMap, isIntegerKey, isSymbol, hasOwn, isObject, hasChanged, makeMap, capitalize, toRawType, def, isFunction, NOOP, EMPTY_OBJ, toHandlerKey, toNumber, hyphenate, camelize, isOn, remove, isPromise, isString, isReservedProp, EMPTY_ARR, NO, normalizeClass, normalizeStyle, isSet, isPlainObject, toTypeString, invokeArrayFns } from '@vue/shared'; -export { camelize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared'; -import { isRootHook } from '@dcloudio/uni-shared'; - -function warn(msg, ...args) { - console.warn(`[Vue warn] ${msg}`, ...args); -} - -let activeEffectScope; -const effectScopeStack = []; -class EffectScope { - constructor(detached = false) { - this.active = true; - this.effects = []; - this.cleanups = []; - if (!detached && activeEffectScope) { - this.parent = activeEffectScope; - this.index = - (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; - } - } - run(fn) { - if (this.active) { - try { - this.on(); - return fn(); - } - finally { - this.off(); - } - } - else if ((process.env.NODE_ENV !== 'production')) { - warn(`cannot run an inactive effect scope.`); - } - } - on() { - if (this.active) { - effectScopeStack.push(this); - activeEffectScope = this; - } - } - off() { - if (this.active) { - effectScopeStack.pop(); - activeEffectScope = effectScopeStack[effectScopeStack.length - 1]; - } - } - stop(fromParent) { - if (this.active) { - this.effects.forEach(e => e.stop()); - this.cleanups.forEach(cleanup => cleanup()); - if (this.scopes) { - this.scopes.forEach(e => e.stop(true)); - } - // nested scope, dereference from parent to avoid memory leaks - if (this.parent && !fromParent) { - // optimized O(1) removal - const last = this.parent.scopes.pop(); - if (last && last !== this) { - this.parent.scopes[this.index] = last; - last.index = this.index; - } - } - this.active = false; - } - } -} -function effectScope(detached) { - return new EffectScope(detached); -} -function recordEffectScope(effect, scope) { - scope = scope || activeEffectScope; - if (scope && scope.active) { - scope.effects.push(effect); - } -} -function getCurrentScope() { - return activeEffectScope; -} -function onScopeDispose(fn) { - if (activeEffectScope) { - activeEffectScope.cleanups.push(fn); - } - else if ((process.env.NODE_ENV !== 'production')) { - warn(`onScopeDispose() is called when there is no active effect scope` + - ` to be associated with.`); - } -} - -const createDep = (effects) => { - const dep = new Set(effects); - dep.w = 0; - dep.n = 0; - return dep; -}; -const wasTracked = (dep) => (dep.w & trackOpBit) > 0; -const newTracked = (dep) => (dep.n & trackOpBit) > 0; -const initDepMarkers = ({ deps }) => { - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].w |= trackOpBit; // set was tracked - } - } -}; -const finalizeDepMarkers = (effect) => { - const { deps } = effect; - if (deps.length) { - let ptr = 0; - for (let i = 0; i < deps.length; i++) { - const dep = deps[i]; - if (wasTracked(dep) && !newTracked(dep)) { - dep.delete(effect); - } - else { - deps[ptr++] = dep; - } - // clear bits - dep.w &= ~trackOpBit; - dep.n &= ~trackOpBit; - } - deps.length = ptr; - } -}; - -const targetMap = new WeakMap(); -// The number of effects currently being tracked recursively. -let effectTrackDepth = 0; -let trackOpBit = 1; -/** - * The bitwise track markers support at most 30 levels op recursion. - * This value is chosen to enable modern JS engines to use a SMI on all platforms. - * When recursion depth is greater, fall back to using a full cleanup. - */ -const maxMarkerBits = 30; -const effectStack = []; -let activeEffect; -const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); -const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); -class ReactiveEffect { - constructor(fn, scheduler = null, scope) { - this.fn = fn; - this.scheduler = scheduler; - this.active = true; - this.deps = []; - recordEffectScope(this, scope); - } - run() { - if (!this.active) { - return this.fn(); - } - if (!effectStack.includes(this)) { - try { - effectStack.push((activeEffect = this)); - enableTracking(); - trackOpBit = 1 << ++effectTrackDepth; - if (effectTrackDepth <= maxMarkerBits) { - initDepMarkers(this); - } - else { - cleanupEffect(this); - } - return this.fn(); - } - finally { - if (effectTrackDepth <= maxMarkerBits) { - finalizeDepMarkers(this); - } - trackOpBit = 1 << --effectTrackDepth; - resetTracking(); - effectStack.pop(); - const n = effectStack.length; - activeEffect = n > 0 ? effectStack[n - 1] : undefined; - } - } - } - stop() { - if (this.active) { - cleanupEffect(this); - if (this.onStop) { - this.onStop(); - } - this.active = false; - } - } -} -function cleanupEffect(effect) { - const { deps } = effect; - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } - deps.length = 0; - } -} -function effect(fn, options) { - if (fn.effect) { - fn = fn.effect.fn; - } - const _effect = new ReactiveEffect(fn); - if (options) { - extend(_effect, options); - if (options.scope) - recordEffectScope(_effect, options.scope); - } - if (!options || !options.lazy) { - _effect.run(); - } - const runner = _effect.run.bind(_effect); - runner.effect = _effect; - return runner; -} -function stop(runner) { - runner.effect.stop(); -} -let shouldTrack = true; -const trackStack = []; -function pauseTracking() { - trackStack.push(shouldTrack); - shouldTrack = false; -} -function enableTracking() { - trackStack.push(shouldTrack); - shouldTrack = true; -} -function resetTracking() { - const last = trackStack.pop(); - shouldTrack = last === undefined ? true : last; -} -function track(target, type, key) { - if (!isTracking()) { - return; - } - let depsMap = targetMap.get(target); - if (!depsMap) { - targetMap.set(target, (depsMap = new Map())); - } - let dep = depsMap.get(key); - if (!dep) { - depsMap.set(key, (dep = createDep())); - } - const eventInfo = (process.env.NODE_ENV !== 'production') - ? { effect: activeEffect, target, type, key } - : undefined; - trackEffects(dep, eventInfo); -} -function isTracking() { - return shouldTrack && activeEffect !== undefined; -} -function trackEffects(dep, debuggerEventExtraInfo) { - let shouldTrack = false; - if (effectTrackDepth <= maxMarkerBits) { - if (!newTracked(dep)) { - dep.n |= trackOpBit; // set newly tracked - shouldTrack = !wasTracked(dep); - } - } - else { - // Full cleanup mode. - shouldTrack = !dep.has(activeEffect); - } - if (shouldTrack) { - dep.add(activeEffect); - activeEffect.deps.push(dep); - if ((process.env.NODE_ENV !== 'production') && activeEffect.onTrack) { - activeEffect.onTrack(Object.assign({ - effect: activeEffect - }, debuggerEventExtraInfo)); - } - } -} -function trigger(target, type, key, newValue, oldValue, oldTarget) { - const depsMap = targetMap.get(target); - if (!depsMap) { - // never been tracked - return; - } - let deps = []; - if (type === "clear" /* CLEAR */) { - // collection being cleared - // trigger all effects for target - deps = [...depsMap.values()]; - } - else if (key === 'length' && isArray(target)) { - depsMap.forEach((dep, key) => { - if (key === 'length' || key >= newValue) { - deps.push(dep); - } - }); - } - else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - deps.push(depsMap.get(key)); - } - // also run for iteration key on ADD | DELETE | Map.SET - switch (type) { - case "add" /* ADD */: - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } - else if (isIntegerKey(key)) { - // new index added to array -> length changes - deps.push(depsMap.get('length')); - } - break; - case "delete" /* DELETE */: - if (!isArray(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } - break; - case "set" /* SET */: - if (isMap(target)) { - deps.push(depsMap.get(ITERATE_KEY)); - } - break; - } - } - const eventInfo = (process.env.NODE_ENV !== 'production') - ? { target, type, key, newValue, oldValue, oldTarget } - : undefined; - if (deps.length === 1) { - if (deps[0]) { - if ((process.env.NODE_ENV !== 'production')) { - triggerEffects(deps[0], eventInfo); - } - else { - triggerEffects(deps[0]); - } - } - } - else { - const effects = []; - for (const dep of deps) { - if (dep) { - effects.push(...dep); - } - } - if ((process.env.NODE_ENV !== 'production')) { - triggerEffects(createDep(effects), eventInfo); - } - else { - triggerEffects(createDep(effects)); - } - } -} -function triggerEffects(dep, debuggerEventExtraInfo) { - // spread into array for stabilization - for (const effect of isArray(dep) ? dep : [...dep]) { - if (effect !== activeEffect || effect.allowRecurse) { - if ((process.env.NODE_ENV !== 'production') && effect.onTrigger) { - effect.onTrigger(extend({ effect }, debuggerEventExtraInfo)); - } - if (effect.scheduler) { - effect.scheduler(); - } - else { - effect.run(); - } - } - } -} - -const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`); -const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) - .map(key => Symbol[key]) - .filter(isSymbol)); -const get = /*#__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); - for (let i = 0, l = this.length; i < l; i++) { - track(arr, "get" /* GET */, i + ''); - } - // we run the method using the original args first (which may be reactive) - const res = arr[key](...args); - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return arr[key](...args.map(toRaw)); - } - else { - return res; - } - }; - }); - ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { - instrumentations[key] = function (...args) { - pauseTracking(); - const res = toRaw(this)[key].apply(this, args); - resetTracking(); - return res; - }; - }); - return instrumentations; -} -function createGetter(isReadonly = false, shallow = false) { - return function get(target, key, receiver) { - if (key === "__v_isReactive" /* IS_REACTIVE */) { - return !isReadonly; - } - else if (key === "__v_isReadonly" /* IS_READONLY */) { - return isReadonly; - } - else if (key === "__v_raw" /* RAW */ && - receiver === - (isReadonly - ? shallow - ? shallowReadonlyMap - : readonlyMap - : shallow - ? shallowReactiveMap - : reactiveMap).get(target)) { - return target; - } - const targetIsArray = isArray(target); - if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { - return Reflect.get(arrayInstrumentations, key, receiver); - } - const res = Reflect.get(target, key, receiver); - if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { - return res; - } - if (!isReadonly) { - track(target, "get" /* GET */, key); - } - if (shallow) { - return res; - } - if (isRef(res)) { - // ref unwrapping - does not apply for Array + integer key. - const shouldUnwrap = !targetIsArray || !isIntegerKey(key); - return shouldUnwrap ? res.value : res; - } - if (isObject(res)) { - // Convert returned value into a proxy as well. we do the isObject check - // here to avoid invalid value warning. Also need to lazy access readonly - // and reactive here to avoid circular dependency. - return isReadonly ? readonly(res) : reactive(res); - } - return res; - }; -} -const set = /*#__PURE__*/ createSetter(); -const shallowSet = /*#__PURE__*/ createSetter(true); -function createSetter(shallow = false) { - return function set(target, key, value, receiver) { - let oldValue = target[key]; - if (!shallow) { - value = toRaw(value); - oldValue = toRaw(oldValue); - if (!isArray(target) && isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } - } - const hadKey = isArray(target) && isIntegerKey(key) - ? Number(key) < target.length - : hasOwn(target, key); - const result = Reflect.set(target, key, value, receiver); - // don't trigger if target is something up in the prototype chain of original - if (target === toRaw(receiver)) { - if (!hadKey) { - trigger(target, "add" /* ADD */, key, value); - } - else if (hasChanged(value, oldValue)) { - trigger(target, "set" /* SET */, key, value, oldValue); - } - } - return result; - }; -} -function deleteProperty(target, key) { - const hadKey = hasOwn(target, key); - const oldValue = target[key]; - const result = Reflect.deleteProperty(target, key); - if (result && hadKey) { - trigger(target, "delete" /* DELETE */, key, undefined, oldValue); - } - return result; -} -function has(target, key) { - const result = Reflect.has(target, key); - if (!isSymbol(key) || !builtInSymbols.has(key)) { - track(target, "has" /* HAS */, key); - } - return result; -} -function ownKeys(target) { - track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY); - return Reflect.ownKeys(target); -} -const mutableHandlers = { - get, - set, - deleteProperty, - has, - ownKeys -}; -const readonlyHandlers = { - get: readonlyGet, - set(target, key) { - if ((process.env.NODE_ENV !== 'production')) { - console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); - } - return true; - }, - deleteProperty(target, key) { - if ((process.env.NODE_ENV !== 'production')) { - console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); - } - return true; - } -}; -const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, { - get: shallowGet, - set: shallowSet -}); -// Props handlers are special in the sense that it should not unwrap top-level -// refs (in order to allow refs to be explicitly passed down), but should -// retain the reactivity of the normal readonly object. -const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, { - get: shallowReadonlyGet -}); - -const toShallow = (value) => value; -const getProto = (v) => Reflect.getPrototypeOf(v); -function get$1(target, key, isReadonly = false, isShallow = false) { - // #1772: readonly(reactive(Map)) should return readonly + reactive version - // of the value - target = target["__v_raw" /* RAW */]; - const rawTarget = toRaw(target); - const rawKey = toRaw(key); - if (key !== rawKey) { - !isReadonly && track(rawTarget, "get" /* GET */, key); - } - !isReadonly && track(rawTarget, "get" /* GET */, rawKey); - const { has } = getProto(rawTarget); - const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - if (has.call(rawTarget, key)) { - return wrap(target.get(key)); - } - else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } - else if (target !== rawTarget) { - // #3602 readonly(reactive(Map)) - // ensure that the nested reactive `Map` can do tracking for itself - target.get(key); - } -} -function has$1(key, isReadonly = false) { - const target = this["__v_raw" /* RAW */]; - const rawTarget = toRaw(target); - const rawKey = toRaw(key); - if (key !== rawKey) { - !isReadonly && track(rawTarget, "has" /* HAS */, key); - } - !isReadonly && track(rawTarget, "has" /* HAS */, rawKey); - return key === rawKey - ? target.has(key) - : target.has(key) || target.has(rawKey); -} -function size(target, isReadonly = false) { - target = target["__v_raw" /* RAW */]; - !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY); - return Reflect.get(target, 'size', target); -} -function add(value) { - value = toRaw(value); - const target = toRaw(this); - const proto = getProto(target); - const hadKey = proto.has.call(target, value); - if (!hadKey) { - target.add(value); - trigger(target, "add" /* ADD */, value, value); - } - return this; -} -function set$1(key, value) { - value = toRaw(value); - const target = toRaw(this); - const { has, get } = getProto(target); - let hadKey = has.call(target, key); - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } - else if ((process.env.NODE_ENV !== 'production')) { - checkIdentityKeys(target, has, key); - } - const oldValue = get.call(target, key); - target.set(key, value); - if (!hadKey) { - trigger(target, "add" /* ADD */, key, value); - } - else if (hasChanged(value, oldValue)) { - trigger(target, "set" /* SET */, key, value, oldValue); - } - return this; -} -function deleteEntry(key) { - const target = toRaw(this); - const { has, get } = getProto(target); - let hadKey = has.call(target, key); - if (!hadKey) { - key = toRaw(key); - hadKey = has.call(target, key); - } - else if ((process.env.NODE_ENV !== 'production')) { - checkIdentityKeys(target, has, key); - } - const oldValue = get ? get.call(target, key) : undefined; - // forward the operation before queueing reactions - const result = target.delete(key); - if (hadKey) { - trigger(target, "delete" /* DELETE */, key, undefined, oldValue); - } - return result; -} -function clear() { - const target = toRaw(this); - const hadItems = target.size !== 0; - const oldTarget = (process.env.NODE_ENV !== 'production') - ? isMap(target) - ? new Map(target) - : new Set(target) - : undefined; - // forward the operation before queueing reactions - const result = target.clear(); - if (hadItems) { - trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); - } - return result; -} -function createForEach(isReadonly, isShallow) { - return function forEach(callback, thisArg) { - const observed = this; - const target = observed["__v_raw" /* RAW */]; - const rawTarget = toRaw(target); - const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY); - return target.forEach((value, key) => { - // important: make sure the callback is - // 1. invoked with the reactive map as `this` and 3rd arg - // 2. the value received should be a corresponding reactive/readonly. - return callback.call(thisArg, wrap(value), wrap(key), observed); - }); - }; -} -function createIterableMethod(method, isReadonly, isShallow) { - return function (...args) { - const target = this["__v_raw" /* RAW */]; - const rawTarget = toRaw(target); - const targetIsMap = isMap(rawTarget); - const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap); - const isKeyOnly = method === 'keys' && targetIsMap; - const innerIterator = target[method](...args); - const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; - !isReadonly && - track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); - // return a wrapped iterator which returns observed versions of the - // values emitted from the real iterator - return { - // iterator protocol - next() { - const { value, done } = innerIterator.next(); - return done - ? { value, done } - : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done - }; - }, - // iterable protocol - [Symbol.iterator]() { - return this; - } - }; - }; -} -function createReadonlyMethod(type) { - return function (...args) { - if ((process.env.NODE_ENV !== 'production')) { - const key = args[0] ? `on key "${args[0]}" ` : ``; - console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); - } - return type === "delete" /* DELETE */ ? false : this; - }; -} -function createInstrumentations() { - const mutableInstrumentations = { - get(key) { - return get$1(this, key); - }, - get size() { - return size(this); - }, - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, false) - }; - const shallowInstrumentations = { - get(key) { - return get$1(this, key, false, true); - }, - get size() { - return size(this); - }, - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, true) - }; - const readonlyInstrumentations = { - get(key) { - return get$1(this, key, true); - }, - get size() { - return size(this, true); - }, - has(key) { - return has$1.call(this, key, true); - }, - add: createReadonlyMethod("add" /* ADD */), - set: createReadonlyMethod("set" /* SET */), - delete: createReadonlyMethod("delete" /* DELETE */), - clear: createReadonlyMethod("clear" /* CLEAR */), - forEach: createForEach(true, false) - }; - const shallowReadonlyInstrumentations = { - get(key) { - return get$1(this, key, true, true); - }, - get size() { - return size(this, true); - }, - has(key) { - return has$1.call(this, key, true); - }, - add: createReadonlyMethod("add" /* ADD */), - set: createReadonlyMethod("set" /* SET */), - delete: createReadonlyMethod("delete" /* DELETE */), - clear: createReadonlyMethod("clear" /* CLEAR */), - forEach: createForEach(true, true) - }; - const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; - iteratorMethods.forEach(method => { - mutableInstrumentations[method] = createIterableMethod(method, false, false); - readonlyInstrumentations[method] = createIterableMethod(method, true, false); - shallowInstrumentations[method] = createIterableMethod(method, false, true); - shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); - }); - return [ - mutableInstrumentations, - readonlyInstrumentations, - shallowInstrumentations, - shallowReadonlyInstrumentations - ]; -} -const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations(); -function createInstrumentationGetter(isReadonly, shallow) { - const instrumentations = shallow - ? isReadonly - ? shallowReadonlyInstrumentations - : shallowInstrumentations - : isReadonly - ? readonlyInstrumentations - : mutableInstrumentations; - return (target, key, receiver) => { - if (key === "__v_isReactive" /* IS_REACTIVE */) { - return !isReadonly; - } - else if (key === "__v_isReadonly" /* IS_READONLY */) { - return isReadonly; - } - else if (key === "__v_raw" /* RAW */) { - return target; - } - return Reflect.get(hasOwn(instrumentations, key) && key in target - ? instrumentations - : target, key, receiver); - }; -} -const mutableCollectionHandlers = { - get: /*#__PURE__*/ createInstrumentationGetter(false, false) -}; -const shallowCollectionHandlers = { - get: /*#__PURE__*/ createInstrumentationGetter(false, true) -}; -const readonlyCollectionHandlers = { - get: /*#__PURE__*/ createInstrumentationGetter(true, false) -}; -const shallowReadonlyCollectionHandlers = { - get: /*#__PURE__*/ createInstrumentationGetter(true, true) -}; -function checkIdentityKeys(target, has, key) { - const rawKey = toRaw(key); - if (rawKey !== key && has.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 = new WeakMap(); -const shallowReactiveMap = new WeakMap(); -const readonlyMap = new WeakMap(); -const shallowReadonlyMap = new WeakMap(); -function targetTypeMap(rawType) { - switch (rawType) { - case 'Object': - case 'Array': - return 1 /* COMMON */; - case 'Map': - case 'Set': - case 'WeakMap': - case 'WeakSet': - return 2 /* COLLECTION */; - default: - return 0 /* INVALID */; - } -} -function getTargetType(value) { - return value["__v_skip" /* SKIP */] || !Object.isExtensible(value) - ? 0 /* INVALID */ - : targetTypeMap(toRawType(value)); -} -function reactive(target) { - // if trying to observe a readonly proxy, return the readonly version. - if (target && target["__v_isReadonly" /* IS_READONLY */]) { - return target; - } - return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); -} -/** - * Return a shallowly-reactive copy of the original object, where only the root - * level properties are reactive. It also does not auto-unwrap refs (even at the - * root level). - */ -function shallowReactive(target) { - return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); -} -/** - * Creates a readonly copy of the original object. Note the returned copy is not - * made reactive, but `readonly` can be called on an already reactive object. - */ -function readonly(target) { - return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); -} -/** - * Returns a reactive-copy of the original object, where only the root level - * properties are readonly, and does NOT unwrap refs nor recursively convert - * returned properties. - * This is used for creating the props proxy object for stateful components. - */ -function shallowReadonly(target) { - return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); -} -function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { - if (!isObject(target)) { - if ((process.env.NODE_ENV !== 'production')) { - console.warn(`value cannot be made reactive: ${String(target)}`); - } - return target; - } - // target is already a Proxy, return it. - // exception: calling readonly() on a reactive object - if (target["__v_raw" /* RAW */] && - !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { - return target; - } - // target already has corresponding Proxy - const existingProxy = proxyMap.get(target); - if (existingProxy) { - return existingProxy; - } - // only a whitelist of value types can be observed. - const targetType = getTargetType(target); - if (targetType === 0 /* INVALID */) { - return target; - } - const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers); - proxyMap.set(target, proxy); - return proxy; -} -function isReactive(value) { - if (isReadonly(value)) { - return isReactive(value["__v_raw" /* RAW */]); - } - return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); -} -function isReadonly(value) { - return !!(value && value["__v_isReadonly" /* IS_READONLY */]); -} -function isProxy(value) { - return isReactive(value) || isReadonly(value); -} -function toRaw(observed) { - const raw = observed && observed["__v_raw" /* RAW */]; - return raw ? toRaw(raw) : observed; -} -function markRaw(value) { - def(value, "__v_skip" /* SKIP */, true); - return value; -} -const toReactive = (value) => isObject(value) ? reactive(value) : value; -const toReadonly = (value) => isObject(value) ? readonly(value) : value; - -function trackRefValue(ref) { - if (isTracking()) { - ref = toRaw(ref); - if (!ref.dep) { - ref.dep = createDep(); - } - if ((process.env.NODE_ENV !== 'production')) { - trackEffects(ref.dep, { - target: ref, - type: "get" /* GET */, - key: 'value' - }); - } - else { - trackEffects(ref.dep); - } - } -} -function triggerRefValue(ref, newVal) { - ref = toRaw(ref); - if (ref.dep) { - if ((process.env.NODE_ENV !== 'production')) { - triggerEffects(ref.dep, { - target: ref, - type: "set" /* SET */, - key: 'value', - newValue: newVal - }); - } - else { - triggerEffects(ref.dep); - } - } -} -function isRef(r) { - return Boolean(r && r.__v_isRef === true); -} -function ref(value) { - return createRef(value, false); -} -function shallowRef(value) { - return createRef(value, true); -} -function createRef(rawValue, shallow) { - if (isRef(rawValue)) { - return rawValue; - } - return new RefImpl(rawValue, shallow); -} -class RefImpl { - constructor(value, _shallow) { - this._shallow = _shallow; - this.dep = undefined; - this.__v_isRef = true; - this._rawValue = _shallow ? value : toRaw(value); - this._value = _shallow ? value : toReactive(value); - } - get value() { - trackRefValue(this); - return this._value; - } - set value(newVal) { - newVal = this._shallow ? newVal : toRaw(newVal); - if (hasChanged(newVal, this._rawValue)) { - this._rawValue = newVal; - this._value = this._shallow ? newVal : toReactive(newVal); - triggerRefValue(this, newVal); - } - } -} -function triggerRef(ref) { - triggerRefValue(ref, (process.env.NODE_ENV !== 'production') ? ref.value : void 0); -} -function unref(ref) { - return isRef(ref) ? ref.value : ref; -} -const shallowUnwrapHandlers = { - get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), - set: (target, key, value, receiver) => { - const oldValue = target[key]; - if (isRef(oldValue) && !isRef(value)) { - oldValue.value = value; - return true; - } - else { - return Reflect.set(target, key, value, receiver); - } - } -}; -function proxyRefs(objectWithRefs) { - return isReactive(objectWithRefs) - ? objectWithRefs - : new Proxy(objectWithRefs, shallowUnwrapHandlers); -} -class CustomRefImpl { - constructor(factory) { - this.dep = undefined; - this.__v_isRef = true; - const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this)); - this._get = get; - this._set = set; - } - get value() { - return this._get(); - } - set value(newVal) { - this._set(newVal); - } -} -function customRef(factory) { - return new CustomRefImpl(factory); -} -function toRefs(object) { - if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) { - console.warn(`toRefs() expects a reactive object but received a plain one.`); - } - const ret = isArray(object) ? new Array(object.length) : {}; - for (const key in object) { - ret[key] = toRef(object, key); - } - return ret; -} -class ObjectRefImpl { - constructor(_object, _key) { - this._object = _object; - this._key = _key; - this.__v_isRef = true; - } - get value() { - return this._object[this._key]; - } - set value(newVal) { - this._object[this._key] = newVal; - } -} -function toRef(object, key) { - const val = object[key]; - return isRef(val) ? val : new ObjectRefImpl(object, key); -} - -class ComputedRefImpl { - constructor(getter, _setter, isReadonly) { - this._setter = _setter; - this.dep = undefined; - this._dirty = true; - this.__v_isRef = true; - this.effect = new ReactiveEffect(getter, () => { - if (!this._dirty) { - this._dirty = true; - triggerRefValue(this); - } - }); - this["__v_isReadonly" /* IS_READONLY */] = isReadonly; - } - get value() { - // the computed ref may get wrapped by other proxies e.g. readonly() #3376 - const self = toRaw(this); - trackRefValue(self); - if (self._dirty) { - self._dirty = false; - self._value = self.effect.run(); - } - return self._value; - } - set value(newValue) { - this._setter(newValue); - } -} -function computed(getterOrOptions, debugOptions) { - let getter; - let setter; - const onlyGetter = isFunction(getterOrOptions); - if (onlyGetter) { - getter = getterOrOptions; - setter = (process.env.NODE_ENV !== 'production') - ? () => { - console.warn('Write operation failed: computed value is readonly'); - } - : NOOP; - } - else { - getter = getterOrOptions.get; - setter = getterOrOptions.set; - } - const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter); - if ((process.env.NODE_ENV !== 'production') && debugOptions) { - cRef.effect.onTrack = debugOptions.onTrack; - cRef.effect.onTrigger = debugOptions.onTrigger; - } - return cRef; -} - -function emit(event, ...args) { -} -const devtoolsComponentUpdated = -/*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */); -function createDevtoolsComponentHook(hook) { - return (component) => { - emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); - }; -} -function devtoolsComponentEmit(component, event, params) { - emit("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params); -} - -function emit$1(instance, event, ...rawArgs) { - const props = instance.vnode.props || EMPTY_OBJ; - if ((process.env.NODE_ENV !== 'production')) { - const { emitsOptions, propsOptions: [propsOptions] } = instance; - if (emitsOptions) { - if (!(event in emitsOptions) && - !(false )) { - if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { - warn$1(`Component emitted event "${event}" but it is neither declared in ` + - `the emits option nor as an "${toHandlerKey(event)}" prop.`); - } - } - else { - const validator = emitsOptions[event]; - if (isFunction(validator)) { - const isValid = validator(...rawArgs); - if (!isValid) { - warn$1(`Invalid event arguments: event validation failed for event "${event}".`); - } - } - } - } - } - let args = rawArgs; - const isModelListener = event.startsWith('update:'); - // for v-model update:xxx events, apply modifiers on args - const modelArg = isModelListener && event.slice(7); - if (modelArg && modelArg in props) { - const modifiersKey = `${modelArg === 'modelValue' ? 'model' : modelArg}Modifiers`; - const { number, trim } = props[modifiersKey] || EMPTY_OBJ; - if (trim) { - args = rawArgs.map(a => a.trim()); - } - else if (number) { - args = rawArgs.map(toNumber); - } - } - if ((process.env.NODE_ENV !== 'production') || false) { - devtoolsComponentEmit(instance, event, args); - } - if ((process.env.NODE_ENV !== 'production')) { - const lowerCaseEvent = event.toLowerCase(); - if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { - warn$1(`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))] || - // also try camelCase event handler (#2249) - props[(handlerName = toHandlerKey(camelize(event)))]; - // for v-model update:xxx events, also trigger kebab-case equivalent - // for props passed via kebab-case - if (!handler && isModelListener) { - handler = props[(handlerName = toHandlerKey(hyphenate(event)))]; - } - if (handler) { - callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); - } - const onceHandler = props[handlerName + `Once`]; - if (onceHandler) { - if (!instance.emitted) { - instance.emitted = {}; - } - else if (instance.emitted[handlerName]) { - return; - } - instance.emitted[handlerName] = true; - callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); - } -} -function normalizeEmitsOptions(comp, appContext, asMixin = false) { - const cache = appContext.emitsCache; - const cached = cache.get(comp); - if (cached !== undefined) { - return cached; - } - const raw = comp.emits; - let normalized = {}; - // apply mixin/extends props - let hasExtends = false; - if (__VUE_OPTIONS_API__ && !isFunction(comp)) { - const extendEmits = (raw) => { - const normalizedFromExtend = normalizeEmitsOptions(raw, appContext, true); - if (normalizedFromExtend) { - hasExtends = true; - extend(normalized, normalizedFromExtend); - } - }; - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendEmits); - } - if (comp.extends) { - extendEmits(comp.extends); - } - if (comp.mixins) { - comp.mixins.forEach(extendEmits); - } - } - if (!raw && !hasExtends) { - cache.set(comp, null); - return null; - } - if (isArray(raw)) { - raw.forEach(key => (normalized[key] = null)); - } - else { - extend(normalized, raw); - } - cache.set(comp, normalized); - return normalized; -} -// Check if an incoming prop key is a declared emit event listener. -// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are -// both considered matched listeners. -function isEmitListener(options, key) { - if (!options || !isOn(key)) { - return false; - } - key = key.slice(2).replace(/Once$/, ''); - return (hasOwn(options, key[0].toLowerCase() + key.slice(1)) || - hasOwn(options, hyphenate(key)) || - hasOwn(options, key)); -} - -/** - * mark the current rendering instance for asset resolution (e.g. - * resolveComponent, resolveDirective) during render - */ -let currentRenderingInstance = null; -let currentScopeId = null; -/** - * Note: rendering calls maybe nested. The function returns the parent rendering - * instance if present, which should be restored after the render is done: - * - * ```js - * const prev = setCurrentRenderingInstance(i) - * // ...render - * setCurrentRenderingInstance(prev) - * ``` - */ -function setCurrentRenderingInstance(instance) { - const prev = currentRenderingInstance; - currentRenderingInstance = instance; - currentScopeId = (instance && instance.type.__scopeId) || null; - return prev; -} -/** - * Only for backwards compat - * @private - */ -const withScopeId = (_id) => withCtx; -/** - * Wrap a slot function to memoize current rendering instance - * @private compiler helper - */ -function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // false only -) { - if (!ctx) - return fn; - // already normalized - if (fn._n) { - return fn; - } - const renderFnWithContext = (...args) => { - // If a user calls a compiled slot inside a template expression (#1745), it - // can mess up block tracking, so by default we disable block tracking and - // force bail out when invoking a compiled slot (indicated by the ._d flag). - // This isn't necessary if rendering a compiled ``, so we flip the - // ._d flag off when invoking the wrapped fn inside `renderSlot`. - if (renderFnWithContext._d) { - setBlockTracking(-1); - } - const prevInstance = setCurrentRenderingInstance(ctx); - const res = fn(...args); - setCurrentRenderingInstance(prevInstance); - if (renderFnWithContext._d) { - setBlockTracking(1); - } - if ((process.env.NODE_ENV !== 'production') || false) { - devtoolsComponentUpdated(ctx); - } - return res; - }; - // mark normalized to avoid duplicated wrapping - renderFnWithContext._n = true; - // mark this as compiled by default - // this is used in vnode.ts -> normalizeChildren() to set the slot - // rendering flag. - renderFnWithContext._c = true; - // disable block tracking by default - renderFnWithContext._d = true; - return renderFnWithContext; -} - -function markAttrsAccessed() { -} - -function provide(key, value) { - if (!currentInstance) { - if ((process.env.NODE_ENV !== 'production')) { - warn$1(`provide() can only be used inside setup().`); - } - } - else { - let provides = currentInstance.provides; - // by default an instance inherits its parent's provides object - // but when it needs to provide values of its own, it creates its - // own provides object using parent provides object as prototype. - // this way in `inject` we can simply look up injections from direct - // parent and let the prototype chain do the work. - const parentProvides = currentInstance.parent && currentInstance.parent.provides; - if (parentProvides === provides) { - provides = currentInstance.provides = Object.create(parentProvides); - } - // TS doesn't allow symbol as index type - provides[key] = value; - } -} -function inject(key, defaultValue, treatDefaultAsFactory = false) { - // fallback to `currentRenderingInstance` so that this can be called in - // a functional component - const instance = currentInstance || currentRenderingInstance; - if (instance) { - // #2400 - // to support `app.use` plugins, - // fallback to appContext's `provides` if the intance is at root - const provides = instance.parent == null - ? instance.vnode.appContext && instance.vnode.appContext.provides - : instance.parent.provides; - if (provides && key in provides) { - // TS doesn't allow symbol as index type - return provides[key]; - } - else if (arguments.length > 1) { - return treatDefaultAsFactory && isFunction(defaultValue) - ? defaultValue.call(instance.proxy) - : defaultValue; - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`injection "${String(key)}" not found.`); - } - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`inject() can only be used inside setup() or functional components.`); - } -} - -// implementation, close to no-op -function defineComponent(options) { - return isFunction(options) ? { setup: options, name: options.name } : options; -} - -const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; -function onActivated(hook, target) { - registerKeepAliveHook(hook, "a" /* ACTIVATED */, target); -} -function onDeactivated(hook, target) { - registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target); -} -function registerKeepAliveHook(hook, type, target = currentInstance) { - // cache the deactivate branch check wrapper for injected hooks so the same - // hook can be properly deduped by the scheduler. "__wdc" stands for "with - // deactivation check". - const wrappedHook = hook.__wdc || - (hook.__wdc = () => { - // only fire the hook if the target instance is NOT in a deactivated branch. - let current = target; - while (current) { - if (current.isDeactivated) { - return; - } - current = current.parent; - } - hook(); - }); - injectHook(type, wrappedHook, target); - // In addition to registering it on the target instance, we walk up the parent - // chain and register it on all ancestor instances that are keep-alive roots. - // This avoids the need to walk the entire component tree when invoking these - // hooks, and more importantly, avoids the need to track child components in - // arrays. - if (target) { - let current = target.parent; - while (current && current.parent) { - if (isKeepAlive(current.parent.vnode)) { - injectToKeepAliveRoot(wrappedHook, type, target, current); - } - current = current.parent; - } - } -} -function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { - // injectHook wraps the original for error handling, so make sure to remove - // the wrapped version. - const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); - onUnmounted(() => { - remove(keepAliveRoot[type], injected); - }, target); -} - -function injectHook(type, hook, target = currentInstance, prepend = false) { - if (target) { - // fixed by xxxxxx - if (isRootHook(type)) { - target = target.root; - } - const hooks = target[type] || (target[type] = []); - // cache the error handling wrapper for injected hooks so the same hook - // can be properly deduped by the scheduler. "__weh" stands for "with error - // handling". - const wrappedHook = hook.__weh || - (hook.__weh = (...args) => { - if (target.isUnmounted) { - return; - } - // disable tracking inside all lifecycle hooks - // since they can potentially be called inside effects. - pauseTracking(); - // Set currentInstance during hook invocation. - // This assumes the hook does not synchronously trigger other hooks, which - // can only be false when the user does something really funky. - setCurrentInstance(target); // fixed by xxxxxx - const res = callWithAsyncErrorHandling(hook, target, type, args); - unsetCurrentInstance(); - resetTracking(); - return res; - }); - if (prepend) { - hooks.unshift(wrappedHook); - } - else { - hooks.push(wrappedHook); - } - return wrappedHook; - } - else if ((process.env.NODE_ENV !== 'production')) { - const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, '')); - warn$1(`${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().` + - (``)); - } -} -const createHook = (lifecycle) => (hook, target = currentInstance) => -// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) -(!isInSSRComponentSetup || lifecycle === "sp" /* SERVER_PREFETCH */) && - injectHook(lifecycle, hook, target); -const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */); -const onMounted = createHook("m" /* MOUNTED */); -const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */); -const onUpdated = createHook("u" /* UPDATED */); -const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */); -const onUnmounted = createHook("um" /* UNMOUNTED */); -const onServerPrefetch = createHook("sp" /* SERVER_PREFETCH */); -const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */); -const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */); -function onErrorCaptured(hook, target = currentInstance) { - injectHook("ec" /* ERROR_CAPTURED */, hook, target); -} - -function createDuplicateChecker() { - const cache = Object.create(null); - return (type, key) => { - if (cache[key]) { - warn$1(`${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; - // do not cache property access on public proxy during state initialization - shouldCacheAccess = false; - // call beforeCreate first before accessing other options since - // the hook may mutate resolved options (#2791) - if (options.beforeCreate) { - callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */); - } - const { - // state - data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, - // lifecycle - created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, - // public API - expose, inheritAttrs, - // assets - components, directives, filters } = options; - const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null; - if ((process.env.NODE_ENV !== 'production')) { - const [propsOptions] = instance.propsOptions; - if (propsOptions) { - for (const key in propsOptions) { - checkDuplicateProperties("Props" /* PROPS */, key); - } - } - } - // options initialization order (to be consistent with Vue 2): - // - props (already done outside of this function) - // - inject - // - methods - // - data (deferred since it relies on `this` access) - // - computed - // - watch (deferred since it relies on `this` access) - // fixed by xxxxxx - if (!__VUE_CREATED_DEFERRED__ && injectOptions) { - resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef); - } - if (methods) { - for (const key in methods) { - const methodHandler = methods[key]; - if (isFunction(methodHandler)) { - // In dev mode, we use the `createRenderContext` function to define - // methods to the proxy target, and those are read-only but - // reconfigurable, so it needs to be redefined here - if ((process.env.NODE_ENV !== 'production')) { - Object.defineProperty(ctx, key, { - value: methodHandler.bind(publicThis), - configurable: true, - enumerable: true, - writable: true - }); - } - else { - ctx[key] = methodHandler.bind(publicThis); - } - if ((process.env.NODE_ENV !== 'production')) { - checkDuplicateProperties("Methods" /* METHODS */, key); - } - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + - `Did you reference the function correctly?`); - } - } - } - if (dataOptions) { - if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) { - warn$1(`The data option must be a function. ` + - `Plain object usage is no longer supported.`); - } - const data = dataOptions.call(publicThis, publicThis); - if ((process.env.NODE_ENV !== 'production') && isPromise(data)) { - warn$1(`data() returned a Promise - note data() cannot be async; If you ` + - `intend to perform data fetching before component renders, use ` + - `async setup() + .`); - } - if (!isObject(data)) { - (process.env.NODE_ENV !== 'production') && warn$1(`data() should return an object.`); - } - else { - instance.data = reactive(data); - if ((process.env.NODE_ENV !== 'production')) { - for (const key in data) { - checkDuplicateProperties("Data" /* DATA */, key); - // expose data on ctx during dev - if (key[0] !== '$' && key[0] !== '_') { - Object.defineProperty(ctx, key, { - configurable: true, - enumerable: true, - get: () => data[key], - set: NOOP - }); - } - } - } - } - } - // state initialization complete at this point - start caching access - shouldCacheAccess = true; - if (computedOptions) { - for (const key in computedOptions) { - const opt = computedOptions[key]; - const get = isFunction(opt) - ? opt.bind(publicThis, publicThis) - : isFunction(opt.get) - ? opt.get.bind(publicThis, publicThis) - : NOOP; - if ((process.env.NODE_ENV !== 'production') && get === NOOP) { - warn$1(`Computed property "${key}" has no getter.`); - } - const set = !isFunction(opt) && isFunction(opt.set) - ? opt.set.bind(publicThis) - : (process.env.NODE_ENV !== 'production') - ? () => { - warn$1(`Write operation failed: computed property "${key}" is readonly.`); - } - : NOOP; - const c = computed({ - get, - set - }); - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => c.value, - set: v => (c.value = v) - }); - if ((process.env.NODE_ENV !== 'production')) { - checkDuplicateProperties("Computed" /* COMPUTED */, key); - } - } - } - if (watchOptions) { - for (const key in watchOptions) { - createWatcher(watchOptions[key], ctx, publicThis, key); - } - } - // fixed by xxxxxx - if (!__VUE_CREATED_DEFERRED__) { - if (provideOptions) { - const provides = isFunction(provideOptions) - ? provideOptions.call(publicThis) - : provideOptions; - Reflect.ownKeys(provides).forEach(key => { - provide(key, provides[key]); - }); - } - } - // fixed by xxxxxx - if (__VUE_CREATED_DEFERRED__) { - ctx.$callCreatedHook = function (name) { - if (created) { - return callHook(created, instance, "c" /* CREATED */); - } - }; - } - else { - if (created) { - callHook(created, instance, "c" /* CREATED */); - } - } - function registerLifecycleHook(register, hook) { - if (isArray(hook)) { - hook.forEach(_hook => register(_hook.bind(publicThis))); - } - else if (hook) { - register(hook.bind(publicThis)); - } - } - registerLifecycleHook(onBeforeMount, beforeMount); - registerLifecycleHook(onMounted, mounted); - registerLifecycleHook(onBeforeUpdate, beforeUpdate); - registerLifecycleHook(onUpdated, updated); - registerLifecycleHook(onActivated, activated); - registerLifecycleHook(onDeactivated, deactivated); - registerLifecycleHook(onErrorCaptured, errorCaptured); - registerLifecycleHook(onRenderTracked, renderTracked); - registerLifecycleHook(onRenderTriggered, renderTriggered); - registerLifecycleHook(onBeforeUnmount, beforeUnmount); - registerLifecycleHook(onUnmounted, unmounted); - registerLifecycleHook(onServerPrefetch, serverPrefetch); - if (isArray(expose)) { - if (expose.length) { - const exposed = instance.exposed || (instance.exposed = {}); - expose.forEach(key => { - Object.defineProperty(exposed, key, { - get: () => publicThis[key], - set: val => (publicThis[key] = val) - }); - }); - } - else if (!instance.exposed) { - instance.exposed = {}; - } - } - // options that are handled when creating the instance but also need to be - // applied from mixins - if (render && instance.render === NOOP) { - instance.render = render; - } - if (inheritAttrs != null) { - instance.inheritAttrs = inheritAttrs; - } - // asset options. - if (components) - instance.components = components; - if (directives) - instance.directives = directives; - // fixed by xxxxxx - if (instance.ctx.$onApplyOptions) { - instance.ctx.$onApplyOptions(options, instance, publicThis); - } -} -function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) { - if (isArray(injectOptions)) { - injectOptions = normalizeInject(injectOptions); - } - for (const key in injectOptions) { - const opt = injectOptions[key]; - let injected; - if (isObject(opt)) { - if ('default' in opt) { - injected = inject(opt.from || key, opt.default, true /* treat default function as factory */); - } - else { - injected = inject(opt.from || key); - } - } - else { - injected = inject(opt); - } - if (isRef(injected)) { - // TODO remove the check in 3.3 - if (unwrapRef) { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => injected.value, - set: v => (injected.value = v) - }); - } - else { - if ((process.env.NODE_ENV !== 'production')) { - warn$1(`injected property "${key}" is a ref and will be auto-unwrapped ` + - `and no longer needs \`.value\` in the next minor release. ` + - `To opt-in to the new behavior now, ` + - `set \`app.config.unwrapInjectedRef = true\` (this config is ` + - `temporary and will not be needed in the future.)`); - } - ctx[key] = injected; - } - } - else { - ctx[key] = injected; - } - if ((process.env.NODE_ENV !== 'production')) { - checkDuplicateProperties("Inject" /* INJECT */, key); - } - } -} -function callHook(hook, instance, type) { - callWithAsyncErrorHandling(isArray(hook) - ? hook.map(h => h.bind(instance.proxy)) - : hook.bind(instance.proxy), instance, type); -} -function createWatcher(raw, ctx, publicThis, key) { - const getter = key.includes('.') - ? createPathGetter(publicThis, key) - : () => publicThis[key]; - if (isString(raw)) { - const handler = ctx[raw]; - if (isFunction(handler)) { - watch(getter, handler); - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`Invalid watch handler specified by key "${raw}"`, handler); - } - } - else if (isFunction(raw)) { - watch(getter, raw.bind(publicThis)); - } - else if (isObject(raw)) { - if (isArray(raw)) { - raw.forEach(r => createWatcher(r, ctx, publicThis, key)); - } - else { - const handler = isFunction(raw.handler) - ? raw.handler.bind(publicThis) - : ctx[raw.handler]; - if (isFunction(handler)) { - watch(getter, handler, raw); - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler); - } - } - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`Invalid watch option: "${key}"`, raw); - } -} -/** - * Resolve merged options and cache it on the component. - * This is done only once per-component since the merging does not involve - * instances. - */ -function resolveMergedOptions(instance) { - const base = instance.type; - const { mixins, extends: extendsOptions } = base; - const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext; - const cached = cache.get(base); - let resolved; - if (cached) { - resolved = cached; - } - else if (!globalMixins.length && !mixins && !extendsOptions) { - { - resolved = base; - } - } - else { - resolved = {}; - if (globalMixins.length) { - globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true)); - } - mergeOptions(resolved, base, optionMergeStrategies); - } - cache.set(base, resolved); - return resolved; -} -function mergeOptions(to, from, strats, asMixin = false) { - const { mixins, extends: extendsOptions } = from; - if (extendsOptions) { - mergeOptions(to, extendsOptions, strats, true); - } - if (mixins) { - mixins.forEach((m) => mergeOptions(to, m, strats, true)); - } - for (const key in from) { - if (asMixin && key === 'expose') { - (process.env.NODE_ENV !== 'production') && - warn$1(`"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 = { - data: mergeDataFn, - props: mergeObjectOptions, - emits: mergeObjectOptions, - // objects - methods: mergeObjectOptions, - computed: mergeObjectOptions, - // lifecycle - beforeCreate: mergeAsArray, - created: mergeAsArray, - beforeMount: mergeAsArray, - mounted: mergeAsArray, - beforeUpdate: mergeAsArray, - updated: mergeAsArray, - beforeDestroy: mergeAsArray, - beforeUnmount: mergeAsArray, - destroyed: mergeAsArray, - unmounted: mergeAsArray, - activated: mergeAsArray, - deactivated: mergeAsArray, - errorCaptured: mergeAsArray, - serverPrefetch: mergeAsArray, - // assets - components: mergeObjectOptions, - directives: mergeObjectOptions, - // watch - watch: mergeWatchOptions, - // provide / inject - provide: mergeDataFn, - inject: mergeInject -}; -function mergeDataFn(to, from) { - if (!from) { - return to; - } - if (!to) { - return from; - } - return function mergedDataFn() { - return (extend)(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); - }; -} -function mergeInject(to, from) { - return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); -} -function normalizeInject(raw) { - if (isArray(raw)) { - const res = {}; - for (let i = 0; i < raw.length; i++) { - res[raw[i]] = raw[i]; - } - return res; - } - return raw; -} -function mergeAsArray(to, from) { - return to ? [...new Set([].concat(to, from))] : from; -} -function mergeObjectOptions(to, from) { - return to ? extend(extend(Object.create(null), to), from) : from; -} -function mergeWatchOptions(to, from) { - if (!to) - return from; - if (!from) - return to; - const merged = extend(Object.create(null), to); - for (const key in from) { - merged[key] = mergeAsArray(to[key], from[key]); - } - return merged; -} - -function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison -isSSR = false) { - const props = {}; - const attrs = {}; - // def(attrs, InternalObjectKey, 1) // fixed by xxxxxx - def(attrs, '__vInternal', 1); - instance.propsDefaults = Object.create(null); - setFullProps(instance, rawProps, props, attrs); - // ensure all declared prop keys are present - for (const key in instance.propsOptions[0]) { - if (!(key in props)) { - props[key] = undefined; - } - } - // validation - if ((process.env.NODE_ENV !== 'production')) { - validateProps(rawProps || {}, props, instance); - } - if (isStateful) { - // stateful - instance.props = isSSR ? props : shallowReactive(props); - } - else { - if (!instance.type.props) { - // functional w/ optional props, props === attrs - instance.props = attrs; - } - else { - // functional w/ declared props - instance.props = props; - } - } - instance.attrs = attrs; -} -function setFullProps(instance, rawProps, props, attrs) { - const [options, needCastKeys] = instance.propsOptions; - let hasAttrsChanged = false; - let rawCastValues; - if (rawProps) { - for (let key in rawProps) { - // key, ref are reserved and never passed down - if (isReservedProp(key)) { - continue; - } - const value = rawProps[key]; - // prop option names are camelized during normalization, so to support - // kebab -> camel conversion here we need to camelize the key. - let camelKey; - if (options && hasOwn(options, (camelKey = camelize(key)))) { - if (!needCastKeys || !needCastKeys.includes(camelKey)) { - props[camelKey] = value; - } - else { - (rawCastValues || (rawCastValues = {}))[camelKey] = value; - } - } - else if (!isEmitListener(instance.emitsOptions, key)) { - if (value !== attrs[key]) { - attrs[key] = value; - hasAttrsChanged = true; - } - } - } - } - if (needCastKeys) { - const rawCurrentProps = toRaw(props); - const castValues = rawCastValues || EMPTY_OBJ; - for (let i = 0; i < needCastKeys.length; i++) { - const key = needCastKeys[i]; - props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key)); - } - } - return hasAttrsChanged; -} -function resolvePropValue(options, props, key, value, instance, isAbsent) { - const opt = options[key]; - if (opt != null) { - const hasDefault = hasOwn(opt, 'default'); - // default values - if (hasDefault && value === undefined) { - const defaultValue = opt.default; - if (opt.type !== Function && isFunction(defaultValue)) { - const { propsDefaults } = instance; - if (key in propsDefaults) { - value = propsDefaults[key]; - } - else { - setCurrentInstance(instance); - value = propsDefaults[key] = defaultValue.call(null, props); - unsetCurrentInstance(); - } - } - else { - value = defaultValue; - } - } - // boolean casting - if (opt[0 /* shouldCast */]) { - if (isAbsent && !hasDefault) { - value = false; - } - else if (opt[1 /* shouldCastTrue */] && - (value === '' || value === hyphenate(key))) { - value = true; - } - } - } - return value; -} -function normalizePropsOptions(comp, appContext, asMixin = false) { - const cache = appContext.propsCache; - const cached = cache.get(comp); - if (cached) { - return cached; - } - const raw = comp.props; - const normalized = {}; - const needCastKeys = []; - // apply mixin/extends props - let hasExtends = false; - if (__VUE_OPTIONS_API__ && !isFunction(comp)) { - const extendProps = (raw) => { - hasExtends = true; - const [props, keys] = normalizePropsOptions(raw, appContext, true); - extend(normalized, props); - if (keys) - needCastKeys.push(...keys); - }; - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendProps); - } - if (comp.extends) { - extendProps(comp.extends); - } - if (comp.mixins) { - comp.mixins.forEach(extendProps); - } - } - if (!raw && !hasExtends) { - cache.set(comp, EMPTY_ARR); - return EMPTY_ARR; - } - if (isArray(raw)) { - for (let i = 0; i < raw.length; i++) { - if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) { - warn$1(`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 ((process.env.NODE_ENV !== 'production') && !isObject(raw)) { - warn$1(`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(opt) || isFunction(opt) ? { type: opt } : opt); - if (prop) { - const booleanIndex = getTypeIndex(Boolean, prop.type); - const stringIndex = getTypeIndex(String, prop.type); - prop[0 /* shouldCast */] = booleanIndex > -1; - prop[1 /* shouldCastTrue */] = - stringIndex < 0 || booleanIndex < stringIndex; - // if the prop needs boolean casting or default value - if (booleanIndex > -1 || hasOwn(prop, 'default')) { - needCastKeys.push(normalizedKey); - } - } - } - } - } - const res = [normalized, needCastKeys]; - cache.set(comp, res); - return res; -} -function validatePropName(key) { - if (key[0] !== '$') { - return true; - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`Invalid prop name: "${key}" is a reserved property.`); - } - return false; -} -// use function string name to check type constructors -// so that it works across vms / iframes. -function getType(ctor) { - const match = ctor && ctor.toString().match(/^\s*function (\w+)/); - return match ? match[1] : ctor === null ? 'null' : ''; -} -function isSameType(a, b) { - return getType(a) === getType(b); -} -function getTypeIndex(type, expectedTypes) { - if (isArray(expectedTypes)) { - return expectedTypes.findIndex(t => isSameType(t, type)); - } - else if (isFunction(expectedTypes)) { - return isSameType(expectedTypes, type) ? 0 : -1; - } - return -1; -} -/** - * dev only - */ -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))); - } -} -/** - * dev only - */ -function validateProp(name, value, prop, isAbsent) { - const { type, required, validator } = prop; - // required! - if (required && isAbsent) { - warn$1('Missing required prop: "' + name + '"'); - return; - } - // missing but optional - if (value == null && !prop.required) { - return; - } - // type check - if (type != null && type !== true) { - let isValid = false; - const types = isArray(type) ? type : [type]; - const expectedTypes = []; - // value is valid as long as one of the specified types match - for (let i = 0; i < types.length && !isValid; i++) { - const { valid, expectedType } = assertType(value, types[i]); - expectedTypes.push(expectedType || ''); - isValid = valid; - } - if (!isValid) { - warn$1(getInvalidTypeMessage(name, value, expectedTypes)); - return; - } - } - // custom validator - if (validator && !validator(value)) { - warn$1('Invalid prop: custom validator check failed for prop "' + name + '".'); - } -} -const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol,BigInt'); -/** - * dev only - */ -function assertType(value, type) { - let valid; - const expectedType = getType(type); - if (isSimpleType(expectedType)) { - const t = typeof value; - valid = t === expectedType.toLowerCase(); - // for primitive wrapper objects - if (!valid && t === 'object') { - valid = value instanceof type; - } - } - else if (expectedType === 'Object') { - valid = isObject(value); - } - else if (expectedType === 'Array') { - valid = isArray(value); - } - else if (expectedType === 'null') { - valid = value === null; - } - else { - valid = value instanceof type; - } - return { - valid, - expectedType - }; -} -/** - * dev only - */ -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); - // check if we need to specify expected value - if (expectedTypes.length === 1 && - isExplicable(expectedType) && - !isBoolean(expectedType, receivedType)) { - message += ` with value ${expectedValue}`; - } - message += `, got ${receivedType} `; - // check if we need to specify received value - if (isExplicable(receivedType)) { - message += `with value ${receivedValue}.`; - } - return message; -} -/** - * dev only - */ -function styleValue(value, type) { - if (type === 'String') { - return `"${value}"`; - } - else if (type === 'Number') { - return `${Number(value)}`; - } - else { - return `${value}`; - } -} -/** - * dev only - */ -function isExplicable(type) { - const explicitTypes = ['string', 'number', 'boolean']; - return explicitTypes.some(elem => type.toLowerCase() === elem); -} -/** - * dev only - */ -function isBoolean(...args) { - return args.some(elem => elem.toLowerCase() === 'boolean'); -} - -/** -Runtime helper for applying directives to a vnode. Example usage: - -const comp = resolveComponent('comp') -const foo = resolveDirective('foo') -const bar = resolveDirective('bar') - -return withDirectives(h(comp), [ - [foo, this.x], - [bar, this.y] -]) -*/ -const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text'); -function validateDirectiveName(name) { - if (isBuiltInDirective(name)) { - warn$1('Do not use built-in directive ids as custom directive id: ' + name); - } -} -/** - * Adds directives to a VNode. - */ -function withDirectives(vnode, directives) { - const internalInstance = currentRenderingInstance; - if (internalInstance === null) { - (process.env.NODE_ENV !== 'production') && warn$1(`withDirectives can only be used inside render functions.`); - return vnode; - } - const instance = 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 (isFunction(dir)) { - dir = { - mounted: dir, - updated: dir - }; - } - if (dir.deep) { - traverse(value); - } - bindings.push({ - dir, - instance, - value, - oldValue: void 0, - arg, - modifiers - }); - } - return vnode; -} - -function createAppContext() { - return { - app: null, - config: { - isNativeTag: NO, - performance: false, - globalProperties: {}, - optionMergeStrategies: {}, - errorHandler: undefined, - warnHandler: undefined, - compilerOptions: {} - }, - mixins: [], - components: {}, - directives: {}, - provides: Object.create(null), - optionsCache: new WeakMap(), - propsCache: new WeakMap(), - emitsCache: new WeakMap() - }; -} -let uid = 0; -function createAppAPI(render, // fixed by xxxxxx -hydrate) { - return function createApp(rootComponent, rootProps = null) { - if (rootProps != null && !isObject(rootProps)) { - (process.env.NODE_ENV !== 'production') && warn$1(`root props passed to app.mount() must be an object.`); - rootProps = null; - } - const context = createAppContext(); - const installedPlugins = new Set(); - // fixed by xxxxxx - // let isMounted = false - const app = (context.app = { - _uid: uid++, - _component: rootComponent, - _props: rootProps, - _container: null, - _context: context, - _instance: null, - version, - get config() { - return context.config; - }, - set config(v) { - if ((process.env.NODE_ENV !== 'production')) { - warn$1(`app.config cannot be replaced. Modify individual options instead.`); - } - }, - use(plugin, ...options) { - if (installedPlugins.has(plugin)) { - (process.env.NODE_ENV !== 'production') && warn$1(`Plugin has already been applied to target app.`); - } - else if (plugin && isFunction(plugin.install)) { - installedPlugins.add(plugin); - plugin.install(app, ...options); - } - else if (isFunction(plugin)) { - installedPlugins.add(plugin); - plugin(app, ...options); - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`A plugin must either be a function or an object with an "install" ` + - `function.`); - } - return app; - }, - mixin(mixin) { - if (__VUE_OPTIONS_API__) { - if (!context.mixins.includes(mixin)) { - context.mixins.push(mixin); - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1('Mixin has already been applied to target app' + - (mixin.name ? `: ${mixin.name}` : '')); - } - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1('Mixins are only available in builds supporting Options API'); - } - return app; - }, - component(name, component) { - if ((process.env.NODE_ENV !== 'production')) { - validateComponentName(name, context.config); - } - if (!component) { - return context.components[name]; - } - if ((process.env.NODE_ENV !== 'production') && context.components[name]) { - warn$1(`Component "${name}" has already been registered in target app.`); - } - context.components[name] = component; - return app; - }, - directive(name, directive) { - if ((process.env.NODE_ENV !== 'production')) { - validateDirectiveName(name); - } - if (!directive) { - return context.directives[name]; - } - if ((process.env.NODE_ENV !== 'production') && context.directives[name]) { - warn$1(`Directive "${name}" has already been registered in target app.`); - } - context.directives[name] = directive; - return app; - }, - // fixed by xxxxxx - mount() { }, - // fixed by xxxxxx - unmount() { }, - provide(key, value) { - if ((process.env.NODE_ENV !== 'production') && key in context.provides) { - warn$1(`App already provides property with key "${String(key)}". ` + - `It will be overwritten with the new value.`); - } - // TypeScript doesn't allow symbols as index type - // https://github.com/Microsoft/TypeScript/issues/24587 - context.provides[key] = value; - return app; - } - }); - // fixed by xxxxxx - // if (false) { - // installAppCompatProperties(app, context, render) - // } - return app; - }; -} - -const queuePostRenderEffect = queuePostFlushCb; - -const isTeleport = (type) => type.__isTeleport; - -const COMPONENTS = 'components'; -const DIRECTIVES = 'directives'; -/** - * @private - */ -function resolveComponent(name, maybeSelfReference) { - return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; -} -const NULL_DYNAMIC_COMPONENT = Symbol(); -/** - * @private - */ -function resolveDirective(name) { - return resolveAsset(DIRECTIVES, name); -} -// implementation -function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { - const instance = currentRenderingInstance || currentInstance; - if (instance) { - const Component = instance.type; - // explicit self name has highest priority - if (type === COMPONENTS) { - const selfName = getComponentName(Component); - if (selfName && - (selfName === name || - selfName === camelize(name) || - selfName === capitalize(camelize(name)))) { - return Component; - } - } - const res = - // local registration - // check instance[type] first which is resolved for options API - resolve(instance[type] || Component[type], name) || - // global registration - resolve(instance.appContext[type], name); - if (!res && maybeSelfReference) { - // fallback to implicit self-reference - return Component; - } - if ((process.env.NODE_ENV !== 'production') && warnMissing && !res) { - const extra = type === COMPONENTS - ? `\nIf this is a native custom element, make sure to exclude it from ` + - `component resolution via compilerOptions.isCustomElement.` - : ``; - warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`); - } - return res; - } - else if ((process.env.NODE_ENV !== 'production')) { - warn$1(`resolve${capitalize(type.slice(0, -1))} ` + - `can only be used in render() or setup().`); - } -} -function resolve(registry, name) { - return (registry && - (registry[name] || - registry[camelize(name)] || - registry[capitalize(camelize(name))])); -} - -const Fragment = Symbol((process.env.NODE_ENV !== 'production') ? 'Fragment' : undefined); -const Text = Symbol((process.env.NODE_ENV !== 'production') ? 'Text' : undefined); -const Comment = Symbol((process.env.NODE_ENV !== 'production') ? 'Comment' : undefined); -Symbol((process.env.NODE_ENV !== 'production') ? 'Static' : undefined); -let currentBlock = null; -// Whether we should be tracking dynamic child nodes inside a block. -// Only tracks when this value is > 0 -// We are not using a simple boolean because this value may need to be -// incremented/decremented by nested usage of v-once (see below) -let isBlockTreeEnabled = 1; -/** - * Block tracking sometimes needs to be disabled, for example during the - * creation of a tree that needs to be cached by v-once. The compiler generates - * code like this: - * - * ``` js - * _cache[1] || ( - * setBlockTracking(-1), - * _cache[1] = createVNode(...), - * setBlockTracking(1), - * _cache[1] - * ) - * ``` - * - * @private - */ -function setBlockTracking(value) { - isBlockTreeEnabled += value; -} -function isVNode(value) { - return value ? value.__v_isVNode === true : false; -} -const createVNodeWithArgsTransform = (...args) => { - return _createVNode(...(args)); -}; -const InternalObjectKey = `__vInternal`; -const normalizeKey = ({ key }) => key != null ? key : null; -const normalizeRef = ({ ref }) => { - return (ref != null - ? isString(ref) || isRef(ref) || isFunction(ref) - ? { i: currentRenderingInstance, r: ref } - : ref - : null); -}; -function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1 /* ELEMENT */, isBlockNode = false, needFullChildrenNormalization = false) { - const vnode = { - __v_isVNode: true, - __v_skip: true, - type, - props, - key: props && normalizeKey(props), - ref: props && normalizeRef(props), - scopeId: currentScopeId, - slotScopeIds: null, - children, - component: null, - suspense: null, - ssContent: null, - ssFallback: null, - dirs: null, - transition: null, - el: null, - anchor: null, - target: null, - targetAnchor: null, - staticCount: 0, - shapeFlag, - patchFlag, - dynamicProps, - dynamicChildren: null, - appContext: null - }; - if (needFullChildrenNormalization) { - normalizeChildren(vnode, children); - } - else if (children) { - // compiled element vnode - if children is passed, only possible types are - // string or Array. - vnode.shapeFlag |= isString(children) - ? 8 /* TEXT_CHILDREN */ - : 16 /* ARRAY_CHILDREN */; - } - // validate key - if ((process.env.NODE_ENV !== 'production') && vnode.key !== vnode.key) { - warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type); - } - // track vnode for block tree - if (isBlockTreeEnabled > 0 && - // avoid a block node from tracking itself - !isBlockNode && - // has current parent block - currentBlock && - // presence of a patch flag indicates this node needs patching on updates. - // component nodes also should always be patched, because even if the - // component doesn't need to update, it needs to persist the instance on to - // the next vnode so that it can be properly unmounted later. - (vnode.patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) && - // the EVENTS flag is only for hydration and if it is the only flag, the - // vnode should not be considered dynamic due to handler caching. - vnode.patchFlag !== 32 /* HYDRATE_EVENTS */) { - currentBlock.push(vnode); - } - return vnode; -} -const createVNode = ((process.env.NODE_ENV !== 'production') ? createVNodeWithArgsTransform : _createVNode); -function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) { - if (!type || type === NULL_DYNAMIC_COMPONENT) { - if ((process.env.NODE_ENV !== 'production') && !type) { - warn$1(`Invalid vnode type when creating vnode: ${type}.`); - } - type = Comment; - } - if (isVNode(type)) { - // createVNode receiving an existing vnode. This happens in cases like - // - // #2078 make sure to merge refs during the clone instead of overwriting it - const cloned = cloneVNode(type, props, true /* mergeRef: true */); - if (children) { - normalizeChildren(cloned, children); - } - return cloned; - } - // class component normalization. - if (isClassComponent(type)) { - type = type.__vccOpts; - } - // class & style normalization. - if (props) { - // for reactive or proxy objects, we need to clone it to enable mutation. - props = guardReactiveProps(props); - let { class: klass, style } = props; - if (klass && !isString(klass)) { - props.class = normalizeClass(klass); - } - if (isObject(style)) { - // reactive state objects need to be cloned since they are likely to be - // mutated - if (isProxy(style) && !isArray(style)) { - style = extend({}, style); - } - props.style = normalizeStyle(style); - } - } - // encode the vnode type information into a bitmap - const shapeFlag = isString(type) - ? 1 /* ELEMENT */ - : isTeleport(type) - ? 64 /* TELEPORT */ - : isObject(type) - ? 4 /* STATEFUL_COMPONENT */ - : isFunction(type) - ? 2 /* FUNCTIONAL_COMPONENT */ - : 0; - if ((process.env.NODE_ENV !== 'production') && shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) { - type = toRaw(type); - warn$1(`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\`.`, `\nComponent that was made reactive: `, type); - } - return createBaseVNode(type, props, children, patchFlag, dynamicProps, shapeFlag, isBlockNode, true); -} -function guardReactiveProps(props) { - if (!props) - return null; - return isProxy(props) || InternalObjectKey in props - ? extend({}, props) - : props; -} -function cloneVNode(vnode, extraProps, mergeRef = false) { - // This is intentionally NOT using spread or extend to avoid the runtime - // key enumeration cost. - const { props, ref, patchFlag, children } = vnode; - const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props; - const cloned = { - __v_isVNode: true, - __v_skip: true, - type: vnode.type, - props: mergedProps, - key: mergedProps && normalizeKey(mergedProps), - ref: extraProps && extraProps.ref - ? // #2078 in the case of - // if the vnode itself already has a ref, cloneVNode will need to merge - // the refs so the single vnode can be set on multiple refs - mergeRef && ref - ? isArray(ref) - ? ref.concat(normalizeRef(extraProps)) - : [ref, normalizeRef(extraProps)] - : normalizeRef(extraProps) - : ref, - scopeId: vnode.scopeId, - slotScopeIds: vnode.slotScopeIds, - children: (process.env.NODE_ENV !== 'production') && patchFlag === -1 /* HOISTED */ && isArray(children) - ? children.map(deepCloneVNode) - : children, - target: vnode.target, - targetAnchor: vnode.targetAnchor, - staticCount: vnode.staticCount, - shapeFlag: vnode.shapeFlag, - // if the vnode is cloned with extra props, we can no longer assume its - // existing patch flag to be reliable and need to add the FULL_PROPS flag. - // note: perserve flag for fragments since they use the flag for children - // fast paths only. - patchFlag: extraProps && vnode.type !== Fragment - ? patchFlag === -1 // hoisted node - ? 16 /* FULL_PROPS */ - : patchFlag | 16 /* FULL_PROPS */ - : patchFlag, - dynamicProps: vnode.dynamicProps, - dynamicChildren: vnode.dynamicChildren, - appContext: vnode.appContext, - dirs: vnode.dirs, - transition: vnode.transition, - // These should technically only be non-null on mounted VNodes. However, - // they *should* be copied for kept-alive vnodes. So we just always copy - // them since them being non-null during a mount doesn't affect the logic as - // they will simply be overwritten. - component: vnode.component, - suspense: vnode.suspense, - ssContent: vnode.ssContent && cloneVNode(vnode.ssContent), - ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback), - el: vnode.el, - anchor: vnode.anchor - }; - return cloned; -} -/** - * Dev only, for HMR of hoisted vnodes reused in v-for - * https://github.com/vitejs/vite/issues/2022 - */ -function deepCloneVNode(vnode) { - const cloned = cloneVNode(vnode); - if (isArray(vnode.children)) { - cloned.children = vnode.children.map(deepCloneVNode); - } - return cloned; -} -/** - * @private - */ -function createTextVNode(text = ' ', flag = 0) { - return createVNode(Text, null, text, flag); -} -function normalizeChildren(vnode, children) { - let type = 0; - const { shapeFlag } = vnode; - if (children == null) { - children = null; - } - else if (isArray(children)) { - type = 16 /* ARRAY_CHILDREN */; - } - else if (typeof children === 'object') { - if (shapeFlag & (1 /* ELEMENT */ | 64 /* TELEPORT */)) { - // Normalize slot to plain children for plain element and Teleport - const slot = children.default; - if (slot) { - // _c marker is added by withCtx() indicating this is a compiled slot - slot._c && (slot._d = false); - normalizeChildren(vnode, slot()); - slot._c && (slot._d = true); - } - return; - } - else { - type = 32 /* SLOTS_CHILDREN */; - const slotFlag = children._; - if (!slotFlag && !(InternalObjectKey in children)) { - children._ctx = currentRenderingInstance; - } - else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) { - // a child component receives forwarded slots from the parent. - // its slot type is determined by its parent's slot type. - if (currentRenderingInstance.slots._ === 1 /* STABLE */) { - children._ = 1 /* STABLE */; - } - else { - children._ = 2 /* DYNAMIC */; - vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */; - } - } - } - } - else if (isFunction(children)) { - children = { default: children, _ctx: currentRenderingInstance }; - type = 32 /* SLOTS_CHILDREN */; - } - else { - children = String(children); - // force teleport children to array so it can be moved around - if (shapeFlag & 64 /* TELEPORT */) { - type = 16 /* ARRAY_CHILDREN */; - children = [createTextVNode(children)]; - } - else { - type = 8 /* TEXT_CHILDREN */; - } - } - vnode.children = children; - vnode.shapeFlag |= type; -} -function mergeProps(...args) { - const ret = {}; - for (let i = 0; i < args.length; i++) { - const toMerge = args[i]; - for (const key in toMerge) { - if (key === 'class') { - if (ret.class !== toMerge.class) { - ret.class = normalizeClass([ret.class, toMerge.class]); - } - } - else if (key === 'style') { - ret.style = normalizeStyle([ret.style, toMerge.style]); - } - else if (isOn(key)) { - const existing = ret[key]; - const incoming = toMerge[key]; - if (existing !== incoming) { - ret[key] = existing - ? [].concat(existing, incoming) - : incoming; - } - } - else if (key !== '') { - ret[key] = toMerge[key]; - } - } - } - return ret; -} - -/** - * For prefixing keys in v-on="obj" with "on" - * @private - */ -function toHandlers(obj) { - const ret = {}; - if ((process.env.NODE_ENV !== 'production') && !isObject(obj)) { - warn$1(`v-on with no argument expects an object value.`); - return ret; - } - for (const key in obj) { - ret[toHandlerKey(key)] = obj[key]; - } - return ret; -} - -/** - * #2437 In Vue 3, functional components do not have a public instance proxy but - * they exist in the internal parent chain. For code that relies on traversing - * public $parent chains, skip functional ones and go to the parent instead. - */ -const getPublicInstance = (i) => { - if (!i) - return null; - if (isStatefulComponent(i)) - return getExposeProxy(i) || i.proxy; - return getPublicInstance(i.parent); -}; -const publicPropertiesMap = extend(Object.create(null), { - $: i => i, - $el: i => i.vnode.el, - $data: i => i.data, - $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props), - $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs), - $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots), - $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs), - $parent: i => getPublicInstance(i.parent), - $root: i => getPublicInstance(i.root), - $emit: i => i.emit, - $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), - $forceUpdate: i => () => queueJob(i.update), - // $nextTick: i => nextTick.bind(i.proxy!), // fixed by xxxxxx - $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) -}); -const PublicInstanceProxyHandlers = { - get({ _: instance }, key) { - const { ctx, setupState, data, props, accessCache, type, appContext } = instance; - // for internal formatters to know that this is a Vue instance - if ((process.env.NODE_ENV !== 'production') && key === '__isVue') { - return true; - } - // prioritize