vue 2.7.13 → 2.7.15

package/dist/vue.js

@@ -1,6 +1,6 @@
 /*!
- * Vue.js v2.7.13
- * (c) 2014-2022 Evan You
+ * Vue.js v2.7.15
+ * (c) 2014-2023 Evan You
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -246,9 +246,7 @@
    */
   function genStaticKeys$1(modules) {
       return modules
-          .reduce(function (keys, m) {
-          return keys.concat(m.staticKeys || []);
-      }, [])
+          .reduce(function (keys, m) { return keys.concat(m.staticKeys || []); }, [])
           .join(',');
   }
   /**
@@ -881,79 +879,8 @@
       });
   });
 
-  var rawMap = new WeakMap();
-  function reactive(target) {
-      makeReactive(target, false);
-      return target;
-  }
-  /**
-   * Return a shallowly-reactive copy of the original object, where only the root
-   * level properties are reactive. It also does not auto-unwrap refs (even at the
-   * root level).
-   */
-  function shallowReactive(target) {
-      makeReactive(target, true);
-      def(target, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true);
-      return target;
-  }
-  function makeReactive(target, shallow) {
-      // if trying to observe a readonly proxy, return the readonly version.
-      if (!isReadonly(target)) {
-          {
-              if (isArray(target)) {
-                  warn$2("Avoid using Array as root value for ".concat(shallow ? "shallowReactive()" : "reactive()", " as it cannot be tracked in watch() or watchEffect(). Use ").concat(shallow ? "shallowRef()" : "ref()", " instead. This is a Vue-2-only limitation."));
-              }
-              var existingOb = target && target.__ob__;
-              if (existingOb && existingOb.shallow !== shallow) {
-                  warn$2("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow."));
-              }
-          }
-          var ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */);
-          if (!ob) {
-              if (target == null || isPrimitive(target)) {
-                  warn$2("value cannot be made reactive: ".concat(String(target)));
-              }
-              if (isCollectionType(target)) {
-                  warn$2("Vue 2 does not support reactive collection types such as Map or Set.");
-              }
-          }
-      }
-  }
-  function isReactive(value) {
-      if (isReadonly(value)) {
-          return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
-      }
-      return !!(value && value.__ob__);
-  }
-  function isShallow(value) {
-      return !!(value && value.__v_isShallow);
-  }
-  function isReadonly(value) {
-      return !!(value && value.__v_isReadonly);
-  }
-  function isProxy(value) {
-      return isReactive(value) || isReadonly(value);
-  }
-  function toRaw(observed) {
-      var raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
-      return raw ? toRaw(raw) : observed;
-  }
-  function markRaw(value) {
-      if (isObject(value)) {
-          rawMap.set(value, true);
-      }
-      return value;
-  }
-  /**
-   * @internal
-   */
-  function isCollectionType(value) {
-      var type = toRawType(value);
-      return (type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet');
-  }
-
   var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
-  var NO_INIITIAL_VALUE = {};
+  var NO_INITIAL_VALUE = {};
   /**
    * In some cases we may want to disable observation inside a component's
    * update computation.
@@ -1012,7 +939,7 @@
               var keys = Object.keys(value);
               for (var i = 0; i < keys.length; i++) {
                   var key = keys[i];
-                  defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock);
+                  defineReactive(value, key, NO_INITIAL_VALUE, undefined, shallow, mock);
               }
           }
       }
@@ -1041,7 +968,6 @@
           (isArray(value) || isPlainObject(value)) &&
           Object.isExtensible(value) &&
           !value.__v_skip /* ReactiveFlags.SKIP */ &&
-          !rawMap.has(value) &&
           !isRef(value) &&
           !(value instanceof VNode)) {
           return new Observer(value, shallow, ssrMockReactivity);
@@ -1060,7 +986,7 @@
       var getter = property && property.get;
       var setter = property && property.set;
       if ((!getter || setter) &&
-          (val === NO_INIITIAL_VALUE || arguments.length === 2)) {
+          (val === NO_INITIAL_VALUE || arguments.length === 2)) {
           val = obj[key];
       }
       var childOb = !shallow && observe(val, false, mock);
@@ -1214,6 +1140,77 @@
       }
   }
 
