remove unnecessary vue files

14 files changed, 0 insertions, 73896 deletions

diff --git a/web/assets/vue/vue.common.dev.js b/web/assets/vue/vue.common.dev.js
deleted file mode 100644
index 89964050..00000000
--- a/web/assets/vue/vue.common.dev.js
+++ /dev/null
@@ -1,11818 +0,0 @@
-/*!
- * 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__ :            
                
                    
                        contacts: admin@thfree.ru
                    
                
                
                    
                        mirrors for living