diff --git a/yopa-web/resources/static/bundle.js b/yopa-web/resources/static/bundle.js index 953ff6a..0364e07 100644 --- a/yopa-web/resources/static/bundle.js +++ b/yopa-web/resources/static/bundle.js @@ -1,9188 +1,2 @@ -(function () { - 'use strict'; - - /** - * Make a map and return a function for checking if a key - * is in that map. - * IMPORTANT: all calls of this function must be prefixed with - * \/\*#\_\_PURE\_\_\*\/ - * So that rollup can tree-shake them if necessary. - */ - function makeMap(str, expectsLowerCase) { - const map = Object.create(null); - const list = str.split(','); - for (let i = 0; i < list.length; i++) { - map[list[i]] = true; - } - return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val]; - } - - const GLOBALS_WHITE_LISTED = 'Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,' + - 'decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,' + - 'Object,Boolean,String,RegExp,Map,Set,JSON,Intl'; - const isGloballyWhitelisted = /*#__PURE__*/ makeMap(GLOBALS_WHITE_LISTED); - - /** - * On the client we only need to offer special cases for boolean attributes that - * have different names from their corresponding dom properties: - * - itemscope -> N/A - * - allowfullscreen -> allowFullscreen - * - formnovalidate -> formNoValidate - * - ismap -> isMap - * - nomodule -> noModule - * - novalidate -> noValidate - * - readonly -> readOnly - */ - const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`; - const isSpecialBooleanAttr = /*#__PURE__*/ makeMap(specialBooleanAttrs); - - function normalizeStyle(value) { - if (isArray(value)) { - const res = {}; - for (let i = 0; i < value.length; i++) { - const item = value[i]; - const normalized = normalizeStyle(isString(item) ? parseStringStyle(item) : item); - if (normalized) { - for (const key in normalized) { - res[key] = normalized[key]; - } - } - } - return res; - } - else if (isObject(value)) { - return value; - } - } - const listDelimiterRE = /;(?![^(]*\))/g; - const propertyDelimiterRE = /:(.+)/; - function parseStringStyle(cssText) { - const ret = {}; - cssText.split(listDelimiterRE).forEach(item => { - if (item) { - const tmp = item.split(propertyDelimiterRE); - tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); - } - }); - return ret; - } - function normalizeClass(value) { - let res = ''; - if (isString(value)) { - res = value; - } - else if (isArray(value)) { - for (let i = 0; i < value.length; i++) { - res += normalizeClass(value[i]) + ' '; - } - } - else if (isObject(value)) { - for (const name in value) { - if (value[name]) { - res += name + ' '; - } - } - } - return res.trim(); - } - - function looseCompareArrays(a, b) { - if (a.length !== b.length) - return false; - let equal = true; - for (let i = 0; equal && i < a.length; i++) { - equal = looseEqual(a[i], b[i]); - } - return equal; - } - function looseEqual(a, b) { - if (a === b) - return true; - let aValidType = isDate(a); - let bValidType = isDate(b); - if (aValidType || bValidType) { - return aValidType && bValidType ? a.getTime() === b.getTime() : false; - } - aValidType = isArray(a); - bValidType = isArray(b); - if (aValidType || bValidType) { - return aValidType && bValidType ? looseCompareArrays(a, b) : false; - } - aValidType = isObject(a); - bValidType = isObject(b); - if (aValidType || bValidType) { - /* istanbul ignore if: this if will probably never be called */ - if (!aValidType || !bValidType) { - return false; - } - const aKeysCount = Object.keys(a).length; - const bKeysCount = Object.keys(b).length; - if (aKeysCount !== bKeysCount) { - return false; - } - for (const key in a) { - const aHasKey = a.hasOwnProperty(key); - const bHasKey = b.hasOwnProperty(key); - if ((aHasKey && !bHasKey) || - (!aHasKey && bHasKey) || - !looseEqual(a[key], b[key])) { - return false; - } - } - } - return String(a) === String(b); - } - function looseIndexOf(arr, val) { - return arr.findIndex(item => looseEqual(item, val)); - } - - /** - * For converting {{ interpolation }} values to displayed strings. - * @private - */ - const toDisplayString = (val) => { - return val == null - ? '' - : isObject(val) - ? JSON.stringify(val, replacer, 2) - : String(val); - }; - const replacer = (_key, val) => { - if (isMap(val)) { - return { - [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val]) => { - entries[`${key} =>`] = val; - return entries; - }, {}) - }; - } - else if (isSet(val)) { - return { - [`Set(${val.size})`]: [...val.values()] - }; - } - else if (isObject(val) && !isArray(val) && !isPlainObject(val)) { - return String(val); - } - return val; - }; - const EMPTY_OBJ = {}; - const EMPTY_ARR = []; - const NOOP = () => { }; - /** - * Always return false. - */ - const NO = () => false; - const onRE = /^on[^a-z]/; - const isOn = (key) => onRE.test(key); - const isModelListener = (key) => key.startsWith('onUpdate:'); - const extend = Object.assign; - const remove = (arr, el) => { - const i = arr.indexOf(el); - if (i > -1) { - arr.splice(i, 1); - } - }; - const hasOwnProperty = Object.prototype.hasOwnProperty; - const hasOwn = (val, key) => hasOwnProperty.call(val, key); - const isArray = Array.isArray; - const isMap = (val) => toTypeString(val) === '[object Map]'; - const isSet = (val) => toTypeString(val) === '[object Set]'; - const isDate = (val) => val instanceof Date; - const isFunction = (val) => typeof val === 'function'; - const isString = (val) => typeof val === 'string'; - const isSymbol = (val) => typeof val === 'symbol'; - const isObject = (val) => val !== null && typeof val === 'object'; - const isPromise = (val) => { - return isObject(val) && isFunction(val.then) && isFunction(val.catch); - }; - const objectToString = Object.prototype.toString; - const toTypeString = (value) => objectToString.call(value); - const toRawType = (value) => { - // extract "RawType" from strings like "[object RawType]" - return toTypeString(value).slice(8, -1); - }; - const isPlainObject = (val) => toTypeString(val) === '[object Object]'; - const isIntegerKey = (key) => isString(key) && - key !== 'NaN' && - key[0] !== '-' && - '' + parseInt(key, 10) === key; - const isReservedProp = /*#__PURE__*/ makeMap( - // the leading comma is intentional so empty string "" is also included - ',key,ref,' + - 'onVnodeBeforeMount,onVnodeMounted,' + - 'onVnodeBeforeUpdate,onVnodeUpdated,' + - 'onVnodeBeforeUnmount,onVnodeUnmounted'); - const cacheStringFunction = (fn) => { - const cache = Object.create(null); - return ((str) => { - const hit = cache[str]; - return hit || (cache[str] = fn(str)); - }); - }; - const camelizeRE = /-(\w)/g; - /** - * @private - */ - const camelize = cacheStringFunction((str) => { - return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); - }); - const hyphenateRE = /\B([A-Z])/g; - /** - * @private - */ - const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, '-$1').toLowerCase()); - /** - * @private - */ - const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); - /** - * @private - */ - const toHandlerKey = cacheStringFunction((str) => (str ? `on${capitalize(str)}` : ``)); - // compare whether a value has changed, accounting for NaN. - const hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue); - const invokeArrayFns = (fns, arg) => { - for (let i = 0; i < fns.length; i++) { - fns[i](arg); - } - }; - const def = (obj, key, value) => { - Object.defineProperty(obj, key, { - configurable: true, - enumerable: false, - value - }); - }; - const toNumber = (val) => { - const n = parseFloat(val); - return isNaN(n) ? val : n; - }; - - const targetMap = new WeakMap(); - const effectStack = []; - let activeEffect; - const ITERATE_KEY = Symbol(''); - const MAP_KEY_ITERATE_KEY = Symbol(''); - function isEffect(fn) { - return fn && fn._isEffect === true; - } - function effect(fn, options = EMPTY_OBJ) { - if (isEffect(fn)) { - fn = fn.raw; - } - const effect = createReactiveEffect(fn, options); - if (!options.lazy) { - effect(); - } - return effect; - } - function stop(effect) { - if (effect.active) { - cleanup(effect); - if (effect.options.onStop) { - effect.options.onStop(); - } - effect.active = false; - } - } - let uid = 0; - function createReactiveEffect(fn, options) { - const effect = function reactiveEffect() { - if (!effect.active) { - return options.scheduler ? undefined : fn(); - } - if (!effectStack.includes(effect)) { - cleanup(effect); - try { - enableTracking(); - effectStack.push(effect); - activeEffect = effect; - return fn(); - } - finally { - effectStack.pop(); - resetTracking(); - activeEffect = effectStack[effectStack.length - 1]; - } - } - }; - effect.id = uid++; - effect.allowRecurse = !!options.allowRecurse; - effect._isEffect = true; - effect.active = true; - effect.raw = fn; - effect.deps = []; - effect.options = options; - return effect; - } - function cleanup(effect) { - const { deps } = effect; - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].delete(effect); - } - deps.length = 0; - } - } - 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 (!shouldTrack || activeEffect === undefined) { - 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 = new Set())); - } - if (!dep.has(activeEffect)) { - dep.add(activeEffect); - activeEffect.deps.push(dep); - } - } - function trigger(target, type, key, newValue, oldValue, oldTarget) { - const depsMap = targetMap.get(target); - if (!depsMap) { - // never been tracked - return; - } - const effects = new Set(); - const add = (effectsToAdd) => { - if (effectsToAdd) { - effectsToAdd.forEach(effect => { - if (effect !== activeEffect || effect.allowRecurse) { - effects.add(effect); - } - }); - } - }; - if (type === "clear" /* CLEAR */) { - // collection being cleared - // trigger all effects for target - depsMap.forEach(add); - } - else if (key === 'length' && isArray(target)) { - depsMap.forEach((dep, key) => { - if (key === 'length' || key >= newValue) { - add(dep); - } - }); - } - else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - add(depsMap.get(key)); - } - // also run for iteration key on ADD | DELETE | Map.SET - switch (type) { - case "add" /* ADD */: - if (!isArray(target)) { - add(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } - else if (isIntegerKey(key)) { - // new index added to array -> length changes - add(depsMap.get('length')); - } - break; - case "delete" /* DELETE */: - if (!isArray(target)) { - add(depsMap.get(ITERATE_KEY)); - if (isMap(target)) { - add(depsMap.get(MAP_KEY_ITERATE_KEY)); - } - } - break; - case "set" /* SET */: - if (isMap(target)) { - add(depsMap.get(ITERATE_KEY)); - } - break; - } - } - const run = (effect) => { - if (effect.options.scheduler) { - effect.options.scheduler(effect); - } - else { - effect(); - } - }; - effects.forEach(run); - } - - 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 = {}; - ['includes', 'indexOf', 'lastIndexOf'].forEach(key => { - const method = Array.prototype[key]; - arrayInstrumentations[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 = method.apply(arr, args); - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return method.apply(arr, args.map(toRaw)); - } - else { - return res; - } - }; - }); - ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { - const method = Array.prototype[key]; - arrayInstrumentations[key] = function (...args) { - pauseTracking(); - const res = method.apply(this, args); - resetTracking(); - return res; - }; - }); - 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 ? readonlyMap : 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) - : key === `__proto__` || key === `__v_isRef`) { - 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) { - const oldValue = target[key]; - if (!shallow) { - value = toRaw(value); - 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); - } - } - return result; - }; - } - function deleteProperty(target, key) { - const hadKey = hasOwn(target, key); - target[key]; - const result = Reflect.deleteProperty(target, key); - if (result && hadKey) { - trigger(target, "delete" /* DELETE */, key, undefined); - } - 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) { - return true; - }, - deleteProperty(target, key) { - return true; - } - }; - const shallowReactiveHandlers = 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. - extend({}, readonlyHandlers, { - get: shallowReadonlyGet - }); - - const toReactive = (value) => isObject(value) ? reactive(value) : value; - const toReadonly = (value) => isObject(value) ? readonly(value) : value; - 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 = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; - if (has.call(rawTarget, key)) { - return wrap(target.get(key)); - } - else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)); - } - } - 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); - target.add(value); - if (!hadKey) { - 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); - } - 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); - } - 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); - } - 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); - } - return result; - } - function clear() { - const target = toRaw(this); - const hadItems = target.size !== 0; - // forward the operation before queueing reactions - const result = target.clear(); - if (hadItems) { - trigger(target, "clear" /* CLEAR */, undefined, undefined); - } - 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 = isReadonly ? toReadonly : isShallow ? toShallow : 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 = isReadonly ? toReadonly : isShallow ? toShallow : 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) { - return type === "delete" /* DELETE */ ? false : this; - }; - } - 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 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); - }); - function createInstrumentationGetter(isReadonly, shallow) { - const instrumentations = shallow - ? 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: createInstrumentationGetter(false, false) - }; - const shallowCollectionHandlers = { - get: createInstrumentationGetter(false, true) - }; - const readonlyCollectionHandlers = { - get: createInstrumentationGetter(true, false) - }; - - const reactiveMap = new WeakMap(); - const readonlyMap = 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); - } - /** - * 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); - } - /** - * 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); - } - function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { - if (!isObject(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 proxyMap = isReadonly ? readonlyMap : reactiveMap; - 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) { - return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed); - } - function isRef(r) { - return Boolean(r && r.__v_isRef === true); - } - 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 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) { - return isRef(object[key]) - ? object[key] - : new ObjectRefImpl(object, key); - } - - class ComputedRefImpl { - constructor(getter, _setter, isReadonly) { - this._setter = _setter; - this._dirty = true; - this.__v_isRef = true; - this.effect = effect(getter, { - lazy: true, - scheduler: () => { - if (!this._dirty) { - this._dirty = true; - trigger(toRaw(this), "set" /* SET */, 'value'); - } - } - }); - this["__v_isReadonly" /* IS_READONLY */] = isReadonly; - } - get value() { - if (this._dirty) { - this._value = this.effect(); - this._dirty = false; - } - track(toRaw(this), "get" /* GET */, 'value'); - return this._value; - } - set value(newValue) { - this._setter(newValue); - } - } - function computed(getterOrOptions) { - let getter; - let setter; - if (isFunction(getterOrOptions)) { - getter = getterOrOptions; - setter = NOOP; - } - else { - getter = getterOrOptions.get; - setter = getterOrOptions.set; - } - return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); - } - - const stack = []; - function warn(msg, ...args) { - // avoid props formatting or warn handler tracking deps that might be mutated - // during patch, leading to infinite recursion. - pauseTracking(); - const instance = stack.length ? stack[stack.length - 1].component : null; - const appWarnHandler = instance && instance.appContext.config.warnHandler; - const trace = getComponentTrace(); - if (appWarnHandler) { - callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [ - msg + args.join(''), - instance && instance.proxy, - trace - .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) - .join('\n'), - trace - ]); - } - else { - const warnArgs = [`[Vue warn]: ${msg}`, ...args]; - /* istanbul ignore if */ - if (trace.length && - // avoid spamming console during tests - !false) { - warnArgs.push(`\n`, ...formatTrace(trace)); - } - console.warn(...warnArgs); - } - resetTracking(); - } - function getComponentTrace() { - let currentVNode = stack[stack.length - 1]; - if (!currentVNode) { - return []; - } - // we can't just use the stack because it will be incomplete during updates - // that did not start from the root. Re-construct the parent chain using - // instance parent pointers. - const normalizedStack = []; - while (currentVNode) { - const last = normalizedStack[0]; - if (last && last.vnode === currentVNode) { - last.recurseCount++; - } - else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }); - } - const parentInstance = currentVNode.component && currentVNode.component.parent; - currentVNode = parentInstance && parentInstance.vnode; - } - return normalizedStack; - } - /* istanbul ignore next */ - function formatTrace(trace) { - const logs = []; - trace.forEach((entry, i) => { - logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry)); - }); - return logs; - } - function formatTraceEntry({ vnode, recurseCount }) { - const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; - const isRoot = vnode.component ? vnode.component.parent == null : false; - const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; - const close = `>` + postfix; - return vnode.props - ? [open, ...formatProps(vnode.props), close] - : [open + close]; - } - /* istanbul ignore next */ - function formatProps(props) { - const res = []; - const keys = Object.keys(props); - keys.slice(0, 3).forEach(key => { - res.push(...formatProp(key, props[key])); - }); - if (keys.length > 3) { - res.push(` ...`); - } - return res; - } - /* istanbul ignore next */ - function formatProp(key, value, raw) { - if (isString(value)) { - value = JSON.stringify(value); - return raw ? value : [`${key}=${value}`]; - } - else if (typeof value === 'number' || - typeof value === 'boolean' || - value == null) { - return raw ? value : [`${key}=${value}`]; - } - else if (isRef(value)) { - value = formatProp(key, toRaw(value.value), true); - return raw ? value : [`${key}=Ref<`, value, `>`]; - } - else if (isFunction(value)) { - return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; - } - else { - value = toRaw(value); - return raw ? value : [`${key}=`, value]; - } - } - function callWithErrorHandling(fn, instance, type, args) { - let res; - try { - res = args ? fn(...args) : fn(); - } - catch (err) { - handleError(err, instance, type); - } - return res; - } - function callWithAsyncErrorHandling(fn, instance, type, args) { - if (isFunction(fn)) { - const res = callWithErrorHandling(fn, instance, type, args); - if (res && isPromise(res)) { - res.catch(err => { - handleError(err, instance, type); - }); - } - return res; - } - const values = []; - for (let i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); - } - return values; - } - function handleError(err, instance, type, throwInDev = true) { - const contextVNode = instance ? instance.vnode : null; - if (instance) { - let cur = instance.parent; - // the exposed instance is the render proxy to keep it consistent with 2.x - const exposedInstance = instance.proxy; - // in production the hook receives only the error code - const errorInfo = type; - while (cur) { - const errorCapturedHooks = cur.ec; - if (errorCapturedHooks) { - for (let i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { - return; - } - } - } - cur = cur.parent; - } - // app-level handling - const appErrorHandler = instance.appContext.config.errorHandler; - if (appErrorHandler) { - callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); - return; - } - } - logError(err, type, contextVNode, throwInDev); - } - function logError(err, type, contextVNode, throwInDev = true) { - { - // recover in prod to reduce the impact on end-user - console.error(err); - } - } - - let isFlushing = false; - let isFlushPending = false; - const queue = []; - let flushIndex = 0; - const pendingPreFlushCbs = []; - let activePreFlushCbs = null; - let preFlushIndex = 0; - const pendingPostFlushCbs = []; - let activePostFlushCbs = null; - let postFlushIndex = 0; - const resolvedPromise = Promise.resolve(); - let currentFlushPromise = null; - let currentPreFlushParentJob = null; - const RECURSION_LIMIT = 100; - function nextTick(fn) { - const p = currentFlushPromise || resolvedPromise; - return fn ? p.then(this ? fn.bind(this) : fn) : p; - } - function queueJob(job) { - // the dedupe search uses the startIndex argument of Array.includes() - // by default the search index includes the current job that is being run - // so it cannot recursively trigger itself again. - // if the job is a watch() callback, the search will start with a +1 index to - // allow it recursively trigger itself - it is the user's responsibility to - // ensure it doesn't end up in an infinite loop. - if ((!queue.length || - !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && - job !== currentPreFlushParentJob) { - queue.push(job); - queueFlush(); - } - } - function queueFlush() { - if (!isFlushing && !isFlushPending) { - isFlushPending = true; - currentFlushPromise = resolvedPromise.then(flushJobs); - } - } - function invalidateJob(job) { - const i = queue.indexOf(job); - if (i > -1) { - queue.splice(i, 1); - } - } - function queueCb(cb, activeQueue, pendingQueue, index) { - if (!isArray(cb)) { - if (!activeQueue || - !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { - pendingQueue.push(cb); - } - } - else { - // if cb is an array, it is a component lifecycle hook which can only be - // triggered by a job, which is already deduped in the main queue, so - // we can skip duplicate check here to improve perf - pendingQueue.push(...cb); - } - queueFlush(); - } - function queuePreFlushCb(cb) { - queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); - } - function queuePostFlushCb(cb) { - queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); - } - function flushPreFlushCbs(seen, parentJob = null) { - if (pendingPreFlushCbs.length) { - currentPreFlushParentJob = parentJob; - activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; - pendingPreFlushCbs.length = 0; - for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { - activePreFlushCbs[preFlushIndex](); - } - activePreFlushCbs = null; - preFlushIndex = 0; - currentPreFlushParentJob = null; - // recursively flush until it drains - flushPreFlushCbs(seen, parentJob); - } - } - function flushPostFlushCbs(seen) { - if (pendingPostFlushCbs.length) { - const deduped = [...new Set(pendingPostFlushCbs)]; - pendingPostFlushCbs.length = 0; - // #1947 already has active queue, nested flushPostFlushCbs call - if (activePostFlushCbs) { - activePostFlushCbs.push(...deduped); - return; - } - activePostFlushCbs = deduped; - activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); - for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { - activePostFlushCbs[postFlushIndex](); - } - activePostFlushCbs = null; - postFlushIndex = 0; - } - } - const getId = (job) => job.id == null ? Infinity : job.id; - function flushJobs(seen) { - isFlushPending = false; - isFlushing = true; - flushPreFlushCbs(seen); - // Sort queue before flush. - // This ensures that: - // 1. Components are updated from parent to child. (because parent is always - // created before the child so its render effect will have smaller - // priority number) - // 2. If a component is unmounted during a parent component's update, - // its update can be skipped. - queue.sort((a, b) => getId(a) - getId(b)); - try { - for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { - const job = queue[flushIndex]; - if (job) { - if (("production" !== 'production')) ; - callWithErrorHandling(job, null, 14 /* SCHEDULER */); - } - } - } - finally { - flushIndex = 0; - queue.length = 0; - flushPostFlushCbs(); - isFlushing = false; - currentFlushPromise = null; - // some postFlushCb queued jobs! - // keep flushing until it drains. - if (queue.length || pendingPostFlushCbs.length) { - flushJobs(seen); - } - } - } - function checkRecursiveUpdates(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1); - } - else { - const count = seen.get(fn); - if (count > RECURSION_LIMIT) { - throw new Error(`Maximum recursive updates exceeded. ` + - `This means you have a reactive effect that is mutating its own ` + - `dependencies and thus recursively triggering itself. Possible sources ` + - `include component template, render function, updated hook or ` + - `watcher source function.`); - } - else { - seen.set(fn, count + 1); - } - } - } - - function emit(instance, event, ...rawArgs) { - const props = instance.vnode.props || EMPTY_OBJ; - 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); - } - } - // convert handler name to camelCase. See issue #2249 - let handlerName = toHandlerKey(camelize(event)); - let handler = props[handlerName]; - // for v-model update:xxx events, also trigger kebab-case equivalent - // for props passed via kebab-case - if (!handler && isModelListener) { - handlerName = toHandlerKey(hyphenate(event)); - handler = props[handlerName]; - } - if (handler) { - callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); - } - const onceHandler = props[handlerName + `Once`]; - if (onceHandler) { - if (!instance.emitted) { - (instance.emitted = {})[handlerName] = true; - } - else if (instance.emitted[handlerName]) { - return; - } - callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); - } - } - function normalizeEmitsOptions(comp, appContext, asMixin = false) { - if (!appContext.deopt && comp.__emits !== undefined) { - return comp.__emits; - } - const raw = comp.emits; - let normalized = {}; - // apply mixin/extends props - let hasExtends = false; - if (!isFunction(comp)) { - const extendEmits = (raw) => { - hasExtends = true; - extend(normalized, normalizeEmitsOptions(raw, appContext, true)); - }; - 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) { - return (comp.__emits = null); - } - if (isArray(raw)) { - raw.forEach(key => (normalized[key] = null)); - } - else { - extend(normalized, raw); - } - return (comp.__emits = 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; - function setCurrentRenderingInstance(instance) { - currentRenderingInstance = instance; - } - /** - * dev only flag to track whether $attrs was used during render. - * If $attrs was used during render then the warning for failed attrs - * fallthrough can be suppressed. - */ - let accessedAttrs = false; - function markAttrsAccessed() { - accessedAttrs = true; - } - function renderComponentRoot(instance) { - const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx } = instance; - let result; - currentRenderingInstance = instance; - try { - let fallthroughAttrs; - if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { - // withProxy is a proxy with a different `has` trap only for - // runtime-compiled render functions using `with` block. - const proxyToUse = withProxy || proxy; - result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); - fallthroughAttrs = attrs; - } - else { - // functional - const render = Component; - // in dev, mark attrs accessed if optional props (attrs === props) - if (("production" !== 'production') && attrs === props) ; - result = normalizeVNode(render.length > 1 - ? render(props, ("production" !== 'production') - ? { - get attrs() { - markAttrsAccessed(); - return attrs; - }, - slots, - emit - } - : { attrs, slots, emit }) - : render(props, null /* we know it doesn't need it */)); - fallthroughAttrs = Component.props - ? attrs - : getFunctionalFallthrough(attrs); - } - // attr merging - // in dev mode, comments are preserved, and it's possible for a template - // to have comments along side the root element which makes it a fragment - let root = result; - let setRoot = undefined; - if (("production" !== 'production') && result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) ; - if (Component.inheritAttrs !== false && fallthroughAttrs) { - const keys = Object.keys(fallthroughAttrs); - const { shapeFlag } = root; - if (keys.length) { - if (shapeFlag & 1 /* ELEMENT */ || - shapeFlag & 6 /* COMPONENT */) { - if (propsOptions && keys.some(isModelListener)) { - // If a v-model listener (onUpdate:xxx) has a corresponding declared - // prop, it indicates this component expects to handle v-model and - // it should not fallthrough. - // related: #1543, #1643, #1989 - fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); - } - root = cloneVNode(root, fallthroughAttrs); - } - else if (("production" !== 'production') && !accessedAttrs && root.type !== Comment) ; - } - } - // inherit directives - if (vnode.dirs) { - if (("production" !== 'production') && !isElementRoot(root)) ; - root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; - } - // inherit transition data - if (vnode.transition) { - if (("production" !== 'production') && !isElementRoot(root)) ; - root.transition = vnode.transition; - } - if (("production" !== 'production') && setRoot) ; - else { - result = root; - } - } - catch (err) { - handleError(err, instance, 1 /* RENDER_FUNCTION */); - result = createVNode(Comment); - } - currentRenderingInstance = null; - return result; - } - /** - * dev only - * In dev mode, template root level comments are rendered, which turns the - * template into a fragment root, but we need to locate the single element - * root for attrs and scope id processing. - */ - const getChildRoot = (vnode) => { - const rawChildren = vnode.children; - const dynamicChildren = vnode.dynamicChildren; - const childRoot = filterSingleRoot(rawChildren); - if (!childRoot) { - return [vnode, undefined]; - } - const index = rawChildren.indexOf(childRoot); - const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; - const setRoot = (updatedRoot) => { - rawChildren[index] = updatedRoot; - if (dynamicChildren) { - if (dynamicIndex > -1) { - dynamicChildren[dynamicIndex] = updatedRoot; - } - else if (updatedRoot.patchFlag > 0) { - vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; - } - } - }; - return [normalizeVNode(childRoot), setRoot]; - }; - function filterSingleRoot(children) { - let singleRoot; - for (let i = 0; i < children.length; i++) { - const child = children[i]; - if (isVNode(child)) { - // ignore user comment - if (child.type !== Comment || child.children === 'v-if') { - if (singleRoot) { - // has more than 1 non-comment child, return now - return; - } - else { - singleRoot = child; - } - } - } - else { - return; - } - } - return singleRoot; - } - const getFunctionalFallthrough = (attrs) => { - let res; - for (const key in attrs) { - if (key === 'class' || key === 'style' || isOn(key)) { - (res || (res = {}))[key] = attrs[key]; - } - } - return res; - }; - const filterModelListeners = (attrs, props) => { - const res = {}; - for (const key in attrs) { - if (!isModelListener(key) || !(key.slice(9) in props)) { - res[key] = attrs[key]; - } - } - return res; - }; - const isElementRoot = (vnode) => { - return (vnode.shapeFlag & 6 /* COMPONENT */ || - vnode.shapeFlag & 1 /* ELEMENT */ || - vnode.type === Comment // potential v-if branch switch - ); - }; - function shouldUpdateComponent(prevVNode, nextVNode, optimized) { - const { props: prevProps, children: prevChildren, component } = prevVNode; - const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; - const emits = component.emitsOptions; - // force child update for runtime directive or transition on component vnode. - if (nextVNode.dirs || nextVNode.transition) { - return true; - } - if (optimized && patchFlag >= 0) { - if (patchFlag & 1024 /* DYNAMIC_SLOTS */) { - // slot content that references values that might have changed, - // e.g. in a v-for - return true; - } - if (patchFlag & 16 /* FULL_PROPS */) { - if (!prevProps) { - return !!nextProps; - } - // presence of this flag indicates props are always non-null - return hasPropsChanged(prevProps, nextProps, emits); - } - else if (patchFlag & 8 /* PROPS */) { - const dynamicProps = nextVNode.dynamicProps; - for (let i = 0; i < dynamicProps.length; i++) { - const key = dynamicProps[i]; - if (nextProps[key] !== prevProps[key] && - !isEmitListener(emits, key)) { - return true; - } - } - } - } - else { - // this path is only taken by manually written render functions - // so presence of any children leads to a forced update - if (prevChildren || nextChildren) { - if (!nextChildren || !nextChildren.$stable) { - return true; - } - } - if (prevProps === nextProps) { - return false; - } - if (!prevProps) { - return !!nextProps; - } - if (!nextProps) { - return true; - } - return hasPropsChanged(prevProps, nextProps, emits); - } - return false; - } - function hasPropsChanged(prevProps, nextProps, emitsOptions) { - const nextKeys = Object.keys(nextProps); - if (nextKeys.length !== Object.keys(prevProps).length) { - return true; - } - for (let i = 0; i < nextKeys.length; i++) { - const key = nextKeys[i]; - if (nextProps[key] !== prevProps[key] && - !isEmitListener(emitsOptions, key)) { - return true; - } - } - return false; - } - function updateHOCHostEl({ vnode, parent }, el // HostNode - ) { - while (parent && parent.subTree === vnode) { - (vnode = parent.vnode).el = el; - parent = parent.parent; - } - } - - const isSuspense = (type) => type.__isSuspense; - function normalizeSuspenseChildren(vnode) { - const { shapeFlag, children } = vnode; - let content; - let fallback; - if (shapeFlag & 32 /* SLOTS_CHILDREN */) { - content = normalizeSuspenseSlot(children.default); - fallback = normalizeSuspenseSlot(children.fallback); - } - else { - content = normalizeSuspenseSlot(children); - fallback = normalizeVNode(null); - } - return { - content, - fallback - }; - } - function normalizeSuspenseSlot(s) { - if (isFunction(s)) { - s = s(); - } - if (isArray(s)) { - const singleChild = filterSingleRoot(s); - s = singleChild; - } - return normalizeVNode(s); - } - function queueEffectWithSuspense(fn, suspense) { - if (suspense && suspense.pendingBranch) { - if (isArray(fn)) { - suspense.effects.push(...fn); - } - else { - suspense.effects.push(fn); - } - } - else { - queuePostFlushCb(fn); - } - } - - let isRenderingCompiledSlot = 0; - const setCompiledSlotRendering = (n) => (isRenderingCompiledSlot += n); - - /** - * Wrap a slot function to memoize current rendering instance - * @private - */ - function withCtx(fn, ctx = currentRenderingInstance) { - if (!ctx) - 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 need to push a null block to - // avoid that. This isn't necessary if rendering a compiled ``. - if (!isRenderingCompiledSlot) { - openBlock(true /* null block that disables tracking */); - } - const owner = currentRenderingInstance; - setCurrentRenderingInstance(ctx); - const res = fn(...args); - setCurrentRenderingInstance(owner); - if (!isRenderingCompiledSlot) { - closeBlock(); - } - return res; - }; - renderFnWithContext._c = true; - return renderFnWithContext; - } - - // SFC scoped style ID management. - let currentScopeId = null; - const scopeIdStack = []; - /** - * @private - */ - function pushScopeId(id) { - scopeIdStack.push((currentScopeId = id)); - } - /** - * @private - */ - function popScopeId() { - scopeIdStack.pop(); - currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null; - } - /** - * @private - */ - function withScopeId(id) { - return ((fn) => withCtx(function () { - pushScopeId(id); - const res = fn.apply(this, arguments); - popScopeId(); - return res; - })); - } - - function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison - isSSR = false) { - const props = {}; - const attrs = {}; - def(attrs, InternalObjectKey, 1); - setFullProps(instance, rawProps, props, attrs); - 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 updateProps(instance, rawProps, rawPrevProps, optimized) { - const { props, attrs, vnode: { patchFlag } } = instance; - const rawCurrentProps = toRaw(props); - const [options] = instance.propsOptions; - if ( - // always force full diff in dev - // - #1942 if hmr is enabled with sfc component - // - vite#872 non-sfc component used by sfc component - (optimized || patchFlag > 0) && - !(patchFlag & 16 /* FULL_PROPS */)) { - if (patchFlag & 8 /* PROPS */) { - // Compiler-generated props & no keys change, just set the updated - // the props. - const propsToUpdate = instance.vnode.dynamicProps; - for (let i = 0; i < propsToUpdate.length; i++) { - const key = propsToUpdate[i]; - // PROPS flag guarantees rawProps to be non-null - const value = rawProps[key]; - if (options) { - // attr / props separation was done on init and will be consistent - // in this code path, so just check if attrs have it. - if (hasOwn(attrs, key)) { - attrs[key] = value; - } - else { - const camelizedKey = camelize(key); - props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance); - } - } - else { - attrs[key] = value; - } - } - } - } - else { - // full props update. - setFullProps(instance, rawProps, props, attrs); - // in case of dynamic props, check if we need to delete keys from - // the props object - let kebabKey; - for (const key in rawCurrentProps) { - if (!rawProps || - // for camelCase - (!hasOwn(rawProps, key) && - // it's possible the original props was passed in as kebab-case - // and converted to camelCase (#955) - ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) { - if (options) { - if (rawPrevProps && - // for camelCase - (rawPrevProps[key] !== undefined || - // for kebab-case - rawPrevProps[kebabKey] !== undefined)) { - props[key] = resolvePropValue(options, rawProps || EMPTY_OBJ, key, undefined, instance); - } - } - else { - delete props[key]; - } - } - } - // in the case of functional component w/o props declaration, props and - // attrs point to the same object so it should already have been updated. - if (attrs !== rawCurrentProps) { - for (const key in attrs) { - if (!rawProps || !hasOwn(rawProps, key)) { - delete attrs[key]; - } - } - } - } - // trigger updates for $attrs in case it's used in component slots - trigger(instance, "set" /* SET */, '$attrs'); - } - function setFullProps(instance, rawProps, props, attrs) { - const [options, needCastKeys] = instance.propsOptions; - if (rawProps) { - for (const key in rawProps) { - const value = rawProps[key]; - // key, ref are reserved and never passed down - if (isReservedProp(key)) { - continue; - } - // 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)))) { - props[camelKey] = value; - } - else if (!isEmitListener(instance.emitsOptions, key)) { - // Any non-declared (either as a prop or an emitted event) props are put - // into a separate `attrs` object for spreading. Make sure to preserve - // original key casing - attrs[key] = value; - } - } - } - if (needCastKeys) { - const rawCurrentProps = toRaw(props); - for (let i = 0; i < needCastKeys.length; i++) { - const key = needCastKeys[i]; - props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key], instance); - } - } - } - function resolvePropValue(options, props, key, value, instance) { - 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)) { - setCurrentInstance(instance); - value = defaultValue(props); - setCurrentInstance(null); - } - else { - value = defaultValue; - } - } - // boolean casting - if (opt[0 /* shouldCast */]) { - if (!hasOwn(props, key) && !hasDefault) { - value = false; - } - else if (opt[1 /* shouldCastTrue */] && - (value === '' || value === hyphenate(key))) { - value = true; - } - } - } - return value; - } - function normalizePropsOptions(comp, appContext, asMixin = false) { - if (!appContext.deopt && comp.__props) { - return comp.__props; - } - const raw = comp.props; - const normalized = {}; - const needCastKeys = []; - // apply mixin/extends props - let hasExtends = false; - if (!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) { - return (comp.__props = EMPTY_ARR); - } - if (isArray(raw)) { - for (let i = 0; i < raw.length; i++) { - const normalizedKey = camelize(raw[i]); - if (validatePropName(normalizedKey)) { - normalized[normalizedKey] = EMPTY_OBJ; - } - } - } - else if (raw) { - for (const key in raw) { - const normalizedKey = camelize(key); - if (validatePropName(normalizedKey)) { - const opt = raw[key]; - const prop = (normalized[normalizedKey] = - isArray(opt) || isFunction(opt) ? { type: opt } : 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); - } - } - } - } - } - return (comp.__props = [normalized, needCastKeys]); - } - function validatePropName(key) { - if (key[0] !== '$') { - return true; - } - 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] : ''; - } - function isSameType(a, b) { - return getType(a) === getType(b); - } - function getTypeIndex(type, expectedTypes) { - if (isArray(expectedTypes)) { - for (let i = 0, len = expectedTypes.length; i < len; i++) { - if (isSameType(expectedTypes[i], type)) { - return i; - } - } - } - else if (isFunction(expectedTypes)) { - return isSameType(expectedTypes, type) ? 0 : -1; - } - return -1; - } - - function injectHook(type, hook, target = currentInstance, prepend = false) { - if (target) { - 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); - const res = callWithAsyncErrorHandling(hook, target, type, args); - setCurrentInstance(null); - resetTracking(); - return res; - }); - if (prepend) { - hooks.unshift(wrappedHook); - } - else { - hooks.push(wrappedHook); - } - return wrappedHook; - } - } - const createHook = (lifecycle) => (hook, target = currentInstance) => - // post-create lifecycle registrations are noops during SSR - !isInSSRComponentSetup && 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 onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */); - const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */); - const onErrorCaptured = (hook, target = currentInstance) => { - injectHook("ec" /* ERROR_CAPTURED */, hook, target); - }; - // initial value for watchers to trigger on undefined initial values - const INITIAL_WATCHER_VALUE = {}; - // implementation - function watch(source, cb, options) { - return doWatch(source, cb, options); - } - function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) { - let getter; - let forceTrigger = false; - if (isRef(source)) { - getter = () => source.value; - forceTrigger = !!source._shallow; - } - else if (isReactive(source)) { - getter = () => source; - deep = true; - } - else if (isArray(source)) { - getter = () => source.map(s => { - if (isRef(s)) { - return s.value; - } - else if (isReactive(s)) { - return traverse(s); - } - else if (isFunction(s)) { - return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */); - } - else ; - }); - } - else if (isFunction(source)) { - if (cb) { - // getter with cb - getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */); - } - else { - // no cb -> simple effect - getter = () => { - if (instance && instance.isUnmounted) { - return; - } - if (cleanup) { - cleanup(); - } - return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); - }; - } - } - else { - getter = NOOP; - } - if (cb && deep) { - const baseGetter = getter; - getter = () => traverse(baseGetter()); - } - let cleanup; - const onInvalidate = (fn) => { - cleanup = runner.options.onStop = () => { - callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */); - }; - }; - let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE; - const job = () => { - if (!runner.active) { - return; - } - if (cb) { - // watch(source, cb) - const newValue = runner(); - if (deep || forceTrigger || hasChanged(newValue, oldValue)) { - // cleanup before running cb again - if (cleanup) { - cleanup(); - } - callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ - newValue, - // pass undefined as the old value when it's changed for the first time - oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, - onInvalidate - ]); - oldValue = newValue; - } - } - else { - // watchEffect - runner(); - } - }; - // important: mark the job as a watcher callback so that scheduler knows - // it is allowed to self-trigger (#1727) - job.allowRecurse = !!cb; - let scheduler; - if (flush === 'sync') { - scheduler = job; - } - else if (flush === 'post') { - scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); - } - else { - // default: 'pre' - scheduler = () => { - if (!instance || instance.isMounted) { - queuePreFlushCb(job); - } - else { - // with 'pre' option, the first call must happen before - // the component is mounted so it is called synchronously. - job(); - } - }; - } - const runner = effect(getter, { - lazy: true, - onTrack, - onTrigger, - scheduler - }); - recordInstanceBoundEffect(runner, instance); - // initial run - if (cb) { - if (immediate) { - job(); - } - else { - oldValue = runner(); - } - } - else if (flush === 'post') { - queuePostRenderEffect(runner, instance && instance.suspense); - } - else { - runner(); - } - return () => { - stop(runner); - if (instance) { - remove(instance.effects, runner); - } - }; - } - // this.$watch - function instanceWatch(source, cb, options) { - const publicThis = this.proxy; - const getter = isString(source) - ? () => publicThis[source] - : source.bind(publicThis); - return doWatch(getter, cb.bind(publicThis), options, this); - } - function traverse(value, seen = new Set()) { - if (!isObject(value) || seen.has(value)) { - return value; - } - seen.add(value); - if (isRef(value)) { - traverse(value.value, seen); - } - else if (isArray(value)) { - for (let i = 0; i < value.length; i++) { - traverse(value[i], seen); - } - } - else if (isSet(value) || isMap(value)) { - value.forEach((v) => { - traverse(v, seen); - }); - } - else { - for (const key in value) { - traverse(value[key], seen); - } - } - return value; - } - - 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); - } - - const isInternalKey = (key) => key[0] === '_' || key === '$stable'; - const normalizeSlotValue = (value) => isArray(value) - ? value.map(normalizeVNode) - : [normalizeVNode(value)]; - const normalizeSlot = (key, rawSlot, ctx) => withCtx((props) => { - return normalizeSlotValue(rawSlot(props)); - }, ctx); - const normalizeObjectSlots = (rawSlots, slots) => { - const ctx = rawSlots._ctx; - for (const key in rawSlots) { - if (isInternalKey(key)) - continue; - const value = rawSlots[key]; - if (isFunction(value)) { - slots[key] = normalizeSlot(key, value, ctx); - } - else if (value != null) { - const normalized = normalizeSlotValue(value); - slots[key] = () => normalized; - } - } - }; - const normalizeVNodeSlots = (instance, children) => { - const normalized = normalizeSlotValue(children); - instance.slots.default = () => normalized; - }; - const initSlots = (instance, children) => { - if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { - const type = children._; - if (type) { - instance.slots = children; - // make compiler marker non-enumerable - def(children, '_', type); - } - else { - normalizeObjectSlots(children, (instance.slots = {})); - } - } - else { - instance.slots = {}; - if (children) { - normalizeVNodeSlots(instance, children); - } - } - def(instance.slots, InternalObjectKey, 1); - }; - const updateSlots = (instance, children) => { - const { vnode, slots } = instance; - let needDeletionCheck = true; - let deletionComparisonTarget = EMPTY_OBJ; - if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { - const type = children._; - if (type) { - // compiled slots. - if (type === 1 /* STABLE */) { - // compiled AND stable. - // no need to update, and skip stale slots removal. - needDeletionCheck = false; - } - else { - // compiled but dynamic (v-if/v-for on slots) - update slots, but skip - // normalization. - extend(slots, children); - } - } - else { - needDeletionCheck = !children.$stable; - normalizeObjectSlots(children, slots); - } - deletionComparisonTarget = children; - } - else if (children) { - // non slot object children (direct value) passed to a component - normalizeVNodeSlots(instance, children); - deletionComparisonTarget = { default: 1 }; - } - // delete stale slots - if (needDeletionCheck) { - for (const key in slots) { - if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { - delete slots[key]; - } - } - } - }; - /** - * Adds directives to a VNode. - */ - function withDirectives(vnode, directives) { - const internalInstance = currentRenderingInstance; - if (internalInstance === null) { - 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 - }; - } - 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; - } - const hook = binding.dir[name]; - if (hook) { - callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [ - vnode.el, - binding, - vnode, - prevVNode - ]); - } - } - } - - function createAppContext() { - return { - app: null, - config: { - isNativeTag: NO, - performance: false, - globalProperties: {}, - optionMergeStrategies: {}, - isCustomElement: NO, - errorHandler: undefined, - warnHandler: undefined - }, - mixins: [], - components: {}, - directives: {}, - provides: Object.create(null) - }; - } - let uid$1 = 0; - function createAppAPI(render, hydrate) { - return function createApp(rootComponent, rootProps = null) { - if (rootProps != null && !isObject(rootProps)) { - rootProps = null; - } - const context = createAppContext(); - const installedPlugins = new Set(); - let isMounted = false; - const app = (context.app = { - _uid: uid$1++, - _component: rootComponent, - _props: rootProps, - _container: null, - _context: context, - version, - get config() { - return context.config; - }, - set config(v) { - }, - use(plugin, ...options) { - if (installedPlugins.has(plugin)) ; - else if (plugin && isFunction(plugin.install)) { - installedPlugins.add(plugin); - plugin.install(app, ...options); - } - else if (isFunction(plugin)) { - installedPlugins.add(plugin); - plugin(app, ...options); - } - else ; - return app; - }, - mixin(mixin) { - { - if (!context.mixins.includes(mixin)) { - context.mixins.push(mixin); - // global mixin with props/emits de-optimizes props/emits - // normalization caching. - if (mixin.props || mixin.emits) { - context.deopt = true; - } - } - } - return app; - }, - component(name, component) { - if (!component) { - return context.components[name]; - } - context.components[name] = component; - return app; - }, - directive(name, directive) { - if (!directive) { - return context.directives[name]; - } - context.directives[name] = directive; - return app; - }, - mount(rootContainer, isHydrate) { - if (!isMounted) { - const vnode = createVNode(rootComponent, rootProps); - // store app context on the root VNode. - // this will be set on the root instance on initial mount. - vnode.appContext = context; - if (isHydrate && hydrate) { - hydrate(vnode, rootContainer); - } - else { - render(vnode, rootContainer); - } - isMounted = true; - app._container = rootContainer; - rootContainer.__vue_app__ = app; - return vnode.component.proxy; - } - }, - unmount() { - if (isMounted) { - render(null, app._container); - } - }, - provide(key, value) { - // TypeScript doesn't allow symbols as index type - // https://github.com/Microsoft/TypeScript/issues/24587 - context.provides[key] = value; - return app; - } - }); - return app; - }; - } - - const isAsyncWrapper = (i) => !!i.type.__asyncLoader; - - const prodEffectOptions = { - scheduler: queueJob, - // #1801, #2043 component render effects should allow recursive updates - allowRecurse: true - }; - const queuePostRenderEffect = queueEffectWithSuspense - ; - const setRef = (rawRef, oldRawRef, parentSuspense, vnode) => { - if (isArray(rawRef)) { - rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode)); - return; - } - let value; - if (!vnode || isAsyncWrapper(vnode)) { - value = null; - } - else { - if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { - value = vnode.component.exposed || vnode.component.proxy; - } - else { - value = vnode.el; - } - } - const { i: owner, r: ref } = rawRef; - const oldRef = oldRawRef && oldRawRef.r; - const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs; - const setupState = owner.setupState; - // unset old ref - if (oldRef != null && oldRef !== ref) { - if (isString(oldRef)) { - refs[oldRef] = null; - if (hasOwn(setupState, oldRef)) { - setupState[oldRef] = null; - } - } - else if (isRef(oldRef)) { - oldRef.value = null; - } - } - if (isString(ref)) { - const doSet = () => { - refs[ref] = value; - if (hasOwn(setupState, ref)) { - setupState[ref] = value; - } - }; - // #1789: for non-null values, set them after render - // null values means this is unmount and it should not overwrite another - // ref with the same key - if (value) { - doSet.id = -1; - queuePostRenderEffect(doSet, parentSuspense); - } - else { - doSet(); - } - } - else if (isRef(ref)) { - const doSet = () => { - ref.value = value; - }; - if (value) { - doSet.id = -1; - queuePostRenderEffect(doSet, parentSuspense); - } - else { - doSet(); - } - } - else if (isFunction(ref)) { - callWithErrorHandling(ref, owner, 12 /* FUNCTION_REF */, [value, refs]); - } - else ; - }; - /** - * The createRenderer function accepts two generic arguments: - * HostNode and HostElement, corresponding to Node and Element types in the - * host environment. For example, for runtime-dom, HostNode would be the DOM - * `Node` interface and HostElement would be the DOM `Element` interface. - * - * Custom renderers can pass in the platform specific types like this: - * - * ``` js - * const { render, createApp } = createRenderer({ - * patchProp, - * ...nodeOps - * }) - * ``` - */ - function createRenderer(options) { - return baseCreateRenderer(options); - } - // implementation - function baseCreateRenderer(options, createHydrationFns) { - const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options; - // Note: functions inside this closure should use `const xxx = () => {}` - // style in order to prevent being inlined by minifiers. - const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, optimized = false) => { - // patching & not same type, unmount old tree - if (n1 && !isSameVNodeType(n1, n2)) { - anchor = getNextHostNode(n1); - unmount(n1, parentComponent, parentSuspense, true); - n1 = null; - } - if (n2.patchFlag === -2 /* BAIL */) { - optimized = false; - n2.dynamicChildren = null; - } - const { type, ref, shapeFlag } = n2; - switch (type) { - case Text: - processText(n1, n2, container, anchor); - break; - case Comment: - processCommentNode(n1, n2, container, anchor); - break; - case Static: - if (n1 == null) { - mountStaticNode(n2, container, anchor, isSVG); - } - break; - case Fragment: - processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); - break; - default: - if (shapeFlag & 1 /* ELEMENT */) { - processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); - } - else if (shapeFlag & 6 /* COMPONENT */) { - processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); - } - else if (shapeFlag & 64 /* TELEPORT */) { - type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals); - } - else if ( shapeFlag & 128 /* SUSPENSE */) { - type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized, internals); - } - else ; - } - // set ref - if (ref != null && parentComponent) { - setRef(ref, n1 && n1.ref, parentSuspense, n2); - } - }; - const processText = (n1, n2, container, anchor) => { - if (n1 == null) { - hostInsert((n2.el = hostCreateText(n2.children)), container, anchor); - } - else { - const el = (n2.el = n1.el); - if (n2.children !== n1.children) { - hostSetText(el, n2.children); - } - } - }; - const processCommentNode = (n1, n2, container, anchor) => { - if (n1 == null) { - hostInsert((n2.el = hostCreateComment(n2.children || '')), container, anchor); - } - else { - // there's no support for dynamic comments - n2.el = n1.el; - } - }; - const mountStaticNode = (n2, container, anchor, isSVG) => { - [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG); - }; - const moveStaticNode = ({ el, anchor }, container, nextSibling) => { - let next; - while (el && el !== anchor) { - next = hostNextSibling(el); - hostInsert(el, container, nextSibling); - el = next; - } - hostInsert(anchor, container, nextSibling); - }; - const removeStaticNode = ({ el, anchor }) => { - let next; - while (el && el !== anchor) { - next = hostNextSibling(el); - hostRemove(el); - el = next; - } - hostRemove(anchor); - }; - const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { - isSVG = isSVG || n2.type === 'svg'; - if (n1 == null) { - mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, optimized); - } - else { - patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized); - } - }; - const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, optimized) => { - let el; - let vnodeHook; - const { type, props, shapeFlag, transition, scopeId, patchFlag, dirs } = vnode; - if (vnode.el && - hostCloneNode !== undefined && - patchFlag === -1 /* HOISTED */) { - // If a vnode has non-null el, it means it's being reused. - // Only static vnodes can be reused, so its mounted DOM nodes should be - // exactly the same, and we can simply do a clone here. - // only do this in production since cloned trees cannot be HMR updated. - el = vnode.el = hostCloneNode(vnode.el); - } - else { - el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is); - // mount children first, since some props may rely on child content - // being already rendered, e.g. `