/*! * Vue.js v2.7.16 * (c) 2014-2023 Evan You * Released under the MIT License. */ 'use strict'; const emptyObject = Object.freeze({}); const isArray = Array.isArray; // These helpers produce better VM code in JS engines due to their // explicitness and function inlining. function isUndef(v) { return v === undefined || v === null; } function isDef(v) { return v !== undefined && v !== null; } function isTrue(v) { return v === true; } function isFalse(v) { return v === false; } /** * Check if value is primitive. */ function isPrimitive(value) { return (typeof value === 'string' || typeof value === 'number' || // $flow-disable-line typeof value === 'symbol' || typeof value === 'boolean'); } function isFunction(value) { return typeof value === 'function'; } /** * Quick object check - this is primarily used to tell * objects from primitive values when we know the value * is a JSON-compliant type. */ function isObject(obj) { return obj !== null && typeof obj === 'object'; } /** * Get the raw type string of a value, e.g., [object Object]. */ const _toString = Object.prototype.toString; function toRawType(value) { return _toString.call(value).slice(8, -1); } /** * Strict object type check. Only returns true * for plain JavaScript objects. */ function isPlainObject(obj) { return _toString.call(obj) === '[object Object]'; } function isRegExp(v) { return _toString.call(v) === '[object RegExp]'; } /** * Check if val is a valid array index. */ function isValidArrayIndex(val) { const n = parseFloat(String(val)); return n >= 0 && Math.floor(n) === n && isFinite(val); } function isPromise(val) { return (isDef(val) && typeof val.then === 'function' && typeof val.catch === 'function'); } /** * Convert a value to a string that is actually rendered. */ function toString(val) { return val == null ? '' : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString) ? JSON.stringify(val, replacer, 2) : String(val); } function replacer(_key, val) { // avoid circular deps from v3 if (val && val.__v_isRef) { return val.value; } return val; } /** * Convert an input value to a number for persistence. * If the conversion fails, return original string. */ function toNumber(val) { const n = parseFloat(val); return isNaN(n) ? val : n; } /** * Make a map and return a function for checking if a key * is in that map. */ 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]; } /** * Check if a tag is a built-in tag. */ const isBuiltInTag = makeMap('slot,component', true); /** * Check if an attribute is a reserved attribute. */ const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); /** * Remove an item from an array. */ function remove$2(arr, item) { const len = arr.length; if (len) { // fast path for the only / last item if (item === arr[len - 1]) { arr.length = len - 1; return; } const index = arr.indexOf(item); if (index > -1) { return arr.splice(index, 1); } } } /** * Check whether an object has the property. */ const hasOwnProperty = Object.prototype.hasOwnProperty; function hasOwn(obj, key) { return hasOwnProperty.call(obj, key); } /** * Create a cached version of a pure function. */ function cached(fn) { const cache = Object.create(null); return function cachedFn(str) { const hit = cache[str]; return hit || (cache[str] = fn(str)); }; } /** * Camelize a hyphen-delimited string. */ const camelizeRE = /-(\w)/g; const camelize = cached((str) => { return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : '')); }); /** * Capitalize a string. */ const capitalize = cached((str) => { return str.charAt(0).toUpperCase() + str.slice(1); }); /** * Hyphenate a camelCase string. */ const hyphenateRE = /\B([A-Z])/g; const hyphenate = cached((str) => { return str.replace(hyphenateRE, '-$1').toLowerCase(); }); /** * Simple bind polyfill for environments that do not support it, * e.g., PhantomJS 1.x. Technically, we don't need this anymore * since native bind is now performant enough in most browsers. * But removing it would mean breaking code that was able to run in * PhantomJS 1.x, so this must be kept for backward compatibility. */ /* istanbul ignore next */ function polyfillBind(fn, ctx) { function boundFn(a) { const l = arguments.length; return l ? l > 1 ? fn.apply(ctx, arguments) : fn.call(ctx, a) : fn.call(ctx); } boundFn._length = fn.length; return boundFn; } function nativeBind(fn, ctx) { return fn.bind(ctx); } // @ts-expect-error bind cannot be `undefined` const bind$1 = Function.prototype.bind ? nativeBind : polyfillBind; /** * Convert an Array-like object to a real Array. */ function toArray(list, start) { start = start || 0; let i = list.length - start; const ret = new Array(i); while (i--) { ret[i] = list[i + start]; } return ret; } /** * Mix properties into target object. */ function extend(to, _from) { for (const key in _from) { to[key] = _from[key]; } return to; } /** * Merge an Array of Objects into a single Object. */ function toObject(arr) { const res = {}; for (let i = 0; i < arr.length; i++) { if (arr[i]) { extend(res, arr[i]); } } return res; } /* eslint-disable no-unused-vars */ /** * Perform no operation. * Stubbing args to make Flow happy without leaving useless transpiled code * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/). */ function noop(a, b, c) { } /** * Always return false. */ const no = (a, b, c) => false; /* eslint-enable no-unused-vars */ /** * Return the same value. */ const identity = (_) => _; /** * Generate a string containing static keys from compiler modules. */ function genStaticKeys$1(modules) { return modules .reduce((keys, m) => keys.concat(m.staticKeys || []), []) .join(','); } /** * Check if two values are loosely equal - that is, * if they are plain objects, do they have the same shape? */ function looseEqual(a, b) { if (a === b) return true; const isObjectA = isObject(a); const isObjectB = isObject(b); if (isObjectA && isObjectB) { try { const isArrayA = Array.isArray(a); const isArrayB = Array.isArray(b); if (isArrayA && isArrayB) { return (a.length === b.length && a.every((e, i) => { return looseEqual(e, b[i]); })); } else if (a instanceof Date && b instanceof Date) { return a.getTime() === b.getTime(); } else if (!isArrayA && !isArrayB) { const keysA = Object.keys(a); const keysB = Object.keys(b); return (keysA.length === keysB.length && keysA.every(key => { return looseEqual(a[key], b[key]); })); } else { /* istanbul ignore next */ return false; } } catch (e) { /* istanbul ignore next */ return false; } } else if (!isObjectA && !isObjectB) { return String(a) === String(b); } else { return false; } } /** * Return the first index at which a loosely equal value can be * found in the array (if value is a plain object, the array must * contain an object of the same shape), or -1 if it is not present. */ function looseIndexOf(arr, val) { for (let i = 0; i < arr.length; i++) { if (looseEqual(arr[i], val)) return i; } return -1; } /** * Ensure a function is called only once. */ function once(fn) { let called = false; return function () { if (!called) { called = true; fn.apply(this, arguments); } }; } // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill function hasChanged(x, y) { if (x === y) { return x === 0 && 1 / x !== 1 / y; } else { return x === x || y === y; } } const SSR_ATTR = 'data-server-rendered'; const ASSET_TYPES = ['component', 'directive', 'filter']; const LIFECYCLE_HOOKS = [ 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUpdate', 'updated', 'beforeDestroy', 'destroyed', 'activated', 'deactivated', 'errorCaptured', 'serverPrefetch', 'renderTracked', 'renderTriggered' ]; var config = { /** * Option merge strategies (used in core/util/options) */ // $flow-disable-line optionMergeStrategies: Object.create(null), /** * Whether to suppress warnings. */ silent: false, /** * Show production mode tip message on boot? */ productionTip: true, /** * Whether to enable devtools */ devtools: true, /** * Whether to record perf */ performance: false, /** * Error handler for watcher errors */ errorHandler: null, /** * Warn handler for watcher warns */ warnHandler: null, /** * Ignore certain custom elements */ ignoredElements: [], /** * Custom user key aliases for v-on */ // $flow-disable-line keyCodes: Object.create(null), /** * Check if a tag is reserved so that it cannot be registered as a * component. This is platform-dependent and may be overwritten. */ isReservedTag: no, /** * Check if an attribute is reserved so that it cannot be used as a component * prop. This is platform-dependent and may be overwritten. */ isReservedAttr: no, /** * Check if a tag is an unknown element. * Platform-dependent. */ isUnknownElement: no, /** * Get the namespace of an element */ getTagNamespace: noop, /** * Parse the real tag name for the specific platform. */ parsePlatformTagName: identity, /** * Check if an attribute must be bound using property, e.g. value * Platform-dependent. */ mustUseProp: no, /** * Perform updates asynchronously. Intended to be used by Vue Test Utils * This will significantly reduce performance if set to false. */ async: true, /** * Exposed for legacy reasons */ _lifecycleHooks: LIFECYCLE_HOOKS }; /** * unicode letters used for parsing html tags, component names and property paths. * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname * skipping \u10000-\uEFFFF due to it freezing up PhantomJS */ const unicodeRegExp = /a-zA-Z\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD/; /** * Check if a string starts with $ or _ */ function isReserved(str) { const c = (str + '').charCodeAt(0); return c === 0x24 || c === 0x5f; } /** * Define a property. */ function def(obj, key, val, enumerable) { Object.defineProperty(obj, key, { value: val, enumerable: !!enumerable, writable: true, configurable: true }); } /** * Parse simple path. */ const bailRE = new RegExp(`[^${unicodeRegExp.source}.$_\\d]`); function parsePath(path) { if (bailRE.test(path)) { return; } const segments = path.split('.'); return function (obj) { for (let i = 0; i < segments.length; i++) { if (!obj) return; obj = obj[segments[i]]; } return obj; }; } // can we use __proto__? const hasProto = '__proto__' in {}; // Browser environment sniffing const inBrowser = typeof window !== 'undefined'; const UA = inBrowser && window.navigator.userAgent.toLowerCase(); const isIE = UA && /msie|trident/.test(UA); const isIE9 = UA && UA.indexOf('msie 9.0') > 0; const isEdge = UA && UA.indexOf('edge/') > 0; UA && UA.indexOf('android') > 0; const isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); UA && /chrome\/\d+/.test(UA) && !isEdge; UA && /phantomjs/.test(UA); const isFF = UA && UA.match(/firefox\/(\d+)/); // Firefox has a "watch" function on Object.prototype... // @ts-expect-error firebox support const nativeWatch = {}.watch; let supportsPassive = false; if (inBrowser) { try { const opts = {}; Object.defineProperty(opts, 'passive', { get() { /* istanbul ignore next */ supportsPassive = true; } }); // https://github.com/facebook/flow/issues/285 window.addEventListener('test-passive', null, opts); } catch (e) { } } // this needs to be lazy-evaled because vue may be required before // vue-server-renderer can set VUE_ENV let _isServer; const isServerRendering = () => { if (_isServer === undefined) { /* istanbul ignore if */ if (!inBrowser && typeof global !== 'undefined') { // detect presence of vue-server-renderer and avoid // Webpack shimming the process _isServer = global['process'] && global['process'].env.VUE_ENV === 'server'; } else { _isServer = false; } } return _isServer; }; // detect devtools const devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; /* istanbul ignore next */ function isNative(Ctor) { return typeof Ctor === 'function' && /native code/.test(Ctor.toString()); } const hasSymbol = typeof Symbol !== 'undefined' && isNative(Symbol) && typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys); let _Set; // $flow-disable-line /* istanbul ignore if */ if (typeof Set !== 'undefined' && isNative(Set)) { // use native Set when available. _Set = Set; } else { // a non-standard Set polyfill that only works with primitive keys. _Set = class Set { constructor() { this.set = Object.create(null); } has(key) { return this.set[key] === true; } add(key) { this.set[key] = true; } clear() { this.set = Object.create(null); } }; } let currentInstance = null; /** * This is exposed for compatibility with v3 (e.g. some functions in VueUse * relies on it). Do not use this internally, just use `currentInstance`. * * @internal this function needs manual type declaration because it relies * on previously manually authored types from Vue 2 */ function getCurrentInstance() { return currentInstance && { proxy: currentInstance }; } /** * @internal */ function setCurrentInstance(vm = null) { if (!vm) currentInstance && currentInstance._scope.off(); currentInstance = vm; vm && vm._scope.on(); } /** * @internal */ class VNode { constructor(tag, data, children, text, elm, context, componentOptions, asyncFactory) { this.tag = tag; this.data = data; this.children = children; this.text = text; this.elm = elm; this.ns = undefined; this.context = context; this.fnContext = undefined; this.fnOptions = undefined; this.fnScopeId = undefined; this.key = data && data.key; this.componentOptions = componentOptions; this.componentInstance = undefined; this.parent = undefined; this.raw = false; this.isStatic = false; this.isRootInsert = true; this.isComment = false; this.isCloned = false; this.isOnce = false; this.asyncFactory = asyncFactory; this.asyncMeta = undefined; this.isAsyncPlaceholder = false; } // DEPRECATED: alias for componentInstance for backwards compat. /* istanbul ignore next */ get child() { return this.componentInstance; } } const createEmptyVNode = (text = '') => { const node = new VNode(); node.text = text; node.isComment = true; return node; }; function createTextVNode(val) { return new VNode(undefined, undefined, undefined, String(val)); } // optimized shallow clone // used for static nodes and slot nodes because they may be reused across // multiple renders, cloning them avoids errors when DOM manipulations rely // on their elm reference. function cloneVNode(vnode) { const cloned = new VNode(vnode.tag, vnode.data, // #7975 // clone children array to avoid mutating original in case of cloning // a child. vnode.children && vnode.children.slice(), vnode.text, vnode.elm, vnode.context, vnode.componentOptions, vnode.asyncFactory); cloned.ns = vnode.ns; cloned.isStatic = vnode.isStatic; cloned.key = vnode.key; cloned.isComment = vnode.isComment; cloned.fnContext = vnode.fnContext; cloned.fnOptions = vnode.fnOptions; cloned.fnScopeId = vnode.fnScopeId; cloned.asyncMeta = vnode.asyncMeta; cloned.isCloned = true; return cloned; } /* not type checking this file because flow doesn't play well with Proxy */ let initProxy; { const allowedGlobals = makeMap('Infinity,undefined,NaN,isFinite,isNaN,' + 'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' + 'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,' + 'require' // for Webpack/Browserify ); const warnNonPresent = (target, key) => { warn$2(`Property or method "${key}" is not defined on the instance but ` + 'referenced during render. Make sure that this property is reactive, ' + 'either in the data option, or for class-based components, by ' + 'initializing the property. ' + 'See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target); }; const warnReservedPrefix = (target, key) => { warn$2(`Property "${key}" must be accessed with "$data.${key}" because ` + 'properties starting with "$" or "_" are not proxied in the Vue instance to ' + 'prevent conflicts with Vue internals. ' + 'See: https://v2.vuejs.org/v2/api/#data', target); }; const hasProxy = typeof Proxy !== 'undefined' && isNative(Proxy); if (hasProxy) { const isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact'); config.keyCodes = new Proxy(config.keyCodes, { set(target, key, value) { if (isBuiltInModifier(key)) { warn$2(`Avoid overwriting built-in modifier in config.keyCodes: .${key}`); return false; } else { target[key] = value; return true; } } }); } const hasHandler = { has(target, key) { const has = key in target; const isAllowed = allowedGlobals(key) || (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data)); if (!has && !isAllowed) { if (key in target.$data) warnReservedPrefix(target, key); else warnNonPresent(target, key); } return has || !isAllowed; } }; const getHandler = { get(target, key) { if (typeof key === 'string' && !(key in target)) { if (key in target.$data) warnReservedPrefix(target, key); else warnNonPresent(target, key); } return target[key]; } }; initProxy = function initProxy(vm) { if (hasProxy) { // determine which proxy handler to use const options = vm.$options; const handlers = options.render && options.render._withStripped ? getHandler : hasHandler; vm._renderProxy = new Proxy(vm, handlers); } else { vm._renderProxy = vm; } }; } let uid$2 = 0; const pendingCleanupDeps = []; const cleanupDeps = () => { for (let i = 0; i < pendingCleanupDeps.length; i++) { const dep = pendingCleanupDeps[i]; dep.subs = dep.subs.filter(s => s); dep._pending = false; } pendingCleanupDeps.length = 0; }; /** * A dep is an observable that can have multiple * directives subscribing to it. * @internal */ class Dep { constructor() { // pending subs cleanup this._pending = false; this.id = uid$2++; this.subs = []; } addSub(sub) { this.subs.push(sub); } removeSub(sub) { // #12696 deps with massive amount of subscribers are extremely slow to // clean up in Chromium // to workaround this, we unset the sub for now, and clear them on // next scheduler flush. this.subs[this.subs.indexOf(sub)] = null; if (!this._pending) { this._pending = true; pendingCleanupDeps.push(this); } } depend(info) { if (Dep.target) { Dep.target.addDep(this); if (info && Dep.target.onTrack) { Dep.target.onTrack(Object.assign({ effect: Dep.target }, info)); } } } notify(info) { // stabilize the subscriber list first const subs = this.subs.filter(s => s); if (!config.async) { // subs aren't sorted in scheduler if not running async // we need to sort them now to make sure they fire in correct // order subs.sort((a, b) => a.id - b.id); } for (let i = 0, l = subs.length; i < l; i++) { const sub = subs[i]; if (info) { sub.onTrigger && sub.onTrigger(Object.assign({ effect: subs[i] }, info)); } sub.update(); } } } // The current target watcher being evaluated. // This is globally unique because only one watcher // can be evaluated at a time. Dep.target = null; const targetStack = []; function pushTarget(target) { targetStack.push(target); Dep.target = target; } function popTarget() { targetStack.pop(); Dep.target = targetStack[targetStack.length - 1]; } /* * not type checking this file because flow doesn't play well with * dynamically accessing methods on Array prototype */ const arrayProto = Array.prototype; const arrayMethods = Object.create(arrayProto); const methodsToPatch = [ 'push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse' ]; /** * Intercept mutating methods and emit events */ methodsToPatch.forEach(function (method) { // cache original method const original = arrayProto[method]; def(arrayMethods, method, function mutator(...args) { const result = original.apply(this, args); const ob = this.__ob__; let inserted; switch (method) { case 'push': case 'unshift': inserted = args; break; case 'splice': inserted = args.slice(2); break; } if (inserted) ob.observeArray(inserted); // notify change { ob.dep.notify({ type: "array mutation" /* TriggerOpTypes.ARRAY_MUTATION */, target: this, key: method }); } return result; }); }); const arrayKeys = Object.getOwnPropertyNames(arrayMethods); const NO_INITIAL_VALUE = {}; /** * In some cases we may want to disable observation inside a component's * update computation. */ let shouldObserve = true; function toggleObserving(value) { shouldObserve = value; } // ssr mock dep const mockDep = { notify: noop, depend: noop, addSub: noop, removeSub: noop }; /** * Observer class that is attached to each observed * object. Once attached, the observer converts the target * object's property keys into getter/setters that * collect dependencies and dispatch updates. */ class Observer { constructor(value, shallow = false, mock = false) { this.value = value; this.shallow = shallow; this.mock = mock; // this.value = value this.dep = mock ? mockDep : new Dep(); this.vmCount = 0; def(value, '__ob__', this); if (isArray(value)) { if (!mock) { if (hasProto) { value.__proto__ = arrayMethods; /* eslint-enable no-proto */ } else { for (let i = 0, l = arrayKeys.length; i < l; i++) { const key = arrayKeys[i]; def(value, key, arrayMethods[key]); } } } if (!shallow) { this.observeArray(value); } } else { /** * Walk through all properties and convert them into * getter/setters. This method should only be called when * value type is Object. */ const keys = Object.keys(value); for (let i = 0; i < keys.length; i++) { const key = keys[i]; defineReactive(value, key, NO_INITIAL_VALUE, undefined, shallow, mock); } } } /** * Observe a list of Array items. */ observeArray(value) { for (let i = 0, l = value.length; i < l; i++) { observe(value[i], false, this.mock); } } } // helpers /** * Attempt to create an observer instance for a value, * returns the new observer if successfully observed, * or the existing observer if the value already has one. */ function observe(value, shallow, ssrMockReactivity) { if (value && hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) { return value.__ob__; } if (shouldObserve && (ssrMockReactivity || !isServerRendering()) && (isArray(value) || isPlainObject(value)) && Object.isExtensible(value) && !value.__v_skip /* ReactiveFlags.SKIP */ && !isRef(value) && !(value instanceof VNode)) { return new Observer(value, shallow, ssrMockReactivity); } } /** * Define a reactive property on an Object. */ function defineReactive(obj, key, val, customSetter, shallow, mock, observeEvenIfShallow = false) { const dep = new Dep(); const property = Object.getOwnPropertyDescriptor(obj, key); if (property && property.configurable === false) { return; } // cater for pre-defined getter/setters const getter = property && property.get; const setter = property && property.set; if ((!getter || setter) && (val === NO_INITIAL_VALUE || arguments.length === 2)) { val = obj[key]; } let childOb = shallow ? val && val.__ob__ : observe(val, false, mock); Object.defineProperty(obj, key, { enumerable: true, configurable: true, get: function reactiveGetter() { const value = getter ? getter.call(obj) : val; if (Dep.target) { { dep.depend({ target: obj, type: "get" /* TrackOpTypes.GET */, key }); } if (childOb) { childOb.dep.depend(); if (isArray(value)) { dependArray(value); } } } return isRef(value) && !shallow ? value.value : value; }, set: function reactiveSetter(newVal) { const value = getter ? getter.call(obj) : val; if (!hasChanged(value, newVal)) { return; } if (customSetter) { customSetter(); } if (setter) { setter.call(obj, newVal); } else if (getter) { // #7981: for accessor properties without setter return; } else if (!shallow && isRef(value) && !isRef(newVal)) { value.value = newVal; return; } else { val = newVal; } childOb = shallow ? newVal && newVal.__ob__ : observe(newVal, false, mock); { dep.notify({ type: "set" /* TriggerOpTypes.SET */, target: obj, key, newValue: newVal, oldValue: value }); } } }); return dep; } function set(target, key, val) { if ((isUndef(target) || isPrimitive(target))) { warn$2(`Cannot set reactive property on undefined, null, or primitive value: ${target}`); } if (isReadonly(target)) { warn$2(`Set operation on key "${key}" failed: target is readonly.`); return; } const ob = target.__ob__; if (isArray(target) && isValidArrayIndex(key)) { target.length = Math.max(target.length, key); target.splice(key, 1, val); // when mocking for SSR, array methods are not hijacked if (ob && !ob.shallow && ob.mock) { observe(val, false, true); } return val; } if (key in target && !(key in Object.prototype)) { target[key] = val; return val; } if (target._isVue || (ob && ob.vmCount)) { warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' + 'at runtime - declare it upfront in the data option.'); return val; } if (!ob) { target[key] = val; return val; } defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock); { ob.dep.notify({ type: "add" /* TriggerOpTypes.ADD */, target: target, key, newValue: val, oldValue: undefined }); } return val; } function del(target, key) { if ((isUndef(target) || isPrimitive(target))) { warn$2(`Cannot delete reactive property on undefined, null, or primitive value: ${target}`); } if (isArray(target) && isValidArrayIndex(key)) { target.splice(key, 1); return; } const ob = target.__ob__; if (target._isVue || (ob && ob.vmCount)) { warn$2('Avoid deleting properties on a Vue instance or its root $data ' + '- just set it to null.'); return; } if (isReadonly(target)) { warn$2(`Delete operation on key "${key}" failed: target is readonly.`); return; } if (!hasOwn(target, key)) { return; } delete target[key]; if (!ob) { return; } { ob.dep.notify({ type: "delete" /* TriggerOpTypes.DELETE */, target: target, key }); } } /** * Collect dependencies on array elements when the array is touched, since * we cannot intercept array element access like property getters. */ function dependArray(value) { for (let e, i = 0, l = value.length; i < l; i++) { e = value[i]; if (e && e.__ob__) { e.__ob__.dep.depend(); } if (isArray(e)) { dependArray(e); } } } function reactive(target) { makeReactive(target, false); return target; } /** * 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) { makeReactive(target, true); def(target, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true); return target; } function makeReactive(target, shallow) { // if trying to observe a readonly proxy, return the readonly version. if (!isReadonly(target)) { { if (isArray(target)) { warn$2(`Avoid using Array as root value for ${shallow ? `shallowReactive()` : `reactive()`} as it cannot be tracked in watch() or watchEffect(). Use ${shallow ? `shallowRef()` : `ref()`} instead. This is a Vue-2-only limitation.`); } const existingOb = target && target.__ob__; if (existingOb && existingOb.shallow !== shallow) { warn$2(`Target is already a ${existingOb.shallow ? `` : `non-`}shallow reactive object, and cannot be converted to ${shallow ? `` : `non-`}shallow.`); } } const ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */); if (!ob) { if (target == null || isPrimitive(target)) { warn$2(`value cannot be made reactive: ${String(target)}`); } if (isCollectionType(target)) { warn$2(`Vue 2 does not support reactive collection types such as Map or Set.`); } } } } function isReactive(value) { if (isReadonly(value)) { return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]); } return !!(value && value.__ob__); } function isShallow(value) { return !!(value && value.__v_isShallow); } function isReadonly(value) { return !!(value && value.__v_isReadonly); } function isProxy(value) { return isReactive(value) || isReadonly(value); } function toRaw(observed) { const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */]; return raw ? toRaw(raw) : observed; } function markRaw(value) { // non-extensible objects won't be observed anyway if (Object.isExtensible(value)) { def(value, "__v_skip" /* ReactiveFlags.SKIP */, true); } return value; } /** * @internal */ function isCollectionType(value) { const type = toRawType(value); return (type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet'); } /** * @internal */ const RefFlag = `__v_isRef`; function isRef(r) { return !!(r && r.__v_isRef === true); } function ref$1(value) { return createRef(value, false); } function shallowRef(value) { return createRef(value, true); } function createRef(rawValue, shallow) { if (isRef(rawValue)) { return rawValue; } const ref = {}; def(ref, RefFlag, true); def(ref, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, shallow); def(ref, 'dep', defineReactive(ref, 'value', rawValue, null, shallow, isServerRendering())); return ref; } function triggerRef(ref) { if (!ref.dep) { warn$2(`received object is not a triggerable ref.`); } { ref.dep && ref.dep.notify({ type: "set" /* TriggerOpTypes.SET */, target: ref, key: 'value' }); } } function unref(ref) { return isRef(ref) ? ref.value : ref; } function proxyRefs(objectWithRefs) { if (isReactive(objectWithRefs)) { return objectWithRefs; } const proxy = {}; const keys = Object.keys(objectWithRefs); for (let i = 0; i < keys.length; i++) { proxyWithRefUnwrap(proxy, objectWithRefs, keys[i]); } return proxy; } function proxyWithRefUnwrap(target, source, key) { Object.defineProperty(target, key, { enumerable: true, configurable: true, get: () => { const val = source[key]; if (isRef(val)) { return val.value; } else { const ob = val && val.__ob__; if (ob) ob.dep.depend(); return val; } }, set: value => { const oldValue = source[key]; if (isRef(oldValue) && !isRef(value)) { oldValue.value = value; } else { source[key] = value; } } }); } function customRef(factory) { const dep = new Dep(); const { get, set } = factory(() => { { dep.depend({ target: ref, type: "get" /* TrackOpTypes.GET */, key: 'value' }); } }, () => { { dep.notify({ target: ref, type: "set" /* TriggerOpTypes.SET */, key: 'value' }); } }); const ref = { get value() { return get(); }, set value(newVal) { set(newVal); } }; def(ref, RefFlag, true); return ref; } function toRefs(object) { if (!isReactive(object)) { warn$2(`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; } function toRef(object, key, defaultValue) { const val = object[key]; if (isRef(val)) { return val; } const ref = { get value() { const val = object[key]; return val === undefined ? defaultValue : val; }, set value(newVal) { object[key] = newVal; } }; def(ref, RefFlag, true); return ref; } const rawToReadonlyFlag = `__v_rawToReadonly`; const rawToShallowReadonlyFlag = `__v_rawToShallowReadonly`; function readonly(target) { return createReadonly(target, false); } function createReadonly(target, shallow) { if (!isPlainObject(target)) { { if (isArray(target)) { warn$2(`Vue 2 does not support readonly arrays.`); } else if (isCollectionType(target)) { warn$2(`Vue 2 does not support readonly collection types such as Map or Set.`); } else { warn$2(`value cannot be made readonly: ${typeof target}`); } } return target; } if (!Object.isExtensible(target)) { warn$2(`Vue 2 does not support creating readonly proxy for non-extensible object.`); } // already a readonly object if (isReadonly(target)) { return target; } // already has a readonly proxy const existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag; const existingProxy = target[existingFlag]; if (existingProxy) { return existingProxy; } const proxy = Object.create(Object.getPrototypeOf(target)); def(target, existingFlag, proxy); def(proxy, "__v_isReadonly" /* ReactiveFlags.IS_READONLY */, true); def(proxy, "__v_raw" /* ReactiveFlags.RAW */, target); if (isRef(target)) { def(proxy, RefFlag, true); } if (shallow || isShallow(target)) { def(proxy, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true); } const keys = Object.keys(target); for (let i = 0; i < keys.length; i++) { defineReadonlyProperty(proxy, target, keys[i], shallow); } return proxy; } function defineReadonlyProperty(proxy, target, key, shallow) { Object.defineProperty(proxy, key, { enumerable: true, configurable: true, get() { const val = target[key]; return shallow || !isPlainObject(val) ? val : readonly(val); }, set() { warn$2(`Set operation on key "${key}" failed: target is readonly.`); } }); } /** * 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 createReadonly(target, true); } function computed(getterOrOptions, debugOptions) { let getter; let setter; const onlyGetter = isFunction(getterOrOptions); if (onlyGetter) { getter = getterOrOptions; setter = () => { warn$2('Write operation failed: computed value is readonly'); } ; } else { getter = getterOrOptions.get; setter = getterOrOptions.set; } const watcher = isServerRendering() ? null : new Watcher(currentInstance, getter, noop, { lazy: true }); if (watcher && debugOptions) { watcher.onTrack = debugOptions.onTrack; watcher.onTrigger = debugOptions.onTrigger; } const ref = { // some libs rely on the presence effect for checking computed refs // from normal refs, but the implementation doesn't matter effect: watcher, get value() { if (watcher) { if (watcher.dirty) { watcher.evaluate(); } if (Dep.target) { if (Dep.target.onTrack) { Dep.target.onTrack({ effect: Dep.target, target: ref, type: "get" /* TrackOpTypes.GET */, key: 'value' }); } watcher.depend(); } return watcher.value; } else { return getter(); } }, set value(newVal) { setter(newVal); } }; def(ref, RefFlag, true); def(ref, "__v_isReadonly" /* ReactiveFlags.IS_READONLY */, onlyGetter); return ref; } let mark; let measure; { const perf = inBrowser && window.performance; /* istanbul ignore if */ if (perf && // @ts-ignore perf.mark && // @ts-ignore perf.measure && // @ts-ignore perf.clearMarks && // @ts-ignore perf.clearMeasures) { mark = tag => perf.mark(tag); measure = (name, startTag, endTag) => { perf.measure(name, startTag, endTag); perf.clearMarks(startTag); perf.clearMarks(endTag); // perf.clearMeasures(name) }; } } const normalizeEvent = cached((name) => { const passive = name.charAt(0) === '&'; name = passive ? name.slice(1) : name; const once = name.charAt(0) === '~'; // Prefixed last, checked first name = once ? name.slice(1) : name; const capture = name.charAt(0) === '!'; name = capture ? name.slice(1) : name; return { name, once, capture, passive }; }); function createFnInvoker(fns, vm) { function invoker() { const fns = invoker.fns; if (isArray(fns)) { const cloned = fns.slice(); for (let i = 0; i < cloned.length; i++) { invokeWithErrorHandling(cloned[i], null, arguments, vm, `v-on handler`); } } else { // return handler return value for single handlers return invokeWithErrorHandling(fns, null, arguments, vm, `v-on handler`); } } invoker.fns = fns; return invoker; } function updateListeners(on, oldOn, add, remove, createOnceHandler, vm) { let name, cur, old, event; for (name in on) { cur = on[name]; old = oldOn[name]; event = normalizeEvent(name); if (isUndef(cur)) { warn$2(`Invalid handler for event "${event.name}": got ` + String(cur), vm); } else if (isUndef(old)) { if (isUndef(cur.fns)) { cur = on[name] = createFnInvoker(cur, vm); } if (isTrue(event.once)) { cur = on[name] = createOnceHandler(event.name, cur, event.capture); } add(event.name, cur, event.capture, event.passive, event.params); } else if (cur !== old) { old.fns = cur; on[name] = old; } } for (name in oldOn) { if (isUndef(on[name])) { event = normalizeEvent(name); remove(event.name, oldOn[name], event.capture); } } } function mergeVNodeHook(def, hookKey, hook) { if (def instanceof VNode) { def = def.data.hook || (def.data.hook = {}); } let invoker; const oldHook = def[hookKey]; function wrappedHook() { hook.apply(this, arguments); // important: remove merged hook to ensure it's called only once // and prevent memory leak remove$2(invoker.fns, wrappedHook); } if (isUndef(oldHook)) { // no existing hook invoker = createFnInvoker([wrappedHook]); } else { /* istanbul ignore if */ if (isDef(oldHook.fns) && isTrue(oldHook.merged)) { // already a merged invoker invoker = oldHook; invoker.fns.push(wrappedHook); } else { // existing plain hook invoker = createFnInvoker([oldHook, wrappedHook]); } } invoker.merged = true; def[hookKey] = invoker; } function extractPropsFromVNodeData(data, Ctor, tag) { // we are only extracting raw values here. // validation and default values are handled in the child // component itself. const propOptions = Ctor.options.props; if (isUndef(propOptions)) { return; } const res = {}; const { attrs, props } = data; if (isDef(attrs) || isDef(props)) { for (const key in propOptions) { const altKey = hyphenate(key); { const keyInLowerCase = key.toLowerCase(); if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) { tip(`Prop "${keyInLowerCase}" is passed to component ` + `${formatComponentName( // @ts-expect-error tag is string tag || Ctor)}, but the declared prop name is` + ` "${key}". ` + `Note that HTML attributes are case-insensitive and camelCased ` + `props need to use their kebab-case equivalents when using in-DOM ` + `templates. You should probably use "${altKey}" instead of "${key}".`); } } checkProp(res, props, key, altKey, true) || checkProp(res, attrs, key, altKey, false); } } return res; } function checkProp(res, hash, key, altKey, preserve) { if (isDef(hash)) { if (hasOwn(hash, key)) { res[key] = hash[key]; if (!preserve) { delete hash[key]; } return true; } else if (hasOwn(hash, altKey)) { res[key] = hash[altKey]; if (!preserve) { delete hash[altKey]; } return true; } } return false; } // The template compiler attempts to minimize the need for normalization by // statically analyzing the template at compile time. // // For plain HTML markup, normalization can be completely skipped because the // generated render function is guaranteed to return Array. There are // two cases where extra normalization is needed: // 1. When the children contains components - because a functional component // may return an Array instead of a single root. In this case, just a simple // normalization is needed - if any child is an Array, we flatten the whole // thing with Array.prototype.concat. It is guaranteed to be only 1-level deep // because functional components already normalize their own children. function simpleNormalizeChildren(children) { for (let i = 0; i < children.length; i++) { if (isArray(children[i])) { return Array.prototype.concat.apply([], children); } } return children; } // 2. When the children contains constructs that always generated nested Arrays, // e.g.