+  function reactive(target) {
+      makeReactive(target, false);
+      return target;
+  }
+  /**
+   * Return a shallowly-reactive copy of the original object, where only the root
+   * level properties are reactive. It also does not auto-unwrap refs (even at the
+   * root level).
+   */
+  function shallowReactive(target) {
+      makeReactive(target, true);
+      def(target, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true);
+      return target;
+  }
+  function makeReactive(target, shallow) {
+      // if trying to observe a readonly proxy, return the readonly version.
+      if (!isReadonly(target)) {
+          {
+              if (isArray(target)) {
+                  warn$2("Avoid using Array as root value for ".concat(shallow ? "shallowReactive()" : "reactive()", " as it cannot be tracked in watch() or watchEffect(). Use ").concat(shallow ? "shallowRef()" : "ref()", " instead. This is a Vue-2-only limitation."));
+              }
+              var existingOb = target && target.__ob__;
+              if (existingOb && existingOb.shallow !== shallow) {
+                  warn$2("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow."));
+              }
+          }
+          var ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */);
+          if (!ob) {
+              if (target == null || isPrimitive(target)) {
+                  warn$2("value cannot be made reactive: ".concat(String(target)));
+              }
+              if (isCollectionType(target)) {
+                  warn$2("Vue 2 does not support reactive collection types such as Map or Set.");
+              }
+          }
+      }
+  }
+  function isReactive(value) {
+      if (isReadonly(value)) {
+          return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
+      }
+      return !!(value && value.__ob__);
+  }
+  function isShallow(value) {
+      return !!(value && value.__v_isShallow);
+  }
+  function isReadonly(value) {
+      return !!(value && value.__v_isReadonly);
+  }
+  function isProxy(value) {
+      return isReactive(value) || isReadonly(value);
+  }
+  function toRaw(observed) {
+      var raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
+      return raw ? toRaw(raw) : observed;
+  }
+  function markRaw(value) {
+      // non-extensible objects won't be observed anyway
+      if (Object.isExtensible(value)) {
+          def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
+      }
+      return value;
+  }
+  /**
+   * @internal
+   */
+  function isCollectionType(value) {
+      var type = toRawType(value);
+      return (type === 'Map' || type === 'WeakMap' || type === 'Set' || type === 'WeakSet');
+  }
+
   /**
    * @internal
    */
@@ -1349,8 +1346,8 @@
       return ref;
   }
 
-  var rawToReadonlyMap = new WeakMap();
-  var rawToShallowReadonlyMap = new WeakMap();
+  var rawToReadonlyFlag = "__v_rawToReadonly";
+  var rawToShallowReadonlyFlag = "__v_rawToShallowReadonly";
   function readonly(target) {
       return createReadonly(target, false);
   }
@@ -1369,18 +1366,21 @@
           }
           return target;
       }
+      if (!Object.isExtensible(target)) {
+          warn$2("Vue 2 does not support creating readonly proxy for non-extensible object.");
+      }
       // already a readonly object
       if (isReadonly(target)) {
           return target;
       }
       // already has a readonly proxy
-      var map = shallow ? rawToShallowReadonlyMap : rawToReadonlyMap;
-      var existingProxy = map.get(target);
+      var existingFlag = shallow ? rawToShallowReadonlyFlag : rawToReadonlyFlag;
+      var existingProxy = target[existingFlag];
       if (existingProxy) {
           return existingProxy;
       }
       var proxy = Object.create(Object.getPrototypeOf(target));
-      map.set(target, proxy);
+      def(target, existingFlag, proxy);
       def(proxy, "__v_isReadonly" /* ReactiveFlags.IS_READONLY */, true);
       def(proxy, "__v_raw" /* ReactiveFlags.RAW */, target);
       if (isRef(target)) {
@@ -2791,6 +2791,112 @@
       };
   }
 
