feat(vue3): init mp

packages/uni-cli-shared/lib/platform.js

@@ -88,8 +88,20 @@ module.exports = {
   getPlatformFilterTag () {
     return uniPluginOptions.filterTag
   },
+  getMPRuntimePath () {
+    if (process.env.UNI_USING_VUE3) {
+      return require.resolve('@dcloudio/uni-' + process.env.UNI_PLATFORM + '/dist/uni.mp.esm.js')
+    }
+    return require.resolve('@dcloudio/uni-' + process.env.UNI_PLATFORM)
+  },
   getPlatformVue (vueOptions) {
-    return uniPluginOptions.vue || '@dcloudio/vue-cli-plugin-uni/packages/mp-vue'
+    if (uniPluginOptions.vue) {
+      return uniPluginOptions.vue
+    }
+    if (process.env.UNI_USING_VUE3) {
+      return '@dcloudio/uni-mp-vue'
+    }
+    return '@dcloudio/vue-cli-plugin-uni/packages/mp-vue'
   },
   getPlatformCssVars () {
     return uniPluginOptions.cssVars || {}
@@ -134,4 +146,4 @@ module.exports = {
       ]
     }
   }
-}
+}

packages/uni-mp-vue/LICENSE

+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
\ No newline at end of file

packages/uni-mp-vue/dist/vue.runtime.esm.js

