From d37dbb7dc81ee5957e72e1173a9aa9ea626240fb Mon Sep 17 00:00:00 2001 From: mhsanaei Date: Wed, 17 Apr 2024 12:41:33 +0330 Subject: vue v2.7.16 --- web/assets/vue@2.7.16/vue.runtime.esm.js | 8825 ++++++++++++++++++++++++++++++ 1 file changed, 8825 insertions(+) create mode 100644 web/assets/vue@2.7.16/vue.runtime.esm.js (limited to 'web/assets/vue@2.7.16/vue.runtime.esm.js') diff --git a/web/assets/vue@2.7.16/vue.runtime.esm.js b/web/assets/vue@2.7.16/vue.runtime.esm.js new file mode 100644 index 00000000..ae5d8a20 --- /dev/null +++ b/web/assets/vue@2.7.16/vue.runtime.esm.js @@ -0,0 +1,8825 @@ +/*! + * Vue.js v2.7.16 + * (c) 2014-2023 Evan You + * Released under the MIT License. + */ +var emptyObject = Object.freeze({}); +var 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]. + */ +var _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) { + var 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) { + var 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) { + var map = Object.create(null); + var list = str.split(','); + for (var i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? function (val) { return map[val.toLowerCase()]; } : function (val) { return map[val]; }; +} +/** + * Check if a tag is a built-in tag. + */ +var isBuiltInTag = makeMap('slot,component', true); +/** + * Check if an attribute is a reserved attribute. + */ +var isReservedAttribute = makeMap('key,ref,slot,slot-scope,is'); +/** + * Remove an item from an array. + */ +function remove$2(arr, item) { + var len = arr.length; + if (len) { + // fast path for the only / last item + if (item === arr[len - 1]) { + arr.length = len - 1; + return; + } + var index = arr.indexOf(item); + if (index > -1) { + return arr.splice(index, 1); + } + } +} +/** + * Check whether an object has the property. + */ +var hasOwnProperty = Object.prototype.hasOwnProperty; +function hasOwn(obj, key) { + return hasOwnProperty.call(obj, key); +} +/** + * Create a cached version of a pure function. + */ +function cached(fn) { + var cache = Object.create(null); + return function cachedFn(str) { + var hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; +} +/** + * Camelize a hyphen-delimited string. + */ +var camelizeRE = /-(\w)/g; +var camelize = cached(function (str) { + return str.replace(camelizeRE, function (_, c) { return (c ? c.toUpperCase() : ''); }); +}); +/** + * Capitalize a string. + */ +var capitalize = cached(function (str) { + return str.charAt(0).toUpperCase() + str.slice(1); +}); +/** + * Hyphenate a camelCase string. + */ +var hyphenateRE = /\B([A-Z])/g; +var hyphenate = cached(function (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) { + var 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` +var bind = Function.prototype.bind ? nativeBind : polyfillBind; +/** + * Convert an Array-like object to a real Array. + */ +function toArray(list, start) { + start = start || 0; + var i = list.length - start; + var ret = new Array(i); + while (i--) { + ret[i] = list[i + start]; + } + return ret; +} +/** + * Mix properties into target object. + */ +function extend(to, _from) { + for (var key in _from) { + to[key] = _from[key]; + } + return to; +} +/** + * Merge an Array of Objects into a single Object. + */ +function toObject(arr) { + var res = {}; + for (var 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. + */ +var no = function (a, b, c) { return false; }; +/* eslint-enable no-unused-vars */ +/** + * Return the same value. + */ +var identity = function (_) { return _; }; +/** + * 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; + var isObjectA = isObject(a); + var isObjectB = isObject(b); + if (isObjectA && isObjectB) { + try { + var isArrayA = Array.isArray(a); + var isArrayB = Array.isArray(b); + if (isArrayA && isArrayB) { + return (a.length === b.length && + a.every(function (e, i) { + return looseEqual(e, b[i]); + })); + } + else if (a instanceof Date && b instanceof Date) { + return a.getTime() === b.getTime(); + } + else if (!isArrayA && !isArrayB) { + var keysA = Object.keys(a); + var keysB = Object.keys(b); + return (keysA.length === keysB.length && + keysA.every(function (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 (var 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) { + var 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; + } +} + +var SSR_ATTR = 'data-server-rendered'; +var ASSET_TYPES = ['component', 'directive', 'filter']; +var 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: process.env.NODE_ENV !== 'production', + /** + * Whether to enable devtools + */ + devtools: process.env.NODE_ENV !== 'production', + /** + * 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 + */ +var 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) { + var 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. + */ +var bailRE = new RegExp("[^".concat(unicodeRegExp.source, ".$_\\d]")); +function parsePath(path) { + if (bailRE.test(path)) { + return; + } + var segments = path.split('.'); + return function (obj) { + for (var i = 0; i < segments.length; i++) { + if (!obj) + return; + obj = obj[segments[i]]; + } + return obj; + }; +} + +// can we use __proto__? +var hasProto = '__proto__' in {}; +// Browser environment sniffing +var inBrowser = typeof window !== 'undefined'; +var UA = inBrowser && window.navigator.userAgent.toLowerCase(); +var isIE = UA && /msie|trident/.test(UA); +var isIE9 = UA && UA.indexOf('msie 9.0') > 0; +var isEdge = UA && UA.indexOf('edge/') > 0; +UA && UA.indexOf('android') > 0; +var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA); +UA && /chrome\/\d+/.test(UA) && !isEdge; +UA && /phantomjs/.test(UA); +var isFF = UA && UA.match(/firefox\/(\d+)/); +// Firefox has a "watch" function on Object.prototype... +// @ts-expect-error firebox support +var nativeWatch = {}.watch; +var supportsPassive = false; +if (inBrowser) { + try { + var opts = {}; + Object.defineProperty(opts, 'passive', { + get: function () { + /* 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 +var _isServer; +var isServerRendering = function () { + 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 +var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__; +/* istanbul ignore next */ +function isNative(Ctor) { + return typeof Ctor === 'function' && /native code/.test(Ctor.toString()); +} +var hasSymbol = typeof Symbol !== 'undefined' && + isNative(Symbol) && + typeof Reflect !== 'undefined' && + isNative(Reflect.ownKeys); +var _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 */ (function () { + function Set() { + this.set = Object.create(null); + } + Set.prototype.has = function (key) { + return this.set[key] === true; + }; + Set.prototype.add = function (key) { + this.set[key] = true; + }; + Set.prototype.clear = function () { + this.set = Object.create(null); + }; + return Set; + }()); +} + +var 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) { + if (vm === void 0) { vm = null; } + if (!vm) + currentInstance && currentInstance._scope.off(); + currentInstance = vm; + vm && vm._scope.on(); +} + +/** + * @internal + */ +var VNode = /** @class */ (function () { + function VNode(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; + } + Object.defineProperty(VNode.prototype, "child", { + // DEPRECATED: alias for componentInstance for backwards compat. + /* istanbul ignore next */ + get: function () { + return this.componentInstance; + }, + enumerable: false, + configurable: true + }); + return VNode; +}()); +var createEmptyVNode = function (text) { + if (text === void 0) { text = ''; } + var 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) { + var 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; +} + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ + +var __assign = function() { + __assign = Object.assign || function __assign(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; + +typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}; + +var uid$2 = 0; +var pendingCleanupDeps = []; +var cleanupDeps = function () { + for (var i = 0; i < pendingCleanupDeps.length; i++) { + var dep = pendingCleanupDeps[i]; + dep.subs = dep.subs.filter(function (s) { return s; }); + dep._pending = false; + } + pendingCleanupDeps.length = 0; +}; +/** + * A dep is an observable that can have multiple + * directives subscribing to it. + * @internal + */ +var Dep = /** @class */ (function () { + function Dep() { + // pending subs cleanup + this._pending = false; + this.id = uid$2++; + this.subs = []; + } + Dep.prototype.addSub = function (sub) { + this.subs.push(sub); + }; + Dep.prototype.removeSub = function (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); + } + }; + Dep.prototype.depend = function (info) { + if (Dep.target) { + Dep.target.addDep(this); + if (process.env.NODE_ENV !== 'production' && info && Dep.target.onTrack) { + Dep.target.onTrack(__assign({ effect: Dep.target }, info)); + } + } + }; + Dep.prototype.notify = function (info) { + // stabilize the subscriber list first + var subs = this.subs.filter(function (s) { return s; }); + if (process.env.NODE_ENV !== 'production' && !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(function (a, b) { return a.id - b.id; }); + } + for (var i = 0, l = subs.length; i < l; i++) { + var sub = subs[i]; + if (process.env.NODE_ENV !== 'production' && info) { + sub.onTrigger && + sub.onTrigger(__assign({ effect: subs[i] }, info)); + } + sub.update(); + } + }; + return Dep; +}()); +// The current target watcher being evaluated. +// This is globally unique because only one watcher +// can be evaluated at a time. +Dep.target = null; +var 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 + */ +var arrayProto = Array.prototype; +var arrayMethods = Object.create(arrayProto); +var methodsToPatch = [ + 'push', + 'pop', + 'shift', + 'unshift', + 'splice', + 'sort', + 'reverse' +]; +/** + * Intercept mutating methods and emit events + */ +methodsToPatch.forEach(function (method) { + // cache original method + var original = arrayProto[method]; + def(arrayMethods, method, function mutator() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var result = original.apply(this, args); + var ob = this.__ob__; + var inserted; + switch (method) { + case 'push': + case 'unshift': + inserted = args; + break; + case 'splice': + inserted = args.slice(2); + break; + } + if (inserted) + ob.observeArray(inserted); + // notify change + if (process.env.NODE_ENV !== 'production') { + ob.dep.notify({ + type: "array mutation" /* TriggerOpTypes.ARRAY_MUTATION */, + target: this, + key: method + }); + } + else { + ob.dep.notify(); + } + return result; + }); +}); + +var arrayKeys = Object.getOwnPropertyNames(arrayMethods); +var NO_INITIAL_VALUE = {}; +/** + * In some cases we may want to disable observation inside a component's + * update computation. + */ +var shouldObserve = true; +function toggleObserving(value) { + shouldObserve = value; +} +// ssr mock dep +var 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. + */ +var Observer = /** @class */ (function () { + function Observer(value, shallow, mock) { + if (shallow === void 0) { shallow = false; } + if (mock === void 0) { 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 (var i = 0, l = arrayKeys.length; i < l; i++) { + var 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. + */ + var keys = Object.keys(value); + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + defineReactive(value, key, NO_INITIAL_VALUE, undefined, shallow, mock); + } + } + } + /** + * Observe a list of Array items. + */ + Observer.prototype.observeArray = function (value) { + for (var i = 0, l = value.length; i < l; i++) { + observe(value[i], false, this.mock); + } + }; + return Observer; +}()); +// 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) { + if (observeEvenIfShallow === void 0) { observeEvenIfShallow = false; } + var dep = new Dep(); + var property = Object.getOwnPropertyDescriptor(obj, key); + if (property && property.configurable === false) { + return; + } + // cater for pre-defined getter/setters + var getter = property && property.get; + var setter = property && property.set; + if ((!getter || setter) && + (val === NO_INITIAL_VALUE || arguments.length === 2)) { + val = obj[key]; + } + var childOb = shallow ? val && val.__ob__ : observe(val, false, mock); + Object.defineProperty(obj, key, { + enumerable: true, + configurable: true, + get: function reactiveGetter() { + var value = getter ? getter.call(obj) : val; + if (Dep.target) { + if (process.env.NODE_ENV !== 'production') { + dep.depend({ + target: obj, + type: "get" /* TrackOpTypes.GET */, + key: key + }); + } + else { + dep.depend(); + } + if (childOb) { + childOb.dep.depend(); + if (isArray(value)) { + dependArray(value); + } + } + } + return isRef(value) && !shallow ? value.value : value; + }, + set: function reactiveSetter(newVal) { + var value = getter ? getter.call(obj) : val; + if (!hasChanged(value, newVal)) { + return; + } + if (process.env.NODE_ENV !== 'production' && 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); + if (process.env.NODE_ENV !== 'production') { + dep.notify({ + type: "set" /* TriggerOpTypes.SET */, + target: obj, + key: key, + newValue: newVal, + oldValue: value + }); + } + else { + dep.notify(); + } + } + }); + return dep; +} +function set(target, key, val) { + if (process.env.NODE_ENV !== 'production' && (isUndef(target) || isPrimitive(target))) { + warn("Cannot set reactive property on undefined, null, or primitive value: ".concat(target)); + } + if (isReadonly(target)) { + process.env.NODE_ENV !== 'production' && warn("Set operation on key \"".concat(key, "\" failed: target is readonly.")); + return; + } + var 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)) { + process.env.NODE_ENV !== 'production' && + warn('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); + if (process.env.NODE_ENV !== 'production') { + ob.dep.notify({ + type: "add" /* TriggerOpTypes.ADD */, + target: target, + key: key, + newValue: val, + oldValue: undefined + }); + } + else { + ob.dep.notify(); + } + return val; +} +function del(target, key) { + if (process.env.NODE_ENV !== 'production' && (isUndef(target) || isPrimitive(target))) { + warn("Cannot delete reactive property on undefined, null, or primitive value: ".concat(target)); + } + if (isArray(target) && isValidArrayIndex(key)) { + target.splice(key, 1); + return; + } + var ob = target.__ob__; + if (target._isVue || (ob && ob.vmCount)) { + process.env.NODE_ENV !== 'production' && + warn('Avoid deleting properties on a Vue instance or its root $data ' + + '- just set it to null.'); + return; + } + if (isReadonly(target)) { + process.env.NODE_ENV !== 'production' && + warn("Delete operation on key \"".concat(key, "\" failed: target is readonly.")); + return; + } + if (!hasOwn(target, key)) { + return; + } + delete target[key]; + if (!ob) { + return; + } + if (process.env.NODE_ENV !== 'production') { + ob.dep.notify({ + type: "delete" /* TriggerOpTypes.DELETE */, + target: target, + key: key + }); + } + else { + ob.dep.notify(); + } +} +/** + * Collect dependencies on array elements when the array is touched, since + * we cannot intercept array element access like property getters. + */ +function dependArray(value) { + for (var e = void 0, 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 (process.env.NODE_ENV !== 'production') { + if (isArray(target)) { + warn("Avoid using Array as root value for ".concat(shallow ? "shallowReactive()" : "reactive()", " as it cannot be tracked in watch() or watchEffect(). Use ").concat(shallow ? "shallowRef()" : "ref()", " instead. This is a Vue-2-only limitation.")); + } + var existingOb = target && target.__ob__; + if (existingOb && existingOb.shallow !== shallow) { + warn("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow.")); + } + } + var ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */); + if (process.env.NODE_ENV !== 'production' && !ob) { + if (target == null || isPrimitive(target)) { + warn("value cannot be made reactive: ".concat(String(target))); + } + if (isCollectionType(target)) { + warn("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) { + var 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) { + var type = toRawType(value); + return (type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet'); +} + +/** + * @internal + */ +var 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; + } + var 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 (process.env.NODE_ENV !== 'production' && !ref.dep) { + warn("received object is not a triggerable ref."); + } + if (process.env.NODE_ENV !== 'production') { + ref.dep && + ref.dep.notify({ + type: "set" /* TriggerOpTypes.SET */, + target: ref, + key: 'value' + }); + } + else { + ref.dep && ref.dep.notify(); + } +} +function unref(ref) { + return isRef(ref) ? ref.value : ref; +} +function proxyRefs(objectWithRefs) { + if (isReactive(objectWithRefs)) { + return objectWithRefs; + } + var proxy = {}; + var keys = Object.keys(objectWithRefs); + for (var 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: function () { + var val = source[key]; + if (isRef(val)) { + return val.value; + } + else { + var ob = val && val.__ob__; + if (ob) + ob.dep.depend(); + return val; + } + }, + set: function (value) { + var oldValue = source[key]; + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + } + else { + source[key] = value; + } + } + }); +} +function customRef(factory) { + var dep = new Dep(); + var _a = factory(function () { + if (process.env.NODE_ENV !== 'production') { + dep.depend({ + target: ref, + type: "get" /* TrackOpTypes.GET */, + key: 'value' + }); + } + else { + dep.depend(); + } + }, function () { + if (process.env.NODE_ENV !== 'production') { + dep.notify({ + target: ref, + type: "set" /* TriggerOpTypes.SET */, + key: 'value' + }); + } + else { + dep.notify(); + } + }), get = _a.get, set = _a.set; + var ref = { + get value() { + return get(); + }, + set value(newVal) { + set(newVal); + } + }; + def(ref, RefFlag, true); + return ref; +} +function toRefs(object) { + if (process.env.NODE_ENV !== 'production' && !isReactive(object)) { + warn("toRefs() expects a reactive object but received a plain one."); + } + var ret = isArray(object) ? new Array(object.length) : {}; + for (var key in object) { + ret[key] = toRef(object, key); + } + return ret; +} +function toRef(object, key, defaultValue) { + var val = object[key]; + if (isRef(val)) { + return val; + } + var ref = { + get value() { + var val = object[key]; + return val === undefined ? defaultValue : val; + }, + set value(newVal) { + object[key] = newVal; + } + }; + def(ref, RefFlag, true); + return ref; +} + +var rawToReadonlyFlag = "__v_rawToReadonly"; +var rawToShallowReadonlyFlag = "__v_rawToShallowReadonly"; +function readonly(target) { + return createReadonly(target, false); +} +function createReadonly(target, shallow) { + if (!isPlainObject(target)) { + if (process.env.NODE_ENV !== 'production') { + if (isArray(target)) { + warn("Vue 2 does not support readonly arrays."); + } + else if (isCollectionType(target)) { + warn("Vue 2 does not support readonly collection types such as Map or Set."); + } + else { + warn("value cannot be made readonly: ".concat(typeof target)); + } + } + return target; + } + if (process.env.NODE_ENV !== 'production' && !Object.isExtensible(target)) { + warn("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 + var existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag; + var existingProxy = target[existingFlag]; + if (existingProxy) { + return existingProxy; + } + var 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); + } + var keys = Object.keys(target); + for (var 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: function () { + var val = target[key]; + return shallow || !isPlainObject(val) ? val : readonly(val); + }, + set: function () { + process.env.NODE_ENV !== 'production' && + warn("Set operation on key \"".concat(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) { + var getter; + var setter; + var onlyGetter = isFunction(getterOrOptions); + if (onlyGetter) { + getter = getterOrOptions; + setter = process.env.NODE_ENV !== 'production' + ? function () { + warn('Write operation failed: computed value is readonly'); + } + : noop; + } + else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + var watcher = isServerRendering() + ? null + : new Watcher(currentInstance, getter, noop, { lazy: true }); + if (process.env.NODE_ENV !== 'production' && watcher && debugOptions) { + watcher.onTrack = debugOptions.onTrack; + watcher.onTrigger = debugOptions.onTrigger; + } + var 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 (process.env.NODE_ENV !== 'production' && 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; +} + +var WATCHER = "watcher"; +var WATCHER_CB = "".concat(WATCHER, " callback"); +var WATCHER_GETTER = "".concat(WATCHER, " getter"); +var WATCHER_CLEANUP = "".concat(WATCHER, " cleanup"); +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options); +} +function watchPostEffect(effect, options) { + return doWatch(effect, null, (process.env.NODE_ENV !== 'production' + ? __assign(__assign({}, options), { flush: 'post' }) : { flush: 'post' })); +} +function watchSyncEffect(effect, options) { + return doWatch(effect, null, (process.env.NODE_ENV !== 'production' + ? __assign(__assign({}, options), { flush: 'sync' }) : { flush: 'sync' })); +} +// initial value for watchers to trigger on undefined initial values +var INITIAL_WATCHER_VALUE = {}; +// implementation +function watch(source, cb, options) { + if (process.env.NODE_ENV !== 'production' && typeof cb !== 'function') { + warn("`watch(fn, options?)` signature has been moved to a separate API. " + + "Use `watchEffect(fn, options?)` instead. `watch` now only " + + "supports `watch(source, cb, options?) signature."); + } + return doWatch(source, cb, options); +} +function doWatch(source, cb, _a) { + var _b = _a === void 0 ? emptyObject : _a, immediate = _b.immediate, deep = _b.deep, _c = _b.flush, flush = _c === void 0 ? 'pre' : _c, onTrack = _b.onTrack, onTrigger = _b.onTrigger; + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn("watch() \"immediate\" option is only respected when using the " + + "watch(source, callback, options?) signature."); + } + if (deep !== undefined) { + warn("watch() \"deep\" option is only respected when using the " + + "watch(source, callback, options?) signature."); + } + } + var warnInvalidSource = function (s) { + warn("Invalid watch source: ".concat(s, ". A watch source can only be a getter/effect ") + + "function, a ref, a reactive object, or an array of these types."); + }; + var instance = currentInstance; + var call = function (fn, type, args) { + if (args === void 0) { args = null; } + var res = invokeWithErrorHandling(fn, null, args, instance, type); + if (deep && res && res.__ob__) + res.__ob__.dep.depend(); + return res; + }; + var getter; + var forceTrigger = false; + var isMultiSource = false; + if (isRef(source)) { + getter = function () { return source.value; }; + forceTrigger = isShallow(source); + } + else if (isReactive(source)) { + getter = function () { + source.__ob__.dep.depend(); + return source; + }; + deep = true; + } + else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(function (s) { return isReactive(s) || isShallow(s); }); + getter = function () { + return source.map(function (s) { + if (isRef(s)) { + return s.value; + } + else if (isReactive(s)) { + s.__ob__.dep.depend(); + return traverse(s); + } + else if (isFunction(s)) { + return call(s, WATCHER_GETTER); + } + else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s); + } + }); + }; + } + else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = function () { return call(source, WATCHER_GETTER); }; + } + else { + // no cb -> simple effect + getter = function () { + if (instance && instance._isDestroyed) { + return; + } + if (cleanup) { + cleanup(); + } + return call(source, WATCHER, [onCleanup]); + }; + } + } + else { + getter = noop; + process.env.NODE_ENV !== 'production' && warnInvalidSource(source); + } + if (cb && deep) { + var baseGetter_1 = getter; + getter = function () { return traverse(baseGetter_1()); }; + } + var cleanup; + var onCleanup = function (fn) { + cleanup = watcher.onStop = function () { + call(fn, WATCHER_CLEANUP); + }; + }; + // in SSR there is no need to setup an actual effect, and it should be noop + // unless it's eager + if (isServerRendering()) { + // we will also not call the invalidate callback (+ runner is not set up) + onCleanup = noop; + if (!cb) { + getter(); + } + else if (immediate) { + call(cb, WATCHER_CB, [ + getter(), + isMultiSource ? [] : undefined, + onCleanup + ]); + } + return noop; + } + var watcher = new Watcher(currentInstance, getter, noop, { + lazy: true + }); + watcher.noRecurse = !cb; + var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + // overwrite default run + watcher.run = function () { + if (!watcher.active) { + return; + } + if (cb) { + // watch(source, cb) + var newValue = watcher.get(); + if (deep || + forceTrigger || + (isMultiSource + ? newValue.some(function (v, i) { + return hasChanged(v, oldValue[i]); + }) + : hasChanged(newValue, oldValue))) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + call(cb, WATCHER_CB, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onCleanup + ]); + oldValue = newValue; + } + } + else { + // watchEffect + watcher.get(); + } + }; + if (flush === 'sync') { + watcher.update = watcher.run; + } + else if (flush === 'post') { + watcher.post = true; + watcher.update = function () { return queueWatcher(watcher); }; + } + else { + // pre + watcher.update = function () { + if (instance && instance === currentInstance && !instance._isMounted) { + // pre-watcher triggered before + var buffer = instance._preWatchers || (instance._preWatchers = []); + if (buffer.indexOf(watcher) < 0) + buffer.push(watcher); + } + else { + queueWatcher(watcher); + } + }; + } + if (process.env.NODE_ENV !== 'production') { + watcher.onTrack = onTrack; + watcher.onTrigger = onTrigger; + } + // initial run + if (cb) { + if (immediate) { + watcher.run(); + } + else { + oldValue = watcher.get(); + } + } + else if (flush === 'post' && instance) { + instance.$once('hook:mounted', function () { return watcher.get(); }); + } + else { + watcher.get(); + } + return function () { + watcher.teardown(); + }; +} + +var activeEffectScope; +var EffectScope = /** @class */ (function () { + function EffectScope(detached) { + if (detached === void 0) { detached = false; } + this.detached = detached; + /** + * @internal + */ + this.active = true; + /** + * @internal + */ + this.effects = []; + /** + * @internal + */ + this.cleanups = []; + this.parent = activeEffectScope; + if (!detached && activeEffectScope) { + this.index = + (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; + } + } + EffectScope.prototype.run = function (fn) { + if (this.active) { + var currentEffectScope = activeEffectScope; + try { + activeEffectScope = this; + return fn(); + } + finally { + activeEffectScope = currentEffectScope; + } + } + else if (process.env.NODE_ENV !== 'production') { + warn("cannot run an inactive effect scope."); + } + }; + /** + * This should only be called on non-detached scopes + * @internal + */ + EffectScope.prototype.on = function () { + activeEffectScope = this; + }; + /** + * This should only be called on non-detached scopes + * @internal + */ + EffectScope.prototype.off = function () { + activeEffectScope = this.parent; + }; + EffectScope.prototype.stop = function (fromParent) { + if (this.active) { + var i = void 0, l = void 0; + for (i = 0, l = this.effects.length; i < l; i++) { + this.effects[i].teardown(); + } + for (i = 0, l = this.cleanups.length; i < l; i++) { + this.cleanups[i](); + } + if (this.scopes) { + for (i = 0, l = this.scopes.length; i < l; i++) { + this.scopes[i].stop(true); + } + } + // nested scope, dereference from parent to avoid memory leaks + if (!this.detached && this.parent && !fromParent) { + // optimized O(1) removal + var last = this.parent.scopes.pop(); + if (last && last !== this) { + this.parent.scopes[this.index] = last; + last.index = this.index; + } + } + this.parent = undefined; + this.active = false; + } + }; + return EffectScope; +}()); +function effectScope(detached) { + return new EffectScope(detached); +} +/** + * @internal + */ +function recordEffectScope(effect, scope) { + if (scope === void 0) { scope = activeEffectScope; } + if (scope && scope.active) { + scope.effects.push(effect); + } +} +function getCurrentScope() { + return activeEffectScope; +} +function onScopeDispose(fn) { + if (activeEffectScope) { + activeEffectScope.cleanups.push(fn); + } + else if (process.env.NODE_ENV !== 'production') { + warn("onScopeDispose() is called when there is no active effect scope" + + " to be associated with."); + } +} + +function provide(key, value) { + if (!currentInstance) { + if (process.env.NODE_ENV !== 'production') { + warn("provide() can only be used inside setup()."); + } + } + else { + // TS doesn't allow symbol as index type + resolveProvided(currentInstance)[key] = value; + } +} +function resolveProvided(vm) { + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + var existing = vm._provided; + var parentProvides = vm.$parent && vm.$parent._provided; + if (parentProvides === existing) { + return (vm._provided = Object.create(parentProvides)); + } + else { + return existing; + } +} +function inject(key, defaultValue, treatDefaultAsFactory) { + if (treatDefaultAsFactory === void 0) { treatDefaultAsFactory = false; } + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + var instance = currentInstance; + if (instance) { + // #2400 + // to support `app.use` plugins, + // fallback to appContext's `provides` if the instance is at root + var provides = instance.$parent && instance.$parent._provided; + if (provides && key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } + else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) + ? defaultValue.call(instance) + : defaultValue; + } + else if (process.env.NODE_ENV !== 'production') { + warn("injection \"".concat(String(key), "\" not found.")); + } + } + else if (process.env.NODE_ENV !== 'production') { + warn("inject() can only be used inside setup() or functional components."); + } +} + +var normalizeEvent = cached(function (name) { + var passive = name.charAt(0) === '&'; + name = passive ? name.slice(1) : name; + var once = name.charAt(0) === '~'; // Prefixed last, checked first + name = once ? name.slice(1) : name; + var capture = name.charAt(0) === '!'; + name = capture ? name.slice(1) : name; + return { + name: name, + once: once, + capture: capture, + passive: passive + }; +}); +function createFnInvoker(fns, vm) { + function invoker() { + var fns = invoker.fns; + if (isArray(fns)) { + var cloned = fns.slice(); + for (var 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) { + var name, cur, old, event; + for (name in on) { + cur = on[name]; + old = oldOn[name]; + event = normalizeEvent(name); + if (isUndef(cur)) { + process.env.NODE_ENV !== 'production' && + warn("Invalid handler for event \"".concat(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 = {}); + } + var invoker; + var 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. + var propOptions = Ctor.options.props; + if (isUndef(propOptions)) { + return; + } + var res = {}; + var attrs = data.attrs, props = data.props; + if (isDef(attrs) || isDef(props)) { + for (var key in propOptions) { + var altKey = hyphenate(key); + if (process.env.NODE_ENV !== 'production') { + var keyInLowerCase = key.toLowerCase(); + if (key !== keyInLowerCase && attrs && hasOwn(attrs, keyInLowerCase)) { + tip("Prop \"".concat(keyInLowerCase, "\" is passed to component ") + + "".concat(formatComponentName( + // @ts-expect-error tag is string + tag || Ctor), ", but the declared prop name is") + + " \"".concat(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 \"".concat(altKey, "\" instead of \"").concat(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 (var 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.