+  var activeEffectScope;
+  var EffectScope = /** @class */ (function () {
+      function EffectScope(detached) {
+          if (detached === void 0) { detached = false; }
+          this.detached = detached;
+          /**
+           * @internal
+           */
+          this.active = true;
+          /**
+           * @internal
+           */
+          this.effects = [];
+          /**
+           * @internal
+           */
+          this.cleanups = [];
+          this.parent = activeEffectScope;
+          if (!detached && activeEffectScope) {
+              this.index =
+                  (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
+          }
+      }
+      EffectScope.prototype.run = function (fn) {
+          if (this.active) {
+              var currentEffectScope = activeEffectScope;
+              try {
+                  activeEffectScope = this;
+                  return fn();
+              }
+              finally {
+                  activeEffectScope = currentEffectScope;
+              }
+          }
+          else {
+              warn$2("cannot run an inactive effect scope.");
+          }
+      };
+      /**
+       * This should only be called on non-detached scopes
+       * @internal
+       */
+      EffectScope.prototype.on = function () {
+          activeEffectScope = this;
+      };
+      /**
+       * This should only be called on non-detached scopes
+       * @internal
+       */
+      EffectScope.prototype.off = function () {
+          activeEffectScope = this.parent;
+      };
+      EffectScope.prototype.stop = function (fromParent) {
+          if (this.active) {
+              var i = void 0, l = void 0;
+              for (i = 0, l = this.effects.length; i < l; i++) {
+                  this.effects[i].teardown();
+              }
+              for (i = 0, l = this.cleanups.length; i < l; i++) {
+                  this.cleanups[i]();
+              }
+              if (this.scopes) {
+                  for (i = 0, l = this.scopes.length; i < l; i++) {
+                      this.scopes[i].stop(true);
+                  }
+              }
+              // nested scope, dereference from parent to avoid memory leaks
+              if (!this.detached && this.parent && !fromParent) {
+                  // optimized O(1) removal
+                  var last = this.parent.scopes.pop();
+                  if (last && last !== this) {
+                      this.parent.scopes[this.index] = last;
+                      last.index = this.index;
+                  }
+              }
+              this.parent = undefined;
+              this.active = false;
+          }
+      };
+      return EffectScope;
+  }());
+  function effectScope(detached) {
+      return new EffectScope(detached);
+  }
+  /**
+   * @internal
+   */
+  function recordEffectScope(effect, scope) {
+      if (scope === void 0) { scope = activeEffectScope; }
+      if (scope && scope.active) {
+          scope.effects.push(effect);
+      }
+  }
+  function getCurrentScope() {
+      return activeEffectScope;
+  }
+  function onScopeDispose(fn) {
+      if (activeEffectScope) {
+          activeEffectScope.cleanups.push(fn);
+      }
+      else {
+          warn$2("onScopeDispose() is called when there is no active effect scope" +
+              " to be associated with.");
+      }
+  }
+
   var activeInstance = null;
   var isUpdatingChildComponent = false;
   function setActiveInstance(vm) {
@@ -3093,7 +3199,8 @@
       if (setContext === void 0) { setContext = true; }
       // #7573 disable dep collection when invoking lifecycle hooks
       pushTarget();
-      var prev = currentInstance;
+      var prevInst = currentInstance;
+      var prevScope = getCurrentScope();
       setContext && setCurrentInstance(vm);
       var handlers = vm.$options[hook];
       var info = "".concat(hook, " hook");
@@ -3105,7 +3212,10 @@
       if (vm._hasHookEvent) {
           vm.$emit('hook:' + hook);
       }
-      setContext && setCurrentInstance(prev);
+      if (setContext) {
+          setCurrentInstance(prevInst);
+          prevScope && prevScope.on();
+      }
       popTarget();
   }
 
@@ -3491,112 +3601,6 @@
       };
   }
 