+import { EMPTY_OBJ, isArray, isSymbol, extend, hasOwn, isObject, hasChanged, capitalize, toRawType, def, makeMap, isFunction, NOOP, isString, isPromise, hyphenate, isOn, isReservedProp, camelize, EMPTY_ARR, remove, NO, isGloballyWhitelisted, toTypeString, invokeArrayFns } from '@vue/shared';
+export { camelize } from '@vue/shared';
+
+const targetMap = new WeakMap();
+const effectStack = [];
+let activeEffect;
+const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');
+const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');
+function isEffect(fn) {
+    return fn && fn._isEffect === true;
+}
+function effect(fn, options = EMPTY_OBJ) {
+    if (isEffect(fn)) {
+        fn = fn.raw;
+    }
+    const effect = createReactiveEffect(fn, options);
+    if (!options.lazy) {
+        effect();
+    }
+    return effect;
+}
+function stop(effect) {
+    if (effect.active) {
+        cleanup(effect);
+        if (effect.options.onStop) {
+            effect.options.onStop();
+        }
+        effect.active = false;
+    }
+}
+let uid = 0;
+function createReactiveEffect(fn, options) {
+    const effect = function reactiveEffect() {
+        if (!effect.active) {
+            return options.scheduler ? undefined : fn();
+        }
+        if (!effectStack.includes(effect)) {
+            cleanup(effect);
+            try {
+                enableTracking();
+                effectStack.push(effect);
+                activeEffect = effect;
+                return fn();
+            }
+            finally {
+                effectStack.pop();
+                resetTracking();
+                activeEffect = effectStack[effectStack.length - 1];
+            }
+        }
+    };
+    effect.id = uid++;
+    effect._isEffect = true;
+    effect.active = true;
+    effect.raw = fn;
+    effect.deps = [];
+    effect.options = options;
+    return effect;
+}
+function cleanup(effect) {
+    const { deps } = effect;
+    if (deps.length) {
+        for (let i = 0; i < deps.length; i++) {
+            deps[i].delete(effect);
+        }
+        deps.length = 0;
+    }
+}
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+}
+function enableTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = true;
+}
+function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === undefined ? true : last;
+}
+function track(target, type, key) {
+    if (!shouldTrack || activeEffect === undefined) {
+        return;
+    }
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+        targetMap.set(target, (depsMap = new Map()));
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+        depsMap.set(key, (dep = new Set()));
+    }
+    if (!dep.has(activeEffect)) {
+        dep.add(activeEffect);
+        activeEffect.deps.push(dep);
+        if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) {
+            activeEffect.options.onTrack({
+                effect: activeEffect,
+                target,
+                type,
+                key
+            });
+        }
+    }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+        // never been tracked
+        return;
+    }
+    const effects = new Set();
+    const add = (effectsToAdd) => {
+        if (effectsToAdd) {
+            effectsToAdd.forEach(effect => {
+                if (effect !== activeEffect || !shouldTrack) {
+                    effects.add(effect);
+                }
+            });
+        }
+    };
+    if (type === "clear" /* CLEAR */) {
+        // collection being cleared
+        // trigger all effects for target
+        depsMap.forEach(add);
+    }
+    else if (key === 'length' && isArray(target)) {
+        depsMap.forEach((dep, key) => {
+            if (key === 'length' || key >= newValue) {
+                add(dep);
+            }
+        });
+    }
+    else {
+        // schedule runs for SET | ADD | DELETE
+        if (key !== void 0) {
+            add(depsMap.get(key));
+        }
+        // also run for iteration key on ADD | DELETE | Map.SET
+        const isAddOrDelete = type === "add" /* ADD */ ||
+            (type === "delete" /* DELETE */ && !isArray(target));
+        if (isAddOrDelete ||
+            (type === "set" /* SET */ && target instanceof Map)) {
+            add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY));
+        }
+        if (isAddOrDelete && target instanceof Map) {
+            add(depsMap.get(MAP_KEY_ITERATE_KEY));
+        }
+    }
+    const run = (effect) => {
+        if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) {
+            effect.options.onTrigger({
+                effect,
+                target,
+                key,
+                type,
+                newValue,
+                oldValue,
+                oldTarget
+            });
+        }
+        if (effect.options.scheduler) {
+            effect.options.scheduler(effect);
+        }
+        else {
+            effect();
+        }
+    };
+    effects.forEach(run);
+}
+
+const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol)
+    .map(key => Symbol[key])
+    .filter(isSymbol));
+const get = /*#__PURE__*/ createGetter();
+const shallowGet = /*#__PURE__*/ createGetter(false, true);
+const readonlyGet = /*#__PURE__*/ createGetter(true);
+const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
+const arrayInstrumentations = {};
+['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
+    arrayInstrumentations[key] = function (...args) {
+        const arr = toRaw(this);
+        for (let i = 0, l = this.length; i < l; i++) {
+            track(arr, "get" /* GET */, i + '');
+        }
+        // we run the method using the original args first (which may be reactive)
+        const res = arr[key](...args);
+        if (res === -1 || res === false) {
+            // if that didn't work, run it again using raw values.
+            return arr[key](...args.map(toRaw));
+        }
+        else {
+            return res;
+        }
+    };
+});
+function createGetter(isReadonly = false, shallow = false) {
+    return function get(target, key, receiver) {
+        if (key === "__v_isReactive" /* IS_REACTIVE */) {
+            return !isReadonly;
+        }
+        else if (key === "__v_isReadonly" /* IS_READONLY */) {
+            return isReadonly;
+        }
+        else if (key === "__v_raw" /* RAW */ &&
+            receiver ===
+                (isReadonly
+                    ? target["__v_readonly" /* READONLY */]
+                    : target["__v_reactive" /* REACTIVE */])) {
+            return target;
+        }
+        const targetIsArray = isArray(target);
+        if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
+            return Reflect.get(arrayInstrumentations, key, receiver);
+        }
+        const res = Reflect.get(target, key, receiver);
+        if (isSymbol(key)
+            ? builtInSymbols.has(key)
+            : key === `__proto__` || key === `__v_isRef`) {
+            return res;
+        }
+        if (!isReadonly) {
+            track(target, "get" /* GET */, key);
+        }
+        if (shallow) {
+            return res;
+        }
+        if (isRef(res)) {
+            // ref unwrapping, only for Objects, not for Arrays.
+            return targetIsArray ? res : res.value;
+        }
+        if (isObject(res)) {
+            // Convert returned value into a proxy as well. we do the isObject check
+            // here to avoid invalid value warning. Also need to lazy access readonly
+            // and reactive here to avoid circular dependency.
+            return isReadonly ? readonly(res) : reactive(res);
+        }
+        return res;
+    };
+}
+const set = /*#__PURE__*/ createSetter();
+const shallowSet = /*#__PURE__*/ createSetter(true);
+function createSetter(shallow = false) {
+    return function set(target, key, value, receiver) {
+        const oldValue = target[key];
+        if (!shallow) {
+            value = toRaw(value);
+            if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+                oldValue.value = value;
+                return true;
+            }
+        }
+        const hadKey = hasOwn(target, key);
+        const result = Reflect.set(target, key, value, receiver);
+        // don't trigger if target is something up in the prototype chain of original
+        if (target === toRaw(receiver)) {
+            if (!hadKey) {
+                trigger(target, "add" /* ADD */, key, value);
+            }
+            else if (hasChanged(value, oldValue)) {
+                trigger(target, "set" /* SET */, key, value, oldValue);
+            }
+        }
+        return result;
+    };
+}
+function deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+        trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+    }
+    return result;
+}
+function has(target, key) {
+    const result = Reflect.has(target, key);
+    track(target, "has" /* HAS */, key);
+    return result;
+}
+function ownKeys(target) {
+    track(target, "iterate" /* ITERATE */, ITERATE_KEY);
+    return Reflect.ownKeys(target);
+}
+const mutableHandlers = {
+    get,
+    set,
+    deleteProperty,
+    has,
+    ownKeys
+};
+const readonlyHandlers = {
+    get: readonlyGet,
+    has,
+    ownKeys,
+    set(target, key) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
+        }
+        return true;
+    },
+    deleteProperty(target, key) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
+        }
+        return true;
+    }
+};
+const shallowReactiveHandlers = extend({}, mutableHandlers, {
+    get: shallowGet,
+    set: shallowSet
+});
+// Props handlers are special in the sense that it should not unwrap top-level
+// refs (in order to allow refs to be explicitly passed down), but should
+// retain the reactivity of the normal readonly object.
+const shallowReadonlyHandlers = extend({}, readonlyHandlers, {
+    get: shallowReadonlyGet
+});
+
+const toReactive = (value) => isObject(value) ? reactive(value) : value;
+const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+const toShallow = (value) => value;
+const getProto = (v) => Reflect.getPrototypeOf(v);
+function get$1(target, key, wrap) {
+    target = toRaw(target);
+    const rawKey = toRaw(key);
+    if (key !== rawKey) {
+        track(target, "get" /* GET */, key);
+    }
+    track(target, "get" /* GET */, rawKey);
+    const { has, get } = getProto(target);
+    if (has.call(target, key)) {
+        return wrap(get.call(target, key));
+    }
+    else if (has.call(target, rawKey)) {
+        return wrap(get.call(target, rawKey));
+    }
+}
+function has$1(key) {
+    const target = toRaw(this);
+    const rawKey = toRaw(key);
+    if (key !== rawKey) {
+        track(target, "has" /* HAS */, key);
+    }
+    track(target, "has" /* HAS */, rawKey);
+    const has = getProto(target).has;
+    return has.call(target, key) || has.call(target, rawKey);
+}
+function size(target) {
+    target = toRaw(target);
+    track(target, "iterate" /* ITERATE */, ITERATE_KEY);
+    return Reflect.get(getProto(target), 'size', target);
+}
+function add(value) {
+    value = toRaw(value);
+    const target = toRaw(this);
+    const proto = getProto(target);
+    const hadKey = proto.has.call(target, value);
+    const result = proto.add.call(target, value);
+    if (!hadKey) {
+        trigger(target, "add" /* ADD */, value, value);
+    }
+    return result;
+}
+function set$1(key, value) {
+    value = toRaw(value);
+    const target = toRaw(this);
+    const { has, get, set } = getProto(target);
+    let hadKey = has.call(target, key);
+    if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        checkIdentityKeys(target, has, key);
+    }
+    const oldValue = get.call(target, key);
+    const result = set.call(target, key, value);
+    if (!hadKey) {
+        trigger(target, "add" /* ADD */, key, value);
+    }
+    else if (hasChanged(value, oldValue)) {
+        trigger(target, "set" /* SET */, key, value, oldValue);
+    }
+    return result;
+}
+function deleteEntry(key) {
+    const target = toRaw(this);
+    const { has, get, delete: del } = getProto(target);
+    let hadKey = has.call(target, key);
+    if (!hadKey) {
+        key = toRaw(key);
+        hadKey = has.call(target, key);
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        checkIdentityKeys(target, has, key);
+    }
+    const oldValue = get ? get.call(target, key) : undefined;
+    // forward the operation before queueing reactions
+    const result = del.call(target, key);
+    if (hadKey) {
+        trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+    }
+    return result;
+}
+function clear() {
+    const target = toRaw(this);
+    const hadItems = target.size !== 0;
+    const oldTarget = (process.env.NODE_ENV !== 'production')
+        ? target instanceof Map
+            ? new Map(target)
+            : new Set(target)
+        : undefined;
+    // forward the operation before queueing reactions
+    const result = getProto(target).clear.call(target);
+    if (hadItems) {
+        trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
+    }
+    return result;
+}
+function createForEach(isReadonly, shallow) {
+    return function forEach(callback, thisArg) {
+        const observed = this;
+        const target = toRaw(observed);
+        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;
+        !isReadonly && track(target, "iterate" /* ITERATE */, ITERATE_KEY);
+        // important: create sure the callback is
+        // 1. invoked with the reactive map as `this` and 3rd arg
+        // 2. the value received should be a corresponding reactive/readonly.
+        function wrappedCallback(value, key) {
+            return callback.call(thisArg, wrap(value), wrap(key), observed);
+        }
+        return getProto(target).forEach.call(target, wrappedCallback);
+    };
+}
+function createIterableMethod(method, isReadonly, shallow) {
+    return function (...args) {
+        const target = toRaw(this);
+        const isMap = target instanceof Map;
+        const isPair = method === 'entries' || (method === Symbol.iterator && isMap);
+        const isKeyOnly = method === 'keys' && isMap;
+        const innerIterator = getProto(target)[method].apply(target, args);
+        const wrap = isReadonly ? toReadonly : shallow ? toShallow : toReactive;
+        !isReadonly &&
+            track(target, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+        // return a wrapped iterator which returns observed versions of the
+        // values emitted from the real iterator
+        return {
+            // iterator protocol
+            next() {
+                const { value, done } = innerIterator.next();
+                return done
+                    ? { value, done }
+                    : {
+                        value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+                        done
+                    };
+            },
+            // iterable protocol
+            [Symbol.iterator]() {
+                return this;
+            }
+        };
+    };
+}
+function createReadonlyMethod(type) {
+    return function (...args) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            const key = args[0] ? `on key "${args[0]}" ` : ``;
+            console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
+        }
+        return type === "delete" /* DELETE */ ? false : this;
+    };
+}
+const mutableInstrumentations = {
+    get(key) {
+        return get$1(this, key, toReactive);
+    },
+    get size() {
+        return size(this);
+    },
+    has: has$1,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, false)
+};
+const shallowInstrumentations = {
+    get(key) {
+        return get$1(this, key, toShallow);
+    },
+    get size() {
+        return size(this);
+    },
+    has: has$1,
+    add,
+    set: set$1,
+    delete: deleteEntry,
+    clear,
+    forEach: createForEach(false, true)
+};
+const readonlyInstrumentations = {
+    get(key) {
+        return get$1(this, key, toReadonly);
+    },
+    get size() {
+        return size(this);
+    },
+    has: has$1,
+    add: createReadonlyMethod("add" /* ADD */),
+    set: createReadonlyMethod("set" /* SET */),
+    delete: createReadonlyMethod("delete" /* DELETE */),
+    clear: createReadonlyMethod("clear" /* CLEAR */),
+    forEach: createForEach(true, false)
+};
+const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
+iteratorMethods.forEach(method => {
+    mutableInstrumentations[method] = createIterableMethod(method, false, false);
+    readonlyInstrumentations[method] = createIterableMethod(method, true, false);
+    shallowInstrumentations[method] = createIterableMethod(method, false, true);
+});
+function createInstrumentationGetter(isReadonly, shallow) {
+    const instrumentations = shallow
+        ? shallowInstrumentations
+        : isReadonly
+            ? readonlyInstrumentations
+            : mutableInstrumentations;
+    return (target, key, receiver) => {
+        if (key === "__v_isReactive" /* IS_REACTIVE */) {
+            return !isReadonly;
+        }
+        else if (key === "__v_isReadonly" /* IS_READONLY */) {
+            return isReadonly;
+        }
+        else if (key === "__v_raw" /* RAW */) {
+            return target;
+        }
+        return Reflect.get(hasOwn(instrumentations, key) && key in target
+            ? instrumentations
+            : target, key, receiver);
+    };
+}
+const mutableCollectionHandlers = {
+    get: createInstrumentationGetter(false, false)
+};
+const shallowCollectionHandlers = {
+    get: createInstrumentationGetter(false, true)
+};
+const readonlyCollectionHandlers = {
+    get: createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+    const rawKey = toRaw(key);
+    if (rawKey !== key && has.call(target, rawKey)) {
+        const type = toRawType(target);
+        console.warn(`Reactive ${type} contains both the raw and reactive ` +
+            `versions of the same object${type === `Map` ? `as keys` : ``}, ` +
+            `which can lead to inconsistencies. ` +
+            `Avoid differentiating between the raw and reactive versions ` +
+            `of an object and only use the reactive version if possible.`);
+    }
+}
+
+const collectionTypes = new Set([Set, Map, WeakMap, WeakSet]);
+const isObservableType = /*#__PURE__*/ makeMap('Object,Array,Map,Set,WeakMap,WeakSet');
+const canObserve = (value) => {
+    return (!value["__v_skip" /* SKIP */] &&
+        isObservableType(toRawType(value)) &&
+        !Object.isFrozen(value));
+};
+function reactive(target) {
+    // if trying to observe a readonly proxy, return the readonly version.
+    if (target && target["__v_isReadonly" /* IS_READONLY */]) {
+        return target;
+    }
+    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers);
+}
+// Return a reactive-copy of the original object, where only the root level
+// properties are reactive, and does NOT unwrap refs nor recursively convert
+// returned properties.
+function shallowReactive(target) {
+    return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers);
+}
+function readonly(target) {
+    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers);
+}
+// Return a reactive-copy of the original object, where only the root level
+// properties are readonly, and does NOT unwrap refs nor recursively convert
+// returned properties.
+// This is used for creating the props proxy object for stateful components.
+function shallowReadonly(target) {
+    return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers);
+}
+function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) {
+    if (!isObject(target)) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            console.warn(`value cannot be made reactive: ${String(target)}`);
+        }
+        return target;
+    }
+    // target is already a Proxy, return it.
+    // exception: calling readonly() on a reactive object
+    if (target["__v_raw" /* RAW */] &&
+        !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
+        return target;
+    }
+    // target already has corresponding Proxy
+    if (hasOwn(target, isReadonly ? "__v_readonly" /* READONLY */ : "__v_reactive" /* REACTIVE */)) {
+        return isReadonly
+            ? target["__v_readonly" /* READONLY */]
+            : target["__v_reactive" /* REACTIVE */];
+    }
+    // only a whitelist of value types can be observed.
+    if (!canObserve(target)) {
+        return target;
+    }
+    const observed = new Proxy(target, collectionTypes.has(target.constructor) ? collectionHandlers : baseHandlers);
+    def(target, isReadonly ? "__v_readonly" /* READONLY */ : "__v_reactive" /* REACTIVE */, observed);
+    return observed;
+}
+function isReactive(value) {
+    if (isReadonly(value)) {
+        return isReactive(value["__v_raw" /* RAW */]);
+    }
+    return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
+}
+function isReadonly(value) {
+    return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
+}
+function isProxy(value) {
+    return isReactive(value) || isReadonly(value);
+}
+function toRaw(observed) {
+    return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
+}
+function markRaw(value) {
+    def(value, "__v_skip" /* SKIP */, true);
+    return value;
+}
+
+const convert = (val) => isObject(val) ? reactive(val) : val;
+function isRef(r) {
+    return r ? r.__v_isRef === true : false;
+}
+function ref(value) {
+    return createRef(value);
+}
+function shallowRef(value) {
+    return createRef(value, true);
+}
+function createRef(rawValue, shallow = false) {
+    if (isRef(rawValue)) {
+        return rawValue;
+    }
+    let value = shallow ? rawValue : convert(rawValue);
+    const r = {
+        __v_isRef: true,
+        get value() {
+            track(r, "get" /* GET */, 'value');
+            return value;
+        },
+        set value(newVal) {
+            if (hasChanged(toRaw(newVal), rawValue)) {
+                rawValue = newVal;
+                value = shallow ? newVal : convert(newVal);
+                trigger(r, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: newVal } : void 0);
+            }
+        }
+    };
+    return r;
+}
+function triggerRef(ref) {
+    trigger(ref, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? { newValue: ref.value } : void 0);
+}
+function unref(ref) {
+    return isRef(ref) ? ref.value : ref;
+}
+function customRef(factory) {
+    const { get, set } = factory(() => track(r, "get" /* GET */, 'value'), () => trigger(r, "set" /* SET */, 'value'));
+    const r = {
+        __v_isRef: true,
+        get value() {
+            return get();
+        },
+        set value(v) {
+            set(v);
+        }
+    };
+    return r;
+}
+function toRefs(object) {
+    if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) {
+        console.warn(`toRefs() expects a reactive object but received a plain one.`);
+    }
+    const ret = {};
+    for (const key in object) {
+        ret[key] = toRef(object, key);
+    }
+    return ret;
+}
+function toRef(object, key) {
+    return {
+        __v_isRef: true,
+        get value() {
+            return object[key];
+        },
+        set value(newVal) {
+            object[key] = newVal;
+        }
+    };
+}
+
+function computed(getterOrOptions) {
+    let getter;
+    let setter;
+    if (isFunction(getterOrOptions)) {
+        getter = getterOrOptions;
+        setter = (process.env.NODE_ENV !== 'production')
+            ? () => {
+                console.warn('Write operation failed: computed value is readonly');
+            }
+            : NOOP;
+    }
+    else {
+        getter = getterOrOptions.get;
+        setter = getterOrOptions.set;
+    }
+    let dirty = true;
+    let value;
+    let computed;
+    const runner = effect(getter, {
+        lazy: true,
+        scheduler: () => {
+            if (!dirty) {
+                dirty = true;
+                trigger(computed, "set" /* SET */, 'value');
+            }
+        }
+    });
+    computed = {
+        __v_isRef: true,
+        // expose effect so computed can be stopped
+        effect: runner,
+        get value() {
+            if (dirty) {
+                value = runner();
+                dirty = false;
+            }
+            track(computed, "get" /* GET */, 'value');
+            return value;
+        },
+        set value(newValue) {
+            setter(newValue);
+        }
+    };
+    return computed;
+}
+
+const stack = [];
+function pushWarningContext(vnode) {
+    stack.push(vnode);
+}
+function popWarningContext() {
+    stack.pop();
+}
+function warn(msg, ...args) {
+    // avoid props formatting or warn handler tracking deps that might be mutated
+    // during patch, leading to infinite recursion.
+    pauseTracking();
+    const instance = stack.length ? stack[stack.length - 1].component : null;
+    const appWarnHandler = instance && instance.appContext.config.warnHandler;
+    const trace = getComponentTrace();
+    if (appWarnHandler) {
+        callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [
+            msg + args.join(''),
+            instance && instance.proxy,
+            trace
+                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)
+                .join('\n'),
+            trace
+        ]);
+    }
+    else {
+        const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+        /* istanbul ignore if */
+        if (trace.length &&
+            // avoid spamming console during tests
+            !false) {
+            warnArgs.push(`\n`, ...formatTrace(trace));
+        }
+        console.warn(...warnArgs);
+    }
+    resetTracking();
+}
+function getComponentTrace() {
+    let currentVNode = stack[stack.length - 1];
+    if (!currentVNode) {
+        return [];
+    }
+    // we can't just use the stack because it will be incomplete during updates
+    // that did not start from the root. Re-construct the parent chain using
+    // instance parent pointers.
+    const normalizedStack = [];
+    while (currentVNode) {
+        const last = normalizedStack[0];
+        if (last && last.vnode === currentVNode) {
+            last.recurseCount++;
+        }
+        else {
+            normalizedStack.push({
+                vnode: currentVNode,
+                recurseCount: 0
+            });
+        }
+        const parentInstance = currentVNode.component && currentVNode.component.parent;
+        currentVNode = parentInstance && parentInstance.vnode;
+    }
+    return normalizedStack;
+}
+/* istanbul ignore next */
+function formatTrace(trace) {
+    const logs = [];
+    trace.forEach((entry, i) => {
+        logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry));
+    });
+    return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+    const isRoot = vnode.component ? vnode.component.parent == null : false;
+    const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`;
+    const close = `>` + postfix;
+    return vnode.props
+        ? [open, ...formatProps(vnode.props), close]
+        : [open + close];
+}
+/* istanbul ignore next */
+function formatProps(props) {
+    const res = [];
+    const keys = Object.keys(props);
+    keys.slice(0, 3).forEach(key => {
+        res.push(...formatProp(key, props[key]));
+    });
+    if (keys.length > 3) {
+        res.push(` ...`);
+    }
+    return res;
+}
+/* istanbul ignore next */
+function formatProp(key, value, raw) {
+    if (isString(value)) {
+        value = JSON.stringify(value);
+        return raw ? value : [`${key}=${value}`];
+    }
+    else if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value == null) {
+        return raw ? value : [`${key}=${value}`];
+    }
+    else if (isRef(value)) {
+        value = formatProp(key, toRaw(value.value), true);
+        return raw ? value : [`${key}=Ref<`, value, `>`];
+    }
+    else if (isFunction(value)) {
+        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+    }
+    else {
+        value = toRaw(value);
+        return raw ? value : [`${key}=`, value];
+    }
+}
+
+const ErrorTypeStrings = {
+    ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook',
+    ["c" /* CREATED */]: 'created hook',
+    ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook',
+    ["m" /* MOUNTED */]: 'mounted hook',
+    ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook',
+    ["u" /* UPDATED */]: 'updated',
+    ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',
+    ["um" /* UNMOUNTED */]: 'unmounted hook',
+    ["a" /* ACTIVATED */]: 'activated hook',
+    ["da" /* DEACTIVATED */]: 'deactivated hook',
+    ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook',
+    ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook',
+    ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook',
+    [0 /* SETUP_FUNCTION */]: 'setup function',
+    [1 /* RENDER_FUNCTION */]: 'render function',
+    [2 /* WATCH_GETTER */]: 'watcher getter',
+    [3 /* WATCH_CALLBACK */]: 'watcher callback',
+    [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',
+    [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',
+    [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',
+    [7 /* VNODE_HOOK */]: 'vnode hook',
+    [8 /* DIRECTIVE_HOOK */]: 'directive hook',
+    [9 /* TRANSITION_HOOK */]: 'transition hook',
+    [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',
+    [11 /* APP_WARN_HANDLER */]: 'app warnHandler',
+    [12 /* FUNCTION_REF */]: 'ref function',
+    [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',
+    [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
+        'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'
+};
+function callWithErrorHandling(fn, instance, type, args) {
+    let res;
+    try {
+        res = args ? fn(...args) : fn();
+    }
+    catch (err) {
+        handleError(err, instance, type);
+    }
+    return res;
+}
+function callWithAsyncErrorHandling(fn, instance, type, args) {
+    if (isFunction(fn)) {
+        const res = callWithErrorHandling(fn, instance, type, args);
+        if (res && isPromise(res)) {
+            res.catch(err => {
+                handleError(err, instance, type);
+            });
+        }
+        return res;
+    }
+    const values = [];
+    for (let i = 0; i < fn.length; i++) {
+        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
+    }
+    return values;
+}
+function handleError(err, instance, type) {
+    const contextVNode = instance ? instance.vnode : null;
+    if (instance) {
+        let cur = instance.parent;
+        // the exposed instance is the render proxy to keep it consistent with 2.x
+        const exposedInstance = instance.proxy;
+        // in production the hook receives only the error code
+        const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] || type : type; // fixed by xxxxxx
+        while (cur) {
+            const errorCapturedHooks = cur.ec;
+            if (errorCapturedHooks) {
+                for (let i = 0; i < errorCapturedHooks.length; i++) {
+                    if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {
+                        return;
+                    }
+                }
+            }
+            cur = cur.parent;
+        }
+        // app-level handling
+        const appErrorHandler = instance.appContext.config.errorHandler;
+        if (appErrorHandler) {
+            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
+            return;
+        }
+    }
+    logError(err, type, contextVNode);
+}
+// fixed by xxxxxx
+function logError(err, type, contextVNode) {
+    // default behavior is crash in prod & test, recover in dev.
+    if ((process.env.NODE_ENV !== 'production') && ( !false)) {
+        const info = ErrorTypeStrings[type] || type; // fixed by xxxxxx
+        if (contextVNode) {
+            pushWarningContext(contextVNode);
+        }
+        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+        console.error(err);
+        if (contextVNode) {
+            popWarningContext();
+        }
+    }
+    else {
+        throw err;
+    }
+}
+
+// fixed by xxxxxx
+const queue = [];
+const postFlushCbs = [];
+const p = Promise.resolve();
+let isFlushing = false;
+let isFlushPending = false;
+let flushIndex = 0;
+let pendingPostFlushCbs = null;
+let pendingPostFlushIndex = 0;
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+    return fn ? p.then(fn) : p;
+}
+function queueJob(job) {
+    if (!queue.includes(job, flushIndex)) {
+        queue.push(job);
+        queueFlush();
+    }
+}
+function queuePostFlushCb(cb) {
+    if (!isArray(cb)) {
+        if (!pendingPostFlushCbs ||
+            !pendingPostFlushCbs.includes(cb, pendingPostFlushIndex)) {
+            postFlushCbs.push(cb);
+        }
+    }
+    else {
+        // if cb is an array, it is a component lifecycle hook which can only be
+        // triggered by a job, which is already deduped in the main queue, so
+        // we can skip dupicate check here to improve perf
+        postFlushCbs.push(...cb);
+    }
+    queueFlush();
+}
+function queueFlush() {
+    if (!isFlushing && !isFlushPending) {
+        isFlushPending = true;
+        nextTick(flushJobs);
+    }
+}
+function flushPostFlushCbs(seen) {
+    if (postFlushCbs.length) {
+        pendingPostFlushCbs = [...new Set(postFlushCbs)];
+        postFlushCbs.length = 0;
+        if ((process.env.NODE_ENV !== 'production')) {
+            seen = seen || new Map();
+        }
+        for (pendingPostFlushIndex = 0; pendingPostFlushIndex < pendingPostFlushCbs.length; pendingPostFlushIndex++) {
+            if ((process.env.NODE_ENV !== 'production')) {
+                checkRecursiveUpdates(seen, pendingPostFlushCbs[pendingPostFlushIndex]);
+            }
+            pendingPostFlushCbs[pendingPostFlushIndex]();
+        }
+        pendingPostFlushCbs = null;
+        pendingPostFlushIndex = 0;
+    }
+}
+const getId = (job) => (job.id == null ? Infinity : job.id);
+function flushJobs(seen) {
+    isFlushPending = false;
+    isFlushing = true;
+    if ((process.env.NODE_ENV !== 'production')) {
+        seen = seen || new Map();
+    }
+    // Sort queue before flush.
+    // This ensures that:
+    // 1. Components are updated from parent to child. (because parent is always
+    //    created before the child so its render effect will have smaller
+    //    priority number)
+    // 2. If a component is unmounted during a parent component's update,
+    //    its update can be skipped.
+    // Jobs can never be null before flush starts, since they are only invalidated
+    // during execution of another flushed job.
+    queue.sort((a, b) => getId(a) - getId(b));
+    for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+        const job = queue[flushIndex];
+        if (job) {
+            if ((process.env.NODE_ENV !== 'production')) {
+                checkRecursiveUpdates(seen, job);
+            }
+            callWithErrorHandling(job, null, 14 /* SCHEDULER */);
+        }
+    }
+    flushIndex = 0;
+    queue.length = 0;
+    flushPostFlushCbs(seen);
+    isFlushing = false;
+    // some postFlushCb queued jobs!
+    // keep flushing until it drains.
+    if (queue.length || postFlushCbs.length) {
+        flushJobs(seen);
+    }
+}
+function checkRecursiveUpdates(seen, fn) {
+    if (!seen.has(fn)) {
+        seen.set(fn, 1);
+    }
+    else {
+        const count = seen.get(fn);
+        if (count > RECURSION_LIMIT) {
+            throw new Error('Maximum recursive updates exceeded. ' +
+                "You may have code that is mutating state in your component's " +
+                'render function or updated hook or watcher source function.');
+        }
+        else {
+            seen.set(fn, count + 1);
+        }
+    }
+}
+
+// mark the current rendering instance for asset resolution (e.g.
+// resolveComponent, resolveDirective) during render
+let currentRenderingInstance = null;
+function markAttrsAccessed() {
+}
+
+function emit(instance, event, ...args) {
+    const props = instance.vnode.props || EMPTY_OBJ;
+    if ((process.env.NODE_ENV !== 'production')) {
+        const options = normalizeEmitsOptions(instance.type);
+        if (options) {
+            if (!(event in options)) {
+                const propsOptions = normalizePropsOptions(instance.type)[0];
+                if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) {
+                    warn(`Component emitted event "${event}" but it is neither declared in ` +
+                        `the emits option nor as an "on${capitalize(event)}" prop.`);
+                }
+            }
+            else {
+                const validator = options[event];
+                if (isFunction(validator)) {
+                    const isValid = validator(...args);
+                    if (!isValid) {
+                        warn(`Invalid event arguments: event validation failed for event "${event}".`);
+                    }
+                }
+            }
+        }
+    }
+    let handlerName = `on${capitalize(event)}`;
+    let handler = props[handlerName];
+    // for v-model update:xxx events, also trigger kebab-case equivalent
+    // for props passed via kebab-case
+    if (!handler && event.startsWith('update:')) {
+        handlerName = `on${capitalize(hyphenate(event))}`;
+        handler = props[handlerName];
+    }
+    if (!handler) {
+        handler = props[handlerName + `Once`];
+        if (!instance.emitted) {
+            (instance.emitted = {})[handlerName] = true;
+        }
+        else if (instance.emitted[handlerName]) {
+            return;
+        }
+    }
+    if (handler) {
+        callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+    }
+}
+function normalizeEmitsOptions(comp) {
+    if (hasOwn(comp, '__emits')) {
+        return comp.__emits;
+    }
+    const raw = comp.emits;
+    let normalized = {};
+    // apply mixin/extends props
+    let hasExtends = false;
+    if (__FEATURE_OPTIONS__ && !isFunction(comp)) {
+        if (comp.extends) {
+            hasExtends = true;
+            extend(normalized, normalizeEmitsOptions(comp.extends));
+        }
+        if (comp.mixins) {
+            hasExtends = true;
+            comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m)));
+        }
+    }
+    if (!raw && !hasExtends) {
+        return (comp.__emits = undefined);
+    }
+    if (isArray(raw)) {
+        raw.forEach(key => (normalized[key] = null));
+    }
+    else {
+        extend(normalized, raw);
+    }
+    return (comp.__emits = normalized);
+}
+// Check if an incoming prop key is a declared emit event listener.
+// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are
+// both considered matched listeners.
+function isEmitListener(comp, key) {
+    let emits;
+    if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) {
+        return false;
+    }
+    key = key.replace(/Once$/, '');
+    return (hasOwn(emits, key[2].toLowerCase() + key.slice(3)) ||
+        hasOwn(emits, key.slice(2)));
+}
+
+function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison
+isSSR = false) {
+    const props = {};
+    const attrs = {};
+    // def(attrs, InternalObjectKey, 1) // fixed by xxxxx
+    def(attrs, '__vInternal', 1);
+    setFullProps(instance, rawProps, props, attrs);
+    // validation
+    if ((process.env.NODE_ENV !== 'production')) {
+        validateProps(props, instance.type);
+    }
+    if (isStateful) {
+        // stateful
+        instance.props = isSSR ? props : shallowReactive(props);
+    }
+    else {
+        if (!instance.type.props) {
+            // functional w/ optional props, props === attrs
+            instance.props = attrs;
+        }
+        else {
+            // functional w/ declared props
+            instance.props = props;
+        }
+    }
+    instance.attrs = attrs;
+}
+function setFullProps(instance, rawProps, props, attrs) {
+    const [options, needCastKeys] = normalizePropsOptions(instance.type);
+    if (rawProps) {
+        for (const key in rawProps) {
+            const value = rawProps[key];
+            // key, ref are reserved and never passed down
+            if (isReservedProp(key)) {
+                continue;
+            }
+            // prop option names are camelized during normalization, so to support
+            // kebab -> camel conversion here we need to camelize the key.
+            let camelKey;
+            if (options && hasOwn(options, (camelKey = camelize(key)))) {
+                props[camelKey] = value;
+            }
+            else if (!isEmitListener(instance.type, key)) {
+                // Any non-declared (either as a prop or an emitted event) props are put
+                // into a separate `attrs` object for spreading. Make sure to preserve
+                // original key casing
+                attrs[key] = value;
+            }
+        }
+    }
+    if (needCastKeys) {
+        const rawCurrentProps = toRaw(props);
+        for (let i = 0; i < needCastKeys.length; i++) {
+            const key = needCastKeys[i];
+            props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]);
+        }
+    }
+}
+function resolvePropValue(options, props, key, value) {
+    const opt = options[key];
+    if (opt != null) {
+        const hasDefault = hasOwn(opt, 'default');
+        // default values
+        if (hasDefault && value === undefined) {
+            const defaultValue = opt.default;
+            value =
+                opt.type !== Function && isFunction(defaultValue)
+                    ? defaultValue()
+                    : defaultValue;
+        }
+        // boolean casting
+        if (opt[0 /* shouldCast */]) {
+            if (!hasOwn(props, key) && !hasDefault) {
+                value = false;
+            }
+            else if (opt[1 /* shouldCastTrue */] &&
+                (value === '' || value === hyphenate(key))) {
+                value = true;
+            }
+        }
+    }
+    return value;
+}
+function normalizePropsOptions(comp) {
+    if (comp.__props) {
+        return comp.__props;
+    }
+    const raw = comp.props;
+    const normalized = {};
+    const needCastKeys = [];
+    // apply mixin/extends props
+    let hasExtends = false;
+    if (__FEATURE_OPTIONS__ && !isFunction(comp)) {
+        const extendProps = (raw) => {
+            const [props, keys] = normalizePropsOptions(raw);
+            extend(normalized, props);
+            if (keys)
+                needCastKeys.push(...keys);
+        };
+        if (comp.extends) {
+            hasExtends = true;
+            extendProps(comp.extends);
+        }
+        if (comp.mixins) {
+            hasExtends = true;
+            comp.mixins.forEach(extendProps);
+        }
+    }
+    if (!raw && !hasExtends) {
+        return (comp.__props = EMPTY_ARR);
+    }
+    if (isArray(raw)) {
+        for (let i = 0; i < raw.length; i++) {
+            if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) {
+                warn(`props must be strings when using array syntax.`, raw[i]);
+            }
+            const normalizedKey = camelize(raw[i]);
+            if (validatePropName(normalizedKey)) {
+                normalized[normalizedKey] = EMPTY_OBJ;
+            }
+        }
+    }
+    else if (raw) {
+        if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) {
+            warn(`invalid props options`, raw);
+        }
+        for (const key in raw) {
+            const normalizedKey = camelize(key);
+            if (validatePropName(normalizedKey)) {
+                const opt = raw[key];
+                const prop = (normalized[normalizedKey] =
+                    isArray(opt) || isFunction(opt) ? { type: opt } : opt);
+                if (prop) {
+                    const booleanIndex = getTypeIndex(Boolean, prop.type);
+                    const stringIndex = getTypeIndex(String, prop.type);
+                    prop[0 /* shouldCast */] = booleanIndex > -1;
+                    prop[1 /* shouldCastTrue */] =
+                        stringIndex < 0 || booleanIndex < stringIndex;
+                    // if the prop needs boolean casting or default value
+                    if (booleanIndex > -1 || hasOwn(prop, 'default')) {
+                        needCastKeys.push(normalizedKey);
+                    }
+                }
+            }
+        }
+    }
+    const normalizedEntry = [normalized, needCastKeys];
+    comp.__props = normalizedEntry;
+    return normalizedEntry;
+}
+// use function string name to check type constructors
+// so that it works across vms / iframes.
+function getType(ctor) {
+    const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
+    return match ? match[1] : '';
+}
+function isSameType(a, b) {
+    return getType(a) === getType(b);
+}
+function getTypeIndex(type, expectedTypes) {
+    if (isArray(expectedTypes)) {
+        for (let i = 0, len = expectedTypes.length; i < len; i++) {
+            if (isSameType(expectedTypes[i], type)) {
+                return i;
+            }
+        }
+    }
+    else if (isFunction(expectedTypes)) {
+        return isSameType(expectedTypes, type) ? 0 : -1;
+    }
+    return -1;
+}
+/**
+ * dev only
+ */
+function validateProps(props, comp) {
+    const rawValues = toRaw(props);
+    const options = normalizePropsOptions(comp)[0];
+    for (const key in options) {
+        let opt = options[key];
+        if (opt == null)
+            continue;
+        validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key));
+    }
+}
+/**
+ * dev only
+ */
+function validatePropName(key) {
+    if (key[0] !== '$') {
+        return true;
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        warn(`Invalid prop name: "${key}" is a reserved property.`);
+    }
+    return false;
+}
+/**
+ * dev only
+ */
+function validateProp(name, value, prop, isAbsent) {
+    const { type, required, validator } = prop;
+    // required!
+    if (required && isAbsent) {
+        warn('Missing required prop: "' + name + '"');
+        return;
+    }
+    // missing but optional
+    if (value == null && !prop.required) {
+        return;
+    }
+    // type check
+    if (type != null && type !== true) {
+        let isValid = false;
+        const types = isArray(type) ? type : [type];
+        const expectedTypes = [];
+        // value is valid as long as one of the specified types match
+        for (let i = 0; i < types.length && !isValid; i++) {
+            const { valid, expectedType } = assertType(value, types[i]);
+            expectedTypes.push(expectedType || '');
+            isValid = valid;
+        }
+        if (!isValid) {
+            warn(getInvalidTypeMessage(name, value, expectedTypes));
+            return;
+        }
+    }
+    // custom validator
+    if (validator && !validator(value)) {
+        warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+    }
+}
+const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol');
+/**
+ * dev only
+ */
+function assertType(value, type) {
+    let valid;
+    const expectedType = getType(type);
+    if (isSimpleType(expectedType)) {
+        const t = typeof value;
+        valid = t === expectedType.toLowerCase();
+        // for primitive wrapper objects
+        if (!valid && t === 'object') {
+            valid = value instanceof type;
+        }
+    }
+    else if (expectedType === 'Object') {
+        valid = toRawType(value) === 'Object';
+    }
+    else if (expectedType === 'Array') {
+        valid = isArray(value);
+    }
+    else {
+        valid = value instanceof type;
+    }
+    return {
+        valid,
+        expectedType
+    };
+}
+/**
+ * dev only
+ */
+function getInvalidTypeMessage(name, value, expectedTypes) {
+    let message = `Invalid prop: type check failed for prop "${name}".` +
+        ` Expected ${expectedTypes.map(capitalize).join(', ')}`;
+    const expectedType = expectedTypes[0];
+    const receivedType = toRawType(value);
+    const expectedValue = styleValue(value, expectedType);
+    const receivedValue = styleValue(value, receivedType);
+    // check if we need to specify expected value
+    if (expectedTypes.length === 1 &&
+        isExplicable(expectedType) &&
+        !isBoolean(expectedType, receivedType)) {
+        message += ` with value ${expectedValue}`;
+    }
+    message += `, got ${receivedType} `;
+    // check if we need to specify received value
+    if (isExplicable(receivedType)) {
+        message += `with value ${receivedValue}.`;
+    }
+    return message;
+}
+/**
+ * dev only
+ */
+function styleValue(value, type) {
+    if (type === 'String') {
+        return `"${value}"`;
+    }
+    else if (type === 'Number') {
+        return `${Number(value)}`;
+    }
+    else {
+        return `${value}`;
+    }
+}
+/**
+ * dev only
+ */
+function isExplicable(type) {
+    const explicitTypes = ['string', 'number', 'boolean'];
+    return explicitTypes.some(elem => type.toLowerCase() === elem);
+}
+/**
+ * dev only
+ */
+function isBoolean(...args) {
+    return args.some(elem => elem.toLowerCase() === 'boolean');
+}
+
+function injectHook(type, hook, target = currentInstance, prepend = false) {
+    if (target) {
+        const hooks = target[type] || (target[type] = []);
+        // cache the error handling wrapper for injected hooks so the same hook
+        // can be properly deduped by the scheduler. "__weh" stands for "with error
+        // handling".
+        const wrappedHook = hook.__weh ||
+            (hook.__weh = (...args) => {
+                if (target.isUnmounted) {
+                    return;
+                }
+                // disable tracking inside all lifecycle hooks
+                // since they can potentially be called inside effects.
+                pauseTracking();
+                // Set currentInstance during hook invocation.
+                // This assumes the hook does not synchronously trigger other hooks, which
+                // can only be false when the user does something really funky.
+                setCurrentInstance(target);
+                const res = callWithAsyncErrorHandling(hook, target, type, args);
+                setCurrentInstance(null);
+                resetTracking();
+                return res;
+            });
+        if (prepend) {
+            hooks.unshift(wrappedHook);
+        }
+        else {
+            hooks.push(wrappedHook);
+        }
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`;
+        warn(`${apiName} is called when there is no active component instance to be ` +
+            `associated with. ` +
+            `Lifecycle injection APIs can only be used during execution of setup().` +
+            ( ``));
+    }
+}
+const createHook = (lifecycle) => (hook, target = currentInstance) => 
+// post-create lifecycle registrations are noops during SSR
+!isInSSRComponentSetup && injectHook(lifecycle, hook, target);
+const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */);
+const onMounted = createHook("m" /* MOUNTED */);
+const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */);
+const onUpdated = createHook("u" /* UPDATED */);
+const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */);
+const onUnmounted = createHook("um" /* UNMOUNTED */);
+const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */);
+const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */);
+const onErrorCaptured = (hook, target = currentInstance) => {
+    injectHook("ec" /* ERROR_CAPTURED */, hook, target);
+};
+
+const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+function onActivated(hook, target) {
+    registerKeepAliveHook(hook, "a" /* ACTIVATED */, target);
+}
+function onDeactivated(hook, target) {
+    registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target);
+}
+function registerKeepAliveHook(hook, type, target = currentInstance) {
+    // cache the deactivate branch check wrapper for injected hooks so the same
+    // hook can be properly deduped by the scheduler. "__wdc" stands for "with
+    // deactivation check".
+    const wrappedHook = hook.__wdc ||
+        (hook.__wdc = () => {
+            // only fire the hook if the target instance is NOT in a deactivated branch.
+            let current = target;
+            while (current) {
+                if (current.isDeactivated) {
+                    return;
+                }
+                current = current.parent;
+            }
+            hook();
+        });
+    injectHook(type, wrappedHook, target);
+    // In addition to registering it on the target instance, we walk up the parent
+    // chain and register it on all ancestor instances that are keep-alive roots.
+    // This avoids the need to walk the entire component tree when invoking these
+    // hooks, and more importantly, avoids the need to track child components in
+    // arrays.
+    if (target) {
+        let current = target.parent;
+        while (current && current.parent) {
+            if (isKeepAlive(current.parent.vnode)) {
+                injectToKeepAliveRoot(wrappedHook, type, target, current);
+            }
+            current = current.parent;
+        }
+    }
+}
+function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+    injectHook(type, hook, keepAliveRoot, true /* prepend */);
+    onUnmounted(() => {
+        remove(keepAliveRoot[type], hook);
+    }, target);
+}
+
+/**
+Runtime helper for applying directives to a vnode. Example usage:
+
+const comp = resolveComponent('comp')
+const foo = resolveDirective('foo')
+const bar = resolveDirective('bar')
+
+return withDirectives(h(comp), [
+  [foo, this.x],
+  [bar, this.y]
+])
+*/
+const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text');
+function validateDirectiveName(name) {
+    if (isBuiltInDirective(name)) {
+        warn('Do not use built-in directive ids as custom directive id: ' + name);
+    }
+}
+
+function createAppContext() {
+    return {
+        config: {
+            isNativeTag: NO,
+            devtools: true,
+            performance: false,
+            globalProperties: {},
+            optionMergeStrategies: {},
+            isCustomElement: NO,
+            errorHandler: undefined,
+            warnHandler: undefined
+        },
+        mixins: [],
+        components: {},
+        directives: {},
+        provides: Object.create(null)
+    };
+}
+// fixed by xxxxxx
+function createAppAPI() {
+    return function createApp(rootComponent, rootProps = null) {
+        if (rootProps != null && !isObject(rootProps)) {
+            (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`);
+            rootProps = null;
+        }
+        const context = createAppContext();
+        const installedPlugins = new Set();
+        // fixed by xxxxxx
+        // let isMounted = false
+        const app = {
+            _component: rootComponent,
+            _props: rootProps,
+            _container: null,
+            _context: context,
+            version,
+            get config() {
+                return context.config;
+            },
+            set config(v) {
+                if ((process.env.NODE_ENV !== 'production')) {
+                    warn(`app.config cannot be replaced. Modify individual options instead.`);
+                }
+            },
+            use(plugin, ...options) {
+                if (installedPlugins.has(plugin)) {
+                    (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`);
+                }
+                else if (plugin && isFunction(plugin.install)) {
+                    installedPlugins.add(plugin);
+                    plugin.install(app, ...options);
+                }
+                else if (isFunction(plugin)) {
+                    installedPlugins.add(plugin);
+                    plugin(app, ...options);
+                }
+                else if ((process.env.NODE_ENV !== 'production')) {
+                    warn(`A plugin must either be a function or an object with an "install" ` +
+                        `function.`);
+                }
+                return app;
+            },
+            mixin(mixin) {
+                if (__FEATURE_OPTIONS__) {
+                    if (!context.mixins.includes(mixin)) {
+                        context.mixins.push(mixin);
+                    }
+                    else if ((process.env.NODE_ENV !== 'production')) {
+                        warn('Mixin has already been applied to target app' +
+                            (mixin.name ? `: ${mixin.name}` : ''));
+                    }
+                }
+                else if ((process.env.NODE_ENV !== 'production')) {
+                    warn('Mixins are only available in builds supporting Options API');
+                }
+                return app;
+            },
+            component(name, component) {
+                if ((process.env.NODE_ENV !== 'production')) {
+                    validateComponentName(name, context.config);
+                }
+                if (!component) {
+                    return context.components[name];
+                }
+                if ((process.env.NODE_ENV !== 'production') && context.components[name]) {
+                    warn(`Component "${name}" has already been registered in target app.`);
+                }
+                context.components[name] = component;
+                return app;
+            },
+            directive(name, directive) {
+                if ((process.env.NODE_ENV !== 'production')) {
+                    validateDirectiveName(name);
+                }
+                if (!directive) {
+                    return context.directives[name];
+                }
+                if ((process.env.NODE_ENV !== 'production') && context.directives[name]) {
+                    warn(`Directive "${name}" has already been registered in target app.`);
+                }
+                context.directives[name] = directive;
+                return app;
+            },
+            // fixed by xxxxxx
+            mount() { },
+            // fixed by xxxxxx
+            unmount() { },
+            provide(key, value) {
+                if ((process.env.NODE_ENV !== 'production') && key in context.provides) {
+                    warn(`App already provides property with key "${String(key)}". ` +
+                        `It will be overwritten with the new value.`);
+                }
+                // TypeScript doesn't allow symbols as index type
+                // https://github.com/Microsoft/TypeScript/issues/24587
+                context.provides[key] = value;
+                return app;
+            }
+        };
+        context.__app = app;
+        return app;
+    };
+}
+
+var DevtoolsHooks;
+(function (DevtoolsHooks) {
+    DevtoolsHooks["APP_INIT"] = "app:init";
+    DevtoolsHooks["APP_UNMOUNT"] = "app:unmount";
+    DevtoolsHooks["COMPONENT_UPDATED"] = "component:updated";
+    DevtoolsHooks["COMPONENT_ADDED"] = "component:added";
+    DevtoolsHooks["COMPONENT_REMOVED"] = "component:removed";
+})(DevtoolsHooks || (DevtoolsHooks = {}));
+const componentAdded = createDevtoolsHook(DevtoolsHooks.COMPONENT_ADDED);
+const componentUpdated = createDevtoolsHook(DevtoolsHooks.COMPONENT_UPDATED);
+const componentRemoved = createDevtoolsHook(DevtoolsHooks.COMPONENT_REMOVED);
+function createDevtoolsHook(hook) {
+    return (component) => {
+        return;
+    };
+}
+
+const queuePostRenderEffect =  queuePostFlushCb;
+
+// Simple effect.
+function watchEffect(effect, options) {
+    return doWatch(effect, null, options);
+}
+// initial value for watchers to trigger on undefined initial values
+const INITIAL_WATCHER_VALUE = {};
+// implementation
+function watch(source, cb, options) {
+    if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) {
+        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, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) {
+    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.`);
+        }
+    }
+    const warnInvalidSource = (s) => {
+        warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` +
+            `a reactive object, or an array of these types.`);
+    };
+    let getter;
+    if (isArray(source)) {
+        getter = () => source.map(s => {
+            if (isRef(s)) {
+                return s.value;
+            }
+            else if (isReactive(s)) {
+                return traverse(s);
+            }
+            else if (isFunction(s)) {
+                return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);
+            }
+            else {
+                (process.env.NODE_ENV !== 'production') && warnInvalidSource(s);
+            }
+        });
+    }
+    else if (isRef(source)) {
+        getter = () => source.value;
+    }
+    else if (isReactive(source)) {
+        getter = () => source;
+        deep = true;
+    }
+    else if (isFunction(source)) {
+        if (cb) {
+            // getter with cb
+            getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);
+        }
+        else {
+            // no cb -> simple effect
+            getter = () => {
+                if (instance && instance.isUnmounted) {
+                    return;
+                }
+                if (cleanup) {
+                    cleanup();
+                }
+                return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]);
+            };
+        }
+    }
+    else {
+        getter = NOOP;
+        (process.env.NODE_ENV !== 'production') && warnInvalidSource(source);
+    }
+    if (cb && deep) {
+        const baseGetter = getter;
+        getter = () => traverse(baseGetter());
+    }
+    let cleanup;
+    const onInvalidate = (fn) => {
+        cleanup = runner.options.onStop = () => {
+            callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);
+        };
+    };
+    let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;
+    const job = () => {
+        if (!runner.active) {
+            return;
+        }
+        if (cb) {
+            // watch(source, cb)
+            const newValue = runner();
+            if (deep || hasChanged(newValue, oldValue)) {
+                // cleanup before running cb again
+                if (cleanup) {
+                    cleanup();
+                }
+                callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [
+                    newValue,
+                    // pass undefined as the old value when it's changed for the first time
+                    oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,
+                    onInvalidate
+                ]);
+                oldValue = newValue;
+            }
+        }
+        else {
+            // watchEffect
+            runner();
+        }
+    };
+    let scheduler;
+    if (flush === 'sync') {
+        scheduler = job;
+    }
+    else if (flush === 'pre') {
+        // ensure it's queued before component updates (which have positive ids)
+        job.id = -1;
+        scheduler = () => {
+            if (!instance || instance.isMounted) {
+                queueJob(job);
+            }
+            else {
+                // with 'pre' option, the first call must happen before
+                // the component is mounted so it is called synchronously.
+                job();
+            }
+        };
+    }
+    else {
+        scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
+    }
+    const runner = effect(getter, {
+        lazy: true,
+        onTrack,
+        onTrigger,
+        scheduler
+    });
+    recordInstanceBoundEffect(runner);
+    // initial run
+    if (cb) {
+        if (immediate) {
+            job();
+        }
+        else {
+            oldValue = runner();
+        }
+    }
+    else {
+        runner();
+    }
+    return () => {
+        stop(runner);
+        if (instance) {
+            remove(instance.effects, runner);
+        }
+    };
+}
+// this.$watch
+function instanceWatch(source, cb, options) {
+    const publicThis = this.proxy;
+    const getter = isString(source)
+        ? () => publicThis[source]
+        : source.bind(publicThis);
+    return doWatch(getter, cb.bind(publicThis), options, this);
+}
+function traverse(value, seen = new Set()) {
+    if (!isObject(value) || seen.has(value)) {
+        return value;
+    }
+    seen.add(value);
+    if (isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            traverse(value[i], seen);
+        }
+    }
+    else if (value instanceof Map) {
+        value.forEach((v, key) => {
+            // to register mutation dep for existing keys
+            traverse(value.get(key), seen);
+        });
+    }
+    else if (value instanceof Set) {
+        value.forEach(v => {
+            traverse(v, seen);
+        });
+    }
+    else {
+        for (const key in value) {
+            traverse(value[key], seen);
+        }
+    }
+    return value;
+}
+
+function provide(key, value) {
+    if (!currentInstance) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            warn(`provide() can only be used inside setup().`);
+        }
+    }
+    else {
+        let provides = currentInstance.provides;
+        // by default an instance inherits its parent's provides object
+        // but when it needs to provide values of its own, it creates its
+        // own provides object using parent provides object as prototype.
+        // this way in `inject` we can simply look up injections from direct
+        // parent and let the prototype chain do the work.
+        const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+        if (parentProvides === provides) {
+            provides = currentInstance.provides = Object.create(parentProvides);
+        }
+        // TS doesn't allow symbol as index type
+        provides[key] = value;
+    }
+}
+function inject(key, defaultValue) {
+    // fallback to `currentRenderingInstance` so that this can be called in
+    // a functional component
+    const instance = currentInstance || currentRenderingInstance;
+    if (instance) {
+        const provides = instance.provides;
+        if (key in provides) {
+            // TS doesn't allow symbol as index type
+            return provides[key];
+        }
+        else if (arguments.length > 1) {
+            return defaultValue;
+        }
+        else if ((process.env.NODE_ENV !== 'production')) {
+            warn(`injection "${String(key)}" not found.`);
+        }
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        warn(`inject() can only be used inside setup() or functional components.`);
+    }
+}
+
+function createDuplicateChecker() {
+    const cache = Object.create(null);
+    return (type, key) => {
+        if (cache[key]) {
+            warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
+        }
+        else {
+            cache[key] = type;
+        }
+    };
+}
+function applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) {
+    const { 
+    // composition
+    mixins, extends: extendsOptions, 
+    // state
+    data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, 
+    // assets
+    components, directives, 
+    // lifecycle
+    beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, renderTracked, renderTriggered, errorCaptured } = options;
+    const publicThis = instance.proxy;
+    const ctx = instance.ctx;
+    const globalMixins = instance.appContext.mixins;
+    // call it only during dev
+    // applyOptions is called non-as-mixin once per instance
+    if (!asMixin) {
+        callSyncHook('beforeCreate', options, publicThis, globalMixins);
+        // global mixins are applied first
+        applyMixins(instance, globalMixins, deferredData, deferredWatch);
+    }
+    // extending a base component...
+    if (extendsOptions) {
+        applyOptions(instance, extendsOptions, deferredData, deferredWatch, true);
+    }
+    // local mixins
+    if (mixins) {
+        applyMixins(instance, mixins, deferredData, deferredWatch);
+    }
+    const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null;
+    if ((process.env.NODE_ENV !== 'production')) {
+        const propsOptions = normalizePropsOptions(options)[0];
+        if (propsOptions) {
+            for (const key in propsOptions) {
+                checkDuplicateProperties("Props" /* PROPS */, key);
+            }
+        }
+    }
+    // options initialization order (to be consistent with Vue 2):
+    // - props (already done outside of this function)
+    // - inject
+    // - methods
+    // - data (deferred since it relies on `this` access)
+    // - computed
+    // - watch (deferred since it relies on `this` access)
+    if (injectOptions) {
+        if (isArray(injectOptions)) {
+            for (let i = 0; i < injectOptions.length; i++) {
+                const key = injectOptions[i];
+                ctx[key] = inject(key);
+                if ((process.env.NODE_ENV !== 'production')) {
+                    checkDuplicateProperties("Inject" /* INJECT */, key);
+                }
+            }
+        }
+        else {
+            for (const key in injectOptions) {
+                const opt = injectOptions[key];
+                if (isObject(opt)) {
+                    ctx[key] = inject(opt.from, opt.default);
+                }
+                else {
+                    ctx[key] = inject(opt);
+                }
+                if ((process.env.NODE_ENV !== 'production')) {
+                    checkDuplicateProperties("Inject" /* INJECT */, key);
+                }
+            }
+        }
+    }
+    if (methods) {
+        for (const key in methods) {
+            const methodHandler = methods[key];
+            if (isFunction(methodHandler)) {
+                ctx[key] = methodHandler.bind(publicThis);
+                if ((process.env.NODE_ENV !== 'production')) {
+                    checkDuplicateProperties("Methods" /* METHODS */, key);
+                }
+            }
+            else if ((process.env.NODE_ENV !== 'production')) {
+                warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` +
+                    `Did you reference the function correctly?`);
+            }
+        }
+    }
+    if (dataOptions) {
+        if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) {
+            warn(`The data option must be a function. ` +
+                `Plain object usage is no longer supported.`);
+        }
+        if (asMixin) {
+            deferredData.push(dataOptions);
+        }
+        else {
+            resolveData(instance, dataOptions, publicThis);
+        }
+    }
+    if (!asMixin) {
+        if (deferredData.length) {
+            deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis));
+        }
+        if ((process.env.NODE_ENV !== 'production')) {
+            const rawData = toRaw(instance.data);
+            for (const key in rawData) {
+                checkDuplicateProperties("Data" /* DATA */, key);
+                // expose data on ctx during dev
+                if (key[0] !== '$' && key[0] !== '_') {
+                    Object.defineProperty(ctx, key, {
+                        configurable: true,
+                        enumerable: true,
+                        get: () => rawData[key],
+                        set: NOOP
+                    });
+                }
+            }
+        }
+    }
+    if (computedOptions) {
+        for (const key in computedOptions) {
+            const opt = computedOptions[key];
+            const get = isFunction(opt)
+                ? opt.bind(publicThis, publicThis)
+                : isFunction(opt.get)
+                    ? opt.get.bind(publicThis, publicThis)
+                    : NOOP;
+            if ((process.env.NODE_ENV !== 'production') && get === NOOP) {
+                warn(`Computed property "${key}" has no getter.`);
+            }
+            const set = !isFunction(opt) && isFunction(opt.set)
+                ? opt.set.bind(publicThis)
+                : (process.env.NODE_ENV !== 'production')
+                    ? () => {
+                        warn(`Write operation failed: computed property "${key}" is readonly.`);
+                    }
+                    : NOOP;
+            const c = computed$1({
+                get,
+                set
+            });
+            Object.defineProperty(ctx, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => c.value,
+                set: v => (c.value = v)
+            });
+            if ((process.env.NODE_ENV !== 'production')) {
+                checkDuplicateProperties("Computed" /* COMPUTED */, key);
+            }
+        }
+    }
+    if (watchOptions) {
+        deferredWatch.push(watchOptions);
+    }
+    if (!asMixin && deferredWatch.length) {
+        deferredWatch.forEach(watchOptions => {
+            for (const key in watchOptions) {
+                createWatcher(watchOptions[key], ctx, publicThis, key);
+            }
+        });
+    }
+    if (provideOptions) {
+        const provides = isFunction(provideOptions)
+            ? provideOptions.call(publicThis)
+            : provideOptions;
+        for (const key in provides) {
+            provide(key, provides[key]);
+        }
+    }
+    // asset options
+    if (components) {
+        extend(instance.components, components);
+    }
+    if (directives) {
+        extend(instance.directives, directives);
+    }
+    // lifecycle options
+    if (!asMixin) {
+        callSyncHook('created', options, publicThis, globalMixins);
+    }
+    if (beforeMount) {
+        onBeforeMount(beforeMount.bind(publicThis));
+    }
+    if (mounted) {
+        onMounted(mounted.bind(publicThis));
+    }
+    if (beforeUpdate) {
+        onBeforeUpdate(beforeUpdate.bind(publicThis));
+    }
+    if (updated) {
+        onUpdated(updated.bind(publicThis));
+    }
+    if (activated) {
+        onActivated(activated.bind(publicThis));
+    }
+    if (deactivated) {
+        onDeactivated(deactivated.bind(publicThis));
+    }
+    if (errorCaptured) {
+        onErrorCaptured(errorCaptured.bind(publicThis));
+    }
+    if (renderTracked) {
+        onRenderTracked(renderTracked.bind(publicThis));
+    }
+    if (renderTriggered) {
+        onRenderTriggered(renderTriggered.bind(publicThis));
+    }
+    if (beforeUnmount) {
+        onBeforeUnmount(beforeUnmount.bind(publicThis));
+    }
+    if (unmounted) {
+        onUnmounted(unmounted.bind(publicThis));
+    }
+    // fixed by xxxxxx
+    if (instance.ctx.$onApplyOptions) {
+        instance.ctx.$onApplyOptions(options, instance, publicThis);
+    }
+}
+function callSyncHook(name, options, ctx, globalMixins) {
+    callHookFromMixins(name, globalMixins, ctx);
+    const baseHook = options.extends && options.extends[name];
+    if (baseHook) {
+        baseHook.call(ctx);
+    }
+    const mixins = options.mixins;
+    if (mixins) {
+        callHookFromMixins(name, mixins, ctx);
+    }
+    const selfHook = options[name];
+    if (selfHook) {
+        selfHook.call(ctx);
+    }
+}
+function callHookFromMixins(name, mixins, ctx) {
+    for (let i = 0; i < mixins.length; i++) {
+        const fn = mixins[i][name];
+        if (fn) {
+            fn.call(ctx);
+        }
+    }
+}
+function applyMixins(instance, mixins, deferredData, deferredWatch) {
+    for (let i = 0; i < mixins.length; i++) {
+        applyOptions(instance, mixins[i], deferredData, deferredWatch, true);
+    }
+}
+function resolveData(instance, dataFn, publicThis) {
+    const data = dataFn.call(publicThis, publicThis);
+    if ((process.env.NODE_ENV !== 'production') && isPromise(data)) {
+        warn(`data() returned a Promise - note data() cannot be async; If you ` +
+            `intend to perform data fetching before component renders, use ` +
+            `async setup() + <Suspense>.`);
+    }
+    if (!isObject(data)) {
+        (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`);
+    }
+    else if (instance.data === EMPTY_OBJ) {
+        instance.data = reactive(data);
+    }
+    else {
+        // existing data: this is a mixin or extends.
+        extend(instance.data, data);
+    }
+}
+function createWatcher(raw, ctx, publicThis, key) {
+    const getter = () => publicThis[key];
+    if (isString(raw)) {
+        const handler = ctx[raw];
+        if (isFunction(handler)) {
+            watch(getter, handler);
+        }
+        else if ((process.env.NODE_ENV !== 'production')) {
+            warn(`Invalid watch handler specified by key "${raw}"`, handler);
+        }
+    }
+    else if (isFunction(raw)) {
+        watch(getter, raw.bind(publicThis));
+    }
+    else if (isObject(raw)) {
+        if (isArray(raw)) {
+            raw.forEach(r => createWatcher(r, ctx, publicThis, key));
+        }
+        else {
+            watch(getter, raw.handler.bind(publicThis), raw);
+        }
+    }
+    else if ((process.env.NODE_ENV !== 'production')) {
+        warn(`Invalid watch option: "${key}"`);
+    }
+}
+function resolveMergedOptions(instance) {
+    const raw = instance.type;
+    const { __merged, mixins, extends: extendsOptions } = raw;
+    if (__merged)
+        return __merged;
+    const globalMixins = instance.appContext.mixins;
+    if (!globalMixins.length && !mixins && !extendsOptions)
+        return raw;
+    const options = {};
+    globalMixins.forEach(m => mergeOptions(options, m, instance));
+    extendsOptions && mergeOptions(options, extendsOptions, instance);
+    mixins && mixins.forEach(m => mergeOptions(options, m, instance));
+    mergeOptions(options, raw, instance);
+    return (raw.__merged = options);
+}
+function mergeOptions(to, from, instance) {
+    const strats = instance.appContext.config.optionMergeStrategies;
+    for (const key in from) {
+        if (strats && hasOwn(strats, key)) {
+            to[key] = strats[key](to[key], from[key], instance.proxy, key);
+        }
+        else if (!hasOwn(to, key)) {
+            to[key] = from[key];
+        }
+    }
+}
+
+const publicPropertiesMap = extend(Object.create(null), {
+    $: i => i,
+    $el: i => i.vnode.el,
+    $data: i => i.data,
+    $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props),
+    $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs),
+    $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots),
+    // $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs), // fixed by xxxxxx
+    $parent: i => i.parent && i.parent.proxy,
+    $root: i => i.root && i.root.proxy,
+    $emit: i => i.emit,
+    $options: i => (__FEATURE_OPTIONS__ ? resolveMergedOptions(i) : i.type),
+    $forceUpdate: i => () => queueJob(i.update),
+    // $nextTick: () => nextTick, // fixed by xxxxxx
+    $watch: __FEATURE_OPTIONS__ ? i => instanceWatch.bind(i) : NOOP
+});
+const PublicInstanceProxyHandlers = {
+    get({ _: instance }, key) {
+        const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+        // let @vue/reactivity know it should never observe Vue public instances.
+        if (key === "__v_skip" /* SKIP */) {
+            return true;
+        }
+        // data / props / ctx
+        // This getter gets called for every property access on the render context
+        // during render and is a major hotspot. The most expensive part of this
+        // is the multiple hasOwn() calls. It's much faster to do a simple property
+        // access on a plain object, so we use an accessCache object (with null
+        // prototype) to memoize what access type a key corresponds to.
+        let normalizedProps;
+        if (key[0] !== '$') {
+            const n = accessCache[key];
+            if (n !== undefined) {
+                switch (n) {
+                    case 0 /* SETUP */:
+                        return setupState[key];
+                    case 1 /* DATA */:
+                        return data[key];
+                    case 3 /* CONTEXT */:
+                        return ctx[key];
+                    case 2 /* PROPS */:
+                        return props[key];
+                    // default: just fallthrough
+                }
+            }
+            else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+                accessCache[key] = 0 /* SETUP */;
+                return setupState[key];
+            }
+            else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+                accessCache[key] = 1 /* DATA */;
+                return data[key];
+            }
+            else if (
+            // only cache other properties when instance has declared (thus stable)
+            // props
+            (normalizedProps = normalizePropsOptions(type)[0]) &&
+                hasOwn(normalizedProps, key)) {
+                accessCache[key] = 2 /* PROPS */;
+                return props[key];
+            }
+            else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+                accessCache[key] = 3 /* CONTEXT */;
+                return ctx[key];
+            }
+            else {
+                accessCache[key] = 4 /* OTHER */;
+            }
+        }
+        const publicGetter = publicPropertiesMap[key];
+        let cssModule, globalProperties;
+        // public $xxx properties
+        if (publicGetter) {
+            if (key === '$attrs') {
+                track(instance, "get" /* GET */, key);
+                (process.env.NODE_ENV !== 'production') && markAttrsAccessed();
+            }
+            return publicGetter(instance);
+        }
+        else if (
+        // css module (injected by vue-loader)
+        (cssModule = type.__cssModules) &&
+            (cssModule = cssModule[key])) {
+            return cssModule;
+        }
+        else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+            // user may set custom properties to `this` that start with `$`
+            accessCache[key] = 3 /* CONTEXT */;
+            return ctx[key];
+        }
+        else if (
+        // global properties
+        ((globalProperties = appContext.config.globalProperties),
+            hasOwn(globalProperties, key))) {
+            return globalProperties[key];
+        }
+        else if ((process.env.NODE_ENV !== 'production') &&
+            currentRenderingInstance &&
+            // #1091 avoid internal isRef/isVNode checks on component instance leading
+            // to infinite warning loop
+            key.indexOf('__v') !== 0) {
+            if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) {
+                warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` +
+                    `character and is not proxied on the render context.`);
+            }
+            else {
+                warn(`Property ${JSON.stringify(key)} was accessed during render ` +
+                    `but is not defined on instance.`);
+            }
+        }
+    },
+    set({ _: instance }, key, value) {
+        const { data, setupState, ctx } = instance;
+        if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+            setupState[key] = value;
+        }
+        else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+            data[key] = value;
+        }
+        else if (key in instance.props) {
+            (process.env.NODE_ENV !== 'production') &&
+                warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance);
+            return false;
+        }
+        if (key[0] === '$' && key.slice(1) in instance) {
+            (process.env.NODE_ENV !== 'production') &&
+                warn(`Attempting to mutate public property "${key}". ` +
+                    `Properties starting with $ are reserved and readonly.`, instance);
+            return false;
+        }
+        else {
+            if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) {
+                Object.defineProperty(ctx, key, {
+                    enumerable: true,
+                    configurable: true,
+                    value
+                });
+            }
+            else {
+                ctx[key] = value;
+            }
+        }
+        return true;
+    },
+    has({ _: { data, setupState, accessCache, ctx, type, appContext } }, key) {
+        let normalizedProps;
+        return (accessCache[key] !== undefined ||
+            (data !== EMPTY_OBJ && hasOwn(data, key)) ||
+            (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||
+            ((normalizedProps = normalizePropsOptions(type)[0]) &&
+                hasOwn(normalizedProps, key)) ||
+            hasOwn(ctx, key) ||
+            hasOwn(publicPropertiesMap, key) ||
+            hasOwn(appContext.config.globalProperties, key));
+    }
+};
+if ((process.env.NODE_ENV !== 'production') && !false) {
+    PublicInstanceProxyHandlers.ownKeys = (target) => {
+        warn(`Avoid app logic that relies on enumerating keys on a component instance. ` +
+            `The keys will be empty in production mode to avoid performance overhead.`);
+        return Reflect.ownKeys(target);
+    };
+}
+const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, {
+    get(target, key) {
+        // fast path for unscopables when using `with` block
+        if (key === Symbol.unscopables) {
+            return;
+        }
+        return PublicInstanceProxyHandlers.get(target, key, target);
+    },
+    has(_, key) {
+        const has = key[0] !== '_' && !isGloballyWhitelisted(key);
+        if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) {
+            warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);
+        }
+        return has;
+    }
+});
+// In dev mode, the proxy target exposes the same properties as seen on `this`
+// for easier console inspection. In prod mode it will be an empty object so
+// these properties definitions can be skipped.
+function createRenderContext(instance) {
+    const target = {};
+    // expose internal instance for proxy handlers
+    Object.defineProperty(target, `_`, {
+        configurable: true,
+        enumerable: false,
+        get: () => instance
+    });
+    // expose public properties
+    Object.keys(publicPropertiesMap).forEach(key => {
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: false,
+            get: () => publicPropertiesMap[key](instance),
+            // intercepted by the proxy so no need for implementation,
+            // but needed to prevent set errors
+            set: NOOP
+        });
+    });
+    // expose global properties
+    const { globalProperties } = instance.appContext.config;
+    Object.keys(globalProperties).forEach(key => {
+        Object.defineProperty(target, key, {
+            configurable: true,
+            enumerable: false,
+            get: () => globalProperties[key],
+            set: NOOP
+        });
+    });
+    return target;
+}
+// dev only
+function exposePropsOnRenderContext(instance) {
+    const { ctx, type } = instance;
+    const propsOptions = normalizePropsOptions(type)[0];
+    if (propsOptions) {
+        Object.keys(propsOptions).forEach(key => {
+            Object.defineProperty(ctx, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => instance.props[key],
+                set: NOOP
+            });
+        });
+    }
+}
+// dev only
+function exposeSetupStateOnRenderContext(instance) {
+    const { ctx, setupState } = instance;
+    Object.keys(toRaw(setupState)).forEach(key => {
+        Object.defineProperty(ctx, key, {
+            enumerable: true,
+            configurable: true,
+            get: () => setupState[key],
+            set: NOOP
+        });
+    });
+}
+
+const emptyAppContext = createAppContext();
+let uid$1 = 0;
+function createComponentInstance(vnode, parent, suspense) {
+    // inherit parent app context - or - if root, adopt from root vnode
+    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+    const instance = {
+        uid: uid$1++,
+        vnode,
+        parent,
+        appContext,
+        type: vnode.type,
+        root: null,
+        next: null,
+        subTree: null,
+        update: null,
+        render: null,
+        proxy: null,
+        withProxy: null,
+        effects: null,
+        provides: parent ? parent.provides : Object.create(appContext.provides),
+        accessCache: null,
+        renderCache: [],
+        // state
+        ctx: EMPTY_OBJ,
+        data: EMPTY_OBJ,
+        props: EMPTY_OBJ,
+        attrs: EMPTY_OBJ,
+        slots: EMPTY_OBJ,
+        refs: EMPTY_OBJ,
+        setupState: EMPTY_OBJ,
+        setupContext: null,
+        // per-instance asset storage (mutable during options resolution)
+        components: Object.create(appContext.components),
+        directives: Object.create(appContext.directives),
+        // suspense related
+        suspense,
+        asyncDep: null,
+        asyncResolved: false,
+        // lifecycle hooks
+        // not using enums here because it results in computed properties
+        isMounted: false,
+        isUnmounted: false,
+        isDeactivated: false,
+        bc: null,
+        c: null,
+        bm: null,
+        m: null,
+        bu: null,
+        u: null,
+        um: null,
+        bum: null,
+        da: null,
+        a: null,
+        rtg: null,
+        rtc: null,
+        ec: null,
+        emit: null,
+        emitted: null
+    };
+    if ((process.env.NODE_ENV !== 'production')) {
+        instance.ctx = createRenderContext(instance);
+    }
+    else {
+        instance.ctx = { _: instance };
+    }
+    instance.root = parent ? parent.root : instance;
+    instance.emit = emit.bind(null, instance);
+    (process.env.NODE_ENV !== 'production') && componentAdded(instance);
+    return instance;
+}
+let currentInstance = null;
+const setCurrentInstance = (instance) => {
+    currentInstance = instance;
+};
+const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component');
+function validateComponentName(name, config) {
+    const appIsNativeTag = config.isNativeTag || NO;
+    if (isBuiltInTag(name) || appIsNativeTag(name)) {
+        warn('Do not use built-in or reserved HTML elements as component id: ' + name);
+    }
+}
+let isInSSRComponentSetup = false;
+function setupComponent(instance, isSSR = false) {
+    isInSSRComponentSetup = isSSR;
+    const { props, /* children, */ shapeFlag } = instance.vnode;
+    const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */;
+    initProps(instance, props, isStateful, isSSR);
+    // initSlots(instance, children) // fixed by xxxxxx
+    const setupResult = isStateful
+        ? setupStatefulComponent(instance, isSSR)
+        : undefined;
+    isInSSRComponentSetup = false;
+    return setupResult;
+}
+function setupStatefulComponent(instance, isSSR) {
+    const Component = instance.type;
+    if ((process.env.NODE_ENV !== 'production')) {
+        if (Component.name) {
+            validateComponentName(Component.name, instance.appContext.config);
+        }
+        if (Component.components) {
+            const names = Object.keys(Component.components);
+            for (let i = 0; i < names.length; i++) {
+                validateComponentName(names[i], instance.appContext.config);
+            }
+        }
+        if (Component.directives) {
+            const names = Object.keys(Component.directives);
+            for (let i = 0; i < names.length; i++) {
+                validateDirectiveName(names[i]);
+            }
+        }
+    }
+    // 0. create render proxy property access cache
+    instance.accessCache = {};
+    // 1. create public instance / render proxy
+    // also mark it raw so it's never observed
+    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
+    if ((process.env.NODE_ENV !== 'production')) {
+        exposePropsOnRenderContext(instance);
+    }
+    // 2. call setup()
+    const { setup } = Component;
+    if (setup) {
+        const setupContext = (instance.setupContext =
+            setup.length > 1 ? createSetupContext(instance) : null);
+        currentInstance = instance;
+        pauseTracking();
+        const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [(process.env.NODE_ENV !== 'production') ? shallowReadonly(instance.props) : instance.props, setupContext]);
+        resetTracking();
+        currentInstance = null;
+        if (isPromise(setupResult)) {
+            if (isSSR) {
+                // return the promise so server-renderer can wait on it
+                return setupResult.then((resolvedResult) => {
+                    handleSetupResult(instance, resolvedResult);
+                });
+            }
+            else if ((process.env.NODE_ENV !== 'production')) {
+                warn(`setup() returned a Promise, but the version of Vue you are using ` +
+                    `does not support it yet.`);
+            }
+        }
+        else {
+            handleSetupResult(instance, setupResult);
+        }
+    }
+    else {
+        finishComponentSetup(instance);
+    }
+}
+function handleSetupResult(instance, setupResult, isSSR) {
+    if (isFunction(setupResult)) {
+        // setup returned an inline render function
+        instance.render = setupResult;
+    }
+    else if (isObject(setupResult)) {
+        // if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) {
+        //   warn(
+        //     `setup() should not return VNodes directly - ` +
+        //       `return a render function instead.`
+        //   )
+        // }
+        // setup returned bindings.
+        // assuming a render function compiled from template is present.
+        instance.setupState = reactive(setupResult);
+        if ((process.env.NODE_ENV !== 'production')) {
+            exposeSetupStateOnRenderContext(instance);
+        }
+    }
+    else if ((process.env.NODE_ENV !== 'production') && setupResult !== undefined) {
+        warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`);
+    }
+    finishComponentSetup(instance);
+}
+function finishComponentSetup(instance, isSSR) {
+    const Component = instance.type;
+    // template / render function normalization
+    if (!instance.render) {
+        if ((process.env.NODE_ENV !== 'production') && !Component.render) {
+            /* istanbul ignore if */
+            if ( Component.template) {
+                warn(`Component provided template option but ` +
+                    `runtime compilation is not supported in this build of Vue.` +
+                    ( ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".`
+                        ) /* should not happen */);
+            }
+            else {
+                warn(`Component is missing template or render function.`);
+            }
+        }
+        instance.render = (Component.render || NOOP);
+        // for runtime-compiled render functions using `with` blocks, the render
+        // proxy used needs a different `has` handler which is more performant and
+        // also only allows a whitelist of globals to fallthrough.
+        if (instance.render._rc) {
+            instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
+        }
+    }
+    // support for 2.x options
+    if (__FEATURE_OPTIONS__) {
+        currentInstance = instance;
+        applyOptions(instance, Component);
+        currentInstance = null;
+    }
+}
+const attrHandlers = {
+    get: (target, key) => {
+        if ((process.env.NODE_ENV !== 'production')) ;
+        return target[key];
+    },
+    set: () => {
+        warn(`setupContext.attrs is readonly.`);
+        return false;
+    },
+    deleteProperty: () => {
+        warn(`setupContext.attrs is readonly.`);
+        return false;
+    }
+};
+function createSetupContext(instance) {
+    if ((process.env.NODE_ENV !== 'production')) {
+        // We use getters in dev in case libs like test-utils overwrite instance
+        // properties (overwrites should not be done in prod)
+        return Object.freeze({
+            get attrs() {
+                return new Proxy(instance.attrs, attrHandlers);
+            },
+            get slots() {
+                return shallowReadonly(instance.slots);
+            },
+            get emit() {
+                return (event, ...args) => instance.emit(event, ...args);
+            }
+        });
+    }
+    else {
+        return {
+            attrs: instance.attrs,
+            slots: instance.slots,
+            emit: instance.emit
+        };
+    }
+}
+// record effects created during a component's setup() so that they can be
+// stopped when the component unmounts
+function recordInstanceBoundEffect(effect) {
+    if (currentInstance) {
+        (currentInstance.effects || (currentInstance.effects = [])).push(effect);
+    }
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
+/* istanbul ignore next */
+function formatComponentName(instance, Component, isRoot = false) {
+    let name = isFunction(Component)
+        ? Component.displayName || Component.name
+        : Component.name;
+    if (!name && Component.__file) {
+        const match = Component.__file.match(/([^/\\]+)\.vue$/);
+        if (match) {
+            name = match[1];
+        }
+    }
+    if (!name && instance && instance.parent) {
+        // try to infer the name based on local resolution
+        const registry = instance.parent.components;
+        for (const key in registry) {
+            if (registry[key] === Component) {
+                name = key;
+                break;
+            }
+        }
+    }
+    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+
+function computed$1(getterOrOptions) {
+    const c = computed(getterOrOptions);
+    recordInstanceBoundEffect(c.effect);
+    return c;
+}
+
+// Core API ------------------------------------------------------------------
+const version = "3.0.0-rc.2";
+
+// import deepCopy from './deepCopy'
+/**
+ * https://raw.githubusercontent.com/Tencent/westore/master/packages/westore/utils/diff.js
+ */
+const ARRAYTYPE = '[object Array]';
+const OBJECTTYPE = '[object Object]';
+// const FUNCTIONTYPE = '[object Function]'
+function diff(current, pre) {
+    const result = {};
+    syncKeys(current, pre);
+    _diff(current, pre, '', result);
+    return result;
+}
+function syncKeys(current, pre) {
+    current = unref(current);
+    if (current === pre)
+        return;
+    const rootCurrentType = toTypeString(current);
+    const rootPreType = toTypeString(pre);
+    if (rootCurrentType == OBJECTTYPE && rootPreType == OBJECTTYPE) {
+        for (let key in pre) {
+            const currentValue = current[key];
+            if (currentValue === undefined) {
+                current[key] = null;
+            }
+            else {
+                syncKeys(currentValue, pre[key]);
+            }
+        }
+    }
+    else if (rootCurrentType == ARRAYTYPE && rootPreType == ARRAYTYPE) {
+        if (current.length >= pre.length) {
+            pre.forEach((item, index) => {
+                syncKeys(current[index], item);
+            });
+        }
+    }
+}
+function _diff(current, pre, path, result) {
+    current = unref(current);
+    if (current === pre)
+        return;
+    const rootCurrentType = toTypeString(current);
+    const rootPreType = toTypeString(pre);
+    if (rootCurrentType == OBJECTTYPE) {
+        if (rootPreType != OBJECTTYPE ||
+            Object.keys(current).length < Object.keys(pre).length) {
+            setResult(result, path, current);
+        }
+        else {
+            for (let key in current) {
+                const currentValue = unref(current[key]);
+                const preValue = pre[key];
+                const currentType = toTypeString(currentValue);
+                const preType = toTypeString(preValue);
+                if (currentType != ARRAYTYPE && currentType != OBJECTTYPE) {
+                    if (currentValue != preValue) {
+                        setResult(result, (path == '' ? '' : path + '.') + key, currentValue);
+                    }
+                }
+                else if (currentType == ARRAYTYPE) {
+                    if (preType != ARRAYTYPE) {
+                        setResult(result, (path == '' ? '' : path + '.') + key, currentValue);
+                    }
+                    else {
+                        if (currentValue.length < preValue.length) {
+                            setResult(result, (path == '' ? '' : path + '.') + key, currentValue);
+                        }
+                        else {
+                            currentValue.forEach((item, index) => {
+                                _diff(item, preValue[index], (path == '' ? '' : path + '.') + key + '[' + index + ']', result);
+                            });
+                        }
+                    }
+                }
+                else if (currentType == OBJECTTYPE) {
+                    if (preType != OBJECTTYPE ||
+                        Object.keys(currentValue).length < Object.keys(preValue).length) {
+                        setResult(result, (path == '' ? '' : path + '.') + key, currentValue);
+                    }
+                    else {
+                        for (let subKey in currentValue) {
+                            _diff(currentValue[subKey], preValue[subKey], (path == '' ? '' : path + '.') + key + '.' + subKey, result);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else if (rootCurrentType == ARRAYTYPE) {
+        if (rootPreType != ARRAYTYPE) {
+            setResult(result, path, current);
+        }
+        else {
+            if (current.length < pre.length) {
+                setResult(result, path, current);
+            }
+            else {
+                current.forEach((item, index) => {
+                    _diff(item, pre[index], path + '[' + index + ']', result);
+                });
+            }
+        }
+    }
+    else {
+        setResult(result, path, current);
+    }
+}
+function setResult(result, k, v) {
+    result[k] = v; //deepCopy(v)
+}
+
+function hasComponentEffect(instance) {
+    return queue.includes(instance.update);
+}
+function flushCallbacks(instance) {
+    const ctx = instance.ctx;
+    const callbacks = ctx.__next_tick_callbacks;
+    if (callbacks && callbacks.length) {
+        if (process.env.VUE_APP_DEBUG) {
+            const mpInstance = ctx.$scope;
+            console.log('[' +
+                +new Date() +
+                '][' +
+                (mpInstance.is || mpInstance.route) +
+                '][' +
+                instance.uid +
+                ']:flushCallbacks[' +
+                callbacks.length +
+                ']');
+        }
+        const copies = callbacks.slice(0);
+        callbacks.length = 0;
+        for (let i = 0; i < copies.length; i++) {
+            copies[i]();
+        }
+    }
+}
+function nextTick$1(instance, fn) {
+    const ctx = instance.ctx;
+    if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) {
+        if (process.env.VUE_APP_DEBUG) {
+            const mpInstance = ctx.$scope;
+            console.log('[' +
+                +new Date() +
+                '][' +
+                (mpInstance.is || mpInstance.route) +
+                '][' +
+                instance.uid +
+                ']:nextVueTick');
+        }
+        return nextTick(fn);
+    }
+    if (process.env.VUE_APP_DEBUG) {
+        const mpInstance = ctx.$scope;
+        console.log('[' +
+            +new Date() +
+            '][' +
+            (mpInstance.is || mpInstance.route) +
+            '][' +
+            instance.uid +
+            ']:nextMPTick');
+    }
+    let _resolve;
+    if (!ctx.__next_tick_callbacks) {
+        ctx.__next_tick_callbacks = [];
+    }
+    ctx.__next_tick_callbacks.push(() => {
+        if (fn) {
+            callWithErrorHandling(fn, instance, 14 /* SCHEDULER */);
+        }
+        else if (_resolve) {
+            _resolve(instance.proxy);
+        }
+    });
+    return new Promise(resolve => {
+        _resolve = resolve;
+    });
+}
+
+function getMPInstanceData(instance, keys) {
+    const data = instance.data;
+    const ret = Object.create(null);
+    //仅同步 data 中有的数据
+    keys.forEach(key => {
+        ret[key] = data[key];
+    });
+    return ret;
+}
+function getVueInstanceData(instance) {
+    const { data, setupState, ctx } = instance;
+    const keys = new Set();
+    const ret = Object.create(null);
+    Object.keys(setupState).forEach(key => {
+        keys.add(key);
+        ret[key] = setupState[key];
+    });
+    if (data) {
+        Object.keys(data).forEach(key => {
+            if (!keys.has(key)) {
+                keys.add(key);
+                ret[key] = data[key];
+            }
+        });
+    }
+    if (__FEATURE_OPTIONS__) {
+        if (ctx.$computedKeys) {
+            ctx.$computedKeys.forEach((key) => {
+                if (!keys.has(key)) {
+                    keys.add(key);
+                    ret[key] = ctx[key];
+                }
+            });
+        }
+    }
+    // track
+    return { keys, data: JSON.parse(JSON.stringify(ret)) };
+}
+function patch(instance) {
+    const ctx = instance.ctx;
+    const mpType = ctx.mpType;
+    if (mpType === 'page' || mpType === 'component') {
+        const start = Date.now();
+        const mpInstance = ctx.$scope;
+        const { keys, data } = getVueInstanceData(instance);
+        // data.__webviewId__ = mpInstance.data.__webviewId__
+        const diffData = diff(data, getMPInstanceData(mpInstance, keys));
+        if (Object.keys(diffData).length) {
+            if (process.env.VUE_APP_DEBUG) {
+                console.log('[' +
+                    +new Date() +
+                    '][' +
+                    (mpInstance.is || mpInstance.route) +
+                    '][' +
+                    instance.uid +
+                    '][耗时' +
+                    (Date.now() - start) +
+                    ']差量更新', JSON.stringify(diffData));
+            }
+            ctx.__next_tick_pending = true;
+            mpInstance.setData(diffData, () => {
+                ctx.__next_tick_pending = false;
+                flushCallbacks(instance);
+            });
+        }
+        else {
+            flushCallbacks(instance);
+        }
+    }
+}
+
+function errorHandler(err, instance, info) {
+    let hasOnError = false;
+    if (instance) {
+        const appInstance = instance.$.appContext.$appInstance;
+        hasOnError = appInstance && appInstance.$hasHook("onError" /* ON_ERROR */);
+        hasOnError && appInstance.$callHook("onError" /* ON_ERROR */, err);
+    }
+    logError(err, info, instance ? instance.$.vnode : null);
+}
+function initAppConfig(appConfig) {
+    appConfig.errorHandler = errorHandler;
+    appConfig.globalProperties.$nextTick = function $nextTick(fn) {
+        return nextTick$1(this.$, fn);
+    };
+}
+
+function onApplyOptions(options, instance, publicThis) {
+    Object.keys(options).forEach(name => {
+        if (name.indexOf('on') === 0) {
+            const hook = options[name];
+            if (isFunction(hook)) {
+                injectHook(name, hook.bind(publicThis), instance);
+            }
+        }
+    });
+    const computedOptions = options.computed;
+    if (computedOptions) {
+        const keys = Object.keys(computedOptions);
+        if (keys.length) {
+            const ctx = instance.ctx;
+            if (!ctx.$computedKeys) {
+                ctx.$computedKeys = [];
+            }
+            ctx.$computedKeys.push(...keys);
+        }
+    }
+    // remove
+    delete instance.ctx.$onApplyOptions;
+}
+
+var MPType;
+(function (MPType) {
+    MPType["APP"] = "app";
+    MPType["PAGE"] = "page";
+    MPType["COMPONENT"] = "component";
+})(MPType || (MPType = {}));
+const queuePostRenderEffect$1 = queuePostFlushCb;
+function mountComponent(initialVNode, options) {
+    const instance = (initialVNode.component = createComponentInstance(initialVNode, options.parentComponent, null));
+    if (__FEATURE_OPTIONS__) {
+        instance.ctx.$onApplyOptions = onApplyOptions;
+        instance.ctx.$children = [];
+    }
+    if (options.mpType === 'app') {
+        instance.render = NOOP;
+    }
+    if (options.onBeforeSetup) {
+        options.onBeforeSetup(instance, options);
+    }
+    if ((process.env.NODE_ENV !== 'production')) {
+        pushWarningContext(initialVNode);
+    }
+    setupComponent(instance);
+    if (__FEATURE_OPTIONS__) {
+        // $children
+        if (options.parentComponent && instance.proxy) {
+            options.parentComponent.ctx
+                .$children.push(instance.proxy);
+        }
+    }
+    setupRenderEffect(instance);
+    if ((process.env.NODE_ENV !== 'production')) {
+        popWarningContext();
+    }
+    return instance.proxy;
+}
+const prodEffectOptions = {
+    scheduler: queueJob
+};
+function createDevEffectOptions(instance) {
+    return {
+        scheduler: queueJob,
+        onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0,
+        onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0
+    };
+}
+function setupRenderEffect(instance) {
+    // create reactive effect for rendering
+    instance.update = effect(function componentEffect() {
+        if (!instance.isMounted) {
+            const { bm } = instance;
+            // beforeMount hook
+            if (bm) {
+                invokeArrayFns(bm);
+            }
+            patch(instance);
+            instance.isMounted = true;
+        }
+        else {
+            // updateComponent
+            const { bu, u } = instance;
+            // beforeUpdate hook
+            if (bu) {
+                invokeArrayFns(bu);
+            }
+            patch(instance);
+            // updated hook
+            if (u) {
+                queuePostRenderEffect$1(u);
+            }
+        }
+    }, (process.env.NODE_ENV !== 'production') ? createDevEffectOptions(instance) : prodEffectOptions);
+}
+function unmountComponent(instance) {
+    const { bum, effects, update, um } = instance;
+    // beforeUnmount hook
+    if (bum) {
+        invokeArrayFns(bum);
+    }
+    if (effects) {
+        for (let i = 0; i < effects.length; i++) {
+            stop(effects[i]);
+        }
+    }
+    // update may be null if a component is unmounted before its async
+    // setup has resolved.
+    if (update) {
+        stop(update);
+    }
+    // unmounted hook
+    if (um) {
+        queuePostRenderEffect$1(um);
+    }
+    queuePostRenderEffect$1(() => {
+        instance.isUnmounted = true;
+    });
+}
+const oldCreateApp = createAppAPI();
+function createApp(rootComponent, rootProps = null) {
+    const app = oldCreateApp(rootComponent, rootProps);
+    const appContext = app._context;
+    initAppConfig(appContext.config);
+    const createVNode = initialVNode => {
+        initialVNode.appContext = appContext;
+        initialVNode.shapeFlag = 6 /* COMPONENT */;
+        return initialVNode;
+    };
+    const createComponent = function createComponent(initialVNode, options) {
+        return mountComponent(createVNode(initialVNode), options);
+    };
+    const destroyComponent = function destroyComponent(component) {
+        return component && unmountComponent(component.$);
+    };
+    app.mount = function mount() {
+        const instance = mountComponent(createVNode({ type: rootComponent }), {
+            mpType: MPType.APP,
+            mpInstance: null,
+            parentComponent: null,
+            slots: [],
+            props: null
+        });
+        instance.$app = app;
+        instance.$createComponent = createComponent;
+        instance.$destroyComponent = destroyComponent;
+        appContext.$appInstance = instance;
+        createMiniProgramApp(instance);
+        return instance;
+    };
+    app.unmount = function unmount() {
+        warn(`Cannot unmount an app.`);
+    };
+    return app;
+}
+
+const createHook$1 = (lifecycle) => (hook, target = currentInstance) => 
+// post-create lifecycle registrations are noops during SSR
+!isInSSRComponentSetup &&
+    injectHook(lifecycle, hook, target);
+const onShow = /*#__PURE__*/ createHook$1("onShow" /* ON_SHOW */);
+const onHide = /*#__PURE__*/ createHook$1("onHide" /* ON_HIDE */);
+const onLaunch = /*#__PURE__*/ createHook$1("onLaunch" /* ON_LAUCH */);
+const onError = /*#__PURE__*/ createHook$1("onError" /* ON_ERROR */);
+const onThemeChange = /*#__PURE__*/ createHook$1("onThemeChange" /* ON_THEME_CHANGE */);
+const onPageNotFound = /*#__PURE__*/ createHook$1("onPageNotFound" /* ON_PAGE_NOT_FOUND */);
+const onUniNViewMessage = /*#__PURE__*/ createHook$1("onUniNViewMessage" /* ON_UNI_NVIEW_MESSAGE */);
+const onUnhandledRejection = /*#__PURE__*/ createHook$1("onUnhandledRejection" /* ON_UNHANDLE_REJECTION */);
+const onLoad = /*#__PURE__*/ createHook$1("onLoad" /* ON_LOAD */);
+const onReady = /*#__PURE__*/ createHook$1("onReady" /* ON_READY */);
+const onUnload = /*#__PURE__*/ createHook$1("onUnload" /* ON_UNLOAD */);
+const onResize = /*#__PURE__*/ createHook$1("onResize" /* ON_RESIZE */);
+const onBackPress = /*#__PURE__*/ createHook$1("onBackPress" /* ON_BACK_PRESS */);
+const onPageScroll = /*#__PURE__*/ createHook$1("onPageScroll" /* ON_PAGE_SCROLL */);
+const onTabItemTap = /*#__PURE__*/ createHook$1("onTabItemTap" /* ON_TAB_ITEM_TAP */);
+const onReachBottom = /*#__PURE__*/ createHook$1("onReachBottom" /* ON_REACH_BOTTOM */);
+const onPullDownRefresh = /*#__PURE__*/ createHook$1("onPullDownRefresh" /* ON_PULL_DOWN_REFRESH */);
+const onShareTimeline = /*#__PURE__*/ createHook$1("onShareTimeline" /* ON_SHARE_TIMELINE */);
+const onAddToFavorites = /*#__PURE__*/ createHook$1("onAddToFavorites" /* ON_ADD_TO_FAVORITES */);
+const onShareAppMessage = /*#__PURE__*/ createHook$1("onShareAppMessage" /* ON_SHARE_APP_MESSAGE */);
+const onNavigationBarButtonTap = /*#__PURE__*/ createHook$1("onNavigationBarButtonTap" /* ON_NAVIGATION_BAR_BUTTON_TAP */);
+const onNavigationBarSearchInputChanged = /*#__PURE__*/ createHook$1("onNavigationBarSearchInputChanged" /* ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED */);
+const onNavigationBarSearchInputClicked = /*#__PURE__*/ createHook$1("onNavigationBarSearchInputClicked" /* ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED */);
+const onNavigationBarSearchInputConfirmed = /*#__PURE__*/ createHook$1("onNavigationBarSearchInputConfirmed" /* ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED */);
+const onNavigationBarSearchInputFocusChanged = /*#__PURE__*/ createHook$1("onNavigationBarSearchInputFocusChanged" /* ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED */);
+
+export { callWithAsyncErrorHandling, callWithErrorHandling, computed$1 as computed, createApp, createHook$1 as createHook, customRef, inject, isProxy, isReactive, isReadonly, isRef, markRaw, nextTick, onActivated, onAddToFavorites, onBackPress, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onError, onErrorCaptured, onHide, onLaunch, onLoad, onMounted, onNavigationBarButtonTap, onNavigationBarSearchInputChanged, onNavigationBarSearchInputClicked, onNavigationBarSearchInputConfirmed, onNavigationBarSearchInputFocusChanged, onPageNotFound, onPageScroll, onPullDownRefresh, onReachBottom, onReady, onRenderTracked, onRenderTriggered, onResize, onShareAppMessage, onShareTimeline, onShow, onTabItemTap, onThemeChange, onUnhandledRejection, onUniNViewMessage, onUnload, onUnmounted, onUpdated, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, version, warn, watch, watchEffect };

packages/uni-mp-vue/package.json

+{
+  "name": "@dcloudio/uni-mp-vue",
+  "version": "2.0.0-alpha-26920200407011",
+  "description": "@dcloudio/uni-mp-vue",
+  "main": "dist/vue.runtime.esm.js",
+  "module": "dist/vue.runtime.esm.js",
+  "files": [
+    "dist"
+  ],
+  "buildOptions": {
+    "name": "Vue",
+    "formats": [
+      "esm-bundler-vue"
+    ]
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-mp-vue"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/dcloudio/uni-app/issues"
+  }
+}

packages/uni-mp-weixin/dist/uni.api.esm.js

+import { isArray, isPromise, isFunction, isPlainObject, hasOwn, isString } from '@vue/shared';
+
+const EPS = 1e-4;
+const BASE_DEVICE_WIDTH = 750;
+let isIOS = false;
+let deviceWidth = 0;
+let deviceDPR = 0;
+function checkDeviceWidth() {
+    const { platform, pixelRatio, windowWidth } = wx.getSystemInfoSync();
+    deviceWidth = windowWidth;
+    deviceDPR = pixelRatio;
+    isIOS = platform === 'ios';
+}
+function upx2px(number, newDeviceWidth) {
+    if (deviceWidth === 0) {
+        checkDeviceWidth();
+    }
+    number = Number(number);
+    if (number === 0) {
+        return 0;
+    }
+    let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth);
+    if (result < 0) {
+        result = -result;
+    }
+    result = Math.floor(result + EPS);
+    if (result === 0) {
+        if (deviceDPR === 1 || !isIOS) {
+            result = 1;
+        }
+        else {
+            result = 0.5;
+        }
+    }
+    return number < 0 ? -result : result;
+}
+
+var HOOKS;
+(function (HOOKS) {
+    HOOKS["INVOKE"] = "invoke";
+    HOOKS["SUCCESS"] = "success";
+    HOOKS["FAIL"] = "fail";
+    HOOKS["COMPLETE"] = "complete";
+    HOOKS["RETURN_VALUE"] = "returnValue";
+})(HOOKS || (HOOKS = {}));
+const globalInterceptors = {};
+const scopedInterceptors = {};
+function wrapperHook(hook) {
+    return function (data) {
+        return hook(data) || data;
+    };
+}
+function queue(hooks, data) {
+    let promise = false;
+    for (let i = 0; i < hooks.length; i++) {
+        const hook = hooks[i];
+        if (promise) {
+            promise = Promise.resolve(wrapperHook(hook));
+        }
+        else {
+            const res = hook(data);
+            if (isPromise(res)) {
+                promise = Promise.resolve(res);
+            }
+            if (res === false) {
+                return {
+                    then() { },
+                    catch() { }
+                };
+            }
+        }
+    }
+    return (promise || {
+        then(callback) {
+            return callback(data);
+        },
+        catch() { }
+    });
+}
+function wrapperOptions(interceptors, options = {}) {
+    [HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => {
+        const hooks = interceptors[name];
+        if (!isArray(hooks)) {
+            return;
+        }
+        const oldCallback = options[name];
+        options[name] = function callbackInterceptor(res) {
+            queue(hooks, res).then((res) => {
+                return (isFunction(oldCallback) && oldCallback(res)) || res;
+            });
+        };
+    });
+    return options;
+}
+function wrapperReturnValue(method, returnValue) {
+    const returnValueHooks = [];
+    if (isArray(globalInterceptors.returnValue)) {
+        returnValueHooks.push(...globalInterceptors.returnValue);
+    }
+    const interceptor = scopedInterceptors[method];
+    if (interceptor && isArray(interceptor.returnValue)) {
+        returnValueHooks.push(...interceptor.returnValue);
+    }
+    returnValueHooks.forEach(hook => {
+        returnValue = hook(returnValue) || returnValue;
+    });
+    return returnValue;
+}
+function getApiInterceptorHooks(method) {
+    const interceptor = Object.create(null);
+    Object.keys(globalInterceptors).forEach(hook => {
+        if (hook !== 'returnValue') {
+            interceptor[hook] = globalInterceptors[hook].slice();
+        }
+    });
+    const scopedInterceptor = scopedInterceptors[method];
+    if (scopedInterceptor) {
+        Object.keys(scopedInterceptor).forEach(hook => {
+            if (hook !== 'returnValue') {
+                interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]);
+            }
+        });
+    }
+    return interceptor;
+}
+function invokeApi(method, api, options, ...params) {
+    const interceptor = getApiInterceptorHooks(method);
+    if (interceptor && Object.keys(interceptor).length) {
+        if (isArray(interceptor.invoke)) {
+            const res = queue(interceptor.invoke, options);
+            return res.then(options => {
+                return api(wrapperOptions(interceptor, options), ...params);
+            });
+        }
+        else {
+            return api(wrapperOptions(interceptor, options), ...params);
+        }
+    }
+    return api(options, ...params);
+}
+
+function mergeInterceptorHook(interceptors, interceptor) {
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function removeInterceptorHook(interceptors, interceptor) {
+    if (!interceptors || !interceptor) {
+        return;
+    }
+    Object.keys(interceptor).forEach(hook => {
+        if (isFunction(interceptor[hook])) {
+            removeHook(interceptors[hook], interceptor[hook]);
+        }
+    });
+}
+function mergeHook(parentVal, childVal) {
+    const res = childVal
+        ? parentVal
+            ? parentVal.concat(childVal)
+            : isArray(childVal)
+                ? childVal
+                : [childVal]
+        : parentVal;
+    return res ? dedupeHooks(res) : res;
+}
+function dedupeHooks(hooks) {
+    const res = [];
+    for (let i = 0; i < hooks.length; i++) {
+        if (res.indexOf(hooks[i]) === -1) {
+            res.push(hooks[i]);
+        }
+    }
+    return res;
+}
+function removeHook(hooks, hook) {
+    if (!hooks) {
+        return;
+    }
+    const index = hooks.indexOf(hook);
+    if (index !== -1) {
+        hooks.splice(index, 1);
+    }
+}
+function addInterceptor(method, interceptor) {
+    if (typeof method === 'string' && isPlainObject(interceptor)) {
+        mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor);
+    }
+    else if (isPlainObject(method)) {
+        mergeInterceptorHook(globalInterceptors, method);
+    }
+}
+function removeInterceptor(method, interceptor) {
+    if (typeof method === 'string') {
+        if (isPlainObject(interceptor)) {
+            removeInterceptorHook(scopedInterceptors[method], interceptor);
+        }
+        else {
+            delete scopedInterceptors[method];
+        }
+    }
+    else if (isPlainObject(method)) {
+        removeInterceptorHook(globalInterceptors, method);
+    }
+}
+
+const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/;
+const CONTEXT_API_RE = /^create|Manager$/;
+// Context例外情况
+const CONTEXT_API_RE_EXC = ['createBLEConnection'];
+// 同步例外情况
+const ASYNC_API = ['createBLEConnection'];
+const CALLBACK_API_RE = /^on|^off/;
+function isContextApi(name) {
+    return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1;
+}
+function isSyncApi(name) {
+    return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1;
+}
+function isCallbackApi(name) {
+    return CALLBACK_API_RE.test(name) && name !== 'onPush';
+}
+function handlePromise(promise) {
+    return promise
+        .then(data => {
+        return [null, data];
+    })
+        .catch(err => [err]);
+}
+function shouldPromise(name) {
+    if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) {
+        return false;
+    }
+    return true;
+}
+/* eslint-disable no-extend-native */
+if (!Promise.prototype.finally) {
+    Promise.prototype.finally = function (onfinally) {
+        const promise = this.constructor;
+        return this.then(value => promise.resolve(onfinally && onfinally()).then(() => value), reason => promise.resolve(onfinally && onfinally()).then(() => {
+            throw reason;
+        }));
+    };
+}
+function promisify(name, api) {
+    if (!shouldPromise(name)) {
+        return api;
+    }
+    if (!isFunction(api)) {
+        return api;
+    }
+    return function promiseApi(options = {}, ...params) {
+        if (isFunction(options.success) ||
+            isFunction(options.fail) ||
+            isFunction(options.complete)) {
+            return wrapperReturnValue(name, invokeApi(name, api, options, ...params));
+        }
+        return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => {
+            invokeApi(name, api, Object.assign({}, options, {
+                success: resolve,
+                fail: reject
+            }), ...params);
+        })));
+    };
+}
+
+const CALLBACKS = ['success', 'fail', 'cancel', 'complete'];
+function initWrapper(protocols) {
+    function processCallback(methodName, method, returnValue) {
+        return function (res) {
+            return method(processReturnValue(methodName, res, returnValue));
+        };
+    }
+    function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) {
+        if (isPlainObject(fromArgs)) {
+            // 一般 api 的参数解析
+            const toArgs = (keepFromArgs === true ? fromArgs : {}); // returnValue 为 false 时，说明是格式化返回值，直接在返回值对象上修改赋值
+            if (isFunction(argsOption)) {
+                argsOption = argsOption(fromArgs, toArgs) || {};
+            }
+            for (const key in fromArgs) {
+                if (hasOwn(argsOption, key)) {
+                    let keyOption = argsOption[key];
+                    if (isFunction(keyOption)) {
+                        keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
+                    }
+                    if (!keyOption) {
+                        // 不支持的参数
+                        console.warn(`__MP_TITLE__ ${methodName}暂不支持${key}`);
+                    }
+                    else if (isString(keyOption)) {
+                        // 重写参数 key
+                        toArgs[keyOption] = fromArgs[key];
+                    }
+                    else if (isPlainObject(keyOption)) {
+                        // {name:newName,value:value}可重新指定参数 key:value
+                        toArgs[keyOption.name ? keyOption.name : key] = keyOption.value;
+                    }
+                }
+                else if (CALLBACKS.indexOf(key) !== -1) {
+                    const callback = fromArgs[key];
+                    if (isFunction(callback)) {
+                        toArgs[key] = processCallback(methodName, callback, returnValue);
+                    }
+                }
+                else {
+                    if (!keepFromArgs) {
+                        toArgs[key] = fromArgs[key];
+                    }
+                }
+            }
+            return toArgs;
+        }
+        else if (isFunction(fromArgs)) {
+            fromArgs = processCallback(methodName, fromArgs, returnValue);
+        }
+        return fromArgs;
+    }
+    function processReturnValue(methodName, res, returnValue, keepReturnValue = false) {
+        if (isFunction(protocols.returnValue)) {
+            // 处理通用 returnValue
+            res = protocols.returnValue(methodName, res);
+        }
+        return processArgs(methodName, res, returnValue, {}, keepReturnValue);
+    }
+    return function wrapper(methodName, method) {
+        if (!hasOwn(protocols, methodName)) {
+            return method;
+        }
+        const protocol = protocols[methodName];
+        if (!protocol) {
+            // 暂不支持的 api
+            return function () {
+                console.error(`__MP_TITLE__ 暂不支持${methodName}`);
+            };
+        }
+        return function (arg1, arg2) {
+            // 目前 api 最多两个参数
+            let options = protocol;
+            if (isFunction(protocol)) {
+                options = protocol(arg1);
+            }
+            arg1 = processArgs(methodName, arg1, options.args, options.returnValue);
+            const args = [arg1];
+            if (typeof arg2 !== 'undefined') {
+                args.push(arg2);
+            }
+            const returnValue = wx[options.name || methodName].apply(wx, args);
+            if (isSyncApi(methodName)) {
+                // 同步 api
+                return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName));
+            }
+            return returnValue;
+        };
+    };
+}
+
+const baseApis = { upx2px, addInterceptor, removeInterceptor };
+function initUni(api, protocols) {
+    const wrapper = initWrapper(protocols);
+    const UniProxyHandlers = {
+        get(target, key) {
+            if (hasOwn(target, key)) {
+                return target[key];
+            }
+            if (hasOwn(api, key)) {
+                return promisify(key, api[key]);
+            }
+            if (hasOwn(baseApis, key)) {
+                return promisify(key, baseApis[key]);
+            }
+            // event-api
+            // provider-api?
+            return promisify(key, wrapper(key, wx[key]));
+        }
+    };
+    return new Proxy({}, UniProxyHandlers);
+}
+
+const previewImage = {
+    args(fromArgs) {
+        let currentIndex = parseInt(fromArgs.current);
+        if (isNaN(currentIndex)) {
+            return;
+        }
+        const urls = fromArgs.urls;
+        if (!isArray(urls)) {
+            return;
+        }
+        const len = urls.length;
+        if (!len) {
+            return;
+        }
+        if (currentIndex < 0) {
+            currentIndex = 0;
+        }
+        else if (currentIndex >= len) {
+            currentIndex = len - 1;
+        }
+        if (currentIndex > 0) {
+            fromArgs.current = urls[currentIndex];
+            fromArgs.urls = urls.filter((item, index) => index < currentIndex ? item !== urls[currentIndex] : true);
+        }
+        else {
+            fromArgs.current = urls[0];
+        }
+        return {
+            indicator: false,
+            loop: false
+        };
+    }
+};
+
+function addSafeAreaInsets(result) {
+    if (result.safeArea) {
+        const safeArea = result.safeArea;
+        result.safeAreaInsets = {
+            top: safeArea.top,
+            left: safeArea.left,
+            right: result.windowWidth - safeArea.right,
+            bottom: result.windowHeight - safeArea.bottom
+        };
+    }
+}
+const getSystemInfo = {
+    returnValue: addSafeAreaInsets
+};
+const getSystemInfoSync = getSystemInfo;
+
+var protocols = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  getSystemInfo: getSystemInfo,
+  getSystemInfoSync: getSystemInfoSync,
+  previewImage: previewImage
+});
+
+var index = initUni({}, protocols);
+
+export default index;

