@module-federation/bridge-react 0.16.0 → 0.17.1

package/dist/utils-C4oPJV34.mjs

@@ -0,0 +1,2016 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _a, _constructing, _b, _c, _max, _maxSize, _dispose, _disposeAfter, _fetchMethod, _memoMethod, _size, _calculatedSize, _keyMap, _keyList, _valList, _next, _prev, _head, _tail, _free, _disposed, _sizes, _starts, _ttls, _hasDispose, _hasFetchMethod, _hasDisposeAfter, _LRUCache_instances, initializeTTLTracking_fn, _updateItemAge, _statusTTL, _setItemTTL, _isStale, initializeSizeTracking_fn, _removeItemSize, _addItemSize, _requireSize, indexes_fn, rindexes_fn, isValidIndex_fn, evict_fn, backgroundFetch_fn, isBackgroundFetch_fn, connect_fn, moveToTail_fn, delete_fn, clear_fn;
+import { c as createLogger, i as isBrowserEnv, a as composeKeyWithSeparator } from "./index.esm-BCeUd-x9.mjs";
+const PLUGIN_IDENTIFIER = "[ Module Federation React ]";
+const DOWNGRADE_KEY = "_mfSSRDowngrade";
+const DATA_FETCH_FUNCTION = "_mfDataFetch";
+const FS_HREF = "_mfFSHref";
+const ERROR_TYPE = {
+  DATA_FETCH: 1,
+  LOAD_REMOTE: 2,
+  UNKNOWN: 3
+};
+const WRAP_DATA_FETCH_ID_IDENTIFIER = "wrap_dfip_identifier";
+var MF_DATA_FETCH_TYPE = /* @__PURE__ */ ((MF_DATA_FETCH_TYPE2) => {
+  MF_DATA_FETCH_TYPE2[MF_DATA_FETCH_TYPE2["FETCH_SERVER"] = 1] = "FETCH_SERVER";
+  MF_DATA_FETCH_TYPE2[MF_DATA_FETCH_TYPE2["FETCH_CLIENT"] = 2] = "FETCH_CLIENT";
+  return MF_DATA_FETCH_TYPE2;
+})(MF_DATA_FETCH_TYPE || {});
+var MF_DATA_FETCH_STATUS = /* @__PURE__ */ ((MF_DATA_FETCH_STATUS2) => {
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["LOADED"] = 1] = "LOADED";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["LOADING"] = 2] = "LOADING";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["AWAIT"] = 0] = "AWAIT";
+  MF_DATA_FETCH_STATUS2[MF_DATA_FETCH_STATUS2["ERROR"] = 3] = "ERROR";
+  return MF_DATA_FETCH_STATUS2;
+})(MF_DATA_FETCH_STATUS || {});
+const DATA_FETCH_IDENTIFIER = "data";
+const DATA_FETCH_CLIENT_SUFFIX = ".client";
+const DATA_FETCH_QUERY = "x-mf-data-fetch";
+const DATA_FETCH_ERROR_PREFIX = "caught the following error during dataFetch: ";
+const LOAD_REMOTE_ERROR_PREFIX = "caught the following error during loadRemote: ";
+const logger = createLogger(PLUGIN_IDENTIFIER);
+const perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+const warned = /* @__PURE__ */ new Set();
+const PROCESS = typeof process === "object" && !!process ? process : {};
+const emitWarning = (msg, type, code, fn) => {
+  typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+if (typeof AC === "undefined") {
+  AS = class AbortSignal {
+    constructor() {
+      __publicField(this, "onabort");
+      __publicField(this, "_onabort", []);
+      __publicField(this, "reason");
+      __publicField(this, "aborted", false);
+    }
+    addEventListener(_, fn) {
+      this._onabort.push(fn);
+    }
+  };
+  AC = class AbortController {
+    constructor() {
+      __publicField(this, "signal", new AS());
+      warnACPolyfill();
+    }
+    abort(reason) {
+      var _a2, _b2;
+      if (this.signal.aborted)
+        return;
+      this.signal.reason = reason;
+      this.signal.aborted = true;
+      for (const fn of this.signal._onabort) {
+        fn(reason);
+      }
+      (_b2 = (_a2 = this.signal).onabort) == null ? void 0 : _b2.call(_a2, reason);
+    }
+  };
+  let printACPolyfillWarning = ((_a = PROCESS.env) == null ? void 0 : _a.LRU_CACHE_IGNORE_AC_WARNING) !== "1";
+  const warnACPolyfill = () => {
+    if (!printACPolyfillWarning)
+      return;
+    printACPolyfillWarning = false;
+    emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+  };
+}
+const shouldWarn = (code) => !warned.has(code);
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+const getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+class ZeroArray extends Array {
+  constructor(size) {
+    super(size);
+    this.fill(0);
+  }
+}
+const _Stack = class _Stack {
+  constructor(max, HeapCls) {
+    __publicField(this, "heap");
+    __publicField(this, "length");
+    if (!__privateGet(_Stack, _constructing)) {
+      throw new TypeError("instantiate Stack using Stack.create(n)");
+    }
+    this.heap = new HeapCls(max);
+    this.length = 0;
+  }
+  static create(max) {
+    const HeapCls = getUintArray(max);
+    if (!HeapCls)
+      return [];
+    __privateSet(_Stack, _constructing, true);
+    const s = new _Stack(max, HeapCls);
+    __privateSet(_Stack, _constructing, false);
+    return s;
+  }
+  push(n) {
+    this.heap[this.length++] = n;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+};
+_constructing = new WeakMap();
+// private constructor
+__privateAdd(_Stack, _constructing, false);
+let Stack = _Stack;
+const _LRUCache = class _LRUCache {
+  constructor(options) {
+    __privateAdd(this, _LRUCache_instances);
+    // options that cannot be changed without disaster
+    __privateAdd(this, _max);
+    __privateAdd(this, _maxSize);
+    __privateAdd(this, _dispose);
+    __privateAdd(this, _disposeAfter);
+    __privateAdd(this, _fetchMethod);
+    __privateAdd(this, _memoMethod);
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    __publicField(this, "ttl");
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    __publicField(this, "ttlResolution");
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    __publicField(this, "ttlAutopurge");
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    __publicField(this, "updateAgeOnGet");
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    __publicField(this, "updateAgeOnHas");
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    __publicField(this, "allowStale");
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    __publicField(this, "noDisposeOnSet");
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    __publicField(this, "noUpdateTTL");
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    __publicField(this, "maxEntrySize");
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    __publicField(this, "sizeCalculation");
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    __publicField(this, "noDeleteOnFetchRejection");
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    __publicField(this, "noDeleteOnStaleGet");
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    __publicField(this, "allowStaleOnFetchAbort");
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    __publicField(this, "allowStaleOnFetchRejection");
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    __publicField(this, "ignoreFetchAbort");
+    // computed properties
+    __privateAdd(this, _size);
+    __privateAdd(this, _calculatedSize);
+    __privateAdd(this, _keyMap);
+    __privateAdd(this, _keyList);
+    __privateAdd(this, _valList);
+    __privateAdd(this, _next);
+    __privateAdd(this, _prev);
+    __privateAdd(this, _head);
+    __privateAdd(this, _tail);
+    __privateAdd(this, _free);
+    __privateAdd(this, _disposed);
+    __privateAdd(this, _sizes);
+    __privateAdd(this, _starts);
+    __privateAdd(this, _ttls);
+    __privateAdd(this, _hasDispose);
+    __privateAdd(this, _hasFetchMethod);
+    __privateAdd(this, _hasDisposeAfter);
+    // conditionally set private methods related to TTL
+    __privateAdd(this, _updateItemAge, () => {
+    });
+    __privateAdd(this, _statusTTL, () => {
+    });
+    __privateAdd(this, _setItemTTL, () => {
+    });
+    /* c8 ignore stop */
+    __privateAdd(this, _isStale, () => false);
+    __privateAdd(this, _removeItemSize, (_i) => {
+    });
+    __privateAdd(this, _addItemSize, (_i, _s, _st) => {
+    });
+    __privateAdd(this, _requireSize, (_k, _v, size, sizeCalculation) => {
+      if (size || sizeCalculation) {
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      }
+      return 0;
+    });
+    /**
+     * A String value that is used in the creation of the default string
+     * description of an object. Called by the built-in method
+     * `Object.prototype.toString`.
+     */
+    __publicField(this, _b, "LRUCache");
+    const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+    if (max !== 0 && !isPosInt(max)) {
+      throw new TypeError("max option must be a nonnegative integer");
+    }
+    const UintArray = max ? getUintArray(max) : Array;
+    if (!UintArray) {
+      throw new Error("invalid max value: " + max);
+    }
+    __privateSet(this, _max, max);
+    __privateSet(this, _maxSize, maxSize);
+    this.maxEntrySize = maxEntrySize || __privateGet(this, _maxSize);
+    this.sizeCalculation = sizeCalculation;
+    if (this.sizeCalculation) {
+      if (!__privateGet(this, _maxSize) && !this.maxEntrySize) {
+        throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+      }
+      if (typeof this.sizeCalculation !== "function") {
+        throw new TypeError("sizeCalculation set to non-function");
+      }
+    }
+    if (memoMethod !== void 0 && typeof memoMethod !== "function") {
+      throw new TypeError("memoMethod must be a function if defined");
+    }
+    __privateSet(this, _memoMethod, memoMethod);
+    if (fetchMethod !== void 0 && typeof fetchMethod !== "function") {
+      throw new TypeError("fetchMethod must be a function if specified");
+    }
+    __privateSet(this, _fetchMethod, fetchMethod);
+    __privateSet(this, _hasFetchMethod, !!fetchMethod);
+    __privateSet(this, _keyMap, /* @__PURE__ */ new Map());
+    __privateSet(this, _keyList, new Array(max).fill(void 0));
+    __privateSet(this, _valList, new Array(max).fill(void 0));
+    __privateSet(this, _next, new UintArray(max));
+    __privateSet(this, _prev, new UintArray(max));
+    __privateSet(this, _head, 0);
+    __privateSet(this, _tail, 0);
+    __privateSet(this, _free, Stack.create(max));
+    __privateSet(this, _size, 0);
+    __privateSet(this, _calculatedSize, 0);
+    if (typeof dispose === "function") {
+      __privateSet(this, _dispose, dispose);
+    }
+    if (typeof disposeAfter === "function") {
+      __privateSet(this, _disposeAfter, disposeAfter);
+      __privateSet(this, _disposed, []);
+    } else {
+      __privateSet(this, _disposeAfter, void 0);
+      __privateSet(this, _disposed, void 0);
+    }
+    __privateSet(this, _hasDispose, !!__privateGet(this, _dispose));
+    __privateSet(this, _hasDisposeAfter, !!__privateGet(this, _disposeAfter));
+    this.noDisposeOnSet = !!noDisposeOnSet;
+    this.noUpdateTTL = !!noUpdateTTL;
+    this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+    this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+    this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+    this.ignoreFetchAbort = !!ignoreFetchAbort;
+    if (this.maxEntrySize !== 0) {
+      if (__privateGet(this, _maxSize) !== 0) {
+        if (!isPosInt(__privateGet(this, _maxSize))) {
+          throw new TypeError("maxSize must be a positive integer if specified");
+        }
+      }
+      if (!isPosInt(this.maxEntrySize)) {
+        throw new TypeError("maxEntrySize must be a positive integer if specified");
+      }
+      __privateMethod(this, _LRUCache_instances, initializeSizeTracking_fn).call(this);
+    }
+    this.allowStale = !!allowStale;
+    this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+    this.updateAgeOnGet = !!updateAgeOnGet;
+    this.updateAgeOnHas = !!updateAgeOnHas;
+    this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+    this.ttlAutopurge = !!ttlAutopurge;
+    this.ttl = ttl || 0;
+    if (this.ttl) {
+      if (!isPosInt(this.ttl)) {
+        throw new TypeError("ttl must be a positive integer if specified");
+      }
+      __privateMethod(this, _LRUCache_instances, initializeTTLTracking_fn).call(this);
+    }
+    if (__privateGet(this, _max) === 0 && this.ttl === 0 && __privateGet(this, _maxSize) === 0) {
+      throw new TypeError("At least one of max, maxSize, or ttl is required");
+    }
+    if (!this.ttlAutopurge && !__privateGet(this, _max) && !__privateGet(this, _maxSize)) {
+      const code = "LRU_CACHE_UNBOUNDED";
+      if (shouldWarn(code)) {
+        warned.add(code);
+        const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+        emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
+      }
+    }
+  }
+  /**
+   * Do not call this method unless you need to inspect the
+   * inner workings of the cache.  If anything returned by this
+   * object is modified in any way, strange breakage may occur.
+   *
+   * These fields are private for a reason!
+   *
+   * @internal
+   */
+  static unsafeExposeInternals(c) {
+    return {
+      // properties
+      starts: __privateGet(c, _starts),
+      ttls: __privateGet(c, _ttls),
+      sizes: __privateGet(c, _sizes),
+      keyMap: __privateGet(c, _keyMap),
+      keyList: __privateGet(c, _keyList),
+      valList: __privateGet(c, _valList),
+      next: __privateGet(c, _next),
+      prev: __privateGet(c, _prev),
+      get head() {
+        return __privateGet(c, _head);
+      },
+      get tail() {
+        return __privateGet(c, _tail);
+      },
+      free: __privateGet(c, _free),
+      // methods
+      isBackgroundFetch: (p) => {
+        var _a2;
+        return __privateMethod(_a2 = c, _LRUCache_instances, isBackgroundFetch_fn).call(_a2, p);
+      },
+      backgroundFetch: (k, index, options, context) => {
+        var _a2;
+        return __privateMethod(_a2 = c, _LRUCache_instances, backgroundFetch_fn).call(_a2, k, index, options, context);
+      },
+      moveToTail: (index) => {
+        var _a2;
+        return __privateMethod(_a2 = c, _LRUCache_instances, moveToTail_fn).call(_a2, index);
+      },
+      indexes: (options) => {
+        var _a2;
+        return __privateMethod(_a2 = c, _LRUCache_instances, indexes_fn).call(_a2, options);
+      },
+      rindexes: (options) => {
+        var _a2;
+        return __privateMethod(_a2 = c, _LRUCache_instances, rindexes_fn).call(_a2, options);
+      },
+      isStale: (index) => {
+        var _a2;
+        return __privateGet(_a2 = c, _isStale).call(_a2, index);
+      }
+    };
+  }
+  // Protected read-only members
+  /**
+   * {@link LRUCache.OptionsBase.max} (read-only)
+   */
+  get max() {
+    return __privateGet(this, _max);
+  }
+  /**
+   * {@link LRUCache.OptionsBase.maxSize} (read-only)
+   */
+  get maxSize() {
+    return __privateGet(this, _maxSize);
+  }
+  /**
+   * The total computed size of items in the cache (read-only)
+   */
+  get calculatedSize() {
+    return __privateGet(this, _calculatedSize);
+  }
+  /**
+   * The number of items stored in the cache (read-only)
+   */
+  get size() {
+    return __privateGet(this, _size);
+  }
+  /**
+   * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+   */
+  get fetchMethod() {
+    return __privateGet(this, _fetchMethod);
+  }
+  get memoMethod() {
+    return __privateGet(this, _memoMethod);
+  }
+  /**
+   * {@link LRUCache.OptionsBase.dispose} (read-only)
+   */
+  get dispose() {
+    return __privateGet(this, _dispose);
+  }
+  /**
+   * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+   */
+  get disposeAfter() {
+    return __privateGet(this, _disposeAfter);
+  }
+  /**
+   * Return the number of ms left in the item's TTL. If item is not in cache,
+   * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+   */
+  getRemainingTTL(key) {
+    return __privateGet(this, _keyMap).has(key) ? Infinity : 0;
+  }
+  /**
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from most recently used to least recently used.
+   */
+  *entries() {
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this)) {
+      if (__privateGet(this, _valList)[i] !== void 0 && __privateGet(this, _keyList)[i] !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield [__privateGet(this, _keyList)[i], __privateGet(this, _valList)[i]];
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.entries}
+   *
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from least recently used to most recently used.
+   */
+  *rentries() {
+    for (const i of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this)) {
+      if (__privateGet(this, _valList)[i] !== void 0 && __privateGet(this, _keyList)[i] !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield [__privateGet(this, _keyList)[i], __privateGet(this, _valList)[i]];
+      }
+    }
+  }
+  /**
+   * Return a generator yielding the keys in the cache,
+   * in order from most recently used to least recently used.
+   */
+  *keys() {
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this)) {
+      const k = __privateGet(this, _keyList)[i];
+      if (k !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield k;
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.keys}
+   *
+   * Return a generator yielding the keys in the cache,
+   * in order from least recently used to most recently used.
+   */
+  *rkeys() {
+    for (const i of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this)) {
+      const k = __privateGet(this, _keyList)[i];
+      if (k !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield k;
+      }
+    }
+  }
+  /**
+   * Return a generator yielding the values in the cache,
+   * in order from most recently used to least recently used.
+   */
+  *values() {
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this)) {
+      const v = __privateGet(this, _valList)[i];
+      if (v !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield __privateGet(this, _valList)[i];
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.values}
+   *
+   * Return a generator yielding the values in the cache,
+   * in order from least recently used to most recently used.
+   */
+  *rvalues() {
+    for (const i of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this)) {
+      const v = __privateGet(this, _valList)[i];
+      if (v !== void 0 && !__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, __privateGet(this, _valList)[i])) {
+        yield __privateGet(this, _valList)[i];
+      }
+    }
+  }
+  /**
+   * Iterating over the cache itself yields the same results as
+   * {@link LRUCache.entries}
+   */
+  [(_c = Symbol.iterator, _b = Symbol.toStringTag, _c)]() {
+    return this.entries();
+  }
+  /**
+   * Find a value for which the supplied fn method returns a truthy value,
+   * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+   */
+  find(fn, getOptions = {}) {
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this)) {
+      const v = __privateGet(this, _valList)[i];
+      const value = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      if (fn(value, __privateGet(this, _keyList)[i], this)) {
+        return this.get(__privateGet(this, _keyList)[i], getOptions);
+      }
+    }
+  }
+  /**
+   * Call the supplied function on each item in the cache, in order from most
+   * recently used to least recently used.
+   *
+   * `fn` is called as `fn(value, key, cache)`.
+   *
+   * If `thisp` is provided, function will be called in the `this`-context of
+   * the provided object, or the cache if no `thisp` object is provided.
+   *
+   * Does not update age or recenty of use, or iterate over stale values.
+   */
+  forEach(fn, thisp = this) {
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this)) {
+      const v = __privateGet(this, _valList)[i];
+      const value = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, __privateGet(this, _keyList)[i], this);
+    }
+  }
+  /**
+   * The same as {@link LRUCache.forEach} but items are iterated over in
+   * reverse order.  (ie, less recently used items are iterated over first.)
+   */
+  rforEach(fn, thisp = this) {
+    for (const i of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this)) {
+      const v = __privateGet(this, _valList)[i];
+      const value = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, __privateGet(this, _keyList)[i], this);
+    }
+  }
+  /**
+   * Delete any stale entries. Returns true if anything was removed,
+   * false otherwise.
+   */
+  purgeStale() {
+    let deleted = false;
+    for (const i of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this, { allowStale: true })) {
+      if (__privateGet(this, _isStale).call(this, i)) {
+        __privateMethod(this, _LRUCache_instances, delete_fn).call(this, __privateGet(this, _keyList)[i], "expire");
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Get the extended info about a given entry, to get its value, size, and
+   * TTL info simultaneously. Returns `undefined` if the key is not present.
+   *
+   * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+   * serialization, the `start` value is always the current timestamp, and the
+   * `ttl` is a calculated remaining time to live (negative if expired).
+   *
+   * Always returns stale values, if their info is found in the cache, so be
+   * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+   * if relevant.
+   */
+  info(key) {
+    const i = __privateGet(this, _keyMap).get(key);
+    if (i === void 0)
+      return void 0;
+    const v = __privateGet(this, _valList)[i];
+    const value = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+    if (value === void 0)
+      return void 0;
+    const entry = { value };
+    if (__privateGet(this, _ttls) && __privateGet(this, _starts)) {
+      const ttl = __privateGet(this, _ttls)[i];
+      const start = __privateGet(this, _starts)[i];
+      if (ttl && start) {
+        const remain = ttl - (perf.now() - start);
+        entry.ttl = remain;
+        entry.start = Date.now();
+      }
+    }
+    if (__privateGet(this, _sizes)) {
+      entry.size = __privateGet(this, _sizes)[i];
+    }
+    return entry;
+  }
+  /**
+   * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+   * passed to {@link LRLUCache#load}.
+   *
+   * The `start` fields are calculated relative to a portable `Date.now()`
+   * timestamp, even if `performance.now()` is available.
+   *
+   * Stale entries are always included in the `dump`, even if
+   * {@link LRUCache.OptionsBase.allowStale} is false.
+   *
+   * Note: this returns an actual array, not a generator, so it can be more
+   * easily passed around.
+   */
+  dump() {
+    const arr = [];
+    for (const i of __privateMethod(this, _LRUCache_instances, indexes_fn).call(this, { allowStale: true })) {
+      const key = __privateGet(this, _keyList)[i];
+      const v = __privateGet(this, _valList)[i];
+      const value = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+      if (value === void 0 || key === void 0)
+        continue;
+      const entry = { value };
+      if (__privateGet(this, _ttls) && __privateGet(this, _starts)) {
+        entry.ttl = __privateGet(this, _ttls)[i];
+        const age = perf.now() - __privateGet(this, _starts)[i];
+        entry.start = Math.floor(Date.now() - age);
+      }
+      if (__privateGet(this, _sizes)) {
+        entry.size = __privateGet(this, _sizes)[i];
+      }
+      arr.unshift([key, entry]);
+    }
+    return arr;
+  }
+  /**
+   * Reset the cache and load in the items in entries in the order listed.
+   *
+   * The shape of the resulting cache may be different if the same options are
+   * not used in both caches.
+   *
+   * The `start` fields are assumed to be calculated relative to a portable
+   * `Date.now()` timestamp, even if `performance.now()` is available.
+   */
+  load(arr) {
+    this.clear();
+    for (const [key, entry] of arr) {
+      if (entry.start) {
+        const age = Date.now() - entry.start;
+        entry.start = perf.now() - age;
+      }
+      this.set(key, entry.value, entry);
+    }
+  }
+  /**
+   * Add a value to the cache.
+   *
+   * Note: if `undefined` is specified as a value, this is an alias for
+   * {@link LRUCache#delete}
+   *
+   * Fields on the {@link LRUCache.SetOptions} options param will override
+   * their corresponding values in the constructor options for the scope
+   * of this single `set()` operation.
+   *
+   * If `start` is provided, then that will set the effective start
+   * time for the TTL calculation. Note that this must be a previous
+   * value of `performance.now()` if supported, or a previous value of
+   * `Date.now()` if not.
+   *
+   * Options object may also include `size`, which will prevent
+   * calling the `sizeCalculation` function and just use the specified
+   * number if it is a positive integer, and `noDisposeOnSet` which
+   * will prevent calling a `dispose` function in the case of
+   * overwrites.
+   *
+   * If the `size` (or return value of `sizeCalculation`) for a given
+   * entry is greater than `maxEntrySize`, then the item will not be
+   * added to the cache.
+   *
+   * Will update the recency of the entry.
+   *
+   * If the value is `undefined`, then this is an alias for
+   * `cache.delete(key)`. `undefined` is never stored in the cache.
+   */
+  set(k, v, setOptions = {}) {
+    var _a2, _b2, _c2, _d, _e;
+    if (v === void 0) {
+      this.delete(k);
+      return this;
+    }
+    const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+    let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+    const size = __privateGet(this, _requireSize).call(this, k, v, setOptions.size || 0, sizeCalculation);
+    if (this.maxEntrySize && size > this.maxEntrySize) {
+      if (status) {
+        status.set = "miss";
+        status.maxEntrySizeExceeded = true;
+      }
+      __privateMethod(this, _LRUCache_instances, delete_fn).call(this, k, "set");
+      return this;
+    }
+    let index = __privateGet(this, _size) === 0 ? void 0 : __privateGet(this, _keyMap).get(k);
+    if (index === void 0) {
+      index = __privateGet(this, _size) === 0 ? __privateGet(this, _tail) : __privateGet(this, _free).length !== 0 ? __privateGet(this, _free).pop() : __privateGet(this, _size) === __privateGet(this, _max) ? __privateMethod(this, _LRUCache_instances, evict_fn).call(this, false) : __privateGet(this, _size);
+      __privateGet(this, _keyList)[index] = k;
+      __privateGet(this, _valList)[index] = v;
+      __privateGet(this, _keyMap).set(k, index);
+      __privateGet(this, _next)[__privateGet(this, _tail)] = index;
+      __privateGet(this, _prev)[index] = __privateGet(this, _tail);
+      __privateSet(this, _tail, index);
+      __privateWrapper(this, _size)._++;
+      __privateGet(this, _addItemSize).call(this, index, size, status);
+      if (status)
+        status.set = "add";
+      noUpdateTTL = false;
+    } else {
+      __privateMethod(this, _LRUCache_instances, moveToTail_fn).call(this, index);
+      const oldVal = __privateGet(this, _valList)[index];
+      if (v !== oldVal) {
+        if (__privateGet(this, _hasFetchMethod) && __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, oldVal)) {
+          oldVal.__abortController.abort(new Error("replaced"));
+          const { __staleWhileFetching: s } = oldVal;
+          if (s !== void 0 && !noDisposeOnSet) {
+            if (__privateGet(this, _hasDispose)) {
+              (_a2 = __privateGet(this, _dispose)) == null ? void 0 : _a2.call(this, s, k, "set");
+            }
+            if (__privateGet(this, _hasDisposeAfter)) {
+              (_b2 = __privateGet(this, _disposed)) == null ? void 0 : _b2.push([s, k, "set"]);
+            }
+          }
+        } else if (!noDisposeOnSet) {
+          if (__privateGet(this, _hasDispose)) {
+            (_c2 = __privateGet(this, _dispose)) == null ? void 0 : _c2.call(this, oldVal, k, "set");
+          }
+          if (__privateGet(this, _hasDisposeAfter)) {
+            (_d = __privateGet(this, _disposed)) == null ? void 0 : _d.push([oldVal, k, "set"]);
+          }
+        }
+        __privateGet(this, _removeItemSize).call(this, index);
+        __privateGet(this, _addItemSize).call(this, index, size, status);
+        __privateGet(this, _valList)[index] = v;
+        if (status) {
+          status.set = "replace";
+          const oldValue = oldVal && __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, oldVal) ? oldVal.__staleWhileFetching : oldVal;
+          if (oldValue !== void 0)
+            status.oldValue = oldValue;
+        }
+      } else if (status) {
+        status.set = "update";
+      }
+    }
+    if (ttl !== 0 && !__privateGet(this, _ttls)) {
+      __privateMethod(this, _LRUCache_instances, initializeTTLTracking_fn).call(this);
+    }
+    if (__privateGet(this, _ttls)) {
+      if (!noUpdateTTL) {
+        __privateGet(this, _setItemTTL).call(this, index, ttl, start);
+      }
+      if (status)
+        __privateGet(this, _statusTTL).call(this, status, index);
+    }
+    if (!noDisposeOnSet && __privateGet(this, _hasDisposeAfter) && __privateGet(this, _disposed)) {
+      const dt = __privateGet(this, _disposed);
+      let task;
+      while (task = dt == null ? void 0 : dt.shift()) {
+        (_e = __privateGet(this, _disposeAfter)) == null ? void 0 : _e.call(this, ...task);
+      }
+    }
+    return this;
+  }
+  /**
+   * Evict the least recently used item, returning its value or
+   * `undefined` if cache is empty.
+   */
+  pop() {
+    var _a2;
+    try {
+      while (__privateGet(this, _size)) {
+        const val = __privateGet(this, _valList)[__privateGet(this, _head)];
+        __privateMethod(this, _LRUCache_instances, evict_fn).call(this, true);
+        if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, val)) {
+          if (val.__staleWhileFetching) {
+            return val.__staleWhileFetching;
+          }
+        } else if (val !== void 0) {
+          return val;
+        }
+      }
+    } finally {
+      if (__privateGet(this, _hasDisposeAfter) && __privateGet(this, _disposed)) {
+        const dt = __privateGet(this, _disposed);
+        let task;
+        while (task = dt == null ? void 0 : dt.shift()) {
+          (_a2 = __privateGet(this, _disposeAfter)) == null ? void 0 : _a2.call(this, ...task);
+        }
+      }
+    }
+  }
+  /**
+   * Check if a key is in the cache, without updating the recency of use.
+   * Will return false if the item is stale, even though it is technically
+   * in the cache.
+   *
+   * Check if a key is in the cache, without updating the recency of
+   * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+   * to `true` in either the options or the constructor.
+   *
+   * Will return `false` if the item is stale, even though it is technically in
+   * the cache. The difference can be determined (if it matters) by using a
+   * `status` argument, and inspecting the `has` field.
+   *
+   * Will not update item age unless
+   * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+   */
+  has(k, hasOptions = {}) {
+    const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+    const index = __privateGet(this, _keyMap).get(k);
+    if (index !== void 0) {
+      const v = __privateGet(this, _valList)[index];
+      if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) && v.__staleWhileFetching === void 0) {
+        return false;
+      }
+      if (!__privateGet(this, _isStale).call(this, index)) {
+        if (updateAgeOnHas) {
+          __privateGet(this, _updateItemAge).call(this, index);
+        }
+        if (status) {
+          status.has = "hit";
+          __privateGet(this, _statusTTL).call(this, status, index);
+        }
+        return true;
+      } else if (status) {
+        status.has = "stale";
+        __privateGet(this, _statusTTL).call(this, status, index);
+      }
+    } else if (status) {
+      status.has = "miss";
+    }
+    return false;
+  }
+  /**
+   * Like {@link LRUCache#get} but doesn't update recency or delete stale
+   * items.
+   *
+   * Returns `undefined` if the item is stale, unless
+   * {@link LRUCache.OptionsBase.allowStale} is set.
+   */
+  peek(k, peekOptions = {}) {
+    const { allowStale = this.allowStale } = peekOptions;
+    const index = __privateGet(this, _keyMap).get(k);
+    if (index === void 0 || !allowStale && __privateGet(this, _isStale).call(this, index)) {
+      return;
+    }
+    const v = __privateGet(this, _valList)[index];
+    return __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v) ? v.__staleWhileFetching : v;
+  }
+  async fetch(k, fetchOptions = {}) {
+    const {
+      // get options
+      allowStale = this.allowStale,
+      updateAgeOnGet = this.updateAgeOnGet,
+      noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+      // set options
+      ttl = this.ttl,
+      noDisposeOnSet = this.noDisposeOnSet,
+      size = 0,
+      sizeCalculation = this.sizeCalculation,
+      noUpdateTTL = this.noUpdateTTL,
+      // fetch exclusive options
+      noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
+      allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
+      ignoreFetchAbort = this.ignoreFetchAbort,
+      allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
+      context,
+      forceRefresh = false,
+      status,
+      signal
+    } = fetchOptions;
+    if (!__privateGet(this, _hasFetchMethod)) {
+      if (status)
+        status.fetch = "get";
+      return this.get(k, {
+        allowStale,
+        updateAgeOnGet,
+        noDeleteOnStaleGet,
+        status
+      });
+    }
+    const options = {
+      allowStale,
+      updateAgeOnGet,
+      noDeleteOnStaleGet,
+      ttl,
+      noDisposeOnSet,
+      size,
+      sizeCalculation,
+      noUpdateTTL,
+      noDeleteOnFetchRejection,
+      allowStaleOnFetchRejection,
+      allowStaleOnFetchAbort,
+      ignoreFetchAbort,
+      status,
+      signal
+    };
+    let index = __privateGet(this, _keyMap).get(k);
+    if (index === void 0) {
+      if (status)
+        status.fetch = "miss";
+      const p = __privateMethod(this, _LRUCache_instances, backgroundFetch_fn).call(this, k, index, options, context);
+      return p.__returned = p;
+    } else {
+      const v = __privateGet(this, _valList)[index];
+      if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+        const stale = allowStale && v.__staleWhileFetching !== void 0;
+        if (status) {
+          status.fetch = "inflight";
+          if (stale)
+            status.returnedStale = true;
+        }
+        return stale ? v.__staleWhileFetching : v.__returned = v;
+      }
+      const isStale = __privateGet(this, _isStale).call(this, index);
+      if (!forceRefresh && !isStale) {
+        if (status)
+          status.fetch = "hit";
+        __privateMethod(this, _LRUCache_instances, moveToTail_fn).call(this, index);
+        if (updateAgeOnGet) {
+          __privateGet(this, _updateItemAge).call(this, index);
+        }
+        if (status)
+          __privateGet(this, _statusTTL).call(this, status, index);
+        return v;
+      }
+      const p = __privateMethod(this, _LRUCache_instances, backgroundFetch_fn).call(this, k, index, options, context);
+      const hasStale = p.__staleWhileFetching !== void 0;
+      const staleVal = hasStale && allowStale;
+      if (status) {
+        status.fetch = isStale ? "stale" : "refresh";
+        if (staleVal && isStale)
+          status.returnedStale = true;
+      }
+      return staleVal ? p.__staleWhileFetching : p.__returned = p;
+    }
+  }
+  async forceFetch(k, fetchOptions = {}) {
+    const v = await this.fetch(k, fetchOptions);
+    if (v === void 0)
+      throw new Error("fetch() returned undefined");
+    return v;
+  }
+  memo(k, memoOptions = {}) {
+    const memoMethod = __privateGet(this, _memoMethod);
+    if (!memoMethod) {
+      throw new Error("no memoMethod provided to constructor");
+    }
+    const { context, forceRefresh, ...options } = memoOptions;
+    const v = this.get(k, options);
+    if (!forceRefresh && v !== void 0)
+      return v;
+    const vv = memoMethod(k, v, {
+      options,
+      context
+    });
+    this.set(k, vv, options);
+    return vv;
+  }
+  /**
+   * Return a value from the cache. Will update the recency of the cache
+   * entry found.
+   *
+   * If the key is not found, get() will return `undefined`.
+   */
+  get(k, getOptions = {}) {
+    const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+    const index = __privateGet(this, _keyMap).get(k);
+    if (index !== void 0) {
+      const value = __privateGet(this, _valList)[index];
+      const fetching = __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, value);
+      if (status)
+        __privateGet(this, _statusTTL).call(this, status, index);
+      if (__privateGet(this, _isStale).call(this, index)) {
+        if (status)
+          status.get = "stale";
+        if (!fetching) {
+          if (!noDeleteOnStaleGet) {
+            __privateMethod(this, _LRUCache_instances, delete_fn).call(this, k, "expire");
+          }
+          if (status && allowStale)
+            status.returnedStale = true;
+          return allowStale ? value : void 0;
+        } else {
+          if (status && allowStale && value.__staleWhileFetching !== void 0) {
+            status.returnedStale = true;
+          }
+          return allowStale ? value.__staleWhileFetching : void 0;
+        }
+      } else {
+        if (status)
+          status.get = "hit";
+        if (fetching) {
+          return value.__staleWhileFetching;
+        }
+        __privateMethod(this, _LRUCache_instances, moveToTail_fn).call(this, index);
+        if (updateAgeOnGet) {
+          __privateGet(this, _updateItemAge).call(this, index);
+        }
+        return value;
+      }
+    } else if (status) {
+      status.get = "miss";
+    }
+  }
+  /**
+   * Deletes a key out of the cache.
+   *
+   * Returns true if the key was deleted, false otherwise.
+   */
+  delete(k) {
+    return __privateMethod(this, _LRUCache_instances, delete_fn).call(this, k, "delete");
+  }
+  /**
+   * Clear the cache entirely, throwing away all values.
+   */
+  clear() {
+    return __privateMethod(this, _LRUCache_instances, clear_fn).call(this, "delete");
+  }
+};
+_max = new WeakMap();
+_maxSize = new WeakMap();
+_dispose = new WeakMap();
+_disposeAfter = new WeakMap();
+_fetchMethod = new WeakMap();
+_memoMethod = new WeakMap();
+_size = new WeakMap();
+_calculatedSize = new WeakMap();
+_keyMap = new WeakMap();
+_keyList = new WeakMap();
+_valList = new WeakMap();
+_next = new WeakMap();
+_prev = new WeakMap();
+_head = new WeakMap();
+_tail = new WeakMap();
+_free = new WeakMap();
+_disposed = new WeakMap();
+_sizes = new WeakMap();
+_starts = new WeakMap();
+_ttls = new WeakMap();
+_hasDispose = new WeakMap();
+_hasFetchMethod = new WeakMap();
+_hasDisposeAfter = new WeakMap();
+_LRUCache_instances = new WeakSet();
+initializeTTLTracking_fn = function() {
+  const ttls = new ZeroArray(__privateGet(this, _max));
+  const starts = new ZeroArray(__privateGet(this, _max));
+  __privateSet(this, _ttls, ttls);
+  __privateSet(this, _starts, starts);
+  __privateSet(this, _setItemTTL, (index, ttl, start = perf.now()) => {
+    starts[index] = ttl !== 0 ? start : 0;
+    ttls[index] = ttl;
+    if (ttl !== 0 && this.ttlAutopurge) {
+      const t = setTimeout(() => {
+        if (__privateGet(this, _isStale).call(this, index)) {
+          __privateMethod(this, _LRUCache_instances, delete_fn).call(this, __privateGet(this, _keyList)[index], "expire");
+        }
+      }, ttl + 1);
+      if (t.unref) {
+        t.unref();
+      }
+    }
+  });
+  __privateSet(this, _updateItemAge, (index) => {
+    starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+  });
+  __privateSet(this, _statusTTL, (status, index) => {
+    if (ttls[index]) {
+      const ttl = ttls[index];
+      const start = starts[index];
+      if (!ttl || !start)
+        return;
+      status.ttl = ttl;
+      status.start = start;
+      status.now = cachedNow || getNow();
+      const age = status.now - start;
+      status.remainingTTL = ttl - age;
+    }
+  });
+  let cachedNow = 0;
+  const getNow = () => {
+    const n = perf.now();
+    if (this.ttlResolution > 0) {
+      cachedNow = n;
+      const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+      if (t.unref) {
+        t.unref();
+      }
+    }
+    return n;
+  };
+  this.getRemainingTTL = (key) => {
+    const index = __privateGet(this, _keyMap).get(key);
+    if (index === void 0) {
+      return 0;
+    }
+    const ttl = ttls[index];
+    const start = starts[index];
+    if (!ttl || !start) {
+      return Infinity;
+    }
+    const age = (cachedNow || getNow()) - start;
+    return ttl - age;
+  };
+  __privateSet(this, _isStale, (index) => {
+    const s = starts[index];
+    const t = ttls[index];
+    return !!t && !!s && (cachedNow || getNow()) - s > t;
+  });
+};
+_updateItemAge = new WeakMap();
+_statusTTL = new WeakMap();
+_setItemTTL = new WeakMap();
+_isStale = new WeakMap();
+initializeSizeTracking_fn = function() {
+  const sizes = new ZeroArray(__privateGet(this, _max));
+  __privateSet(this, _calculatedSize, 0);
+  __privateSet(this, _sizes, sizes);
+  __privateSet(this, _removeItemSize, (index) => {
+    __privateSet(this, _calculatedSize, __privateGet(this, _calculatedSize) - sizes[index]);
+    sizes[index] = 0;
+  });
+  __privateSet(this, _requireSize, (k, v, size, sizeCalculation) => {
+    if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+      return 0;
+    }
+    if (!isPosInt(size)) {
+      if (sizeCalculation) {
+        if (typeof sizeCalculation !== "function") {
+          throw new TypeError("sizeCalculation must be a function");
+        }
+        size = sizeCalculation(v, k);
+        if (!isPosInt(size)) {
+          throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+        }
+      } else {
+        throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+      }
+    }
+    return size;
+  });
+  __privateSet(this, _addItemSize, (index, size, status) => {
+    sizes[index] = size;
+    if (__privateGet(this, _maxSize)) {
+      const maxSize = __privateGet(this, _maxSize) - sizes[index];
+      while (__privateGet(this, _calculatedSize) > maxSize) {
+        __privateMethod(this, _LRUCache_instances, evict_fn).call(this, true);
+      }
+    }
+    __privateSet(this, _calculatedSize, __privateGet(this, _calculatedSize) + sizes[index]);
+    if (status) {
+      status.entrySize = size;
+      status.totalCalculatedSize = __privateGet(this, _calculatedSize);
+    }
+  });
+};
+_removeItemSize = new WeakMap();
+_addItemSize = new WeakMap();
+_requireSize = new WeakMap();
+indexes_fn = function* ({ allowStale = this.allowStale } = {}) {
+  if (__privateGet(this, _size)) {
+    for (let i = __privateGet(this, _tail); true; ) {
+      if (!__privateMethod(this, _LRUCache_instances, isValidIndex_fn).call(this, i)) {
+        break;
+      }
+      if (allowStale || !__privateGet(this, _isStale).call(this, i)) {
+        yield i;
+      }
+      if (i === __privateGet(this, _head)) {
+        break;
+      } else {
+        i = __privateGet(this, _prev)[i];
+      }
+    }
+  }
+};
+rindexes_fn = function* ({ allowStale = this.allowStale } = {}) {
+  if (__privateGet(this, _size)) {
+    for (let i = __privateGet(this, _head); true; ) {
+      if (!__privateMethod(this, _LRUCache_instances, isValidIndex_fn).call(this, i)) {
+        break;
+      }
+      if (allowStale || !__privateGet(this, _isStale).call(this, i)) {
+        yield i;
+      }
+      if (i === __privateGet(this, _tail)) {
+        break;
+      } else {
+        i = __privateGet(this, _next)[i];
+      }
+    }
+  }
+};
+isValidIndex_fn = function(index) {
+  return index !== void 0 && __privateGet(this, _keyMap).get(__privateGet(this, _keyList)[index]) === index;
+};
+evict_fn = function(free) {
+  var _a2, _b2;
+  const head = __privateGet(this, _head);
+  const k = __privateGet(this, _keyList)[head];
+  const v = __privateGet(this, _valList)[head];
+  if (__privateGet(this, _hasFetchMethod) && __privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+    v.__abortController.abort(new Error("evicted"));
+  } else if (__privateGet(this, _hasDispose) || __privateGet(this, _hasDisposeAfter)) {
+    if (__privateGet(this, _hasDispose)) {
+      (_a2 = __privateGet(this, _dispose)) == null ? void 0 : _a2.call(this, v, k, "evict");
+    }
+    if (__privateGet(this, _hasDisposeAfter)) {
+      (_b2 = __privateGet(this, _disposed)) == null ? void 0 : _b2.push([v, k, "evict"]);
+    }
+  }
+  __privateGet(this, _removeItemSize).call(this, head);
+  if (free) {
+    __privateGet(this, _keyList)[head] = void 0;
+    __privateGet(this, _valList)[head] = void 0;
+    __privateGet(this, _free).push(head);
+  }
+  if (__privateGet(this, _size) === 1) {
+    __privateSet(this, _head, __privateSet(this, _tail, 0));
+    __privateGet(this, _free).length = 0;
+  } else {
+    __privateSet(this, _head, __privateGet(this, _next)[head]);
+  }
+  __privateGet(this, _keyMap).delete(k);
+  __privateWrapper(this, _size)._--;
+  return head;
+};
+backgroundFetch_fn = function(k, index, options, context) {
+  const v = index === void 0 ? void 0 : __privateGet(this, _valList)[index];
+  if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+    return v;
+  }
+  const ac = new AC();
+  const { signal } = options;
+  signal == null ? void 0 : signal.addEventListener("abort", () => ac.abort(signal.reason), {
+    signal: ac.signal
+  });
+  const fetchOpts = {
+    signal: ac.signal,
+    options,
+    context
+  };
+  const cb = (v2, updateCache = false) => {
+    const { aborted } = ac.signal;
+    const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
+    if (options.status) {
+      if (aborted && !updateCache) {
+        options.status.fetchAborted = true;
+        options.status.fetchError = ac.signal.reason;
+        if (ignoreAbort)
+          options.status.fetchAbortIgnored = true;
+      } else {
+        options.status.fetchResolved = true;
+      }
+    }
+    if (aborted && !ignoreAbort && !updateCache) {
+      return fetchFail(ac.signal.reason);
+    }
+    const bf2 = p;
+    if (__privateGet(this, _valList)[index] === p) {
+      if (v2 === void 0) {
+        if (bf2.__staleWhileFetching) {
+          __privateGet(this, _valList)[index] = bf2.__staleWhileFetching;
+        } else {
+          __privateMethod(this, _LRUCache_instances, delete_fn).call(this, k, "fetch");
+        }
+      } else {
+        if (options.status)
+          options.status.fetchUpdated = true;
+        this.set(k, v2, fetchOpts.options);
+      }
+    }
+    return v2;
+  };
+  const eb = (er) => {
+    if (options.status) {
+      options.status.fetchRejected = true;
+      options.status.fetchError = er;
+    }
+    return fetchFail(er);
+  };
+  const fetchFail = (er) => {
+    const { aborted } = ac.signal;
+    const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+    const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+    const noDelete = allowStale || options.noDeleteOnFetchRejection;
+    const bf2 = p;
+    if (__privateGet(this, _valList)[index] === p) {
+      const del = !noDelete || bf2.__staleWhileFetching === void 0;
+      if (del) {
+        __privateMethod(this, _LRUCache_instances, delete_fn).call(this, k, "fetch");
+      } else if (!allowStaleAborted) {
+        __privateGet(this, _valList)[index] = bf2.__staleWhileFetching;
+      }
+    }
+    if (allowStale) {
+      if (options.status && bf2.__staleWhileFetching !== void 0) {
+        options.status.returnedStale = true;
+      }
+      return bf2.__staleWhileFetching;
+    } else if (bf2.__returned === bf2) {
+      throw er;
+    }
+  };
+  const pcall = (res, rej) => {
+    var _a2;
+    const fmp = (_a2 = __privateGet(this, _fetchMethod)) == null ? void 0 : _a2.call(this, k, v, fetchOpts);
+    if (fmp && fmp instanceof Promise) {
+      fmp.then((v2) => res(v2 === void 0 ? void 0 : v2), rej);
+    }
+    ac.signal.addEventListener("abort", () => {
+      if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+        res(void 0);
+        if (options.allowStaleOnFetchAbort) {
+          res = (v2) => cb(v2, true);
+        }
+      }
+    });
+  };
+  if (options.status)
+    options.status.fetchDispatched = true;
+  const p = new Promise(pcall).then(cb, eb);
+  const bf = Object.assign(p, {
+    __abortController: ac,
+    __staleWhileFetching: v,
+    __returned: void 0
+  });
+  if (index === void 0) {
+    this.set(k, bf, { ...fetchOpts.options, status: void 0 });
+    index = __privateGet(this, _keyMap).get(k);
+  } else {
+    __privateGet(this, _valList)[index] = bf;
+  }
+  return bf;
+};
+isBackgroundFetch_fn = function(p) {
+  if (!__privateGet(this, _hasFetchMethod))
+    return false;
+  const b = p;
+  return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
+};
+connect_fn = function(p, n) {
+  __privateGet(this, _prev)[n] = p;
+  __privateGet(this, _next)[p] = n;
+};
+moveToTail_fn = function(index) {
+  if (index !== __privateGet(this, _tail)) {
+    if (index === __privateGet(this, _head)) {
+      __privateSet(this, _head, __privateGet(this, _next)[index]);
+    } else {
+      __privateMethod(this, _LRUCache_instances, connect_fn).call(this, __privateGet(this, _prev)[index], __privateGet(this, _next)[index]);
+    }
+    __privateMethod(this, _LRUCache_instances, connect_fn).call(this, __privateGet(this, _tail), index);
+    __privateSet(this, _tail, index);
+  }
+};
+delete_fn = function(k, reason) {
+  var _a2, _b2, _c2, _d;
+  let deleted = false;
+  if (__privateGet(this, _size) !== 0) {
+    const index = __privateGet(this, _keyMap).get(k);
+    if (index !== void 0) {
+      deleted = true;
+      if (__privateGet(this, _size) === 1) {
+        __privateMethod(this, _LRUCache_instances, clear_fn).call(this, reason);
+      } else {
+        __privateGet(this, _removeItemSize).call(this, index);
+        const v = __privateGet(this, _valList)[index];
+        if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+          v.__abortController.abort(new Error("deleted"));
+        } else if (__privateGet(this, _hasDispose) || __privateGet(this, _hasDisposeAfter)) {
+          if (__privateGet(this, _hasDispose)) {
+            (_a2 = __privateGet(this, _dispose)) == null ? void 0 : _a2.call(this, v, k, reason);
+          }
+          if (__privateGet(this, _hasDisposeAfter)) {
+            (_b2 = __privateGet(this, _disposed)) == null ? void 0 : _b2.push([v, k, reason]);
+          }
+        }
+        __privateGet(this, _keyMap).delete(k);
+        __privateGet(this, _keyList)[index] = void 0;
+        __privateGet(this, _valList)[index] = void 0;
+        if (index === __privateGet(this, _tail)) {
+          __privateSet(this, _tail, __privateGet(this, _prev)[index]);
+        } else if (index === __privateGet(this, _head)) {
+          __privateSet(this, _head, __privateGet(this, _next)[index]);
+        } else {
+          const pi = __privateGet(this, _prev)[index];
+          __privateGet(this, _next)[pi] = __privateGet(this, _next)[index];
+          const ni = __privateGet(this, _next)[index];
+          __privateGet(this, _prev)[ni] = __privateGet(this, _prev)[index];
+        }
+        __privateWrapper(this, _size)._--;
+        __privateGet(this, _free).push(index);
+      }
+    }
+  }
+  if (__privateGet(this, _hasDisposeAfter) && ((_c2 = __privateGet(this, _disposed)) == null ? void 0 : _c2.length)) {
+    const dt = __privateGet(this, _disposed);
+    let task;
+    while (task = dt == null ? void 0 : dt.shift()) {
+      (_d = __privateGet(this, _disposeAfter)) == null ? void 0 : _d.call(this, ...task);
+    }
+  }
+  return deleted;
+};
+clear_fn = function(reason) {
+  var _a2, _b2, _c2;
+  for (const index of __privateMethod(this, _LRUCache_instances, rindexes_fn).call(this, { allowStale: true })) {
+    const v = __privateGet(this, _valList)[index];
+    if (__privateMethod(this, _LRUCache_instances, isBackgroundFetch_fn).call(this, v)) {
+      v.__abortController.abort(new Error("deleted"));
+    } else {
+      const k = __privateGet(this, _keyList)[index];
+      if (__privateGet(this, _hasDispose)) {
+        (_a2 = __privateGet(this, _dispose)) == null ? void 0 : _a2.call(this, v, k, reason);
+      }
+      if (__privateGet(this, _hasDisposeAfter)) {
+        (_b2 = __privateGet(this, _disposed)) == null ? void 0 : _b2.push([v, k, reason]);
+      }
+    }
+  }
+  __privateGet(this, _keyMap).clear();
+  __privateGet(this, _valList).fill(void 0);
+  __privateGet(this, _keyList).fill(void 0);
+  if (__privateGet(this, _ttls) && __privateGet(this, _starts)) {
+    __privateGet(this, _ttls).fill(0);
+    __privateGet(this, _starts).fill(0);
+  }
+  if (__privateGet(this, _sizes)) {
+    __privateGet(this, _sizes).fill(0);
+  }
+  __privateSet(this, _head, 0);
+  __privateSet(this, _tail, 0);
+  __privateGet(this, _free).length = 0;
+  __privateSet(this, _calculatedSize, 0);
+  __privateSet(this, _size, 0);
+  if (__privateGet(this, _hasDisposeAfter) && __privateGet(this, _disposed)) {
+    const dt = __privateGet(this, _disposed);
+    let task;
+    while (task = dt == null ? void 0 : dt.shift()) {
+      (_c2 = __privateGet(this, _disposeAfter)) == null ? void 0 : _c2.call(this, ...task);
+    }
+  }
+};
+let LRUCache = _LRUCache;
+const CacheSize = {
+  KB: 1024,
+  MB: 1024 * 1024,
+  GB: 1024 * 1024 * 1024
+};
+const CacheTime = {
+  SECOND: 1e3,
+  MINUTE: 60 * 1e3,
+  HOUR: 60 * 60 * 1e3,
+  DAY: 24 * 60 * 60 * 1e3,
+  WEEK: 7 * 24 * 60 * 60 * 1e3,
+  MONTH: 30 * 24 * 60 * 60 * 1e3
+};
+function getTagKeyMap() {
+  const dataFetchCache = getDataFetchCache();
+  if (!dataFetchCache || !dataFetchCache.tagKeyMap) {
+    const tagKeyMap = /* @__PURE__ */ new Map();
+    globalThis.__MF_DATA_FETCH_CACHE__ || (globalThis.__MF_DATA_FETCH_CACHE__ = {});
+    globalThis.__MF_DATA_FETCH_CACHE__.tagKeyMap = tagKeyMap;
+    return tagKeyMap;
+  }
+  return dataFetchCache.tagKeyMap;
+}
+function addTagKeyRelation(tag, key) {
+  const tagKeyMap = getTagKeyMap();
+  let keys = tagKeyMap.get(tag);
+  if (!keys) {
+    keys = /* @__PURE__ */ new Set();
+    tagKeyMap.set(tag, keys);
+  }
+  keys.add(key);
+}
+function getCacheConfig() {
+  const dataFetchCache = getDataFetchCache();
+  if (!dataFetchCache || !dataFetchCache.cacheConfig) {
+    const cacheConfig = {
+      maxSize: CacheSize.GB
+    };
+    globalThis.__MF_DATA_FETCH_CACHE__ || (globalThis.__MF_DATA_FETCH_CACHE__ = {});
+    globalThis.__MF_DATA_FETCH_CACHE__.cacheConfig = cacheConfig;
+    return cacheConfig;
+  }
+  return dataFetchCache.cacheConfig;
+}
+function configureCache(config) {
+  const cacheConfig = getCacheConfig();
+  Object.assign(cacheConfig, config);
+}
+function getLRUCache() {
+  const dataFetchCache = getDataFetchCache();
+  const cacheConfig = getCacheConfig();
+  if (!dataFetchCache || !dataFetchCache.cacheStore) {
+    const cacheStore = new LRUCache({
+      maxSize: cacheConfig.maxSize ?? CacheSize.GB,
+      sizeCalculation: (value) => {
+        if (!value.size) {
+          return 1;
+        }
+        let size = 0;
+        for (const [k, item] of value.entries()) {
+          size += k.length * 2;
+          size += estimateObjectSize(item.data);
+          size += 8;
+        }
+        return size;
+      },
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+    globalThis.__MF_DATA_FETCH_CACHE__ || (globalThis.__MF_DATA_FETCH_CACHE__ = {});
+    globalThis.__MF_DATA_FETCH_CACHE__.cacheStore = cacheStore;
+    return cacheStore;
+  }
+  return dataFetchCache.cacheStore;
+}
+function estimateObjectSize(data) {
+  const type = typeof data;
+  if (type === "number") return 8;
+  if (type === "boolean") return 4;
+  if (type === "string") return Math.max(data.length * 2, 1);
+  if (data === null || data === void 0) return 1;
+  if (ArrayBuffer.isView(data)) {
+    return Math.max(data.byteLength, 1);
+  }
+  if (Array.isArray(data)) {
+    return Math.max(
+      data.reduce((acc, item) => acc + estimateObjectSize(item), 0),
+      1
+    );
+  }
+  if (data instanceof Map || data instanceof Set) {
+    return 1024;
+  }
+  if (data instanceof Date) {
+    return 8;
+  }
+  if (type === "object") {
+    return Math.max(
+      Object.entries(data).reduce(
+        (acc, [key, value]) => acc + key.length * 2 + estimateObjectSize(value),
+        0
+      ),
+      1
+    );
+  }
+  return 1;
+}
+function generateKey(dataFetchOptions) {
+  return JSON.stringify(dataFetchOptions, (_, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((result, key) => {
+        result[key] = value[key];
+        return result;
+      }, {});
+    }
+    return value;
+  });
+}
+function cache(fn, options) {
+  const {
+    tag = "default",
+    maxAge = CacheTime.MINUTE * 5,
+    revalidate = 0,
+    onCache,
+    getKey
+  } = options || {};
+  const tags = Array.isArray(tag) ? tag : [tag];
+  return async (dataFetchOptions) => {
+    if (dataFetchOptions.isDowngrade || !dataFetchOptions._id) {
+      return fn(dataFetchOptions);
+    }
+    const store = getLRUCache();
+    const now = Date.now();
+    const storeKey = dataFetchOptions._id;
+    const cacheKey = getKey ? getKey(dataFetchOptions) : generateKey(dataFetchOptions);
+    tags.forEach((t) => addTagKeyRelation(t, cacheKey));
+    let cacheStore = store.get(cacheKey);
+    if (!cacheStore) {
+      cacheStore = /* @__PURE__ */ new Map();
+    }
+    const cached = cacheStore.get(storeKey);
+    if (cached) {
+      const age = now - cached.timestamp;
+      if (age < maxAge) {
+        if (onCache) {
+          const useCache = onCache({
+            status: "hit",
+            key: cacheKey,
+            params: dataFetchOptions,
+            result: cached.data
+          });
+          if (!useCache) {
+            return fn(dataFetchOptions);
+          }
+        }
+        return cached.data;
+      }
+      if (revalidate > 0 && age < maxAge + revalidate) {
+        if (onCache) {
+          onCache({
+            status: "stale",
+            key: cacheKey,
+            params: dataFetchOptions,
+            result: cached.data
+          });
+        }
+        if (!cached.isRevalidating) {
+          cached.isRevalidating = true;
+          Promise.resolve().then(async () => {
+            try {
+              const newData = await fn(dataFetchOptions);
+              cacheStore.set(storeKey, {
+                data: newData,
+                timestamp: Date.now(),
+                isRevalidating: false
+              });
+              store.set(cacheKey, cacheStore);
+            } catch (error) {
+              cached.isRevalidating = false;
+              console.error("Background revalidation failed:", error);
+            }
+          });
+        }
+        return cached.data;
+      }
+    }
+    const data = await fn(dataFetchOptions);
+    cacheStore.set(storeKey, {
+      data,
+      timestamp: now,
+      isRevalidating: false
+    });
+    store.set(cacheKey, cacheStore);
+    if (onCache) {
+      onCache({
+        status: "miss",
+        key: cacheKey,
+        params: dataFetchOptions,
+        result: data
+      });
+    }
+    return data;
+  };
+}
+function revalidateTag(tag) {
+  const tagKeyMap = getTagKeyMap();
+  const keys = tagKeyMap.get(tag);
+  const lruCache = getLRUCache();
+  if (keys) {
+    keys.forEach((key) => {
+      lruCache == null ? void 0 : lruCache.delete(key);
+    });
+  }
+}
+function clearStore() {
+  var _a2;
+  const lruCache = getLRUCache();
+  const tagKeyMap = getTagKeyMap();
+  lruCache == null ? void 0 : lruCache.clear();
+  (_a2 = globalThis.__MF_DATA_FETCH_CACHE__) == null ? true : delete _a2.cacheStore;
+  tagKeyMap.clear();
+}
+const getDataFetchInfo = ({
+  name,
+  alias,
+  id,
+  remoteSnapshot
+}) => {
+  if (!remoteSnapshot) {
+    return;
+  }
+  if (!("modules" in remoteSnapshot)) {
+    return;
+  }
+  const regex = new RegExp(`^${name}(/[^/].*|)$`);
+  const nameOrAlias = regex.test(id) ? name : alias || name;
+  const expose = id.replace(nameOrAlias, "");
+  let dataFetchName = "";
+  let dataFetchId = "";
+  let dataFetchKey = "";
+  if (expose.startsWith("/")) {
+    dataFetchName = `${expose.slice(1)}.${DATA_FETCH_IDENTIFIER}`;
+    dataFetchId = `${id}.${DATA_FETCH_IDENTIFIER}`;
+    dataFetchKey = `${name}${expose}.${DATA_FETCH_IDENTIFIER}`;
+  } else if (expose === "") {
+    dataFetchName = DATA_FETCH_IDENTIFIER;
+    dataFetchId = `${id}/${DATA_FETCH_IDENTIFIER}`;
+    dataFetchKey = `${name}/${DATA_FETCH_IDENTIFIER}`;
+  } else {
+    return;
+  }
+  if (!dataFetchName || !dataFetchId || !dataFetchKey) {
+    return;
+  }
+  if (!remoteSnapshot.modules.find(
+    (module) => module.moduleName === dataFetchName
+  )) {
+    return;
+  }
+  return {
+    dataFetchName,
+    dataFetchId,
+    dataFetchKey
+  };
+};
+function initDataFetchMap() {
+  globalThis.__MF_DATA_FETCH_MAP__ || (globalThis.__MF_DATA_FETCH_MAP__ = {});
+}
+function getDataFetchItem(id) {
+  var _a2;
+  return (_a2 = globalThis.__MF_DATA_FETCH_MAP__) == null ? void 0 : _a2[id];
+}
+function getDataFetchMap() {
+  return globalThis.__MF_DATA_FETCH_MAP__;
+}
+function getDataFetchCache() {
+  return globalThis.__MF_DATA_FETCH_CACHE__;
+}
+const flushDataFetch = () => {
+  globalThis.__MF_DATA_FETCH_MAP__ = {};
+  globalThis[DOWNGRADE_KEY] = void 0;
+  clearStore();
+};
+function setDataFetchItemLoadedStatus(id) {
+  const dataFetchItem = getDataFetchItem(id);
+  if (!dataFetchItem) {
+    return;
+  }
+  dataFetchItem[2] = MF_DATA_FETCH_STATUS.LOADED;
+}
+const wrapDataFetchId = (id) => {
+  return `${WRAP_DATA_FETCH_ID_IDENTIFIER}${id}${WRAP_DATA_FETCH_ID_IDENTIFIER}`;
+};
+const getDataFetchIdWithErrorMsgs = (errMsgs) => {
+  const firstIdentifierIndex = errMsgs.indexOf(WRAP_DATA_FETCH_ID_IDENTIFIER);
+  if (firstIdentifierIndex === -1) {
+    return void 0;
+  }
+  const secondIdentifierIndex = errMsgs.indexOf(
+    WRAP_DATA_FETCH_ID_IDENTIFIER,
+    firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length
+  );
+  if (secondIdentifierIndex === -1) {
+    return void 0;
+  }
+  return errMsgs.substring(
+    firstIdentifierIndex + WRAP_DATA_FETCH_ID_IDENTIFIER.length,
+    secondIdentifierIndex
+  );
+};
+async function fetchData(id, params, remoteInfo) {
+  var _a2;
+  const callFetchData = async () => {
+    const item = getDataFetchItem(id);
+    if (!item) {
+      return;
+    }
+    const [fetchDataFnArr, ..._rest] = item;
+    const fetchDataFn = await fetchDataFnArr[2];
+    if (!fetchDataFn) {
+      return;
+    }
+    return fetchDataFn({
+      ...params,
+      _id: id
+    });
+  };
+  if (isBrowserEnv()) {
+    const dataFetchItem = getDataFetchItem(id);
+    if (!dataFetchItem) {
+      throw new Error(`dataFetchItem not found, id: ${id}`);
+    }
+    if ((_a2 = dataFetchItem[1]) == null ? void 0 : _a2[0]) {
+      return dataFetchItem[1][0];
+    }
+    if (isCSROnly()) {
+      logger.debug("==========csr only!");
+      return callFetchData();
+    }
+    if (remoteInfo) {
+      return callDowngrade(id, params, remoteInfo);
+    }
+    const mfDowngrade = getDowngradeTag();
+    if (mfDowngrade && (typeof mfDowngrade === "boolean" || mfDowngrade.includes(id))) {
+      return callDowngrade(id, { ...params, isDowngrade: true });
+    }
+    let res;
+    let rej;
+    const p = new Promise((resolve, reject) => {
+      res = resolve;
+      rej = reject;
+    });
+    dataFetchItem[1] = [p, res, rej];
+    dataFetchItem[2] = MF_DATA_FETCH_STATUS.AWAIT;
+    return dataFetchItem[1][0];
+  }
+  return callFetchData();
+}
+function getDataFetchMapKey(dataFetchInfo, hostInfo) {
+  if (!dataFetchInfo || !hostInfo) {
+    return;
+  }
+  const { dataFetchKey } = dataFetchInfo;
+  return composeKeyWithSeparator(dataFetchKey, hostInfo.name, hostInfo.version);
+}
+async function loadDataFetchModule(instance, id) {
+  return instance.loadRemote(id).then((m) => {
+    if (m && typeof m === "object" && "fetchData" in m && typeof m.fetchData === "function") {
+      return m.fetchData;
+    }
+    throw new Error(
+      `fetchData not found in remote ${id}, ${JSON.stringify(m)}`
+    );
+  });
+}
+function isDataLoaderExpose(exposeKey) {
+  return exposeKey.endsWith(DATA_FETCH_IDENTIFIER) || exposeKey.endsWith(DATA_FETCH_CLIENT_SUFFIX);
+}
+function getDowngradeTag() {
+  return globalThis[DOWNGRADE_KEY];
+}
+function callAllDowngrade() {
+  const dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  Object.keys(dataFetchMap).forEach((key) => {
+    callDowngrade(key);
+  });
+}
+async function callDowngrade(id, params, remoteInfo) {
+  const dataFetchMap = getDataFetchMap();
+  if (!dataFetchMap) {
+    return;
+  }
+  const mfDataFetch = dataFetchMap[id];
+  if ((mfDataFetch == null ? void 0 : mfDataFetch[2]) === MF_DATA_FETCH_STATUS.AWAIT) {
+    mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADING;
+    let promise;
+    let res;
+    let rej;
+    if (mfDataFetch[1]) {
+      promise = mfDataFetch[1][0];
+      res = mfDataFetch[1][1];
+      rej = mfDataFetch[1][2];
+    } else {
+      promise = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+      mfDataFetch[1] = [promise, res, rej];
+    }
+    const dataFetchType = mfDataFetch[0][1];
+    if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_CLIENT) {
+      try {
+        mfDataFetch[0][0]().then(async (getDataFetchFn) => {
+          return getDataFetchFn({
+            ...params,
+            isDowngrade: true,
+            _id: id
+          }).then((data) => {
+            mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+            res && res(data);
+          });
+        });
+      } catch (e) {
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+        rej && rej(e);
+      }
+    } else if (dataFetchType === MF_DATA_FETCH_TYPE.FETCH_SERVER) {
+      try {
+        const currentUrl = new URL(window.location.href);
+        currentUrl.searchParams.set(DATA_FETCH_QUERY, encodeURIComponent(id));
+        if (params) {
+          currentUrl.searchParams.set(
+            "params",
+            encodeURIComponent(JSON.stringify(params))
+          );
+        }
+        if (remoteInfo) {
+          currentUrl.searchParams.set(
+            "remoteInfo",
+            encodeURIComponent(JSON.stringify(remoteInfo))
+          );
+        }
+        const fetchServerQuery = globalThis.FEDERATION_SERVER_QUERY;
+        if (fetchServerQuery && typeof fetchServerQuery === "object") {
+          Object.keys(fetchServerQuery).forEach((key) => {
+            currentUrl.searchParams.set(
+              key,
+              JSON.stringify(fetchServerQuery[key])
+            );
+          });
+        }
+        const fetchUrl = currentUrl.toString();
+        const data = await fetch(fetchUrl).then((res2) => res2.json());
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.LOADED;
+        res && res(data);
+      } catch (e) {
+        mfDataFetch[2] = MF_DATA_FETCH_STATUS.ERROR;
+        rej && rej(e);
+      }
+    }
+    return promise;
+  }
+}
+function isCSROnly() {
+  return window._SSR_DATA === void 0;
+}
+function isServerEnv() {
+  return typeof window === "undefined";
+}
+function setSSREnv({
+  fetchServerQuery
+}) {
+  globalThis.FEDERATION_SSR = true;
+  globalThis.FEDERATION_SERVER_QUERY = fetchServerQuery;
+}
+function getLoadedRemoteInfos(id, instance) {
+  if (!instance) {
+    return;
+  }
+  const { name, expose } = instance.remoteHandler.idToRemoteMap[id] || {};
+  if (!name) {
+    return;
+  }
+  const module = instance.moduleCache.get(name);
+  if (!module) {
+    return;
+  }
+  const { remoteSnapshot } = instance.snapshotHandler.getGlobalRemoteInfo(
+    module.remoteInfo
+  );
+  return {
+    ...module.remoteInfo,
+    snapshot: remoteSnapshot,
+    expose
+  };
+}
+export {
+  DOWNGRADE_KEY as A,
+  getDowngradeTag as B,
+  CacheSize as C,
+  DATA_FETCH_QUERY as D,
+  ERROR_TYPE as E,
+  FS_HREF as F,
+  callAllDowngrade as G,
+  callDowngrade as H,
+  getDataFetchCache as I,
+  flushDataFetch as J,
+  LOAD_REMOTE_ERROR_PREFIX as L,
+  MF_DATA_FETCH_STATUS as M,
+  loadDataFetchModule as a,
+  CacheTime as b,
+  configureCache as c,
+  generateKey as d,
+  cache as e,
+  fetchData as f,
+  getDataFetchMap as g,
+  clearStore as h,
+  initDataFetchMap as i,
+  isDataLoaderExpose as j,
+  getDataFetchInfo as k,
+  logger as l,
+  getDataFetchMapKey as m,
+  getDataFetchItem as n,
+  DATA_FETCH_CLIENT_SUFFIX as o,
+  MF_DATA_FETCH_TYPE as p,
+  isCSROnly as q,
+  revalidateTag as r,
+  setSSREnv as s,
+  isServerEnv as t,
+  getDataFetchIdWithErrorMsgs as u,
+  DATA_FETCH_ERROR_PREFIX as v,
+  wrapDataFetchId as w,
+  DATA_FETCH_FUNCTION as x,
+  getLoadedRemoteInfos as y,
+  setDataFetchItemLoadedStatus as z
+};