-  var activeEffectScope;
-  var EffectScope = /** @class */ (function () {
-      function EffectScope(detached) {
-          if (detached === void 0) { detached = false; }
-          this.detached = detached;
-          /**
-           * @internal
-           */
-          this.active = true;
-          /**
-           * @internal
-           */
-          this.effects = [];
-          /**
-           * @internal
-           */
-          this.cleanups = [];
-          this.parent = activeEffectScope;
-          if (!detached && activeEffectScope) {
-              this.index =
-                  (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
-          }
-      }
-      EffectScope.prototype.run = function (fn) {
-          if (this.active) {
-              var currentEffectScope = activeEffectScope;
-              try {
-                  activeEffectScope = this;
-                  return fn();
-              }
-              finally {
-                  activeEffectScope = currentEffectScope;
-              }
-          }
-          else {
-              warn$2("cannot run an inactive effect scope.");
-          }
-      };
-      /**
-       * This should only be called on non-detached scopes
-       * @internal
-       */
-      EffectScope.prototype.on = function () {
-          activeEffectScope = this;
-      };
-      /**
-       * This should only be called on non-detached scopes
-       * @internal
-       */
-      EffectScope.prototype.off = function () {
-          activeEffectScope = this.parent;
-      };
-      EffectScope.prototype.stop = function (fromParent) {
-          if (this.active) {
-              var i = void 0, l = void 0;
-              for (i = 0, l = this.effects.length; i < l; i++) {
-                  this.effects[i].teardown();
-              }
-              for (i = 0, l = this.cleanups.length; i < l; i++) {
-                  this.cleanups[i]();
-              }
-              if (this.scopes) {
-                  for (i = 0, l = this.scopes.length; i < l; i++) {
-                      this.scopes[i].stop(true);
-                  }
-              }
-              // nested scope, dereference from parent to avoid memory leaks
-              if (!this.detached && this.parent && !fromParent) {
-                  // optimized O(1) removal
-                  var last = this.parent.scopes.pop();
-                  if (last && last !== this) {
-                      this.parent.scopes[this.index] = last;
-                      last.index = this.index;
-                  }
-              }
-              this.parent = undefined;
-              this.active = false;
-          }
-      };
-      return EffectScope;
-  }());
-  function effectScope(detached) {
-      return new EffectScope(detached);
-  }
-  /**
-   * @internal
-   */
-  function recordEffectScope(effect, scope) {
-      if (scope === void 0) { scope = activeEffectScope; }
-      if (scope && scope.active) {
-          scope.effects.push(effect);
-      }
-  }
-  function getCurrentScope() {
-      return activeEffectScope;
-  }
-  function onScopeDispose(fn) {
-      if (activeEffectScope) {
-          activeEffectScope.cleanups.push(fn);
-      }
-      else {
-          warn$2("onScopeDispose() is called when there is no active effect scope" +
-              " to be associated with.");
-      }
-  }
-
   function provide(key, value) {
       if (!currentInstance) {
           {
@@ -3891,7 +3895,7 @@
       suspensible = _b === void 0 ? false : _b, // in Vue 3 default is true
       userOnError = source.onError;
       if (suspensible) {
-          warn$2("The suspensiblbe option for async components is not supported in Vue2. It is ignored.");
+          warn$2("The suspensible option for async components is not supported in Vue2. It is ignored.");
       }
       var pendingRequest = null;
       var retries = 0;
@@ -3994,7 +3998,7 @@
   /**
    * Note: also update dist/vue.runtime.mjs when adding new exports to this file.
    */
-  var version = '2.7.13';
+  var version = '2.7.15';
   /**
    * @internal type is manually declared in <root>/types/v3-define-component.d.ts
    */
@@ -5196,7 +5200,8 @@
   /**
    * Helper that recursively merges two data objects together.
    */
-  function mergeData(to, from) {
+  function mergeData(to, from, recursive) {
+      if (recursive === void 0) { recursive = true; }
       if (!from)
           return to;
       var key, toVal, fromVal;
@@ -5210,7 +5215,7 @@
               continue;
           toVal = to[key];
           fromVal = from[key];
-          if (!hasOwn(to, key)) {
+          if (!recursive || !hasOwn(to, key)) {
               set(to, key, fromVal);
           }
           else if (toVal !== fromVal &&
@@ -5370,7 +5375,19 @@
                           extend(ret, childVal);
                       return ret;
                   };
-  strats.provide = mergeDataOrFn;
+  strats.provide = function (parentVal, childVal) {
+      if (!parentVal)
+          return childVal;
+      return function () {
+          var ret = Object.create(null);
+          mergeData(ret, isFunction(parentVal) ? parentVal.call(this) : parentVal);
+          if (childVal) {
+              mergeData(ret, isFunction(childVal) ? childVal.call(this) : childVal, false // non-recursive
+              );
+          }
+          return ret;
+      };
+  };
   /**
    * Default strategy.
    */
@@ -6251,7 +6268,7 @@
       }
       var el = document.createElement(tag);
       if (tag.indexOf('-') > -1) {
-          // http://stackoverflow.com/a/28210364/1070244
+          // https://stackoverflow.com/a/28210364/1070244
           return (unknownElementCache[tag] =
               el.constructor === window.HTMLUnknownElement ||
                   el.constructor === window.HTMLElement);
@@ -7126,8 +7143,11 @@
                               var insert_1 = ancestor.data.hook.insert;
                               if (insert_1.merged) {
                                   // start at index 1 to avoid re-invoking component mounted hook
-                                  for (var i_10 = 1; i_10 < insert_1.fns.length; i_10++) {
-                                      insert_1.fns[i_10]();
+                                  // clone insert hooks to avoid being mutated during iteration.
+                                  // e.g. for customed directives under transition group.
+                                  var cloned = insert_1.fns.slice(1);
+                                  for (var i_10 = 0; i_10 < cloned.length; i_10++) {
+                                      cloned[i_10]();
                                   }
                               }
                           }
@@ -9516,7 +9536,7 @@
                           return "continue";
                       }
                   }
-                  // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+                  // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
                   if (conditionalComment.test(html)) {
                       var conditionalEnd = html.indexOf(']>');
                       if (conditionalEnd >= 0) {
@@ -11124,7 +11144,7 @@
           !el.key) {
           state.warn("<".concat(el.tag, " v-for=\"").concat(alias, " in ").concat(exp, "\">: component lists rendered with ") +
               "v-for should have explicit keys. " +
-              "See https://vuejs.org/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
+              "See https://v2.vuejs.org/v2/guide/list.html#key for more info.", el.rawAttrsMap['v-for'], true /* tip */);
       }
       el.forProcessed = true; // avoid recursion
       return ("".concat(altHelper || '_l', "((").concat(exp, "),") +