@onereach/ui-components 2.65.0-beta.1963.0 → 2.65.0-beta.1964.0

package/dist/bundled/v3/reactivity.esm-bundler-942db00f.js

@@ -1,957 +0,0 @@
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- * IMPORTANT: all calls of this function must be prefixed with
- * \/\*#\_\_PURE\_\_\*\/
- * So that rollup can tree-shake them if necessary.
- */
-function makeMap(str, expectsLowerCase) {
-  const map = Object.create(null);
-  const list = str.split(',');
-  for (let i = 0; i < list.length; i++) {
-    map[list[i]] = true;
-  }
-  return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
-}
-function normalizeStyle(value) {
-  if (isArray(value)) {
-    const res = {};
-    for (let i = 0; i < value.length; i++) {
-      const item = value[i];
-      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
-      if (normalized) {
-        for (const key in normalized) {
-          res[key] = normalized[key];
-        }
-      }
-    }
-    return res;
-  } else if (isString(value)) {
-    return value;
-  } else if (isObject(value)) {
-    return value;
-  }
-}
-const listDelimiterRE = /;(?![^(]*\))/g;
-const propertyDelimiterRE = /:(.+)/;
-function parseStringStyle(cssText) {
-  const ret = {};
-  cssText.split(listDelimiterRE).forEach(item => {
-    if (item) {
-      const tmp = item.split(propertyDelimiterRE);
-      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
-    }
-  });
-  return ret;
-}
-function normalizeClass(value) {
-  let res = '';
-  if (isString(value)) {
-    res = value;
-  } else if (isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      const normalized = normalizeClass(value[i]);
-      if (normalized) {
-        res += normalized + ' ';
-      }
-    }
-  } else if (isObject(value)) {
-    for (const name in value) {
-      if (value[name]) {
-        res += name + ' ';
-      }
-    }
-  }
-  return res.trim();
-}
-const EMPTY_OBJ = {};
-const NOOP = () => {};
-/**
- * Always return false.
- */
-const NO = () => false;
-const onRE = /^on[^a-z]/;
-const isOn = key => onRE.test(key);
-const extend = Object.assign;
-const remove = (arr, el) => {
-  const i = arr.indexOf(el);
-  if (i > -1) {
-    arr.splice(i, 1);
-  }
-};
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-const hasOwn = (val, key) => hasOwnProperty.call(val, key);
-const isArray = Array.isArray;
-const isMap = val => toTypeString(val) === '[object Map]';
-const isSet = val => toTypeString(val) === '[object Set]';
-const isFunction = val => typeof val === 'function';
-const isString = val => typeof val === 'string';
-const isSymbol = val => typeof val === 'symbol';
-const isObject = val => val !== null && typeof val === 'object';
-const isPromise = val => {
-  return isObject(val) && isFunction(val.then) && isFunction(val.catch);
-};
-const objectToString = Object.prototype.toString;
-const toTypeString = value => objectToString.call(value);
-const toRawType = value => {
-  // extract "RawType" from strings like "[object RawType]"
-  return toTypeString(value).slice(8, -1);
-};
-const isPlainObject = val => toTypeString(val) === '[object Object]';
-const isIntegerKey = key => isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;
-// compare whether a value has changed, accounting for NaN.
-const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
-
-let activeEffectScope;
-function recordEffectScope(effect, scope = activeEffectScope) {
-  if (scope && scope.active) {
-    scope.effects.push(effect);
-  }
-}
-const createDep = effects => {
-  const dep = new Set(effects);
-  dep.w = 0;
-  dep.n = 0;
-  return dep;
-};
-const wasTracked = dep => (dep.w & trackOpBit) > 0;
-const newTracked = dep => (dep.n & trackOpBit) > 0;
-const initDepMarkers = ({
-  deps
-}) => {
-  if (deps.length) {
-    for (let i = 0; i < deps.length; i++) {
-      deps[i].w |= trackOpBit; // set was tracked
-    }
-  }
-};
-
-const finalizeDepMarkers = effect => {
-  const {
-    deps
-  } = effect;
-  if (deps.length) {
-    let ptr = 0;
-    for (let i = 0; i < deps.length; i++) {
-      const dep = deps[i];
-      if (wasTracked(dep) && !newTracked(dep)) {
-        dep.delete(effect);
-      } else {
-        deps[ptr++] = dep;
-      }
-      // clear bits
-      dep.w &= ~trackOpBit;
-      dep.n &= ~trackOpBit;
-    }
-    deps.length = ptr;
-  }
-};
-const targetMap = new WeakMap();
-// The number of effects currently being tracked recursively.
-let effectTrackDepth = 0;
-let trackOpBit = 1;
-/**
- * The bitwise track markers support at most 30 levels of recursion.
- * This value is chosen to enable modern JS engines to use a SMI on all platforms.
- * When recursion depth is greater, fall back to using a full cleanup.
- */
-const maxMarkerBits = 30;
-let activeEffect;
-const ITERATE_KEY = Symbol('');
-const MAP_KEY_ITERATE_KEY = Symbol('');
-class ReactiveEffect {
-  constructor(fn, scheduler = null, scope) {
-    this.fn = fn;
-    this.scheduler = scheduler;
-    this.active = true;
-    this.deps = [];
-    this.parent = undefined;
-    recordEffectScope(this, scope);
-  }
-  run() {
-    if (!this.active) {
-      return this.fn();
-    }
-    let parent = activeEffect;
-    let lastShouldTrack = shouldTrack;
-    while (parent) {
-      if (parent === this) {
-        return;
-      }
-      parent = parent.parent;
-    }
-    try {
-      this.parent = activeEffect;
-      activeEffect = this;
-      shouldTrack = true;
-      trackOpBit = 1 << ++effectTrackDepth;
-      if (effectTrackDepth <= maxMarkerBits) {
-        initDepMarkers(this);
-      } else {
-        cleanupEffect(this);
-      }
-      return this.fn();
-    } finally {
-      if (effectTrackDepth <= maxMarkerBits) {
-        finalizeDepMarkers(this);
-      }
-      trackOpBit = 1 << --effectTrackDepth;
-      activeEffect = this.parent;
-      shouldTrack = lastShouldTrack;
-      this.parent = undefined;
-      if (this.deferStop) {
-        this.stop();
-      }
-    }
-  }
-  stop() {
-    // stopped while running itself - defer the cleanup
-    if (activeEffect === this) {
-      this.deferStop = true;
-    } else if (this.active) {
-      cleanupEffect(this);
-      if (this.onStop) {
-        this.onStop();
-      }
-      this.active = false;
-    }
-  }
-}
-function cleanupEffect(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 resetTracking() {
-  const last = trackStack.pop();
-  shouldTrack = last === undefined ? true : last;
-}
-function track(target, type, key) {
-  if (shouldTrack && activeEffect) {
-    let depsMap = targetMap.get(target);
-    if (!depsMap) {
-      targetMap.set(target, depsMap = new Map());
-    }
-    let dep = depsMap.get(key);
-    if (!dep) {
-      depsMap.set(key, dep = createDep());
-    }
-    trackEffects(dep);
-  }
-}
-function trackEffects(dep, debuggerEventExtraInfo) {
-  let shouldTrack = false;
-  if (effectTrackDepth <= maxMarkerBits) {
-    if (!newTracked(dep)) {
-      dep.n |= trackOpBit; // set newly tracked
-      shouldTrack = !wasTracked(dep);
-    }
-  } else {
-    // Full cleanup mode.
-    shouldTrack = !dep.has(activeEffect);
-  }
-  if (shouldTrack) {
-    dep.add(activeEffect);
-    activeEffect.deps.push(dep);
-  }
-}
-function trigger(target, type, key, newValue, oldValue, oldTarget) {
-  const depsMap = targetMap.get(target);
-  if (!depsMap) {
-    // never been tracked
-    return;
-  }
-  let deps = [];
-  if (type === "clear" /* TriggerOpTypes.CLEAR */) {
-    // collection being cleared
-    // trigger all effects for target
-    deps = [...depsMap.values()];
-  } else if (key === 'length' && isArray(target)) {
-    depsMap.forEach((dep, key) => {
-      if (key === 'length' || key >= newValue) {
-        deps.push(dep);
-      }
-    });
-  } else {
-    // schedule runs for SET | ADD | DELETE
-    if (key !== void 0) {
-      deps.push(depsMap.get(key));
-    }
-    // also run for iteration key on ADD | DELETE | Map.SET
-    switch (type) {
-      case "add" /* TriggerOpTypes.ADD */:
-        if (!isArray(target)) {
-          deps.push(depsMap.get(ITERATE_KEY));
-          if (isMap(target)) {
-            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
-          }
-        } else if (isIntegerKey(key)) {
-          // new index added to array -> length changes
-          deps.push(depsMap.get('length'));
-        }
-        break;
-      case "delete" /* TriggerOpTypes.DELETE */:
-        if (!isArray(target)) {
-          deps.push(depsMap.get(ITERATE_KEY));
-          if (isMap(target)) {
-            deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
-          }
-        }
-        break;
-      case "set" /* TriggerOpTypes.SET */:
-        if (isMap(target)) {
-          deps.push(depsMap.get(ITERATE_KEY));
-        }
-        break;
-    }
-  }
-  if (deps.length === 1) {
-    if (deps[0]) {
-      {
-        triggerEffects(deps[0]);
-      }
-    }
-  } else {
-    const effects = [];
-    for (const dep of deps) {
-      if (dep) {
-        effects.push(...dep);
-      }
-    }
-    {
-      triggerEffects(createDep(effects));
-    }
-  }
-}
-function triggerEffects(dep, debuggerEventExtraInfo) {
-  // spread into array for stabilization
-  const effects = isArray(dep) ? dep : [...dep];
-  for (const effect of effects) {
-    if (effect.computed) {
-      triggerEffect(effect);
-    }
-  }
-  for (const effect of effects) {
-    if (!effect.computed) {
-      triggerEffect(effect);
-    }
-  }
-}
-function triggerEffect(effect, debuggerEventExtraInfo) {
-  if (effect !== activeEffect || effect.allowRecurse) {
-    if (effect.scheduler) {
-      effect.scheduler();
-    } else {
-      effect.run();
-    }
-  }
-}
-const isNonTrackableKeys = /*#__PURE__*/makeMap(`__proto__,__v_isRef,__isVue`);
-const builtInSymbols = new Set( /*#__PURE__*/
-Object.getOwnPropertyNames(Symbol)
-// ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
-// but accessing them on Symbol leads to TypeError because Symbol is a strict mode
-// function
-.filter(key => key !== 'arguments' && key !== 'caller').map(key => Symbol[key]).filter(isSymbol));
-const get = /*#__PURE__*/createGetter();
-const readonlyGet = /*#__PURE__*/createGetter(true);
-const arrayInstrumentations = /*#__PURE__*/createArrayInstrumentations();
-function createArrayInstrumentations() {
-  const instrumentations = {};
-  ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
-    instrumentations[key] = function (...args) {
-      const arr = toRaw(this);
-      for (let i = 0, l = this.length; i < l; i++) {
-        track(arr, "get" /* TrackOpTypes.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;
-      }
-    };
-  });
-  ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
-    instrumentations[key] = function (...args) {
-      pauseTracking();
-      const res = toRaw(this)[key].apply(this, args);
-      resetTracking();
-      return res;
-    };
-  });
-  return instrumentations;
-}
-function createGetter(isReadonly = false, shallow = false) {
-  return function get(target, key, receiver) {
-    if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
-      return !isReadonly;
-    } else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
-      return isReadonly;
-    } else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
-      return shallow;
-    } else if (key === "__v_raw" /* ReactiveFlags.RAW */ && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
-      return target;
-    }
-    const targetIsArray = isArray(target);
-    if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
-      return Reflect.get(arrayInstrumentations, key, receiver);
-    }
-    const res = Reflect.get(target, key, receiver);
-    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
-      return res;
-    }
-    if (!isReadonly) {
-      track(target, "get" /* TrackOpTypes.GET */, key);
-    }
-    if (shallow) {
-      return res;
-    }
-    if (isRef(res)) {
-      // ref unwrapping - skip unwrap for Array + integer key.
-      return targetIsArray && isIntegerKey(key) ? 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();
-function createSetter(shallow = false) {
-  return function set(target, key, value, receiver) {
-    let oldValue = target[key];
-    if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
-      return false;
-    }
-    if (!shallow) {
-      if (!isShallow(value) && !isReadonly(value)) {
-        oldValue = toRaw(oldValue);
-        value = toRaw(value);
-      }
-      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
-        oldValue.value = value;
-        return true;
-      }
-    }
-    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : 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" /* TriggerOpTypes.ADD */, key, value);
-      } else if (hasChanged(value, oldValue)) {
-        trigger(target, "set" /* TriggerOpTypes.SET */, key, value);
-      }
-    }
-    return result;
-  };
-}
-function deleteProperty(target, key) {
-  const hadKey = hasOwn(target, key);
-  target[key];
-  const result = Reflect.deleteProperty(target, key);
-  if (result && hadKey) {
-    trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined);
-  }
-  return result;
-}
-function has(target, key) {
-  const result = Reflect.has(target, key);
-  if (!isSymbol(key) || !builtInSymbols.has(key)) {
-    track(target, "has" /* TrackOpTypes.HAS */, key);
-  }
-  return result;
-}
-function ownKeys(target) {
-  track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
-  return Reflect.ownKeys(target);
-}
-const mutableHandlers = {
-  get,
-  set,
-  deleteProperty,
-  has,
-  ownKeys
-};
-const readonlyHandlers = {
-  get: readonlyGet,
-  set(target, key) {
-    return true;
-  },
-  deleteProperty(target, key) {
-    return true;
-  }
-};
-const toShallow = value => value;
-const getProto = v => Reflect.getPrototypeOf(v);
-function get$1(target, key, isReadonly = false, isShallow = false) {
-  // #1772: readonly(reactive(Map)) should return readonly + reactive version
-  // of the value
-  target = target["__v_raw" /* ReactiveFlags.RAW */];
-  const rawTarget = toRaw(target);
-  const rawKey = toRaw(key);
-  if (!isReadonly) {
-    if (key !== rawKey) {
-      track(rawTarget, "get" /* TrackOpTypes.GET */, key);
-    }
-    track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
-  }
-  const {
-    has
-  } = getProto(rawTarget);
-  const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
-  if (has.call(rawTarget, key)) {
-    return wrap(target.get(key));
-  } else if (has.call(rawTarget, rawKey)) {
-    return wrap(target.get(rawKey));
-  } else if (target !== rawTarget) {
-    // #3602 readonly(reactive(Map))
-    // ensure that the nested reactive `Map` can do tracking for itself
-    target.get(key);
-  }
-}
-function has$1(key, isReadonly = false) {
-  const target = this["__v_raw" /* ReactiveFlags.RAW */];
-  const rawTarget = toRaw(target);
-  const rawKey = toRaw(key);
-  if (!isReadonly) {
-    if (key !== rawKey) {
-      track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
-    }
-    track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
-  }
-  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
-}
-function size(target, isReadonly = false) {
-  target = target["__v_raw" /* ReactiveFlags.RAW */];
-  !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
-  return Reflect.get(target, 'size', target);
-}
-function add(value) {
-  value = toRaw(value);
-  const target = toRaw(this);
-  const proto = getProto(target);
-  const hadKey = proto.has.call(target, value);
-  if (!hadKey) {
-    target.add(value);
-    trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
-  }
-  return this;
-}
-function set$1(key, value) {
-  value = toRaw(value);
-  const target = toRaw(this);
-  const {
-    has,
-    get
-  } = getProto(target);
-  let hadKey = has.call(target, key);
-  if (!hadKey) {
-    key = toRaw(key);
-    hadKey = has.call(target, key);
-  }
-  const oldValue = get.call(target, key);
-  target.set(key, value);
-  if (!hadKey) {
-    trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
-  } else if (hasChanged(value, oldValue)) {
-    trigger(target, "set" /* TriggerOpTypes.SET */, key, value);
-  }
-  return this;
-}
-function deleteEntry(key) {
-  const target = toRaw(this);
-  const {
-    has,
-    get
-  } = getProto(target);
-  let hadKey = has.call(target, key);
-  if (!hadKey) {
-    key = toRaw(key);
-    hadKey = has.call(target, key);
-  }
-  get ? get.call(target, key) : undefined;
-  // forward the operation before queueing reactions
-  const result = target.delete(key);
-  if (hadKey) {
-    trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined);
-  }
-  return result;
-}
-function clear() {
-  const target = toRaw(this);
-  const hadItems = target.size !== 0;
-  // forward the operation before queueing reactions
-  const result = target.clear();
-  if (hadItems) {
-    trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined);
-  }
-  return result;
-}
-function createForEach(isReadonly, isShallow) {
-  return function forEach(callback, thisArg) {
-    const observed = this;
-    const target = observed["__v_raw" /* ReactiveFlags.RAW */];
-    const rawTarget = toRaw(target);
-    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
-    !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
-    return target.forEach((value, key) => {
-      // important: make 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.
-      return callback.call(thisArg, wrap(value), wrap(key), observed);
-    });
-  };
-}
-function createIterableMethod(method, isReadonly, isShallow) {
-  return function (...args) {
-    const target = this["__v_raw" /* ReactiveFlags.RAW */];
-    const rawTarget = toRaw(target);
-    const targetIsMap = isMap(rawTarget);
-    const isPair = method === 'entries' || method === Symbol.iterator && targetIsMap;
-    const isKeyOnly = method === 'keys' && targetIsMap;
-    const innerIterator = target[method](...args);
-    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
-    !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.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) {
-    return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
-  };
-}
-function createInstrumentations() {
-  const mutableInstrumentations = {
-    get(key) {
-      return get$1(this, key);
-    },
-    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, false, true);
-    },
-    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, true);
-    },
-    get size() {
-      return size(this, true);
-    },
-    has(key) {
-      return has$1.call(this, key, true);
-    },
-    add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
-    set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
-    delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
-    clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
-    forEach: createForEach(true, false)
-  };
-  const shallowReadonlyInstrumentations = {
-    get(key) {
-      return get$1(this, key, true, true);
-    },
-    get size() {
-      return size(this, true);
-    },
-    has(key) {
-      return has$1.call(this, key, true);
-    },
-    add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
-    set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
-    delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
-    clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
-    forEach: createForEach(true, true)
-  };
-  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);
-    shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
-  });
-  return [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations];
-}
-const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/createInstrumentations();
-function createInstrumentationGetter(isReadonly, shallow) {
-  const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
-  return (target, key, receiver) => {
-    if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
-      return !isReadonly;
-    } else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
-      return isReadonly;
-    } else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
-      return target;
-    }
-    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
-  };
-}
-const mutableCollectionHandlers = {
-  get: /*#__PURE__*/createInstrumentationGetter(false, false)
-};
-const readonlyCollectionHandlers = {
-  get: /*#__PURE__*/createInstrumentationGetter(true, false)
-};
-const reactiveMap = new WeakMap();
-const shallowReactiveMap = new WeakMap();
-const readonlyMap = new WeakMap();
-const shallowReadonlyMap = new WeakMap();
-function targetTypeMap(rawType) {
-  switch (rawType) {
-    case 'Object':
-    case 'Array':
-      return 1 /* TargetType.COMMON */;
-    case 'Map':
-    case 'Set':
-    case 'WeakMap':
-    case 'WeakSet':
-      return 2 /* TargetType.COLLECTION */;
-    default:
-      return 0 /* TargetType.INVALID */;
-  }
-}
-
-function getTargetType(value) {
-  return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value) ? 0 /* TargetType.INVALID */ : targetTypeMap(toRawType(value));
-}
-function reactive(target) {
-  // if trying to observe a readonly proxy, return the readonly version.
-  if (isReadonly(target)) {
-    return target;
-  }
-  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
-}
-/**
- * Creates a readonly copy of the original object. Note the returned copy is not
- * made reactive, but `readonly` can be called on an already reactive object.
- */
-function readonly(target) {
-  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
-}
-function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
-  if (!isObject(target)) {
-    return target;
-  }
-  // target is already a Proxy, return it.
-  // exception: calling readonly() on a reactive object
-  if (target["__v_raw" /* ReactiveFlags.RAW */] && !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
-    return target;
-  }
-  // target already has corresponding Proxy
-  const existingProxy = proxyMap.get(target);
-  if (existingProxy) {
-    return existingProxy;
-  }
-  // only specific value types can be observed.
-  const targetType = getTargetType(target);
-  if (targetType === 0 /* TargetType.INVALID */) {
-    return target;
-  }
-  const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
-  proxyMap.set(target, proxy);
-  return proxy;
-}
-function isReactive(value) {
-  if (isReadonly(value)) {
-    return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
-  }
-
-  return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
-}
-
-function isReadonly(value) {
-  return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
-}
-
-function isShallow(value) {
-  return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
-}
-
-function isProxy(value) {
-  return isReactive(value) || isReadonly(value);
-}
-function toRaw(observed) {
-  const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
-  return raw ? toRaw(raw) : observed;
-}
-const toReactive = value => isObject(value) ? reactive(value) : value;
-const toReadonly = value => isObject(value) ? readonly(value) : value;
-function trackRefValue(ref) {
-  if (shouldTrack && activeEffect) {
-    ref = toRaw(ref);
-    {
-      trackEffects(ref.dep || (ref.dep = createDep()));
-    }
-  }
-}
-function triggerRefValue(ref, newVal) {
-  ref = toRaw(ref);
-  if (ref.dep) {
-    {
-      triggerEffects(ref.dep);
-    }
-  }
-}
-function isRef(r) {
-  return !!(r && r.__v_isRef === true);
-}
-function ref(value) {
-  return createRef(value, false);
-}
-function createRef(rawValue, shallow) {
-  if (isRef(rawValue)) {
-    return rawValue;
-  }
-  return new RefImpl(rawValue, shallow);
-}
-class RefImpl {
-  constructor(value, __v_isShallow) {
-    this.__v_isShallow = __v_isShallow;
-    this.dep = undefined;
-    this.__v_isRef = true;
-    this._rawValue = __v_isShallow ? value : toRaw(value);
-    this._value = __v_isShallow ? value : toReactive(value);
-  }
-  get value() {
-    trackRefValue(this);
-    return this._value;
-  }
-  set value(newVal) {
-    const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
-    newVal = useDirectValue ? newVal : toRaw(newVal);
-    if (hasChanged(newVal, this._rawValue)) {
-      this._rawValue = newVal;
-      this._value = useDirectValue ? newVal : toReactive(newVal);
-      triggerRefValue(this);
-    }
-  }
-}
-function unref(ref) {
-  return isRef(ref) ? ref.value : ref;
-}
-class ObjectRefImpl {
-  constructor(_object, _key, _defaultValue) {
-    this._object = _object;
-    this._key = _key;
-    this._defaultValue = _defaultValue;
-    this.__v_isRef = true;
-  }
-  get value() {
-    const val = this._object[this._key];
-    return val === undefined ? this._defaultValue : val;
-  }
-  set value(newVal) {
-    this._object[this._key] = newVal;
-  }
-}
-function toRef(object, key, defaultValue) {
-  const val = object[key];
-  return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue);
-}
-var _a;
-class ComputedRefImpl {
-  constructor(getter, _setter, isReadonly, isSSR) {
-    this._setter = _setter;
-    this.dep = undefined;
-    this.__v_isRef = true;
-    this[_a] = false;
-    this._dirty = true;
-    this.effect = new ReactiveEffect(getter, () => {
-      if (!this._dirty) {
-        this._dirty = true;
-        triggerRefValue(this);
-      }
-    });
-    this.effect.computed = this;
-    this.effect.active = this._cacheable = !isSSR;
-    this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
-  }
-  get value() {
-    // the computed ref may get wrapped by other proxies e.g. readonly() #3376
-    const self = toRaw(this);
-    trackRefValue(self);
-    if (self._dirty || !self._cacheable) {
-      self._dirty = false;
-      self._value = self.effect.run();
-    }
-    return self._value;
-  }
-  set value(newValue) {
-    this._setter(newValue);
-  }
-}
-_a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
-function computed(getterOrOptions, debugOptions, isSSR = false) {
-  let getter;
-  let setter;
-  const onlyGetter = isFunction(getterOrOptions);
-  if (onlyGetter) {
-    getter = getterOrOptions;
-    setter = NOOP;
-  } else {
-    getter = getterOrOptions.get;
-    setter = getterOrOptions.set;
-  }
-  const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
-  return cRef;
-}
-
-export { track as A, EMPTY_OBJ as E, NOOP as N, ReactiveEffect as R, reactive as a, isShallow as b, isReactive as c, isArray as d, isFunction as e, remove as f, computed as g, isObject as h, isRef as i, hasChanged as j, isSet as k, isMap as l, isPlainObject as m, NO as n, isString as o, normalizeClass as p, isProxy as q, ref as r, extend as s, toRef as t, unref as u, normalizeStyle as v, isOn as w, isPromise as x, pauseTracking as y, resetTracking as z };