packages/uni-mp-weixin/dist/uni.mp.esm.js

+import { hasOwn, isArray, isFunction, toNumber, isPlainObject, isObject, extend, NOOP } from '@vue/shared';
+
+function findHooks(vueOptions, hooks = new Set()) {
+    if (vueOptions) {
+        Object.keys(vueOptions).forEach(name => {
+            if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) {
+                hooks.add(name);
+            }
+        });
+        const { extends: extendsOptions, mixins } = vueOptions;
+        if (mixins) {
+            mixins.forEach(mixin => findHooks(mixin, hooks));
+        }
+        if (extendsOptions) {
+            findHooks(extendsOptions, hooks);
+        }
+    }
+    return hooks;
+}
+function initHook(mpOptions, hook) {
+    mpOptions[hook] = function (args) {
+        return this.$vm && this.$vm.$callHook(hook, args);
+    };
+}
+function initHooks(mpOptions, hooks) {
+    hooks.forEach(hook => initHook(mpOptions, hook));
+}
+function initUnknownHooks(mpOptions, vueOptions) {
+    findHooks(vueOptions).forEach(hook => {
+        if (!mpOptions[hook]) {
+            initHook(mpOptions, hook);
+        }
+    });
+}
+function initVueIds(vueIds, mpInstance) {
+    if (!vueIds) {
+        return;
+    }
+    const ids = vueIds.split(',');
+    const len = ids.length;
+    if (len === 1) {
+        mpInstance._$vueId = ids[0];
+    }
+    else if (len === 2) {
+        mpInstance._$vueId = ids[0];
+        mpInstance._$vuePid = ids[1];
+    }
+}
+function initMocks(instance, mpInstance, mocks) {
+    const ctx = instance.ctx;
+    mocks.forEach(mock => {
+        if (hasOwn(mpInstance, mock)) {
+            ctx[mock] = mpInstance[mock];
+        }
+    });
+}
+const EXTRAS = ['externalClasses'];
+function initExtraOptions(miniProgramComponentOptions, vueOptions) {
+    EXTRAS.forEach(name => {
+        if (hasOwn(vueOptions, name)) {
+            miniProgramComponentOptions[name] = vueOptions[name];
+        }
+    });
+}
+function initWxsCallMethods(methods, wxsCallMethods) {
+    if (!isArray(wxsCallMethods)) {
+        return;
+    }
+    wxsCallMethods.forEach((callMethod) => {
+        methods[callMethod] = function (args) {
+            return this.$vm[callMethod](args);
+        };
+    });
+}
+
+function setModel(target, key, value, modifiers) {
+    if (isArray(modifiers)) {
+        if (modifiers.indexOf('trim') !== -1) {
+            value = value.trim();
+        }
+        if (modifiers.indexOf('number') !== -1) {
+            value = toNumber(value);
+        }
+    }
+    if (!target) {
+        target = this;
+    }
+    target[key] = value;
+}
+function setSync(target, key, value) {
+    if (!target) {
+        target = this;
+    }
+    target[key] = value;
+}
+function getOrig(data) {
+    if (isPlainObject(data)) {
+        return data.$orig || data;
+    }
+    return data;
+}
+function map(val, iteratee) {
+    let ret, i, l, keys, key;
+    if (isArray(val)) {
+        ret = new Array(val.length);
+        for (i = 0, l = val.length; i < l; i++) {
+            ret[i] = iteratee(val[i], i);
+        }
+        return ret;
+    }
+    else if (isObject(val)) {
+        keys = Object.keys(val);
+        ret = Object.create(null);
+        for (i = 0, l = keys.length; i < l; i++) {
+            key = keys[i];
+            ret[key] = iteratee(val[key], key, i);
+        }
+        return ret;
+    }
+    return [];
+}
+const MP_METHODS = [
+    'createSelectorQuery',
+    'createIntersectionObserver',
+    'selectAllComponents',
+    'selectComponent'
+];
+function hasHook(name) {
+    const hooks = this.$[name];
+    if (hooks && hooks.length) {
+        return true;
+    }
+    return false;
+}
+function callHook(name, args) {
+    if (name === 'mounted') {
+        name = 'm';
+    }
+    const hooks = this.$[name];
+    let ret;
+    if (hooks) {
+        for (let i = 0; i < hooks.length; i++) {
+            ret = hooks[i](args);
+        }
+    }
+    return ret;
+}
+function createEmitFn(oldEmit, ctx) {
+    return function emit(event, ...args) {
+        if (ctx.$scope && event) {
+            ctx.$scope.triggerEvent(event, { __args__: args });
+        }
+        return oldEmit.apply(this, [event, ...args]);
+    };
+}
+function set(target, key, val) {
+    return (target[key] = val);
+}
+function initBaseInstance(instance, options) {
+    const ctx = instance.ctx;
+    // mp
+    ctx.mpType = options.mpType; // @deprecated
+    ctx.$mpType = options.mpType;
+    ctx.$scope = options.mpInstance;
+    // $vm
+    ctx.$scope.$vm = instance.proxy;
+    // slots
+    instance.slots = {};
+    if (isArray(options.slots) && options.slots.length) {
+        options.slots.forEach(name => {
+            instance.slots[name] = true;
+        });
+    }
+    if (__FEATURE_OPTIONS__) {
+        // $set
+        ctx.$set = set;
+    }
+    // $emit
+    instance.emit = createEmitFn(instance.emit, ctx);
+    // $callHook
+    ctx.$hasHook = hasHook;
+    ctx.$callHook = callHook;
+}
+function initComponentInstance(instance, options) {
+    initBaseInstance(instance, options);
+    const ctx = instance.ctx;
+    MP_METHODS.forEach(method => {
+        ctx[method] = function (...args) {
+            const mpInstance = ctx.$scope;
+            if (mpInstance && mpInstance[method]) {
+                return mpInstance[method].apply(mpInstance, args);
+            }
+        };
+    });
+    // TODO other
+    ctx.__set_model = setModel;
+    ctx.__set_sync = setSync;
+    ctx.__get_orig = getOrig;
+    // TODO
+    // ctx.__get_style = getStyle
+    ctx.__map = map;
+}
+
+const HOOKS = [
+    'onShow',
+    'onHide',
+    'onError',
+    'onThemeChange',
+    'onPageNotFound',
+    'onUnhandledRejection'
+];
+function parseApp(instance) {
+    const internalInstance = instance.$;
+    const appOptions = {
+        globalData: (instance.$options && instance.$options.globalData) || {},
+        onLaunch(options) {
+            if (this.$vm) {
+                // 已经初始化过了，主要是为了百度，百度 onShow 在 onLaunch 之前
+                return;
+            }
+            initBaseInstance(internalInstance, {
+                mpType: 'app',
+                mpInstance: this,
+                slots: []
+            });
+            const ctx = internalInstance.ctx;
+            ctx.globalData = this.globalData;
+            instance.$callHook('onLaunch', options);
+        }
+    };
+    const vueOptions = instance.$.type;
+    initHooks(appOptions, HOOKS);
+    initUnknownHooks(appOptions, vueOptions);
+    if (__FEATURE_OPTIONS__) {
+        const methods = vueOptions.methods;
+        methods && extend(appOptions, methods);
+    }
+    return appOptions;
+}
+
+const PROP_TYPES = [String, Number, Boolean, Object, Array, null];
+function createObserver(name) {
+    return function observer(newVal, oldVal) {
+        if (this.$vm) {
+            this.$vm.$.props[name] = newVal; // 为了触发其他非 render watcher
+        }
+    };
+}
+function parsePropType(key, type, defaultValue) {
+    // [String]=>String
+    if (isArray(type) && type.length === 1) {
+        return type[0];
+    }
+    return type;
+}
+function initDefaultProps(isBehavior = false) {
+    const properties = {};
+    if (!isBehavior) {
+        properties.vueId = {
+            type: String,
+            value: ''
+        };
+        // 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots
+        properties.vueSlots = {
+            type: null,
+            value: [],
+            observer: function (newVal, oldVal) {
+                const $slots = Object.create(null);
+                newVal.forEach((slotName) => {
+                    $slots[slotName] = true;
+                });
+                this.setData({
+                    $slots
+                });
+            }
+        };
+    }
+    return properties;
+}
+function initProps(miniProgramComponentOptions, rawProps, isBehavior = false) {
+    const properties = initDefaultProps(isBehavior);
+    if (isArray(rawProps)) {
+        rawProps.forEach(key => {
+            properties[key] = {
+                type: null,
+                observer: createObserver(key)
+            };
+        });
+    }
+    else if (isPlainObject(rawProps)) {
+        Object.keys(rawProps).forEach(key => {
+            const opts = rawProps[key];
+            if (isPlainObject(opts)) {
+                // title:{type:String,default:''}
+                let value = opts.default;
+                if (isFunction(value)) {
+                    value = value();
+                }
+                const type = opts.type;
+                opts.type = parsePropType(key, type);
+                properties[key] = {
+                    type: PROP_TYPES.indexOf(type) !== -1 ? type : null,
+                    value,
+                    observer: createObserver(key)
+                };
+            }
+            else {
+                // content:String
+                const type = parsePropType(key, opts);
+                properties[key] = {
+                    type: PROP_TYPES.indexOf(type) !== -1 ? type : null,
+                    observer: createObserver(key)
+                };
+            }
+        });
+    }
+    miniProgramComponentOptions.properties = properties;
+}
+
+function initData(vueOptions) {
+    let data = vueOptions.data || {};
+    if (typeof data === 'function') {
+        try {
+            const appConfig = getApp()
+                .$vm.$.appContext.config;
+            data = data.call(appConfig.globalProperties);
+        }
+        catch (e) {
+            if (process.env.VUE_APP_DEBUG) {
+                console.warn('根据 Vue 的 data 函数初始化小程序 data 失败，请尽量确保 data 函数中不访问 vm 对象，否则可能影响首次数据渲染速度。', data);
+            }
+        }
+    }
+    else {
+        try {
+            // 对 data 格式化
+            data = JSON.parse(JSON.stringify(data));
+        }
+        catch (e) { }
+    }
+    if (!isPlainObject(data)) {
+        data = {};
+    }
+    return data;
+}
+function initBehaviors(vueOptions, initBehavior) {
+    const vueBehaviors = vueOptions.behaviors;
+    const vueExtends = vueOptions.extends;
+    const vueMixins = vueOptions.mixins;
+    let vueProps = vueOptions.props;
+    if (!vueProps) {
+        vueOptions.props = vueProps = [];
+    }
+    const behaviors = [];
+    if (isArray(vueBehaviors)) {
+        vueBehaviors.forEach(behavior => {
+            behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`));
+            if (behavior === 'uni://form-field') {
+                if (isArray(vueProps)) {
+                    vueProps.push('name');
+                    vueProps.push('value');
+                }
+                else {
+                    vueProps.name = {
+                        type: String,
+                        default: ''
+                    };
+                    vueProps.value = {
+                        type: [String, Number, Boolean, Array, Object, Date],
+                        default: ''
+                    };
+                }
+            }
+        });
+    }
+    if (isPlainObject(vueExtends) && vueExtends.props) {
+        const behavior = {};
+        initProps(behavior, vueExtends.props, true);
+        behaviors.push(initBehavior(behavior));
+    }
+    if (isArray(vueMixins)) {
+        vueMixins.forEach(vueMixin => {
+            if (isPlainObject(vueMixin) && vueMixin.props) {
+                const behavior = {};
+                initProps(behavior, vueMixin.props, true);
+                behaviors.push(initBehavior(behavior));
+            }
+        });
+    }
+    return behaviors;
+}
+function applyOptions(miniProgramComponentOptions, vueOptions, initBehavior) {
+    miniProgramComponentOptions.data = initData(vueOptions);
+    miniProgramComponentOptions.behaviors = initBehaviors(vueOptions, initBehavior);
+}
+
+function getValue(obj, path) {
+    const parts = path.split('.');
+    let key = parts[0];
+    if (key.indexOf('__$n') === 0) {
+        //number index
+        key = parseInt(key.replace('__$n', ''));
+    }
+    if (parts.length === 1) {
+        return obj[key];
+    }
+    return getValue(obj[key], parts.slice(1).join('.'));
+}
+function getExtraValue(instance, dataPathsArray) {
+    let context = instance;
+    dataPathsArray.forEach(dataPathArray => {
+        const dataPath = dataPathArray[0];
+        const value = dataPathArray[2];
+        if (dataPath || typeof value !== 'undefined') {
+            // ['','',index,'disable']
+            const propPath = dataPathArray[1];
+            const valuePath = dataPathArray[3];
+            let vFor;
+            if (Number.isInteger(dataPath)) {
+                vFor = dataPath;
+            }
+            else if (!dataPath) {
+                vFor = context;
+            }
+            else if (typeof dataPath === 'string' && dataPath) {
+                if (dataPath.indexOf('#s#') === 0) {
+                    vFor = dataPath.substr(3);
+                }
+                else {
+                    vFor = getValue(context, dataPath);
+                }
+            }
+            if (Number.isInteger(vFor)) {
+                context = value;
+            }
+            else if (!propPath) {
+                context = vFor[value];
+            }
+            else {
+                if (isArray(vFor)) {
+                    context = vFor.find(vForItem => {
+                        return getValue(vForItem, propPath) === value;
+                    });
+                }
+                else if (isPlainObject(vFor)) {
+                    context = Object.keys(vFor).find(vForKey => {
+                        return getValue(vFor[vForKey], propPath) === value;
+                    });
+                }
+                else {
+                    console.error('v-for 暂不支持循环数据：', vFor);
+                }
+            }
+            if (valuePath) {
+                context = getValue(context, valuePath);
+            }
+        }
+    });
+    return context;
+}
+function processEventExtra(instance, extra, event) {
+    const extraObj = {};
+    if (isArray(extra) && extra.length) {
+        /**
+         *[
+         *    ['data.items', 'data.id', item.data.id],
+         *    ['metas', 'id', meta.id]
+         *],
+         *[
+         *    ['data.items', 'data.id', item.data.id],
+         *    ['metas', 'id', meta.id]
+         *],
+         *'test'
+         */
+        extra.forEach((dataPath, index) => {
+            if (typeof dataPath === 'string') {
+                if (!dataPath) {
+                    // model,prop.sync
+                    extraObj['$' + index] = instance;
+                }
+                else {
+                    if (dataPath === '$event') {
+                        // $event
+                        extraObj['$' + index] = event;
+                    }
+                    else if (dataPath === 'arguments') {
+                        if (event.detail && event.detail.__args__) {
+                            extraObj['$' + index] = event.detail.__args__;
+                        }
+                        else {
+                            extraObj['$' + index] = [event];
+                        }
+                    }
+                    else if (dataPath.indexOf('$event.') === 0) {
+                        // $event.target.value
+                        extraObj['$' + index] = getValue(event, dataPath.replace('$event.', ''));
+                    }
+                    else {
+                        extraObj['$' + index] = getValue(instance, dataPath);
+                    }
+                }
+            }
+            else {
+                extraObj['$' + index] = getExtraValue(instance, dataPath);
+            }
+        });
+    }
+    return extraObj;
+}
+function getObjByArray(arr) {
+    const obj = {};
+    for (let i = 1; i < arr.length; i++) {
+        const element = arr[i];
+        obj[element[0]] = element[1];
+    }
+    return obj;
+}
+function processEventArgs(instance, event, args = [], extra = [], isCustom, methodName) {
+    let isCustomMPEvent = false; // wxcomponent 组件，传递原始 event 对象
+    if (isCustom) {
+        // 自定义事件
+        isCustomMPEvent =
+            event.currentTarget &&
+                event.currentTarget.dataset &&
+                event.currentTarget.dataset.comType === 'wx';
+        if (!args.length) {
+            // 无参数，直接传入 event 或 detail 数组
+            if (isCustomMPEvent) {
+                return [event];
+            }
+            return event.detail.__args__ || event.detail;
+        }
+    }
+    const extraObj = processEventExtra(instance, extra, event);
+    const ret = [];
+    args.forEach(arg => {
+        if (arg === '$event') {
+            if (methodName === '__set_model' && !isCustom) {
+                // input v-model value
+                ret.push(event.target.value);
+            }
+            else {
+                if (isCustom && !isCustomMPEvent) {
+                    ret.push(event.detail.__args__[0]);
+                }
+                else {
+                    // wxcomponent 组件或内置组件
+                    ret.push(event);
+                }
+            }
+        }
+        else {
+            if (isArray(arg) && arg[0] === 'o') {
+                ret.push(getObjByArray(arg));
+            }
+            else if (typeof arg === 'string' && hasOwn(extraObj, arg)) {
+                ret.push(extraObj[arg]);
+            }
+            else {
+                ret.push(arg);
+            }
+        }
+    });
+    return ret;
+}
+function wrapper(event) {
+    event.stopPropagation = NOOP;
+    event.preventDefault = NOOP;
+    event.target = event.target || {};
+    if (!hasOwn(event, 'detail')) {
+        event.detail = {};
+    }
+    if (hasOwn(event, 'markerId')) {
+        event.detail = typeof event.detail === 'object' ? event.detail : {};
+        event.detail.markerId = event.markerId;
+    }
+    if (isPlainObject(event.detail)) {
+        event.target = Object.assign({}, event.target, event.detail);
+    }
+    return event;
+}
+const ONCE = '~';
+const CUSTOM = '^';
+function matchEventType(eventType, optType) {
+    return (eventType === optType ||
+        (optType === 'regionchange' &&
+            (eventType === 'begin' || eventType === 'end')));
+}
+function handleEvent(event) {
+    event = wrapper(event);
+    // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]]
+    const dataset = (event.currentTarget || event.target).dataset;
+    if (!dataset) {
+        return console.warn('事件信息不存在');
+    }
+    const eventOpts = (dataset.eventOpts ||
+        dataset['event-opts']); // 支付宝 web-view 组件 dataset 非驼峰
+    if (!eventOpts) {
+        return console.warn('事件信息不存在');
+    }
+    // [['handle',[1,2,a]],['handle1',[1,2,a]]]
+    const eventType = event.type;
+    const ret = [];
+    eventOpts.forEach((eventOpt) => {
+        let type = eventOpt[0];
+        const eventsArray = eventOpt[1];
+        const isCustom = type.charAt(0) === CUSTOM;
+        type = isCustom ? type.slice(1) : type;
+        const isOnce = type.charAt(0) === ONCE;
+        type = isOnce ? type.slice(1) : type;
+        if (eventsArray && matchEventType(eventType, type)) {
+            eventsArray.forEach((eventArray) => {
+                const methodName = eventArray[0];
+                if (methodName) {
+                    let handlerCtx = this.$vm;
+                    if (handlerCtx.$options.generic &&
+                        handlerCtx.$parent &&
+                        handlerCtx.$parent.$parent) {
+                        // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots
+                        handlerCtx = handlerCtx.$parent.$parent;
+                    }
+                    if (methodName === '$emit') {
+                        handlerCtx.$emit.apply(handlerCtx, processEventArgs(this.$vm, event, eventArray[1], eventArray[2], isCustom, methodName));
+                        return;
+                    }
+                    const handler = handlerCtx[methodName];
+                    if (!isFunction(handler)) {
+                        throw new Error(` _vm.${methodName} is not a function`);
+                    }
+                    if (isOnce) {
+                        if (handler.once) {
+                            return;
+                        }
+                        handler.once = true;
+                    }
+                    ret.push(handler.apply(handlerCtx, processEventArgs(this.$vm, event, eventArray[1], eventArray[2], isCustom, methodName)));
+                }
+            });
+        }
+    });
+    if (eventType === 'input' &&
+        ret.length === 1 &&
+        typeof ret[0] !== 'undefined') {
+        return ret[0];
+    }
+}
+
+function parseComponent(vueOptions, { mocks, isPage, initRefs, initRelation, initBehavior, handleLink }) {
+    vueOptions = vueOptions.default || vueOptions;
+    const options = {
+        multipleSlots: true,
+        addGlobalClass: true
+    };
+    if (vueOptions.options) {
+        extend(options, vueOptions.options);
+    }
+    const miniProgramComponentOptions = {
+        options,
+        lifetimes: {
+            attached() {
+                const properties = this.properties;
+                initVueIds(properties.vueId, this);
+                const relationOptions = {
+                    vuePid: this._$vuePid
+                };
+                // 处理父子关系
+                initRelation(this, relationOptions);
+                // TODO mp-toutiao
+                // 初始化 vue 实例
+                const mpInstance = this;
+                this.$vm = getApp().$vm.$createComponent({
+                    type: vueOptions,
+                    props: properties
+                }, {
+                    mpType: isPage(mpInstance) ? 'page' : 'component',
+                    mpInstance,
+                    slots: properties.vueSlots,
+                    parentComponent: relationOptions.parent && relationOptions.parent.$,
+                    onBeforeSetup(instance, options) {
+                        initRefs(instance, mpInstance);
+                        initMocks(instance, mpInstance, mocks);
+                        initComponentInstance(instance, options);
+                    }
+                });
+            },
+            ready() {
+                // 当组件 props 默认值为 true，初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发
+                // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800
+                if (this.$vm) {
+                    this.$vm.$callHook('mounted');
+                    this.$vm.$callHook('onReady');
+                }
+            },
+            detached() {
+                getApp().$vm.$destroyComponent(this.$vm);
+            }
+        },
+        pageLifetimes: {
+            show() {
+                this.$vm && this.$vm.$callHook('onPageShow');
+            },
+            hide() {
+                this.$vm && this.$vm.$callHook('onPageHide');
+            },
+            resize(size) {
+                this.$vm && this.$vm.$callHook('onPageResize', size);
+            }
+        },
+        methods: {
+            __l: handleLink,
+            __e: handleEvent
+        }
+    };
+    if (__FEATURE_OPTIONS__) {
+        applyOptions(miniProgramComponentOptions, vueOptions, initBehavior);
+    }
+    initProps(miniProgramComponentOptions, vueOptions.props, false);
+    initExtraOptions(miniProgramComponentOptions, vueOptions);
+    initWxsCallMethods(miniProgramComponentOptions.methods, vueOptions.wxsCallMethods);
+    return miniProgramComponentOptions;
+}
+
+const HOOKS$1 = [
+    'onLoad',
+    'onShow',
+    'onReady',
+    'onHide',
+    'onUnload',
+    'onResize',
+    // 'onPageScroll', // 影响性能，开发者手动注册
+    'onTabItemTap',
+    'onReachBottom',
+    'onPullDownRefresh',
+    // 'onShareTimeline', // 右上角菜单，开发者手动注册
+    'onAddToFavorites'
+    // 'onShareAppMessage' // 右上角菜单，开发者手动注册
+];
+function parsePage(vueOptions, parseOptions) {
+    const miniProgramPageOptions = parseComponent(vueOptions, parseOptions);
+    initHooks(miniProgramPageOptions.methods, HOOKS$1);
+    initUnknownHooks(miniProgramPageOptions.methods, vueOptions);
+    return miniProgramPageOptions;
+}
+
+function createApp(vm) {
+    return App(parseApp(vm));
+}
+
+const mocks = ['__route__', '__wxExparserNodeId__', '__wxWebviewId__'];
+function findVmByVueId(instance, vuePid) {
+    // TODO vue3 中 没有 $children
+    const $children = instance.$children;
+    // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200)
+    for (let i = $children.length - 1; i >= 0; i--) {
+        const childVm = $children[i];
+        if (childVm.$scope._$vueId === vuePid) {
+            return childVm;
+        }
+    }
+    // 反向递归查找
+    let parentVm;
+    for (let i = $children.length - 1; i >= 0; i--) {
+        parentVm = findVmByVueId($children[i], vuePid);
+        if (parentVm) {
+            return parentVm;
+        }
+    }
+}
+function initBehavior(options) {
+    return Behavior(options);
+}
+function isPage(mpInstance) {
+    return !!mpInstance.route;
+}
+function initRelation(mpInstance, detail) {
+    mpInstance.triggerEvent('__l', detail);
+}
+function initRefs(instance, mpInstance) {
+    // TODO
+    Object.defineProperty(instance.ctx, '$refs', {
+        get() {
+            const $refs = {};
+            const components = mpInstance.selectAllComponents('.vue-ref');
+            components.forEach(component => {
+                const ref = component.dataset.ref;
+                $refs[ref] = component.$vm || component;
+            });
+            const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for');
+            forComponents.forEach(component => {
+                const ref = component.dataset.ref;
+                if (!$refs[ref]) {
+                    $refs[ref] = [];
+                }
+                $refs[ref].push(component.$vm || component);
+            });
+            return $refs;
+        }
+    });
+}
+function handleLink(event) {
+    // detail 是微信,value 是百度(dipatch)
+    const detail = (event.detail ||
+        event.value);
+    const vuePid = detail.vuePid;
+    let parentVm;
+    if (vuePid) {
+        parentVm = findVmByVueId(this.$vm, vuePid);
+    }
+    if (!parentVm) {
+        parentVm = this.$vm;
+    }
+    detail.parent = parentVm;
+}
+
+var parseOptions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  mocks: mocks,
+  initBehavior: initBehavior,
+  isPage: isPage,
+  initRelation: initRelation,
+  initRefs: initRefs,
+  handleLink: handleLink
+});
+
+function createPage(vuePageOptions) {
+    return Component(parsePage(vuePageOptions, parseOptions));
+}
+
+function createComponent(vueComponentOptions) {
+    return Component(parseComponent(vueComponentOptions, parseOptions));
+}
+
+export { createApp, createComponent, createPage };

packages/vue-cli-plugin-uni/generator.js

@@ -17,8 +17,8 @@ module.exports = (api, options, rootOptions) => {
         'dev:mp-alipay': 'cross-env NODE_ENV=development UNI_PLATFORM=mp-alipay vue-cli-service uni-build --watch',
         'dev:mp-toutiao': 'cross-env NODE_ENV=development UNI_PLATFORM=mp-toutiao vue-cli-service uni-build --watch',
         'dev:quickapp-native': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-native vue-cli-service uni-build --watch',
-        'dev:quickapp-webview': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-webview vue-cli-service uni-build --watch',
-        'dev:quickapp-webview-huawei': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-webview-huawei vue-cli-service uni-build --watch',
+        'dev:quickapp-webview': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-webview vue-cli-service uni-build --watch',
+        'dev:quickapp-webview-huawei': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-webview-huawei vue-cli-service uni-build --watch',
         'dev:quickapp-webview-union': 'cross-env NODE_ENV=development UNI_PLATFORM=quickapp-webview-union vue-cli-service uni-build --watch',
         'build:h5': 'cross-env NODE_ENV=production UNI_PLATFORM=h5 vue-cli-service uni-build',
         'build:mp-qq': 'cross-env NODE_ENV=production UNI_PLATFORM=mp-qq vue-cli-service uni-build',
@@ -27,15 +27,15 @@ module.exports = (api, options, rootOptions) => {
         'build:mp-alipay': 'cross-env NODE_ENV=production UNI_PLATFORM=mp-alipay vue-cli-service uni-build',
         'build:mp-toutiao': 'cross-env NODE_ENV=production UNI_PLATFORM=mp-toutiao vue-cli-service uni-build',
         'build:quickapp-native': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-native vue-cli-service uni-build',
-        'build:quickapp-webview': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview vue-cli-service uni-build',
-        'build:quickapp-webview-huawei': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview-huawei vue-cli-service uni-build',
-        'build:quickapp-webview-union': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview-union vue-cli-service uni-build',
-        'dev:mp-360': 'cross-env NODE_ENV=development UNI_PLATFORM=mp-360 vue-cli-service uni-build --watch',
+        'build:quickapp-webview': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview vue-cli-service uni-build',
+        'build:quickapp-webview-huawei': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview-huawei vue-cli-service uni-build',
+        'build:quickapp-webview-union': 'cross-env NODE_ENV=production UNI_PLATFORM=quickapp-webview-union vue-cli-service uni-build',
+        'dev:mp-360': 'cross-env NODE_ENV=development UNI_PLATFORM=mp-360 vue-cli-service uni-build --watch',
         'build:mp-360': 'cross-env NODE_ENV=production UNI_PLATFORM=mp-360 vue-cli-service uni-build',
         'dev:custom': 'cross-env NODE_ENV=development uniapp-cli custom',
         'build:custom': 'cross-env NODE_ENV=production uniapp-cli custom',
-        'test:h5': 'cross-env UNI_PLATFORM=h5 jest -i',
-        'test:ios': 'cross-env UNI_PLATFORM=app-plus UNI_OS_NAME=ios jest -i',
+        'test:h5': 'cross-env UNI_PLATFORM=h5 jest -i',
+        'test:ios': 'cross-env UNI_PLATFORM=app-plus UNI_OS_NAME=ios jest -i',
         'test:android': 'cross-env UNI_PLATFORM=app-plus UNI_OS_NAME=android jest -i',
         'test:mp-weixin': 'cross-env UNI_PLATFORM=mp-weixin jest -i',
         'test:mp-baidu': 'cross-env UNI_PLATFORM=mp-baidu jest -i'
@@ -46,15 +46,17 @@ module.exports = (api, options, rootOptions) => {
       dependencies: {
         '@dcloudio/uni-app-plus': version,
         '@dcloudio/uni-h5': version,
+        '@dcloudio/uni-mp-vue': version,
         '@dcloudio/uni-mp-qq': version,
         '@dcloudio/uni-mp-weixin': version,
         '@dcloudio/uni-mp-baidu': version,
         '@dcloudio/uni-mp-alipay': version,
-        '@dcloudio/uni-mp-toutiao': version,
-        '@dcloudio/uni-mp-360': version,
+        '@dcloudio/uni-mp-toutiao': version,
+        '@dcloudio/uni-mp-360': version,
         '@dcloudio/uni-quickapp-native': version,
         '@dcloudio/uni-quickapp-webview': version,
         '@dcloudio/uni-stat': version,
+        '@vue/shared': 'latest', // TODO
         flyio: '^0.6.2',
         vuex: '^3.2.0'
       },

packages/vue-cli-plugin-uni/lib/chain-webpack.js

@@ -91,6 +91,7 @@ module.exports = function chainWebpack (platformOptions, vueOptions, api) {
     platformOptions.chainWebpack(webpackConfig, vueOptions, api)
     // define
     const defines = {
+      __FEATURE_OPTIONS__: JSON.stringify(process.env.UNI_USING_VUE3_OPTIONS === 'true'),
       'process.env.UNI_ENV': JSON.stringify(process.env.UNI_PLATFORM),
       'process.env.UNI_CLOUD_PROVIDER': process.env.UNI_CLOUD_PROVIDER,
       'process.env.HBX_USER_TOKEN': JSON.stringify(process.env.HBX_USER_TOKEN || ''),

packages/vue-cli-plugin-uni/lib/mp/index.js

@@ -22,13 +22,18 @@ function createUniMPPlugin () {
 }
 
 function getProvides () {
-  const uniPath = require.resolve('@dcloudio/uni-' + process.env.UNI_PLATFORM)
+  const uniPath = require('@dcloudio/uni-cli-shared/lib/platform').getMPRuntimePath()
   const uniCloudPath = path.resolve(__dirname, '../../packages/uni-cloud/dist/index.js')
   const provides = {
     uni: [uniPath, 'default'],
     uniCloud: [uniCloudPath, 'default']
   }
 
+  if (process.env.UNI_USING_VUE3) {
+    provides.uni = ['@dcloudio/uni-' + process.env.UNI_PLATFORM + '/dist/uni.api.esm.js', 'default']
+    provides.createMiniProgramApp = [uniPath, 'createApp']
+  }
+
   if (process.env.UNI_USING_COMPONENTS) {
     provides.createApp = [uniPath, 'createApp']
     provides.createPage = [uniPath, 'createPage']

packages/webpack-uni-mp-loader/lib/plugin/generate-component.js

@@ -15,7 +15,7 @@ const {
 
 const EMPTY_COMPONENT_LEN = 'Component({})'.length
 
-const uniPath = normalizePath(require.resolve('@dcloudio/uni-' + process.env.UNI_PLATFORM))
+const uniPath = require('@dcloudio/uni-cli-shared/lib/platform').getMPRuntimePath()
 
 function findModule (modules, resource, altResource) {
   return modules.find(