@platforma-sdk/ui-vue 1.37.0 → 1.37.1

package/dist/node_modules/.pnpm/lru-cache@11.1.0/node_modules/lru-cache/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/lru-cache@11.1.0/node_modules/lru-cache/src/index.ts"],"sourcesContent":["/**\n * @module LRUCache\n */\n\n// module-private names and types\ntype Perf = { now: () => number }\nconst perf: Perf =\n  typeof performance === 'object' &&\n  performance &&\n  typeof performance.now === 'function'\n    ? performance\n    : Date\n\nconst warned = new Set<string>()\n\n// either a function or a class\ntype ForC = ((...a: any[]) => any) | { new (...a: any[]): any }\n\n/* c8 ignore start */\nconst PROCESS = (\n  typeof process === 'object' && !!process ? process : {}\n) as { [k: string]: any }\n/* c8 ignore start */\n\nconst emitWarning = (\n  msg: string,\n  type: string,\n  code: string,\n  fn: ForC\n) => {\n  typeof PROCESS.emitWarning === 'function'\n    ? PROCESS.emitWarning(msg, type, code, fn)\n    : console.error(`[${code}] ${type}: ${msg}`)\n}\n\nlet AC = globalThis.AbortController\nlet AS = globalThis.AbortSignal\n\n/* c8 ignore start */\nif (typeof AC === 'undefined') {\n  //@ts-ignore\n  AS = class AbortSignal {\n    onabort?: (...a: any[]) => any\n    _onabort: ((...a: any[]) => any)[] = []\n    reason?: any\n    aborted: boolean = false\n    addEventListener(_: string, fn: (...a: any[]) => any) {\n      this._onabort.push(fn)\n    }\n  }\n  //@ts-ignore\n  AC = class AbortController {\n    constructor() {\n      warnACPolyfill()\n    }\n    signal = new AS()\n    abort(reason: any) {\n      if (this.signal.aborted) return\n      //@ts-ignore\n      this.signal.reason = reason\n      //@ts-ignore\n      this.signal.aborted = true\n      //@ts-ignore\n      for (const fn of this.signal._onabort) {\n        fn(reason)\n      }\n      this.signal.onabort?.(reason)\n    }\n  }\n  let printACPolyfillWarning =\n    PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1'\n  const warnACPolyfill = () => {\n    if (!printACPolyfillWarning) return\n    printACPolyfillWarning = false\n    emitWarning(\n      'AbortController is not defined. If using lru-cache in ' +\n        'node 14, load an AbortController polyfill from the ' +\n        '`node-abort-controller` package. A minimal polyfill is ' +\n        'provided for use by LRUCache.fetch(), but it should not be ' +\n        'relied upon in other contexts (eg, passing it to other APIs that ' +\n        'use AbortController/AbortSignal might have undesirable effects). ' +\n        'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.',\n      'NO_ABORT_CONTROLLER',\n      'ENOTSUP',\n      warnACPolyfill\n    )\n  }\n}\n/* c8 ignore stop */\n\nconst shouldWarn = (code: string) => !warned.has(code)\n\nconst TYPE = Symbol('type')\nexport type PosInt = number & { [TYPE]: 'Positive Integer' }\nexport type Index = number & { [TYPE]: 'LRUCache Index' }\n\nconst isPosInt = (n: any): n is PosInt =>\n  n && n === Math.floor(n) && n > 0 && isFinite(n)\n\nexport type UintArray = Uint8Array | Uint16Array | Uint32Array\nexport type NumberArray = UintArray | number[]\n\n/* c8 ignore start */\n// This is a little bit ridiculous, tbh.\n// The maximum array length is 2^32-1 or thereabouts on most JS impls.\n// And well before that point, you're caching the entire world, I mean,\n// that's ~32GB of just integers for the next/prev links, plus whatever\n// else to hold that many keys and values.  Just filling the memory with\n// zeroes at init time is brutal when you get that big.\n// But why not be complete?\n// Maybe in the future, these limits will have expanded.\nconst getUintArray = (max: number) =>\n  !isPosInt(max)\n    ? null\n    : max <= Math.pow(2, 8)\n    ? Uint8Array\n    : max <= Math.pow(2, 16)\n    ? Uint16Array\n    : max <= Math.pow(2, 32)\n    ? Uint32Array\n    : max <= Number.MAX_SAFE_INTEGER\n    ? ZeroArray\n    : null\n/* c8 ignore stop */\n\nclass ZeroArray extends Array<number> {\n  constructor(size: number) {\n    super(size)\n    this.fill(0)\n  }\n}\nexport type { ZeroArray }\nexport type { Stack }\n\nexport type StackLike = Stack | Index[]\nclass Stack {\n  heap: NumberArray\n  length: number\n  // private constructor\n  static #constructing: boolean = false\n  static create(max: number): StackLike {\n    const HeapCls = getUintArray(max)\n    if (!HeapCls) return []\n    Stack.#constructing = true\n    const s = new Stack(max, HeapCls)\n    Stack.#constructing = false\n    return s\n  }\n  constructor(\n    max: number,\n    HeapCls: { new (n: number): NumberArray }\n  ) {\n    /* c8 ignore start */\n    if (!Stack.#constructing) {\n      throw new TypeError('instantiate Stack using Stack.create(n)')\n    }\n    /* c8 ignore stop */\n    this.heap = new HeapCls(max)\n    this.length = 0\n  }\n  push(n: Index) {\n    this.heap[this.length++] = n\n  }\n  pop(): Index {\n    return this.heap[--this.length] as Index\n  }\n}\n\n/**\n * Promise representing an in-progress {@link LRUCache#fetch} call\n */\nexport type BackgroundFetch<V> = Promise<V | undefined> & {\n  __returned: BackgroundFetch<V> | undefined\n  __abortController: AbortController\n  __staleWhileFetching: V | undefined\n}\n\nexport type DisposeTask<K, V> = [\n  value: V,\n  key: K,\n  reason: LRUCache.DisposeReason\n]\n\nexport namespace LRUCache {\n  /**\n   * An integer greater than 0, reflecting the calculated size of items\n   */\n  export type Size = number\n\n  /**\n   * Integer greater than 0, representing some number of milliseconds, or the\n   * time at which a TTL started counting from.\n   */\n  export type Milliseconds = number\n\n  /**\n   * An integer greater than 0, reflecting a number of items\n   */\n  export type Count = number\n\n  /**\n   * The reason why an item was removed from the cache, passed\n   * to the {@link Disposer} methods.\n   *\n   * - `evict`: The item was evicted because it is the least recently used,\n   *   and the cache is full.\n   * - `set`: A new value was set, overwriting the old value being disposed.\n   * - `delete`: The item was explicitly deleted, either by calling\n   *   {@link LRUCache#delete}, {@link LRUCache#clear}, or\n   *   {@link LRUCache#set} with an undefined value.\n   * - `expire`: The item was removed due to exceeding its TTL.\n   * - `fetch`: A {@link OptionsBase#fetchMethod} operation returned\n   *   `undefined` or was aborted, causing the item to be deleted.\n   */\n  export type DisposeReason =\n    | 'evict'\n    | 'set'\n    | 'delete'\n    | 'expire'\n    | 'fetch'\n  /**\n   * A method called upon item removal, passed as the\n   * {@link OptionsBase.dispose} and/or\n   * {@link OptionsBase.disposeAfter} options.\n   */\n  export type Disposer<K, V> = (\n    value: V,\n    key: K,\n    reason: DisposeReason\n  ) => void\n\n  /**\n   * The reason why an item was added to the cache, passed\n   * to the {@link Inserter} methods.\n   *\n   * - `add`: the item was not found in the cache, and was added\n   * - `update`: the item was in the cache, with the same value provided\n   * - `replace`: the item was in the cache, and replaced\n   */\n  export type InsertReason = 'add' | 'update' | 'replace'\n\n  /**\n   * A method called upon item insertion, passed as the\n   * {@link OptionsBase.insert}\n   */\n  export type Inserter<K, V> = (\n    value: V,\n    key: K,\n    reason: InsertReason\n  ) => void\n\n  /**\n   * A function that returns the effective calculated size\n   * of an entry in the cache.\n   */\n  export type SizeCalculator<K, V> = (value: V, key: K) => Size\n\n  /**\n   * Options provided to the\n   * {@link OptionsBase.fetchMethod} function.\n   */\n  export interface FetcherOptions<K, V, FC = unknown> {\n    signal: AbortSignal\n    options: FetcherFetchOptions<K, V, FC>\n    /**\n     * Object provided in the {@link FetchOptions.context} option to\n     * {@link LRUCache#fetch}\n     */\n    context: FC\n  }\n\n  /**\n   * Occasionally, it may be useful to track the internal behavior of the\n   * cache, particularly for logging, debugging, or for behavior within the\n   * `fetchMethod`. To do this, you can pass a `status` object to the\n   * {@link LRUCache#fetch}, {@link LRUCache#get}, {@link LRUCache#set},\n   * {@link LRUCache#memo}, and {@link LRUCache#has} methods.\n   *\n   * The `status` option should be a plain JavaScript object. The following\n   * fields will be set on it appropriately, depending on the situation.\n   */\n  export interface Status<V> {\n    /**\n     * The status of a set() operation.\n     *\n     * - add: the item was not found in the cache, and was added\n     * - update: the item was in the cache, with the same value provided\n     * - replace: the item was in the cache, and replaced\n     * - miss: the item was not added to the cache for some reason\n     */\n    set?: 'add' | 'update' | 'replace' | 'miss'\n\n    /**\n     * the ttl stored for the item, or undefined if ttls are not used.\n     */\n    ttl?: Milliseconds\n\n    /**\n     * the start time for the item, or undefined if ttls are not used.\n     */\n    start?: Milliseconds\n\n    /**\n     * The timestamp used for TTL calculation\n     */\n    now?: Milliseconds\n\n    /**\n     * the remaining ttl for the item, or undefined if ttls are not used.\n     */\n    remainingTTL?: Milliseconds\n\n    /**\n     * The calculated size for the item, if sizes are used.\n     */\n    entrySize?: Size\n\n    /**\n     * The total calculated size of the cache, if sizes are used.\n     */\n    totalCalculatedSize?: Size\n\n    /**\n     * A flag indicating that the item was not stored, due to exceeding the\n     * {@link OptionsBase.maxEntrySize}\n     */\n    maxEntrySizeExceeded?: true\n\n    /**\n     * The old value, specified in the case of `set:'update'` or\n     * `set:'replace'`\n     */\n    oldValue?: V\n\n    /**\n     * The results of a {@link LRUCache#has} operation\n     *\n     * - hit: the item was found in the cache\n     * - stale: the item was found in the cache, but is stale\n     * - miss: the item was not found in the cache\n     */\n    has?: 'hit' | 'stale' | 'miss'\n\n    /**\n     * The status of a {@link LRUCache#fetch} operation.\n     * Note that this can change as the underlying fetch() moves through\n     * various states.\n     *\n     * - inflight: there is another fetch() for this key which is in process\n     * - get: there is no {@link OptionsBase.fetchMethod}, so\n     *   {@link LRUCache#get} was called.\n     * - miss: the item is not in cache, and will be fetched.\n     * - hit: the item is in the cache, and was resolved immediately.\n     * - stale: the item is in the cache, but stale.\n     * - refresh: the item is in the cache, and not stale, but\n     *   {@link FetchOptions.forceRefresh} was specified.\n     */\n    fetch?: 'get' | 'inflight' | 'miss' | 'hit' | 'stale' | 'refresh'\n\n    /**\n     * The {@link OptionsBase.fetchMethod} was called\n     */\n    fetchDispatched?: true\n\n    /**\n     * The cached value was updated after a successful call to\n     * {@link OptionsBase.fetchMethod}\n     */\n    fetchUpdated?: true\n\n    /**\n     * The reason for a fetch() rejection.  Either the error raised by the\n     * {@link OptionsBase.fetchMethod}, or the reason for an\n     * AbortSignal.\n     */\n    fetchError?: Error\n\n    /**\n     * The fetch received an abort signal\n     */\n    fetchAborted?: true\n\n    /**\n     * The abort signal received was ignored, and the fetch was allowed to\n     * continue.\n     */\n    fetchAbortIgnored?: true\n\n    /**\n     * The fetchMethod promise resolved successfully\n     */\n    fetchResolved?: true\n\n    /**\n     * The fetchMethod promise was rejected\n     */\n    fetchRejected?: true\n\n    /**\n     * The status of a {@link LRUCache#get} operation.\n     *\n     * - fetching: The item is currently being fetched.  If a previous value\n     *   is present and allowed, that will be returned.\n     * - stale: The item is in the cache, and is stale.\n     * - hit: the item is in the cache\n     * - miss: the item is not in the cache\n     */\n    get?: 'stale' | 'hit' | 'miss'\n\n    /**\n     * A fetch or get operation returned a stale value.\n     */\n    returnedStale?: true\n  }\n\n  /**\n   * options which override the options set in the LRUCache constructor\n   * when calling {@link LRUCache#fetch}.\n   *\n   * This is the union of {@link GetOptions} and {@link SetOptions}, plus\n   * {@link OptionsBase.noDeleteOnFetchRejection},\n   * {@link OptionsBase.allowStaleOnFetchRejection},\n   * {@link FetchOptions.forceRefresh}, and\n   * {@link FetcherOptions.context}\n   *\n   * Any of these may be modified in the {@link OptionsBase.fetchMethod}\n   * function, but the {@link GetOptions} fields will of course have no\n   * effect, as the {@link LRUCache#get} call already happened by the time\n   * the fetchMethod is called.\n   */\n  export interface FetcherFetchOptions<K, V, FC = unknown>\n    extends Pick<\n      OptionsBase<K, V, FC>,\n      | 'allowStale'\n      | 'updateAgeOnGet'\n      | 'noDeleteOnStaleGet'\n      | 'sizeCalculation'\n      | 'ttl'\n      | 'noDisposeOnSet'\n      | 'noUpdateTTL'\n      | 'noDeleteOnFetchRejection'\n      | 'allowStaleOnFetchRejection'\n      | 'ignoreFetchAbort'\n      | 'allowStaleOnFetchAbort'\n    > {\n    status?: Status<V>\n    size?: Size\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#fetch} method.\n   */\n  export interface FetchOptions<K, V, FC>\n    extends FetcherFetchOptions<K, V, FC> {\n    /**\n     * Set to true to force a re-load of the existing data, even if it\n     * is not yet stale.\n     */\n    forceRefresh?: boolean\n    /**\n     * Context provided to the {@link OptionsBase.fetchMethod} as\n     * the {@link FetcherOptions.context} param.\n     *\n     * If the FC type is specified as unknown (the default),\n     * undefined or void, then this is optional.  Otherwise, it will\n     * be required.\n     */\n    context?: FC\n    signal?: AbortSignal\n    status?: Status<V>\n  }\n  /**\n   * Options provided to {@link LRUCache#fetch} when the FC type is something\n   * other than `unknown`, `undefined`, or `void`\n   */\n  export interface FetchOptionsWithContext<K, V, FC>\n    extends FetchOptions<K, V, FC> {\n    context: FC\n  }\n  /**\n   * Options provided to {@link LRUCache#fetch} when the FC type is\n   * `undefined` or `void`\n   */\n  export interface FetchOptionsNoContext<K, V>\n    extends FetchOptions<K, V, undefined> {\n    context?: undefined\n  }\n\n  export interface MemoOptions<K, V, FC = unknown>\n    extends Pick<\n      OptionsBase<K, V, FC>,\n      | 'allowStale'\n      | 'updateAgeOnGet'\n      | 'noDeleteOnStaleGet'\n      | 'sizeCalculation'\n      | 'ttl'\n      | 'noDisposeOnSet'\n      | 'noUpdateTTL'\n      | 'noDeleteOnFetchRejection'\n      | 'allowStaleOnFetchRejection'\n      | 'ignoreFetchAbort'\n      | 'allowStaleOnFetchAbort'\n    > {\n    /**\n     * Set to true to force a re-load of the existing data, even if it\n     * is not yet stale.\n     */\n    forceRefresh?: boolean\n    /**\n     * Context provided to the {@link OptionsBase.memoMethod} as\n     * the {@link MemoizerOptions.context} param.\n     *\n     * If the FC type is specified as unknown (the default),\n     * undefined or void, then this is optional.  Otherwise, it will\n     * be required.\n     */\n    context?: FC\n    status?: Status<V>\n  }\n  /**\n   * Options provided to {@link LRUCache#memo} when the FC type is something\n   * other than `unknown`, `undefined`, or `void`\n   */\n  export interface MemoOptionsWithContext<K, V, FC>\n    extends MemoOptions<K, V, FC> {\n    context: FC\n  }\n  /**\n   * Options provided to {@link LRUCache#memo} when the FC type is\n   * `undefined` or `void`\n   */\n  export interface MemoOptionsNoContext<K, V>\n    extends MemoOptions<K, V, undefined> {\n    context?: undefined\n  }\n\n  /**\n   * Options provided to the\n   * {@link OptionsBase.memoMethod} function.\n   */\n  export interface MemoizerOptions<K, V, FC = unknown> {\n    options: MemoizerMemoOptions<K, V, FC>\n    /**\n     * Object provided in the {@link MemoOptions.context} option to\n     * {@link LRUCache#memo}\n     */\n    context: FC\n  }\n\n  /**\n   * options which override the options set in the LRUCache constructor\n   * when calling {@link LRUCache#memo}.\n   *\n   * This is the union of {@link GetOptions} and {@link SetOptions}, plus\n   * {@link MemoOptions.forceRefresh}, and\n   * {@link MemoOptions.context}\n   *\n   * Any of these may be modified in the {@link OptionsBase.memoMethod}\n   * function, but the {@link GetOptions} fields will of course have no\n   * effect, as the {@link LRUCache#get} call already happened by the time\n   * the memoMethod is called.\n   */\n  export interface MemoizerMemoOptions<K, V, FC = unknown>\n    extends Pick<\n      OptionsBase<K, V, FC>,\n      | 'allowStale'\n      | 'updateAgeOnGet'\n      | 'noDeleteOnStaleGet'\n      | 'sizeCalculation'\n      | 'ttl'\n      | 'noDisposeOnSet'\n      | 'noUpdateTTL'\n    > {\n    status?: Status<V>\n    size?: Size\n    start?: Milliseconds\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#has} method.\n   */\n  export interface HasOptions<K, V, FC>\n    extends Pick<OptionsBase<K, V, FC>, 'updateAgeOnHas'> {\n    status?: Status<V>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#get} method.\n   */\n  export interface GetOptions<K, V, FC>\n    extends Pick<\n      OptionsBase<K, V, FC>,\n      'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet'\n    > {\n    status?: Status<V>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#peek} method.\n   */\n  export interface PeekOptions<K, V, FC>\n    extends Pick<OptionsBase<K, V, FC>, 'allowStale'> {}\n\n  /**\n   * Options that may be passed to the {@link LRUCache#set} method.\n   */\n  export interface SetOptions<K, V, FC>\n    extends Pick<\n      OptionsBase<K, V, FC>,\n      'sizeCalculation' | 'ttl' | 'noDisposeOnSet' | 'noUpdateTTL'\n    > {\n    /**\n     * If size tracking is enabled, then setting an explicit size\n     * in the {@link LRUCache#set} call will prevent calling the\n     * {@link OptionsBase.sizeCalculation} function.\n     */\n    size?: Size\n    /**\n     * If TTL tracking is enabled, then setting an explicit start\n     * time in the {@link LRUCache#set} call will override the\n     * default time from `performance.now()` or `Date.now()`.\n     *\n     * Note that it must be a valid value for whichever time-tracking\n     * method is in use.\n     */\n    start?: Milliseconds\n    status?: Status<V>\n  }\n\n  /**\n   * The type signature for the {@link OptionsBase.fetchMethod} option.\n   */\n  export type Fetcher<K, V, FC = unknown> = (\n    key: K,\n    staleValue: V | undefined,\n    options: FetcherOptions<K, V, FC>\n  ) => Promise<V | undefined | void> | V | undefined | void\n\n  /**\n   * the type signature for the {@link OptionsBase.memoMethod} option.\n   */\n  export type Memoizer<K, V, FC = unknown> = (\n    key: K,\n    staleValue: V | undefined,\n    options: MemoizerOptions<K, V, FC>\n  ) => V\n\n  /**\n   * Options which may be passed to the {@link LRUCache} constructor.\n   *\n   * Most of these may be overridden in the various options that use\n   * them.\n   *\n   * Despite all being technically optional, the constructor requires that\n   * a cache is at minimum limited by one or more of {@link OptionsBase.max},\n   * {@link OptionsBase.ttl}, or {@link OptionsBase.maxSize}.\n   *\n   * If {@link OptionsBase.ttl} is used alone, then it is strongly advised\n   * (and in fact required by the type definitions here) that the cache\n   * also set {@link OptionsBase.ttlAutopurge}, to prevent potentially\n   * unbounded storage.\n   *\n   * All options are also available on the {@link LRUCache} instance, making\n   * it safe to pass an LRUCache instance as the options argumemnt to\n   * make another empty cache of the same type.\n   *\n   * Some options are marked as read-only, because changing them after\n   * instantiation is not safe. Changing any of the other options will of\n   * course only have an effect on subsequent method calls.\n   */\n  export interface OptionsBase<K, V, FC> {\n    /**\n     * The maximum number of items to store in the cache before evicting\n     * old entries. This is read-only on the {@link LRUCache} instance,\n     * and may not be overridden.\n     *\n     * If set, then storage space will be pre-allocated at construction\n     * time, and the cache will perform significantly faster.\n     *\n     * Note that significantly fewer items may be stored, if\n     * {@link OptionsBase.maxSize} and/or {@link OptionsBase.ttl} are also\n     * set.\n     *\n     * **It is strongly recommended to set a `max` to prevent unbounded growth\n     * of the cache.**\n     */\n    max?: Count\n\n    /**\n     * Max time in milliseconds for items to live in cache before they are\n     * considered stale.  Note that stale items are NOT preemptively removed by\n     * default, and MAY live in the cache, contributing to its LRU max, long\n     * after they have expired, unless {@link OptionsBase.ttlAutopurge} is\n     * set.\n     *\n     * If set to `0` (the default value), then that means \"do not track\n     * TTL\", not \"expire immediately\".\n     *\n     * Also, as this cache is optimized for LRU/MRU operations, some of\n     * the staleness/TTL checks will reduce performance, as they will incur\n     * overhead by deleting items.\n     *\n     * This is not primarily a TTL cache, and does not make strong TTL\n     * guarantees. There is no pre-emptive pruning of expired items, but you\n     * _may_ set a TTL on the cache, and it will treat expired items as missing\n     * when they are fetched, and delete them.\n     *\n     * Optional, but must be a non-negative integer in ms if specified.\n     *\n     * This may be overridden by passing an options object to `cache.set()`.\n     *\n     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a\n     * positive integer if set.\n     *\n     * Even if ttl tracking is enabled, **it is strongly recommended to set a\n     * `max` to prevent unbounded growth of the cache.**\n     *\n     * If ttl tracking is enabled, and `max` and `maxSize` are not set,\n     * and `ttlAutopurge` is not set, then a warning will be emitted\n     * cautioning about the potential for unbounded memory consumption.\n     * (The TypeScript definitions will also discourage this.)\n     */\n    ttl?: Milliseconds\n\n    /**\n     * Minimum amount of time in ms in which to check for staleness.\n     * Defaults to 1, which means that the current time is checked\n     * at most once per millisecond.\n     *\n     * Set to 0 to check the current time every time staleness is tested.\n     * (This reduces performance, and is theoretically unnecessary.)\n     *\n     * Setting this to a higher value will improve performance somewhat\n     * while using ttl tracking, albeit at the expense of keeping stale\n     * items around a bit longer than their TTLs would indicate.\n     *\n     * @default 1\n     */\n    ttlResolution?: Milliseconds\n\n    /**\n     * Preemptively remove stale items from the cache.\n     *\n     * Note that this may *significantly* degrade performance, especially if\n     * the cache is storing a large number of items. It is almost always best\n     * to just leave the stale items in the cache, and let them fall out as new\n     * items are added.\n     *\n     * Note that this means that {@link OptionsBase.allowStale} is a bit\n     * pointless, as stale items will be deleted almost as soon as they\n     * expire.\n     *\n     * Use with caution!\n     */\n    ttlAutopurge?: boolean\n\n    /**\n     * When using time-expiring entries with `ttl`, setting this to `true` will\n     * make each item's age reset to 0 whenever it is retrieved from cache with\n     * {@link LRUCache#get}, causing it to not expire. (It can still fall out\n     * of cache based on recency of use, of course.)\n     *\n     * Has no effect if {@link OptionsBase.ttl} is not set.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     */\n    updateAgeOnGet?: boolean\n\n    /**\n     * When using time-expiring entries with `ttl`, setting this to `true` will\n     * make each item's age reset to 0 whenever its presence in the cache is\n     * checked with {@link LRUCache#has}, causing it to not expire. (It can\n     * still fall out of cache based on recency of use, of course.)\n     *\n     * Has no effect if {@link OptionsBase.ttl} is not set.\n     */\n    updateAgeOnHas?: boolean\n\n    /**\n     * Allow {@link LRUCache#get} and {@link LRUCache#fetch} calls to return\n     * stale data, if available.\n     *\n     * By default, if you set `ttl`, stale items will only be deleted from the\n     * cache when you `get(key)`. That is, it's not preemptively pruning items,\n     * unless {@link OptionsBase.ttlAutopurge} is set.\n     *\n     * If you set `allowStale:true`, it'll return the stale value *as well as*\n     * deleting it. If you don't set this, then it'll return `undefined` when\n     * you try to get a stale entry.\n     *\n     * Note that when a stale entry is fetched, _even if it is returned due to\n     * `allowStale` being set_, it is removed from the cache immediately. You\n     * can suppress this behavior by setting\n     * {@link OptionsBase.noDeleteOnStaleGet}, either in the constructor, or in\n     * the options provided to {@link LRUCache#get}.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     * The `cache.has()` method will always return `false` for stale items.\n     *\n     * Only relevant if a ttl is set.\n     */\n    allowStale?: boolean\n\n    /**\n     * Function that is called on items when they are dropped from the\n     * cache, as `dispose(value, key, reason)`.\n     *\n     * This can be handy if you want to close file descriptors or do\n     * other cleanup tasks when items are no longer stored in the cache.\n     *\n     * **NOTE**: It is called _before_ the item has been fully removed\n     * from the cache, so if you want to put it right back in, you need\n     * to wait until the next tick. If you try to add it back in during\n     * the `dispose()` function call, it will break things in subtle and\n     * weird ways.\n     *\n     * Unlike several other options, this may _not_ be overridden by\n     * passing an option to `set()`, for performance reasons.\n     *\n     * The `reason` will be one of the following strings, corresponding\n     * to the reason for the item's deletion:\n     *\n     * - `evict` Item was evicted to make space for a new addition\n     * - `set` Item was overwritten by a new value\n     * - `expire` Item expired its TTL\n     * - `fetch` Item was deleted due to a failed or aborted fetch, or a\n     *   fetchMethod returning `undefined.\n     * - `delete` Item was removed by explicit `cache.delete(key)`,\n     *   `cache.clear()`, or `cache.set(key, undefined)`.\n     */\n    dispose?: Disposer<K, V>\n\n    /**\n     * Function that is called when new items are inserted into the cache,\n     * as `onInsert(value, key, reason)`.\n     *\n     * This can be useful if you need to perform actions when an item is\n     * added, such as logging or tracking insertions.\n     *\n     * Unlike some other options, this may _not_ be overridden by passing\n     * an option to `set()`, for performance and consistency reasons.\n     */\n    onInsert?: Inserter<K, V>\n\n    /**\n     * The same as {@link OptionsBase.dispose}, but called *after* the entry\n     * is completely removed and the cache is once again in a clean state.\n     *\n     * It is safe to add an item right back into the cache at this point.\n     * However, note that it is *very* easy to inadvertently create infinite\n     * recursion this way.\n     */\n    disposeAfter?: Disposer<K, V>\n\n    /**\n     * Set to true to suppress calling the\n     * {@link OptionsBase.dispose} function if the entry key is\n     * still accessible within the cache.\n     *\n     * This may be overridden by passing an options object to\n     * {@link LRUCache#set}.\n     *\n     * Only relevant if `dispose` or `disposeAfter` are set.\n     */\n    noDisposeOnSet?: boolean\n\n    /**\n     * Boolean flag to tell the cache to not update the TTL when setting a new\n     * value for an existing key (ie, when updating a value rather than\n     * inserting a new value).  Note that the TTL value is _always_ set (if\n     * provided) when adding a new entry into the cache.\n     *\n     * Has no effect if a {@link OptionsBase.ttl} is not set.\n     *\n     * May be passed as an option to {@link LRUCache#set}.\n     */\n    noUpdateTTL?: boolean\n\n    /**\n     * Set to a positive integer to track the sizes of items added to the\n     * cache, and automatically evict items in order to stay below this size.\n     * Note that this may result in fewer than `max` items being stored.\n     *\n     * Attempting to add an item to the cache whose calculated size is greater\n     * that this amount will be a no-op. The item will not be cached, and no\n     * other items will be evicted.\n     *\n     * Optional, must be a positive integer if provided.\n     *\n     * Sets `maxEntrySize` to the same value, unless a different value is\n     * provided for `maxEntrySize`.\n     *\n     * At least one of `max`, `maxSize`, or `TTL` is required. This must be a\n     * positive integer if set.\n     *\n     * Even if size tracking is enabled, **it is strongly recommended to set a\n     * `max` to prevent unbounded growth of the cache.**\n     *\n     * Note also that size tracking can negatively impact performance,\n     * though for most cases, only minimally.\n     */\n    maxSize?: Size\n\n    /**\n     * The maximum allowed size for any single item in the cache.\n     *\n     * If a larger item is passed to {@link LRUCache#set} or returned by a\n     * {@link OptionsBase.fetchMethod} or {@link OptionsBase.memoMethod}, then\n     * it will not be stored in the cache.\n     *\n     * Attempting to add an item whose calculated size is greater than\n     * this amount will not cache the item or evict any old items, but\n     * WILL delete an existing value if one is already present.\n     *\n     * Optional, must be a positive integer if provided. Defaults to\n     * the value of `maxSize` if provided.\n     */\n    maxEntrySize?: Size\n\n    /**\n     * A function that returns a number indicating the item's size.\n     *\n     * Requires {@link OptionsBase.maxSize} to be set.\n     *\n     * If not provided, and {@link OptionsBase.maxSize} or\n     * {@link OptionsBase.maxEntrySize} are set, then all\n     * {@link LRUCache#set} calls **must** provide an explicit\n     * {@link SetOptions.size} or sizeCalculation param.\n     */\n    sizeCalculation?: SizeCalculator<K, V>\n\n    /**\n     * Method that provides the implementation for {@link LRUCache#fetch}\n     *\n     * ```ts\n     * fetchMethod(key, staleValue, { signal, options, context })\n     * ```\n     *\n     * If `fetchMethod` is not provided, then `cache.fetch(key)` is equivalent\n     * to `Promise.resolve(cache.get(key))`.\n     *\n     * If at any time, `signal.aborted` is set to `true`, or if the\n     * `signal.onabort` method is called, or if it emits an `'abort'` event\n     * which you can listen to with `addEventListener`, then that means that\n     * the fetch should be abandoned. This may be passed along to async\n     * functions aware of AbortController/AbortSignal behavior.\n     *\n     * The `fetchMethod` should **only** return `undefined` or a Promise\n     * resolving to `undefined` if the AbortController signaled an `abort`\n     * event. In all other cases, it should return or resolve to a value\n     * suitable for adding to the cache.\n     *\n     * The `options` object is a union of the options that may be provided to\n     * `set()` and `get()`. If they are modified, then that will result in\n     * modifying the settings to `cache.set()` when the value is resolved, and\n     * in the case of\n     * {@link OptionsBase.noDeleteOnFetchRejection} and\n     * {@link OptionsBase.allowStaleOnFetchRejection}, the handling of\n     * `fetchMethod` failures.\n     *\n     * For example, a DNS cache may update the TTL based on the value returned\n     * from a remote DNS server by changing `options.ttl` in the `fetchMethod`.\n     */\n    fetchMethod?: Fetcher<K, V, FC>\n\n    /**\n     * Method that provides the implementation for {@link LRUCache#memo}\n     */\n    memoMethod?: Memoizer<K, V, FC>\n\n    /**\n     * Set to true to suppress the deletion of stale data when a\n     * {@link OptionsBase.fetchMethod} returns a rejected promise.\n     */\n    noDeleteOnFetchRejection?: boolean\n\n    /**\n     * Do not delete stale items when they are retrieved with\n     * {@link LRUCache#get}.\n     *\n     * Note that the `get` return value will still be `undefined`\n     * unless {@link OptionsBase.allowStale} is true.\n     *\n     * When using time-expiring entries with `ttl`, by default stale\n     * items will be removed from the cache when the key is accessed\n     * with `cache.get()`.\n     *\n     * Setting this option will cause stale items to remain in the cache, until\n     * they are explicitly deleted with `cache.delete(key)`, or retrieved with\n     * `noDeleteOnStaleGet` set to `false`.\n     *\n     * This may be overridden by passing an options object to `cache.get()`.\n     *\n     * Only relevant if a ttl is used.\n     */\n    noDeleteOnStaleGet?: boolean\n\n    /**\n     * Set to true to allow returning stale data when a\n     * {@link OptionsBase.fetchMethod} throws an error or returns a rejected\n     * promise.\n     *\n     * This differs from using {@link OptionsBase.allowStale} in that stale\n     * data will ONLY be returned in the case that the {@link LRUCache#fetch}\n     * fails, not any other times.\n     *\n     * If a `fetchMethod` fails, and there is no stale value available, the\n     * `fetch()` will resolve to `undefined`. Ie, all `fetchMethod` errors are\n     * suppressed.\n     *\n     * Implies `noDeleteOnFetchRejection`.\n     *\n     * This may be set in calls to `fetch()`, or defaulted on the constructor,\n     * or overridden by modifying the options object in the `fetchMethod`.\n     */\n    allowStaleOnFetchRejection?: boolean\n\n    /**\n     * Set to true to return a stale value from the cache when the\n     * `AbortSignal` passed to the {@link OptionsBase.fetchMethod} dispatches\n     * an `'abort'` event, whether user-triggered, or due to internal cache\n     * behavior.\n     *\n     * Unless {@link OptionsBase.ignoreFetchAbort} is also set, the underlying\n     * {@link OptionsBase.fetchMethod} will still be considered canceled, and\n     * any value it returns will be ignored and not cached.\n     *\n     * Caveat: since fetches are aborted when a new value is explicitly\n     * set in the cache, this can lead to fetch returning a stale value,\n     * since that was the fallback value _at the moment the `fetch()` was\n     * initiated_, even though the new updated value is now present in\n     * the cache.\n     *\n     * For example:\n     *\n     * ```ts\n     * const cache = new LRUCache<string, any>({\n     *   ttl: 100,\n     *   fetchMethod: async (url, oldValue, { signal }) =>  {\n     *     const res = await fetch(url, { signal })\n     *     return await res.json()\n     *   }\n     * })\n     * cache.set('https://example.com/', { some: 'data' })\n     * // 100ms go by...\n     * const result = cache.fetch('https://example.com/')\n     * cache.set('https://example.com/', { other: 'thing' })\n     * console.log(await result) // { some: 'data' }\n     * console.log(cache.get('https://example.com/')) // { other: 'thing' }\n     * ```\n     */\n    allowStaleOnFetchAbort?: boolean\n\n    /**\n     * Set to true to ignore the `abort` event emitted by the `AbortSignal`\n     * object passed to {@link OptionsBase.fetchMethod}, and still cache the\n     * resulting resolution value, as long as it is not `undefined`.\n     *\n     * When used on its own, this means aborted {@link LRUCache#fetch} calls\n     * are not immediately resolved or rejected when they are aborted, and\n     * instead take the full time to await.\n     *\n     * When used with {@link OptionsBase.allowStaleOnFetchAbort}, aborted\n     * {@link LRUCache#fetch} calls will resolve immediately to their stale\n     * cached value or `undefined`, and will continue to process and eventually\n     * update the cache when they resolve, as long as the resulting value is\n     * not `undefined`, thus supporting a \"return stale on timeout while\n     * refreshing\" mechanism by passing `AbortSignal.timeout(n)` as the signal.\n     *\n     * For example:\n     *\n     * ```ts\n     * const c = new LRUCache({\n     *   ttl: 100,\n     *   ignoreFetchAbort: true,\n     *   allowStaleOnFetchAbort: true,\n     *   fetchMethod: async (key, oldValue, { signal }) => {\n     *     // note: do NOT pass the signal to fetch()!\n     *     // let's say this fetch can take a long time.\n     *     const res = await fetch(`https://slow-backend-server/${key}`)\n     *     return await res.json()\n     *   },\n     * })\n     *\n     * // this will return the stale value after 100ms, while still\n     * // updating in the background for next time.\n     * const val = await c.fetch('key', { signal: AbortSignal.timeout(100) })\n     * ```\n     *\n     * **Note**: regardless of this setting, an `abort` event _is still\n     * emitted on the `AbortSignal` object_, so may result in invalid results\n     * when passed to other underlying APIs that use AbortSignals.\n     *\n     * This may be overridden in the {@link OptionsBase.fetchMethod} or the\n     * call to {@link LRUCache#fetch}.\n     */\n    ignoreFetchAbort?: boolean\n  }\n\n  export interface OptionsMaxLimit<K, V, FC>\n    extends OptionsBase<K, V, FC> {\n    max: Count\n  }\n  export interface OptionsTTLLimit<K, V, FC>\n    extends OptionsBase<K, V, FC> {\n    ttl: Milliseconds\n    ttlAutopurge: boolean\n  }\n  export interface OptionsSizeLimit<K, V, FC>\n    extends OptionsBase<K, V, FC> {\n    maxSize: Size\n  }\n\n  /**\n   * The valid safe options for the {@link LRUCache} constructor\n   */\n  export type Options<K, V, FC> =\n    | OptionsMaxLimit<K, V, FC>\n    | OptionsSizeLimit<K, V, FC>\n    | OptionsTTLLimit<K, V, FC>\n\n  /**\n   * Entry objects used by {@link LRUCache#load} and {@link LRUCache#dump},\n   * and returned by {@link LRUCache#info}.\n   */\n  export interface Entry<V> {\n    value: V\n    ttl?: Milliseconds\n    size?: Size\n    start?: Milliseconds\n  }\n}\n\n/**\n * Default export, the thing you're using this module to get.\n *\n * The `K` and `V` types define the key and value types, respectively. The\n * optional `FC` type defines the type of the `context` object passed to\n * `cache.fetch()` and `cache.memo()`.\n *\n * Keys and values **must not** be `null` or `undefined`.\n *\n * All properties from the options object (with the exception of `max`,\n * `maxSize`, `fetchMethod`, `memoMethod`, `dispose` and `disposeAfter`) are\n * added as normal public members. (The listed options are read-only getters.)\n *\n * Changing any of these will alter the defaults for subsequent method calls.\n */\nexport class LRUCache<K extends {}, V extends {}, FC = unknown> {\n  // options that cannot be changed without disaster\n  readonly #max: LRUCache.Count\n  readonly #maxSize: LRUCache.Size\n  readonly #dispose?: LRUCache.Disposer<K, V>\n  readonly #onInsert?: LRUCache.Inserter<K, V>\n  readonly #disposeAfter?: LRUCache.Disposer<K, V>\n  readonly #fetchMethod?: LRUCache.Fetcher<K, V, FC>\n  readonly #memoMethod?: LRUCache.Memoizer<K, V, FC>\n\n  /**\n   * {@link LRUCache.OptionsBase.ttl}\n   */\n  ttl: LRUCache.Milliseconds\n\n  /**\n   * {@link LRUCache.OptionsBase.ttlResolution}\n   */\n  ttlResolution: LRUCache.Milliseconds\n  /**\n   * {@link LRUCache.OptionsBase.ttlAutopurge}\n   */\n  ttlAutopurge: boolean\n  /**\n   * {@link LRUCache.OptionsBase.updateAgeOnGet}\n   */\n  updateAgeOnGet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.updateAgeOnHas}\n   */\n  updateAgeOnHas: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStale}\n   */\n  allowStale: boolean\n\n  /**\n   * {@link LRUCache.OptionsBase.noDisposeOnSet}\n   */\n  noDisposeOnSet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.noUpdateTTL}\n   */\n  noUpdateTTL: boolean\n  /**\n   * {@link LRUCache.OptionsBase.maxEntrySize}\n   */\n  maxEntrySize: LRUCache.Size\n  /**\n   * {@link LRUCache.OptionsBase.sizeCalculation}\n   */\n  sizeCalculation?: LRUCache.SizeCalculator<K, V>\n  /**\n   * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}\n   */\n  noDeleteOnFetchRejection: boolean\n  /**\n   * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}\n   */\n  noDeleteOnStaleGet: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}\n   */\n  allowStaleOnFetchAbort: boolean\n  /**\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}\n   */\n  allowStaleOnFetchRejection: boolean\n  /**\n   * {@link LRUCache.OptionsBase.ignoreFetchAbort}\n   */\n  ignoreFetchAbort: boolean\n\n  // computed properties\n  #size: LRUCache.Count\n  #calculatedSize: LRUCache.Size\n  #keyMap: Map<K, Index>\n  #keyList: (K | undefined)[]\n  #valList: (V | BackgroundFetch<V> | undefined)[]\n  #next: NumberArray\n  #prev: NumberArray\n  #head: Index\n  #tail: Index\n  #free: StackLike\n  #disposed?: DisposeTask<K, V>[]\n  #sizes?: ZeroArray\n  #starts?: ZeroArray\n  #ttls?: ZeroArray\n\n  #hasDispose: boolean\n  #hasFetchMethod: boolean\n  #hasDisposeAfter: boolean\n  #hasOnInsert: boolean\n\n  /**\n   * Do not call this method unless you need to inspect the\n   * inner workings of the cache.  If anything returned by this\n   * object is modified in any way, strange breakage may occur.\n   *\n   * These fields are private for a reason!\n   *\n   * @internal\n   */\n  static unsafeExposeInternals<\n    K extends {},\n    V extends {},\n    FC extends unknown = unknown\n  >(c: LRUCache<K, V, FC>) {\n    return {\n      // properties\n      starts: c.#starts,\n      ttls: c.#ttls,\n      sizes: c.#sizes,\n      keyMap: c.#keyMap as Map<K, number>,\n      keyList: c.#keyList,\n      valList: c.#valList,\n      next: c.#next,\n      prev: c.#prev,\n      get head() {\n        return c.#head\n      },\n      get tail() {\n        return c.#tail\n      },\n      free: c.#free,\n      // methods\n      isBackgroundFetch: (p: any) => c.#isBackgroundFetch(p),\n      backgroundFetch: (\n        k: K,\n        index: number | undefined,\n        options: LRUCache.FetchOptions<K, V, FC>,\n        context: any\n      ): BackgroundFetch<V> =>\n        c.#backgroundFetch(\n          k,\n          index as Index | undefined,\n          options,\n          context\n        ),\n      moveToTail: (index: number): void =>\n        c.#moveToTail(index as Index),\n      indexes: (options?: { allowStale: boolean }) =>\n        c.#indexes(options),\n      rindexes: (options?: { allowStale: boolean }) =>\n        c.#rindexes(options),\n      isStale: (index: number | undefined) =>\n        c.#isStale(index as Index),\n    }\n  }\n\n  // Protected read-only members\n\n  /**\n   * {@link LRUCache.OptionsBase.max} (read-only)\n   */\n  get max(): LRUCache.Count {\n    return this.#max\n  }\n  /**\n   * {@link LRUCache.OptionsBase.maxSize} (read-only)\n   */\n  get maxSize(): LRUCache.Count {\n    return this.#maxSize\n  }\n  /**\n   * The total computed size of items in the cache (read-only)\n   */\n  get calculatedSize(): LRUCache.Size {\n    return this.#calculatedSize\n  }\n  /**\n   * The number of items stored in the cache (read-only)\n   */\n  get size(): LRUCache.Count {\n    return this.#size\n  }\n  /**\n   * {@link LRUCache.OptionsBase.fetchMethod} (read-only)\n   */\n  get fetchMethod(): LRUCache.Fetcher<K, V, FC> | undefined {\n    return this.#fetchMethod\n  }\n  get memoMethod(): LRUCache.Memoizer<K, V, FC> | undefined {\n    return this.#memoMethod\n  }\n  /**\n   * {@link LRUCache.OptionsBase.dispose} (read-only)\n   */\n  get dispose() {\n    return this.#dispose\n  }\n  /**\n   * {@link LRUCache.OptionsBase.onInsert} (read-only)\n   */\n  get onInsert() {\n    return this.#onInsert\n  }\n  /**\n   * {@link LRUCache.OptionsBase.disposeAfter} (read-only)\n   */\n  get disposeAfter() {\n    return this.#disposeAfter\n  }\n\n  constructor(\n    options: LRUCache.Options<K, V, FC> | LRUCache<K, V, FC>\n  ) {\n    const {\n      max = 0,\n      ttl,\n      ttlResolution = 1,\n      ttlAutopurge,\n      updateAgeOnGet,\n      updateAgeOnHas,\n      allowStale,\n      dispose,\n      onInsert,\n      disposeAfter,\n      noDisposeOnSet,\n      noUpdateTTL,\n      maxSize = 0,\n      maxEntrySize = 0,\n      sizeCalculation,\n      fetchMethod,\n      memoMethod,\n      noDeleteOnFetchRejection,\n      noDeleteOnStaleGet,\n      allowStaleOnFetchRejection,\n      allowStaleOnFetchAbort,\n      ignoreFetchAbort,\n    } = options\n\n    if (max !== 0 && !isPosInt(max)) {\n      throw new TypeError('max option must be a nonnegative integer')\n    }\n\n    const UintArray = max ? getUintArray(max) : Array\n    if (!UintArray) {\n      throw new Error('invalid max value: ' + max)\n    }\n\n    this.#max = max\n    this.#maxSize = maxSize\n    this.maxEntrySize = maxEntrySize || this.#maxSize\n    this.sizeCalculation = sizeCalculation\n    if (this.sizeCalculation) {\n      if (!this.#maxSize && !this.maxEntrySize) {\n        throw new TypeError(\n          'cannot set sizeCalculation without setting maxSize or maxEntrySize'\n        )\n      }\n      if (typeof this.sizeCalculation !== 'function') {\n        throw new TypeError('sizeCalculation set to non-function')\n      }\n    }\n\n    if (\n      memoMethod !== undefined &&\n      typeof memoMethod !== 'function'\n    ) {\n      throw new TypeError('memoMethod must be a function if defined')\n    }\n    this.#memoMethod = memoMethod\n\n    if (\n      fetchMethod !== undefined &&\n      typeof fetchMethod !== 'function'\n    ) {\n      throw new TypeError(\n        'fetchMethod must be a function if specified'\n      )\n    }\n    this.#fetchMethod = fetchMethod\n    this.#hasFetchMethod = !!fetchMethod\n\n    this.#keyMap = new Map()\n    this.#keyList = new Array(max).fill(undefined)\n    this.#valList = new Array(max).fill(undefined)\n    this.#next = new UintArray(max)\n    this.#prev = new UintArray(max)\n    this.#head = 0 as Index\n    this.#tail = 0 as Index\n    this.#free = Stack.create(max)\n    this.#size = 0\n    this.#calculatedSize = 0\n\n    if (typeof dispose === 'function') {\n      this.#dispose = dispose\n    }\n    if (typeof onInsert === 'function') {\n      this.#onInsert = onInsert\n    }\n    if (typeof disposeAfter === 'function') {\n      this.#disposeAfter = disposeAfter\n      this.#disposed = []\n    } else {\n      this.#disposeAfter = undefined\n      this.#disposed = undefined\n    }\n    this.#hasDispose = !!this.#dispose\n    this.#hasOnInsert = !!this.#onInsert\n    this.#hasDisposeAfter = !!this.#disposeAfter\n\n    this.noDisposeOnSet = !!noDisposeOnSet\n    this.noUpdateTTL = !!noUpdateTTL\n    this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection\n    this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection\n    this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort\n    this.ignoreFetchAbort = !!ignoreFetchAbort\n\n    // NB: maxEntrySize is set to maxSize if it's set\n    if (this.maxEntrySize !== 0) {\n      if (this.#maxSize !== 0) {\n        if (!isPosInt(this.#maxSize)) {\n          throw new TypeError(\n            'maxSize must be a positive integer if specified'\n          )\n        }\n      }\n      if (!isPosInt(this.maxEntrySize)) {\n        throw new TypeError(\n          'maxEntrySize must be a positive integer if specified'\n        )\n      }\n      this.#initializeSizeTracking()\n    }\n\n    this.allowStale = !!allowStale\n    this.noDeleteOnStaleGet = !!noDeleteOnStaleGet\n    this.updateAgeOnGet = !!updateAgeOnGet\n    this.updateAgeOnHas = !!updateAgeOnHas\n    this.ttlResolution =\n      isPosInt(ttlResolution) || ttlResolution === 0\n        ? ttlResolution\n        : 1\n    this.ttlAutopurge = !!ttlAutopurge\n    this.ttl = ttl || 0\n    if (this.ttl) {\n      if (!isPosInt(this.ttl)) {\n        throw new TypeError(\n          'ttl must be a positive integer if specified'\n        )\n      }\n      this.#initializeTTLTracking()\n    }\n\n    // do not allow completely unbounded caches\n    if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {\n      throw new TypeError(\n        'At least one of max, maxSize, or ttl is required'\n      )\n    }\n    if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {\n      const code = 'LRU_CACHE_UNBOUNDED'\n      if (shouldWarn(code)) {\n        warned.add(code)\n        const msg =\n          'TTL caching without ttlAutopurge, max, or maxSize can ' +\n          'result in unbounded memory consumption.'\n        emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache)\n      }\n    }\n  }\n\n  /**\n   * Return the number of ms left in the item's TTL. If item is not in cache,\n   * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.\n   */\n  getRemainingTTL(key: K) {\n    return this.#keyMap.has(key) ? Infinity : 0\n  }\n\n  #initializeTTLTracking() {\n    const ttls = new ZeroArray(this.#max)\n    const starts = new ZeroArray(this.#max)\n    this.#ttls = ttls\n    this.#starts = starts\n\n    this.#setItemTTL = (index, ttl, start = perf.now()) => {\n      starts[index] = ttl !== 0 ? start : 0\n      ttls[index] = ttl\n      if (ttl !== 0 && this.ttlAutopurge) {\n        const t = setTimeout(() => {\n          if (this.#isStale(index)) {\n            this.#delete(this.#keyList[index] as K, 'expire')\n          }\n        }, ttl + 1)\n        // unref() not supported on all platforms\n        /* c8 ignore start */\n        if (t.unref) {\n          t.unref()\n        }\n        /* c8 ignore stop */\n      }\n    }\n\n    this.#updateItemAge = index => {\n      starts[index] = ttls[index] !== 0 ? perf.now() : 0\n    }\n\n    this.#statusTTL = (status, index) => {\n      if (ttls[index]) {\n        const ttl = ttls[index]\n        const start = starts[index]\n        /* c8 ignore next */\n        if (!ttl || !start) return\n        status.ttl = ttl\n        status.start = start\n        status.now = cachedNow || getNow()\n        const age = status.now - start\n        status.remainingTTL = ttl - age\n      }\n    }\n\n    // debounce calls to perf.now() to 1s so we're not hitting\n    // that costly call repeatedly.\n    let cachedNow = 0\n    const getNow = () => {\n      const n = perf.now()\n      if (this.ttlResolution > 0) {\n        cachedNow = n\n        const t = setTimeout(\n          () => (cachedNow = 0),\n          this.ttlResolution\n        )\n        // not available on all platforms\n        /* c8 ignore start */\n        if (t.unref) {\n          t.unref()\n        }\n        /* c8 ignore stop */\n      }\n      return n\n    }\n\n    this.getRemainingTTL = key => {\n      const index = this.#keyMap.get(key)\n      if (index === undefined) {\n        return 0\n      }\n      const ttl = ttls[index]\n      const start = starts[index]\n      if (!ttl || !start) {\n        return Infinity\n      }\n      const age = (cachedNow || getNow()) - start\n      return ttl - age\n    }\n\n    this.#isStale = index => {\n      const s = starts[index]\n      const t = ttls[index]\n      return !!t && !!s && (cachedNow || getNow()) - s > t\n    }\n  }\n\n  // conditionally set private methods related to TTL\n  #updateItemAge: (index: Index) => void = () => {}\n  #statusTTL: (status: LRUCache.Status<V>, index: Index) => void =\n    () => {}\n  #setItemTTL: (\n    index: Index,\n    ttl: LRUCache.Milliseconds,\n    start?: LRUCache.Milliseconds\n    // ignore because we never call this if we're not already in TTL mode\n    /* c8 ignore start */\n  ) => void = () => {}\n  /* c8 ignore stop */\n\n  #isStale: (index: Index) => boolean = () => false\n\n  #initializeSizeTracking() {\n    const sizes = new ZeroArray(this.#max)\n    this.#calculatedSize = 0\n    this.#sizes = sizes\n    this.#removeItemSize = index => {\n      this.#calculatedSize -= sizes[index] as number\n      sizes[index] = 0\n    }\n    this.#requireSize = (k, v, size, sizeCalculation) => {\n      // provisionally accept background fetches.\n      // actual value size will be checked when they return.\n      if (this.#isBackgroundFetch(v)) {\n        return 0\n      }\n      if (!isPosInt(size)) {\n        if (sizeCalculation) {\n          if (typeof sizeCalculation !== 'function') {\n            throw new TypeError('sizeCalculation must be a function')\n          }\n          size = sizeCalculation(v, k)\n          if (!isPosInt(size)) {\n            throw new TypeError(\n              'sizeCalculation return invalid (expect positive integer)'\n            )\n          }\n        } else {\n          throw new TypeError(\n            'invalid size value (must be positive integer). ' +\n              'When maxSize or maxEntrySize is used, sizeCalculation ' +\n              'or size must be set.'\n          )\n        }\n      }\n      return size\n    }\n    this.#addItemSize = (\n      index: Index,\n      size: LRUCache.Size,\n      status?: LRUCache.Status<V>\n    ) => {\n      sizes[index] = size\n      if (this.#maxSize) {\n        const maxSize = this.#maxSize - (sizes[index] as number)\n        while (this.#calculatedSize > maxSize) {\n          this.#evict(true)\n        }\n      }\n      this.#calculatedSize += sizes[index] as number\n      if (status) {\n        status.entrySize = size\n        status.totalCalculatedSize = this.#calculatedSize\n      }\n    }\n  }\n\n  #removeItemSize: (index: Index) => void = _i => {}\n  #addItemSize: (\n    index: Index,\n    size: LRUCache.Size,\n    status?: LRUCache.Status<V>\n  ) => void = (_i, _s, _st) => {}\n  #requireSize: (\n    k: K,\n    v: V | BackgroundFetch<V>,\n    size?: LRUCache.Size,\n    sizeCalculation?: LRUCache.SizeCalculator<K, V>\n  ) => LRUCache.Size = (\n    _k: K,\n    _v: V | BackgroundFetch<V>,\n    size?: LRUCache.Size,\n    sizeCalculation?: LRUCache.SizeCalculator<K, V>\n  ) => {\n    if (size || sizeCalculation) {\n      throw new TypeError(\n        'cannot set size without setting maxSize or maxEntrySize on cache'\n      )\n    }\n    return 0\n  };\n\n  *#indexes({ allowStale = this.allowStale } = {}) {\n    if (this.#size) {\n      for (let i = this.#tail; true; ) {\n        if (!this.#isValidIndex(i)) {\n          break\n        }\n        if (allowStale || !this.#isStale(i)) {\n          yield i\n        }\n        if (i === this.#head) {\n          break\n        } else {\n          i = this.#prev[i] as Index\n        }\n      }\n    }\n  }\n\n  *#rindexes({ allowStale = this.allowStale } = {}) {\n    if (this.#size) {\n      for (let i = this.#head; true; ) {\n        if (!this.#isValidIndex(i)) {\n          break\n        }\n        if (allowStale || !this.#isStale(i)) {\n          yield i\n        }\n        if (i === this.#tail) {\n          break\n        } else {\n          i = this.#next[i] as Index\n        }\n      }\n    }\n  }\n\n  #isValidIndex(index: Index) {\n    return (\n      index !== undefined &&\n      this.#keyMap.get(this.#keyList[index] as K) === index\n    )\n  }\n\n  /**\n   * Return a generator yielding `[key, value]` pairs,\n   * in order from most recently used to least recently used.\n   */\n  *entries() {\n    for (const i of this.#indexes()) {\n      if (\n        this.#valList[i] !== undefined &&\n        this.#keyList[i] !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield [this.#keyList[i], this.#valList[i]] as [K, V]\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.entries}\n   *\n   * Return a generator yielding `[key, value]` pairs,\n   * in order from least recently used to most recently used.\n   */\n  *rentries() {\n    for (const i of this.#rindexes()) {\n      if (\n        this.#valList[i] !== undefined &&\n        this.#keyList[i] !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield [this.#keyList[i], this.#valList[i]]\n      }\n    }\n  }\n\n  /**\n   * Return a generator yielding the keys in the cache,\n   * in order from most recently used to least recently used.\n   */\n  *keys() {\n    for (const i of this.#indexes()) {\n      const k = this.#keyList[i]\n      if (\n        k !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield k\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.keys}\n   *\n   * Return a generator yielding the keys in the cache,\n   * in order from least recently used to most recently used.\n   */\n  *rkeys() {\n    for (const i of this.#rindexes()) {\n      const k = this.#keyList[i]\n      if (\n        k !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield k\n      }\n    }\n  }\n\n  /**\n   * Return a generator yielding the values in the cache,\n   * in order from most recently used to least recently used.\n   */\n  *values() {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      if (\n        v !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield this.#valList[i] as V\n      }\n    }\n  }\n\n  /**\n   * Inverse order version of {@link LRUCache.values}\n   *\n   * Return a generator yielding the values in the cache,\n   * in order from least recently used to most recently used.\n   */\n  *rvalues() {\n    for (const i of this.#rindexes()) {\n      const v = this.#valList[i]\n      if (\n        v !== undefined &&\n        !this.#isBackgroundFetch(this.#valList[i])\n      ) {\n        yield this.#valList[i]\n      }\n    }\n  }\n\n  /**\n   * Iterating over the cache itself yields the same results as\n   * {@link LRUCache.entries}\n   */\n  [Symbol.iterator]() {\n    return this.entries()\n  }\n\n  /**\n   * A String value that is used in the creation of the default string\n   * description of an object. Called by the built-in method\n   * `Object.prototype.toString`.\n   */\n  [Symbol.toStringTag] = 'LRUCache'\n\n  /**\n   * Find a value for which the supplied fn method returns a truthy value,\n   * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.\n   */\n  find(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => boolean,\n    getOptions: LRUCache.GetOptions<K, V, FC> = {}\n  ) {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v)\n        ? v.__staleWhileFetching\n        : v\n      if (value === undefined) continue\n      if (fn(value, this.#keyList[i] as K, this)) {\n        return this.get(this.#keyList[i] as K, getOptions)\n      }\n    }\n  }\n\n  /**\n   * Call the supplied function on each item in the cache, in order from most\n   * recently used to least recently used.\n   *\n   * `fn` is called as `fn(value, key, cache)`.\n   *\n   * If `thisp` is provided, function will be called in the `this`-context of\n   * the provided object, or the cache if no `thisp` object is provided.\n   *\n   * Does not update age or recenty of use, or iterate over stale values.\n   */\n  forEach(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => any,\n    thisp: any = this\n  ) {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v)\n        ? v.__staleWhileFetching\n        : v\n      if (value === undefined) continue\n      fn.call(thisp, value, this.#keyList[i] as K, this)\n    }\n  }\n\n  /**\n   * The same as {@link LRUCache.forEach} but items are iterated over in\n   * reverse order.  (ie, less recently used items are iterated over first.)\n   */\n  rforEach(\n    fn: (v: V, k: K, self: LRUCache<K, V, FC>) => any,\n    thisp: any = this\n  ) {\n    for (const i of this.#rindexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v)\n        ? v.__staleWhileFetching\n        : v\n      if (value === undefined) continue\n      fn.call(thisp, value, this.#keyList[i] as K, this)\n    }\n  }\n\n  /**\n   * Delete any stale entries. Returns true if anything was removed,\n   * false otherwise.\n   */\n  purgeStale() {\n    let deleted = false\n    for (const i of this.#rindexes({ allowStale: true })) {\n      if (this.#isStale(i)) {\n        this.#delete(this.#keyList[i] as K, 'expire')\n        deleted = true\n      }\n    }\n    return deleted\n  }\n\n  /**\n   * Get the extended info about a given entry, to get its value, size, and\n   * TTL info simultaneously. Returns `undefined` if the key is not present.\n   *\n   * Unlike {@link LRUCache#dump}, which is designed to be portable and survive\n   * serialization, the `start` value is always the current timestamp, and the\n   * `ttl` is a calculated remaining time to live (negative if expired).\n   *\n   * Always returns stale values, if their info is found in the cache, so be\n   * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})\n   * if relevant.\n   */\n  info(key: K): LRUCache.Entry<V> | undefined {\n    const i = this.#keyMap.get(key)\n    if (i === undefined) return undefined\n    const v = this.#valList[i]\n    const value: V | undefined = this.#isBackgroundFetch(v)\n      ? v.__staleWhileFetching\n      : v\n    if (value === undefined) return undefined\n    const entry: LRUCache.Entry<V> = { value }\n    if (this.#ttls && this.#starts) {\n      const ttl = this.#ttls[i]\n      const start = this.#starts[i]\n      if (ttl && start) {\n        const remain = ttl - (perf.now() - start)\n        entry.ttl = remain\n        entry.start = Date.now()\n      }\n    }\n    if (this.#sizes) {\n      entry.size = this.#sizes[i]\n    }\n    return entry\n  }\n\n  /**\n   * Return an array of [key, {@link LRUCache.Entry}] tuples which can be\n   * passed to {@link LRUCache#load}.\n   *\n   * The `start` fields are calculated relative to a portable `Date.now()`\n   * timestamp, even if `performance.now()` is available.\n   *\n   * Stale entries are always included in the `dump`, even if\n   * {@link LRUCache.OptionsBase.allowStale} is false.\n   *\n   * Note: this returns an actual array, not a generator, so it can be more\n   * easily passed around.\n   */\n  dump() {\n    const arr: [K, LRUCache.Entry<V>][] = []\n    for (const i of this.#indexes({ allowStale: true })) {\n      const key = this.#keyList[i]\n      const v = this.#valList[i]\n      const value: V | undefined = this.#isBackgroundFetch(v)\n        ? v.__staleWhileFetching\n        : v\n      if (value === undefined || key === undefined) continue\n      const entry: LRUCache.Entry<V> = { value }\n      if (this.#ttls && this.#starts) {\n        entry.ttl = this.#ttls[i]\n        // always dump the start relative to a portable timestamp\n        // it's ok for this to be a bit slow, it's a rare operation.\n        const age = perf.now() - (this.#starts[i] as number)\n        entry.start = Math.floor(Date.now() - age)\n      }\n      if (this.#sizes) {\n        entry.size = this.#sizes[i]\n      }\n      arr.unshift([key, entry])\n    }\n    return arr\n  }\n\n  /**\n   * Reset the cache and load in the items in entries in the order listed.\n   *\n   * The shape of the resulting cache may be different if the same options are\n   * not used in both caches.\n   *\n   * The `start` fields are assumed to be calculated relative to a portable\n   * `Date.now()` timestamp, even if `performance.now()` is available.\n   */\n  load(arr: [K, LRUCache.Entry<V>][]) {\n    this.clear()\n    for (const [key, entry] of arr) {\n      if (entry.start) {\n        // entry.start is a portable timestamp, but we may be using\n        // node's performance.now(), so calculate the offset, so that\n        // we get the intended remaining TTL, no matter how long it's\n        // been on ice.\n        //\n        // it's ok for this to be a bit slow, it's a rare operation.\n        const age = Date.now() - entry.start\n        entry.start = perf.now() - age\n      }\n      this.set(key, entry.value, entry)\n    }\n  }\n\n  /**\n   * Add a value to the cache.\n   *\n   * Note: if `undefined` is specified as a value, this is an alias for\n   * {@link LRUCache#delete}\n   *\n   * Fields on the {@link LRUCache.SetOptions} options param will override\n   * their corresponding values in the constructor options for the scope\n   * of this single `set()` operation.\n   *\n   * If `start` is provided, then that will set the effective start\n   * time for the TTL calculation. Note that this must be a previous\n   * value of `performance.now()` if supported, or a previous value of\n   * `Date.now()` if not.\n   *\n   * Options object may also include `size`, which will prevent\n   * calling the `sizeCalculation` function and just use the specified\n   * number if it is a positive integer, and `noDisposeOnSet` which\n   * will prevent calling a `dispose` function in the case of\n   * overwrites.\n   *\n   * If the `size` (or return value of `sizeCalculation`) for a given\n   * entry is greater than `maxEntrySize`, then the item will not be\n   * added to the cache.\n   *\n   * Will update the recency of the entry.\n   *\n   * If the value is `undefined`, then this is an alias for\n   * `cache.delete(key)`. `undefined` is never stored in the cache.\n   */\n  set(\n    k: K,\n    v: V | BackgroundFetch<V> | undefined,\n    setOptions: LRUCache.SetOptions<K, V, FC> = {}\n  ) {\n    if (v === undefined) {\n      this.delete(k)\n      return this\n    }\n    const {\n      ttl = this.ttl,\n      start,\n      noDisposeOnSet = this.noDisposeOnSet,\n      sizeCalculation = this.sizeCalculation,\n      status,\n    } = setOptions\n    let { noUpdateTTL = this.noUpdateTTL } = setOptions\n\n    const size = this.#requireSize(\n      k,\n      v,\n      setOptions.size || 0,\n      sizeCalculation\n    )\n    // if the item doesn't fit, don't do anything\n    // NB: maxEntrySize set to maxSize by default\n    if (this.maxEntrySize && size > this.maxEntrySize) {\n      if (status) {\n        status.set = 'miss'\n        status.maxEntrySizeExceeded = true\n      }\n      // have to delete, in case something is there already.\n      this.#delete(k, 'set')\n      return this\n    }\n    let index = this.#size === 0 ? undefined : this.#keyMap.get(k)\n    if (index === undefined) {\n      // addition\n      index = (\n        this.#size === 0\n          ? this.#tail\n          : this.#free.length !== 0\n          ? this.#free.pop()\n          : this.#size === this.#max\n          ? this.#evict(false)\n          : this.#size\n      ) as Index\n      this.#keyList[index] = k\n      this.#valList[index] = v\n      this.#keyMap.set(k, index)\n      this.#next[this.#tail] = index\n      this.#prev[index] = this.#tail\n      this.#tail = index\n      this.#size++\n      this.#addItemSize(index, size, status)\n      if (status) status.set = 'add'\n      noUpdateTTL = false\n      if (this.#hasOnInsert) {\n        this.#onInsert?.(v as V, k, 'add')\n      }\n    } else {\n      // update\n      this.#moveToTail(index)\n      const oldVal = this.#valList[index] as V | BackgroundFetch<V>\n      if (v !== oldVal) {\n        if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {\n          oldVal.__abortController.abort(new Error('replaced'))\n          const { __staleWhileFetching: s } = oldVal\n          if (s !== undefined && !noDisposeOnSet) {\n            if (this.#hasDispose) {\n              this.#dispose?.(s as V, k, 'set')\n            }\n            if (this.#hasDisposeAfter) {\n              this.#disposed?.push([s as V, k, 'set'])\n            }\n          }\n        } else if (!noDisposeOnSet) {\n          if (this.#hasDispose) {\n            this.#dispose?.(oldVal as V, k, 'set')\n          }\n          if (this.#hasDisposeAfter) {\n            this.#disposed?.push([oldVal as V, k, 'set'])\n          }\n        }\n        this.#removeItemSize(index)\n        this.#addItemSize(index, size, status)\n        this.#valList[index] = v\n        if (status) {\n          status.set = 'replace'\n          const oldValue =\n            oldVal && this.#isBackgroundFetch(oldVal)\n              ? oldVal.__staleWhileFetching\n              : oldVal\n          if (oldValue !== undefined) status.oldValue = oldValue\n        }\n      } else if (status) {\n        status.set = 'update'\n      }\n\n      if (this.#hasOnInsert) {\n        this.onInsert?.(v as V, k, v === oldVal ? 'update' : 'replace');\n      }\n    }\n    if (ttl !== 0 && !this.#ttls) {\n      this.#initializeTTLTracking()\n    }\n    if (this.#ttls) {\n      if (!noUpdateTTL) {\n        this.#setItemTTL(index, ttl, start)\n      }\n      if (status) this.#statusTTL(status, index)\n    }\n    if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n    return this\n  }\n\n  /**\n   * Evict the least recently used item, returning its value or\n   * `undefined` if cache is empty.\n   */\n  pop(): V | undefined {\n    try {\n      while (this.#size) {\n        const val = this.#valList[this.#head]\n        this.#evict(true)\n        if (this.#isBackgroundFetch(val)) {\n          if (val.__staleWhileFetching) {\n            return val.__staleWhileFetching\n          }\n        } else if (val !== undefined) {\n          return val\n        }\n      }\n    } finally {\n      if (this.#hasDisposeAfter && this.#disposed) {\n        const dt = this.#disposed\n        let task: DisposeTask<K, V> | undefined\n        while ((task = dt?.shift())) {\n          this.#disposeAfter?.(...task)\n        }\n      }\n    }\n  }\n\n  #evict(free: boolean) {\n    const head = this.#head\n    const k = this.#keyList[head] as K\n    const v = this.#valList[head] as V\n    if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {\n      v.__abortController.abort(new Error('evicted'))\n    } else if (this.#hasDispose || this.#hasDisposeAfter) {\n      if (this.#hasDispose) {\n        this.#dispose?.(v, k, 'evict')\n      }\n      if (this.#hasDisposeAfter) {\n        this.#disposed?.push([v, k, 'evict'])\n      }\n    }\n    this.#removeItemSize(head)\n    // if we aren't about to use the index, then null these out\n    if (free) {\n      this.#keyList[head] = undefined\n      this.#valList[head] = undefined\n      this.#free.push(head)\n    }\n    if (this.#size === 1) {\n      this.#head = this.#tail = 0 as Index\n      this.#free.length = 0\n    } else {\n      this.#head = this.#next[head] as Index\n    }\n    this.#keyMap.delete(k)\n    this.#size--\n    return head\n  }\n\n  /**\n   * Check if a key is in the cache, without updating the recency of use.\n   * Will return false if the item is stale, even though it is technically\n   * in the cache.\n   *\n   * Check if a key is in the cache, without updating the recency of\n   * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set\n   * to `true` in either the options or the constructor.\n   *\n   * Will return `false` if the item is stale, even though it is technically in\n   * the cache. The difference can be determined (if it matters) by using a\n   * `status` argument, and inspecting the `has` field.\n   *\n   * Will not update item age unless\n   * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.\n   */\n  has(k: K, hasOptions: LRUCache.HasOptions<K, V, FC> = {}) {\n    const { updateAgeOnHas = this.updateAgeOnHas, status } =\n      hasOptions\n    const index = this.#keyMap.get(k)\n    if (index !== undefined) {\n      const v = this.#valList[index]\n      if (\n        this.#isBackgroundFetch(v) &&\n        v.__staleWhileFetching === undefined\n      ) {\n        return false\n      }\n      if (!this.#isStale(index)) {\n        if (updateAgeOnHas) {\n          this.#updateItemAge(index)\n        }\n        if (status) {\n          status.has = 'hit'\n          this.#statusTTL(status, index)\n        }\n        return true\n      } else if (status) {\n        status.has = 'stale'\n        this.#statusTTL(status, index)\n      }\n    } else if (status) {\n      status.has = 'miss'\n    }\n    return false\n  }\n\n  /**\n   * Like {@link LRUCache#get} but doesn't update recency or delete stale\n   * items.\n   *\n   * Returns `undefined` if the item is stale, unless\n   * {@link LRUCache.OptionsBase.allowStale} is set.\n   */\n  peek(k: K, peekOptions: LRUCache.PeekOptions<K, V, FC> = {}) {\n    const { allowStale = this.allowStale } = peekOptions\n    const index = this.#keyMap.get(k)\n    if (\n      index === undefined ||\n      (!allowStale && this.#isStale(index))\n    ) {\n      return\n    }\n    const v = this.#valList[index]\n    // either stale and allowed, or forcing a refresh of non-stale value\n    return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n  }\n\n  #backgroundFetch(\n    k: K,\n    index: Index | undefined,\n    options: LRUCache.FetchOptions<K, V, FC>,\n    context: any\n  ): BackgroundFetch<V> {\n    const v = index === undefined ? undefined : this.#valList[index]\n    if (this.#isBackgroundFetch(v)) {\n      return v\n    }\n\n    const ac = new AC()\n    const { signal } = options\n    // when/if our AC signals, then stop listening to theirs.\n    signal?.addEventListener('abort', () => ac.abort(signal.reason), {\n      signal: ac.signal,\n    })\n\n    const fetchOpts = {\n      signal: ac.signal,\n      options,\n      context,\n    }\n\n    const cb = (\n      v: V | undefined,\n      updateCache = false\n    ): V | undefined => {\n      const { aborted } = ac.signal\n      const ignoreAbort = options.ignoreFetchAbort && v !== undefined\n      if (options.status) {\n        if (aborted && !updateCache) {\n          options.status.fetchAborted = true\n          options.status.fetchError = ac.signal.reason\n          if (ignoreAbort) options.status.fetchAbortIgnored = true\n        } else {\n          options.status.fetchResolved = true\n        }\n      }\n      if (aborted && !ignoreAbort && !updateCache) {\n        return fetchFail(ac.signal.reason)\n      }\n      // either we didn't abort, and are still here, or we did, and ignored\n      const bf = p as BackgroundFetch<V>\n      if (this.#valList[index as Index] === p) {\n        if (v === undefined) {\n          if (bf.__staleWhileFetching) {\n            this.#valList[index as Index] = bf.__staleWhileFetching\n          } else {\n            this.#delete(k, 'fetch')\n          }\n        } else {\n          if (options.status) options.status.fetchUpdated = true\n          this.set(k, v, fetchOpts.options)\n        }\n      }\n      return v\n    }\n\n    const eb = (er: any) => {\n      if (options.status) {\n        options.status.fetchRejected = true\n        options.status.fetchError = er\n      }\n      return fetchFail(er)\n    }\n\n    const fetchFail = (er: any): V | undefined => {\n      const { aborted } = ac.signal\n      const allowStaleAborted =\n        aborted && options.allowStaleOnFetchAbort\n      const allowStale =\n        allowStaleAborted || options.allowStaleOnFetchRejection\n      const noDelete = allowStale || options.noDeleteOnFetchRejection\n      const bf = p as BackgroundFetch<V>\n      if (this.#valList[index as Index] === p) {\n        // if we allow stale on fetch rejections, then we need to ensure that\n        // the stale value is not removed from the cache when the fetch fails.\n        const del = !noDelete || bf.__staleWhileFetching === undefined\n        if (del) {\n          this.#delete(k, 'fetch')\n        } else if (!allowStaleAborted) {\n          // still replace the *promise* with the stale value,\n          // since we are done with the promise at this point.\n          // leave it untouched if we're still waiting for an\n          // aborted background fetch that hasn't yet returned.\n          this.#valList[index as Index] = bf.__staleWhileFetching\n        }\n      }\n      if (allowStale) {\n        if (options.status && bf.__staleWhileFetching !== undefined) {\n          options.status.returnedStale = true\n        }\n        return bf.__staleWhileFetching\n      } else if (bf.__returned === bf) {\n        throw er\n      }\n    }\n\n    const pcall = (\n      res: (v: V | undefined) => void,\n      rej: (e: any) => void\n    ) => {\n      const fmp = this.#fetchMethod?.(k, v, fetchOpts)\n      if (fmp && fmp instanceof Promise) {\n        fmp.then(v => res(v === undefined ? undefined : v), rej)\n      }\n      // ignored, we go until we finish, regardless.\n      // defer check until we are actually aborting,\n      // so fetchMethod can override.\n      ac.signal.addEventListener('abort', () => {\n        if (\n          !options.ignoreFetchAbort ||\n          options.allowStaleOnFetchAbort\n        ) {\n          res(undefined)\n          // when it eventually resolves, update the cache.\n          if (options.allowStaleOnFetchAbort) {\n            res = v => cb(v, true)\n          }\n        }\n      })\n    }\n\n    if (options.status) options.status.fetchDispatched = true\n    const p = new Promise(pcall).then(cb, eb)\n    const bf: BackgroundFetch<V> = Object.assign(p, {\n      __abortController: ac,\n      __staleWhileFetching: v,\n      __returned: undefined,\n    })\n\n    if (index === undefined) {\n      // internal, don't expose status.\n      this.set(k, bf, { ...fetchOpts.options, status: undefined })\n      index = this.#keyMap.get(k)\n    } else {\n      this.#valList[index] = bf\n    }\n    return bf\n  }\n\n  #isBackgroundFetch(p: any): p is BackgroundFetch<V> {\n    if (!this.#hasFetchMethod) return false\n    const b = p as BackgroundFetch<V>\n    return (\n      !!b &&\n      b instanceof Promise &&\n      b.hasOwnProperty('__staleWhileFetching') &&\n      b.__abortController instanceof AC\n    )\n  }\n\n  /**\n   * Make an asynchronous cached fetch using the\n   * {@link LRUCache.OptionsBase.fetchMethod} function.\n   *\n   * If the value is in the cache and not stale, then the returned\n   * Promise resolves to the value.\n   *\n   * If not in the cache, or beyond its TTL staleness, then\n   * `fetchMethod(key, staleValue, { options, signal, context })` is\n   * called, and the value returned will be added to the cache once\n   * resolved.\n   *\n   * If called with `allowStale`, and an asynchronous fetch is\n   * currently in progress to reload a stale value, then the former\n   * stale value will be returned.\n   *\n   * If called with `forceRefresh`, then the cached item will be\n   * re-fetched, even if it is not stale. However, if `allowStale` is also\n   * set, then the old value will still be returned. This is useful\n   * in cases where you want to force a reload of a cached value. If\n   * a background fetch is already in progress, then `forceRefresh`\n   * has no effect.\n   *\n   * If multiple fetches for the same key are issued, then they will all be\n   * coalesced into a single call to fetchMethod.\n   *\n   * Note that this means that handling options such as\n   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort},\n   * {@link LRUCache.FetchOptions.signal},\n   * and {@link LRUCache.OptionsBase.allowStaleOnFetchRejection} will be\n   * determined by the FIRST fetch() call for a given key.\n   *\n   * This is a known (fixable) shortcoming which will be addresed on when\n   * someone complains about it, as the fix would involve added complexity and\n   * may not be worth the costs for this edge case.\n   *\n   * If {@link LRUCache.OptionsBase.fetchMethod} is not specified, then this is\n   * effectively an alias for `Promise.resolve(cache.get(key))`.\n   *\n   * When the fetch method resolves to a value, if the fetch has not\n   * been aborted due to deletion, eviction, or being overwritten,\n   * then it is added to the cache using the options provided.\n   *\n   * If the key is evicted or deleted before the `fetchMethod`\n   * resolves, then the AbortSignal passed to the `fetchMethod` will\n   * receive an `abort` event, and the promise returned by `fetch()`\n   * will reject with the reason for the abort.\n   *\n   * If a `signal` is passed to the `fetch()` call, then aborting the\n   * signal will abort the fetch and cause the `fetch()` promise to\n   * reject with the reason provided.\n   *\n   * **Setting `context`**\n   *\n   * If an `FC` type is set to a type other than `unknown`, `void`, or\n   * `undefined` in the {@link LRUCache} constructor, then all\n   * calls to `cache.fetch()` _must_ provide a `context` option. If\n   * set to `undefined` or `void`, then calls to fetch _must not_\n   * provide a `context` option.\n   *\n   * The `context` param allows you to provide arbitrary data that\n   * might be relevant in the course of fetching the data. It is only\n   * relevant for the course of a single `fetch()` operation, and\n   * discarded afterwards.\n   *\n   * **Note: `fetch()` calls are inflight-unique**\n   *\n   * If you call `fetch()` multiple times with the same key value,\n   * then every call after the first will resolve on the same\n   * promise<sup>1</sup>,\n   * _even if they have different settings that would otherwise change\n   * the behavior of the fetch_, such as `noDeleteOnFetchRejection`\n   * or `ignoreFetchAbort`.\n   *\n   * In most cases, this is not a problem (in fact, only fetching\n   * something once is what you probably want, if you're caching in\n   * the first place). If you are changing the fetch() options\n   * dramatically between runs, there's a good chance that you might\n   * be trying to fit divergent semantics into a single object, and\n   * would be better off with multiple cache instances.\n   *\n   * **1**: Ie, they're not the \"same Promise\", but they resolve at\n   * the same time, because they're both waiting on the same\n   * underlying fetchMethod response.\n   */\n\n  fetch(\n    k: K,\n    fetchOptions: unknown extends FC\n      ? LRUCache.FetchOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.FetchOptionsNoContext<K, V>\n      : LRUCache.FetchOptionsWithContext<K, V, FC>\n  ): Promise<undefined | V>\n\n  // this overload not allowed if context is required\n  fetch(\n    k: unknown extends FC\n      ? K\n      : FC extends undefined | void\n      ? K\n      : never,\n    fetchOptions?: unknown extends FC\n      ? LRUCache.FetchOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.FetchOptionsNoContext<K, V>\n      : never\n  ): Promise<undefined | V>\n\n  async fetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {}\n  ): Promise<undefined | V> {\n    const {\n      // get options\n      allowStale = this.allowStale,\n      updateAgeOnGet = this.updateAgeOnGet,\n      noDeleteOnStaleGet = this.noDeleteOnStaleGet,\n      // set options\n      ttl = this.ttl,\n      noDisposeOnSet = this.noDisposeOnSet,\n      size = 0,\n      sizeCalculation = this.sizeCalculation,\n      noUpdateTTL = this.noUpdateTTL,\n      // fetch exclusive options\n      noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,\n      allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,\n      ignoreFetchAbort = this.ignoreFetchAbort,\n      allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,\n      context,\n      forceRefresh = false,\n      status,\n      signal,\n    } = fetchOptions\n\n    if (!this.#hasFetchMethod) {\n      if (status) status.fetch = 'get'\n      return this.get(k, {\n        allowStale,\n        updateAgeOnGet,\n        noDeleteOnStaleGet,\n        status,\n      })\n    }\n\n    const options = {\n      allowStale,\n      updateAgeOnGet,\n      noDeleteOnStaleGet,\n      ttl,\n      noDisposeOnSet,\n      size,\n      sizeCalculation,\n      noUpdateTTL,\n      noDeleteOnFetchRejection,\n      allowStaleOnFetchRejection,\n      allowStaleOnFetchAbort,\n      ignoreFetchAbort,\n      status,\n      signal,\n    }\n\n    let index = this.#keyMap.get(k)\n    if (index === undefined) {\n      if (status) status.fetch = 'miss'\n      const p = this.#backgroundFetch(k, index, options, context)\n      return (p.__returned = p)\n    } else {\n      // in cache, maybe already fetching\n      const v = this.#valList[index]\n      if (this.#isBackgroundFetch(v)) {\n        const stale =\n          allowStale && v.__staleWhileFetching !== undefined\n        if (status) {\n          status.fetch = 'inflight'\n          if (stale) status.returnedStale = true\n        }\n        return stale ? v.__staleWhileFetching : (v.__returned = v)\n      }\n\n      // if we force a refresh, that means do NOT serve the cached value,\n      // unless we are already in the process of refreshing the cache.\n      const isStale = this.#isStale(index)\n      if (!forceRefresh && !isStale) {\n        if (status) status.fetch = 'hit'\n        this.#moveToTail(index)\n        if (updateAgeOnGet) {\n          this.#updateItemAge(index)\n        }\n        if (status) this.#statusTTL(status, index)\n        return v\n      }\n\n      // ok, it is stale or a forced refresh, and not already fetching.\n      // refresh the cache.\n      const p = this.#backgroundFetch(k, index, options, context)\n      const hasStale = p.__staleWhileFetching !== undefined\n      const staleVal = hasStale && allowStale\n      if (status) {\n        status.fetch = isStale ? 'stale' : 'refresh'\n        if (staleVal && isStale) status.returnedStale = true\n      }\n      return staleVal ? p.__staleWhileFetching : (p.__returned = p)\n    }\n  }\n\n  /**\n   * In some cases, `cache.fetch()` may resolve to `undefined`, either because\n   * a {@link LRUCache.OptionsBase#fetchMethod} was not provided (turning\n   * `cache.fetch(k)` into just an async wrapper around `cache.get(k)`) or\n   * because `ignoreFetchAbort` was specified (either to the constructor or\n   * in the {@link LRUCache.FetchOptions}). Also, the\n   * {@link LRUCache.OptionsBase.fetchMethod} may return `undefined` or `void`, making\n   * the test even more complicated.\n   *\n   * Because inferring the cases where `undefined` might be returned are so\n   * cumbersome, but testing for `undefined` can also be annoying, this method\n   * can be used, which will reject if `this.fetch()` resolves to undefined.\n   */\n  forceFetch(\n    k: K,\n    fetchOptions: unknown extends FC\n      ? LRUCache.FetchOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.FetchOptionsNoContext<K, V>\n      : LRUCache.FetchOptionsWithContext<K, V, FC>\n  ): Promise<V>\n  // this overload not allowed if context is required\n  forceFetch(\n    k: unknown extends FC\n      ? K\n      : FC extends undefined | void\n      ? K\n      : never,\n    fetchOptions?: unknown extends FC\n      ? LRUCache.FetchOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.FetchOptionsNoContext<K, V>\n      : never\n  ): Promise<V>\n  async forceFetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {}\n  ): Promise<V> {\n    const v = await this.fetch(\n      k,\n      fetchOptions as unknown extends FC\n        ? LRUCache.FetchOptions<K, V, FC>\n        : FC extends undefined | void\n        ? LRUCache.FetchOptionsNoContext<K, V>\n        : LRUCache.FetchOptionsWithContext<K, V, FC>\n    )\n    if (v === undefined) throw new Error('fetch() returned undefined')\n    return v\n  }\n\n  /**\n   * If the key is found in the cache, then this is equivalent to\n   * {@link LRUCache#get}. If not, in the cache, then calculate the value using\n   * the {@link LRUCache.OptionsBase.memoMethod}, and add it to the cache.\n   *\n   * If an `FC` type is set to a type other than `unknown`, `void`, or\n   * `undefined` in the LRUCache constructor, then all calls to `cache.memo()`\n   * _must_ provide a `context` option. If set to `undefined` or `void`, then\n   * calls to memo _must not_ provide a `context` option.\n   *\n   * The `context` param allows you to provide arbitrary data that might be\n   * relevant in the course of fetching the data. It is only relevant for the\n   * course of a single `memo()` operation, and discarded afterwards.\n   */\n  memo(\n    k: K,\n    memoOptions: unknown extends FC\n      ? LRUCache.MemoOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.MemoOptionsNoContext<K, V>\n      : LRUCache.MemoOptionsWithContext<K, V, FC>\n  ): V\n  // this overload not allowed if context is required\n  memo(\n    k: unknown extends FC\n      ? K\n      : FC extends undefined | void\n      ? K\n      : never,\n    memoOptions?: unknown extends FC\n      ? LRUCache.MemoOptions<K, V, FC>\n      : FC extends undefined | void\n      ? LRUCache.MemoOptionsNoContext<K, V>\n      : never\n  ): V\n  memo(k: K, memoOptions: LRUCache.MemoOptions<K, V, FC> = {}) {\n    const memoMethod = this.#memoMethod\n    if (!memoMethod) {\n      throw new Error('no memoMethod provided to constructor')\n    }\n    const { context, forceRefresh, ...options } = memoOptions\n    const v = this.get(k, options)\n    if (!forceRefresh && v !== undefined) return v\n    const vv = memoMethod(k, v, {\n      options,\n      context,\n    } as LRUCache.MemoizerOptions<K, V, FC>)\n    this.set(k, vv, options)\n    return vv\n  }\n\n  /**\n   * Return a value from the cache. Will update the recency of the cache\n   * entry found.\n   *\n   * If the key is not found, get() will return `undefined`.\n   */\n  get(k: K, getOptions: LRUCache.GetOptions<K, V, FC> = {}) {\n    const {\n      allowStale = this.allowStale,\n      updateAgeOnGet = this.updateAgeOnGet,\n      noDeleteOnStaleGet = this.noDeleteOnStaleGet,\n      status,\n    } = getOptions\n    const index = this.#keyMap.get(k)\n    if (index !== undefined) {\n      const value = this.#valList[index]\n      const fetching = this.#isBackgroundFetch(value)\n      if (status) this.#statusTTL(status, index)\n      if (this.#isStale(index)) {\n        if (status) status.get = 'stale'\n        // delete only if not an in-flight background fetch\n        if (!fetching) {\n          if (!noDeleteOnStaleGet) {\n            this.#delete(k, 'expire')\n          }\n          if (status && allowStale) status.returnedStale = true\n          return allowStale ? value : undefined\n        } else {\n          if (\n            status &&\n            allowStale &&\n            value.__staleWhileFetching !== undefined\n          ) {\n            status.returnedStale = true\n          }\n          return allowStale ? value.__staleWhileFetching : undefined\n        }\n      } else {\n        if (status) status.get = 'hit'\n        // if we're currently fetching it, we don't actually have it yet\n        // it's not stale, which means this isn't a staleWhileRefetching.\n        // If it's not stale, and fetching, AND has a __staleWhileFetching\n        // value, then that means the user fetched with {forceRefresh:true},\n        // so it's safe to return that value.\n        if (fetching) {\n          return value.__staleWhileFetching\n        }\n        this.#moveToTail(index)\n        if (updateAgeOnGet) {\n          this.#updateItemAge(index)\n        }\n        return value\n      }\n    } else if (status) {\n      status.get = 'miss'\n    }\n  }\n\n  #connect(p: Index, n: Index) {\n    this.#prev[n] = p\n    this.#next[p] = n\n  }\n\n  #moveToTail(index: Index): void {\n    // if tail already, nothing to do\n    // if head, move head to next[index]\n    // else\n    //   move next[prev[index]] to next[index] (head has no prev)\n    //   move prev[next[index]] to prev[index]\n    // prev[index] = tail\n    // next[tail] = index\n    // tail = index\n    if (index !== this.#tail) {\n      if (index === this.#head) {\n        this.#head = this.#next[index] as Index\n      } else {\n        this.#connect(\n          this.#prev[index] as Index,\n          this.#next[index] as Index\n        )\n      }\n      this.#connect(this.#tail, index)\n      this.#tail = index\n    }\n  }\n\n  /**\n   * Deletes a key out of the cache.\n   *\n   * Returns true if the key was deleted, false otherwise.\n   */\n  delete(k: K) {\n    return this.#delete(k, 'delete')\n  }\n\n  #delete(k: K, reason: LRUCache.DisposeReason) {\n    let deleted = false\n    if (this.#size !== 0) {\n      const index = this.#keyMap.get(k)\n      if (index !== undefined) {\n        deleted = true\n        if (this.#size === 1) {\n          this.#clear(reason)\n        } else {\n          this.#removeItemSize(index)\n          const v = this.#valList[index]\n          if (this.#isBackgroundFetch(v)) {\n            v.__abortController.abort(new Error('deleted'))\n          } else if (this.#hasDispose || this.#hasDisposeAfter) {\n            if (this.#hasDispose) {\n              this.#dispose?.(v as V, k, reason)\n            }\n            if (this.#hasDisposeAfter) {\n              this.#disposed?.push([v as V, k, reason])\n            }\n          }\n          this.#keyMap.delete(k)\n          this.#keyList[index] = undefined\n          this.#valList[index] = undefined\n          if (index === this.#tail) {\n            this.#tail = this.#prev[index] as Index\n          } else if (index === this.#head) {\n            this.#head = this.#next[index] as Index\n          } else {\n            const pi = this.#prev[index] as number\n            this.#next[pi] = this.#next[index] as number\n            const ni = this.#next[index] as number\n            this.#prev[ni] = this.#prev[index] as number\n          }\n          this.#size--\n          this.#free.push(index)\n        }\n      }\n    }\n    if (this.#hasDisposeAfter && this.#disposed?.length) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n    return deleted\n  }\n\n  /**\n   * Clear the cache entirely, throwing away all values.\n   */\n  clear() {\n    return this.#clear('delete')\n  }\n  #clear(reason: LRUCache.DisposeReason) {\n    for (const index of this.#rindexes({ allowStale: true })) {\n      const v = this.#valList[index]\n      if (this.#isBackgroundFetch(v)) {\n        v.__abortController.abort(new Error('deleted'))\n      } else {\n        const k = this.#keyList[index]\n        if (this.#hasDispose) {\n          this.#dispose?.(v as V, k as K, reason)\n        }\n        if (this.#hasDisposeAfter) {\n          this.#disposed?.push([v as V, k as K, reason])\n        }\n      }\n    }\n\n    this.#keyMap.clear()\n    this.#valList.fill(undefined)\n    this.#keyList.fill(undefined)\n    if (this.#ttls && this.#starts) {\n      this.#ttls.fill(0)\n      this.#starts.fill(0)\n    }\n    if (this.#sizes) {\n      this.#sizes.fill(0)\n    }\n    this.#head = 0 as Index\n    this.#tail = 0 as Index\n    this.#free.length = 0\n    this.#calculatedSize = 0\n    this.#size = 0\n    if (this.#hasDisposeAfter && this.#disposed) {\n      const dt = this.#disposed\n      let task: DisposeTask<K, V> | undefined\n      while ((task = dt?.shift())) {\n        this.#disposeAfter?.(...task)\n      }\n    }\n  }\n}\n"],"names":["perf","warned","PROCESS","emitWarning","msg","type","code","fn","AC","AS","_a","__publicField","_","warnACPolyfill","reason","_b","printACPolyfillWarning","shouldWarn","isPosInt","n","getUintArray","max","ZeroArray","size","_constructing","_Stack","HeapCls","__privateGet","__privateSet","__privateAdd","Stack","_max","_maxSize","_dispose","_onInsert","_disposeAfter","_fetchMethod","_memoMethod","_size","_calculatedSize","_keyMap","_keyList","_valList","_next","_prev","_head","_tail","_free","_disposed","_sizes","_starts","_ttls","_hasDispose","_hasFetchMethod","_hasDisposeAfter","_hasOnInsert","_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","_LRUCache","options","_i","_s","_st","_k","_v","sizeCalculation","ttl","ttlResolution","ttlAutopurge","updateAgeOnGet","updateAgeOnHas","allowStale","dispose","onInsert","disposeAfter","noDisposeOnSet","noUpdateTTL","maxSize","maxEntrySize","fetchMethod","memoMethod","noDeleteOnFetchRejection","noDeleteOnStaleGet","allowStaleOnFetchRejection","allowStaleOnFetchAbort","ignoreFetchAbort","UintArray","__privateMethod","c","p","k","index","context","key","i","getOptions","v","value","thisp","deleted","entry","start","remain","arr","age","setOptions","_c","_d","_e","_f","_g","status","__privateWrapper","oldVal","s","oldValue","dt","task","val","hasOptions","peekOptions","fetchOptions","forceRefresh","signal","stale","isStale","staleVal","memoOptions","vv","fetching","ttls","starts","t","cachedNow","getNow","sizes","free","head","ac","fetchOpts","cb","updateCache","aborted","ignoreAbort","fetchFail","bf","eb","er","allowStaleAborted","noDelete","pcall","res","rej","fmp","b","pi","ni","LRUCache"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js

@@ -0,0 +1,57 @@
+import { __require as q } from "../internal/parse-options.js";
+import { __require as p } from "../internal/re.js";
+import { __require as _ } from "../functions/cmp.js";
+import { __require as d } from "../internal/debug.js";
+import { __require as W } from "./semver.js";
+import { __require as R } from "./range.js";
+var o, m;
+function S() {
+  if (m) return o;
+  m = 1;
+  const t = Symbol("SemVer ANY");
+  class i {
+    static get ANY() {
+      return t;
+    }
+    constructor(r, e) {
+      if (e = h(e), r instanceof i) {
+        if (r.loose === !!e.loose)
+          return r;
+        r = r.value;
+      }
+      r = r.trim().split(/\s+/).join(" "), u("comparator", r, e), this.options = e, this.loose = !!e.loose, this.parse(r), this.semver === t ? this.value = "" : this.value = this.operator + this.semver.version, u("comp", this);
+    }
+    parse(r) {
+      const e = this.options.loose ? n[l.COMPARATORLOOSE] : n[l.COMPARATOR], s = r.match(e);
+      if (!s)
+        throw new TypeError(`Invalid comparator: ${r}`);
+      this.operator = s[1] !== void 0 ? s[1] : "", this.operator === "=" && (this.operator = ""), s[2] ? this.semver = new f(s[2], this.options.loose) : this.semver = t;
+    }
+    toString() {
+      return this.value;
+    }
+    test(r) {
+      if (u("Comparator.test", r, this.options.loose), this.semver === t || r === t)
+        return !0;
+      if (typeof r == "string")
+        try {
+          r = new f(r, this.options);
+        } catch {
+          return !1;
+        }
+      return a(r, this.operator, this.semver, this.options);
+    }
+    intersects(r, e) {
+      if (!(r instanceof i))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new v(r.value, e).test(this.value) : r.operator === "" ? r.value === "" ? !0 : new v(this.value, e).test(r.semver) : (e = h(e), e.includePrerelease && (this.value === "<0.0.0-0" || r.value === "<0.0.0-0") || !e.includePrerelease && (this.value.startsWith("<0.0.0") || r.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && r.operator.startsWith(">") || this.operator.startsWith("<") && r.operator.startsWith("<") || this.semver.version === r.semver.version && this.operator.includes("=") && r.operator.includes("=") || a(this.semver, "<", r.semver, e) && this.operator.startsWith(">") && r.operator.startsWith("<") || a(this.semver, ">", r.semver, e) && this.operator.startsWith("<") && r.operator.startsWith(">")));
+    }
+  }
+  o = i;
+  const h = q(), { safeRe: n, t: l } = p(), a = _(), u = d(), f = W(), v = R();
+  return o;
+}
+export {
+  S as __require
+};
+//# sourceMappingURL=comparator.js.map

package/dist/node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparator.js","sources":["../../../../../../../../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js"],"sourcesContent":["'use strict'\n\nconst ANY = Symbol('SemVer ANY')\n// hoisted class for cyclic dependency\nclass Comparator {\n  static get ANY () {\n    return ANY\n  }\n\n  constructor (comp, options) {\n    options = parseOptions(options)\n\n    if (comp instanceof Comparator) {\n      if (comp.loose === !!options.loose) {\n        return comp\n      } else {\n        comp = comp.value\n      }\n    }\n\n    comp = comp.trim().split(/\\s+/).join(' ')\n    debug('comparator', comp, options)\n    this.options = options\n    this.loose = !!options.loose\n    this.parse(comp)\n\n    if (this.semver === ANY) {\n      this.value = ''\n    } else {\n      this.value = this.operator + this.semver.version\n    }\n\n    debug('comp', this)\n  }\n\n  parse (comp) {\n    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]\n    const m = comp.match(r)\n\n    if (!m) {\n      throw new TypeError(`Invalid comparator: ${comp}`)\n    }\n\n    this.operator = m[1] !== undefined ? m[1] : ''\n    if (this.operator === '=') {\n      this.operator = ''\n    }\n\n    // if it literally is just '>' or '' then allow anything.\n    if (!m[2]) {\n      this.semver = ANY\n    } else {\n      this.semver = new SemVer(m[2], this.options.loose)\n    }\n  }\n\n  toString () {\n    return this.value\n  }\n\n  test (version) {\n    debug('Comparator.test', version, this.options.loose)\n\n    if (this.semver === ANY || version === ANY) {\n      return true\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    return cmp(version, this.operator, this.semver, this.options)\n  }\n\n  intersects (comp, options) {\n    if (!(comp instanceof Comparator)) {\n      throw new TypeError('a Comparator is required')\n    }\n\n    if (this.operator === '') {\n      if (this.value === '') {\n        return true\n      }\n      return new Range(comp.value, options).test(this.value)\n    } else if (comp.operator === '') {\n      if (comp.value === '') {\n        return true\n      }\n      return new Range(this.value, options).test(comp.semver)\n    }\n\n    options = parseOptions(options)\n\n    // Special cases where nothing can possibly be lower\n    if (options.includePrerelease &&\n      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {\n      return false\n    }\n    if (!options.includePrerelease &&\n      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {\n      return false\n    }\n\n    // Same direction increasing (> or >=)\n    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {\n      return true\n    }\n    // Same direction decreasing (< or <=)\n    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // same SemVer and both sides are inclusive (<= or >=)\n    if (\n      (this.semver.version === comp.semver.version) &&\n      this.operator.includes('=') && comp.operator.includes('=')) {\n      return true\n    }\n    // opposite directions less than\n    if (cmp(this.semver, '<', comp.semver, options) &&\n      this.operator.startsWith('>') && comp.operator.startsWith('<')) {\n      return true\n    }\n    // opposite directions greater than\n    if (cmp(this.semver, '>', comp.semver, options) &&\n      this.operator.startsWith('<') && comp.operator.startsWith('>')) {\n      return true\n    }\n    return false\n  }\n}\n\nmodule.exports = Comparator\n\nconst parseOptions = require('../internal/parse-options')\nconst { safeRe: re, t } = require('../internal/re')\nconst cmp = require('../functions/cmp')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst Range = require('./range')\n"],"names":["ANY","Comparator","comp","options","parseOptions","debug","r","re","t","m","SemVer","version","cmp","Range","comparator","require$$0","require$$1","require$$2","require$$3","require$$4","require$$5"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js

@@ -0,0 +1,149 @@
+import { __require as U } from "../internal/lrucache.js";
+import { __require as V } from "../internal/parse-options.js";
+import { __require as K } from "./comparator.js";
+import { __require as B } from "../internal/debug.js";
+import { __require as J } from "./semver.js";
+import { __require as Q } from "../internal/re.js";
+import { __require as W } from "../internal/constants.js";
+var A, w;
+function le() {
+  if (w) return A;
+  w = 1;
+  const C = /\s+/g;
+  class E {
+    constructor(e, i) {
+      if (i = _(i), e instanceof E)
+        return e.loose === !!i.loose && e.includePrerelease === !!i.includePrerelease ? e : new E(e.raw, i);
+      if (e instanceof p)
+        return this.raw = e.value, this.set = [[e]], this.formatted = void 0, this;
+      if (this.options = i, this.loose = !!i.loose, this.includePrerelease = !!i.includePrerelease, this.raw = e.trim().replace(C, " "), this.set = this.raw.split("||").map((t) => this.parseRange(t.trim())).filter((t) => t.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        const t = this.set[0];
+        if (this.set = this.set.filter((l) => !S(l[0])), this.set.length === 0)
+          this.set = [t];
+        else if (this.set.length > 1) {
+          for (const l of this.set)
+            if (l.length === 1 && x(l[0])) {
+              this.set = [l];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let e = 0; e < this.set.length; e++) {
+          e > 0 && (this.formatted += "||");
+          const i = this.set[e];
+          for (let t = 0; t < i.length; t++)
+            t > 0 && (this.formatted += " "), this.formatted += i[t].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(e) {
+      const t = ((this.options.includePrerelease && v) | (this.options.loose && N)) + ":" + e, l = O.get(t);
+      if (l)
+        return l;
+      const s = this.options.loose, n = s ? d[u.HYPHENRANGELOOSE] : d[u.HYPHENRANGE];
+      e = e.replace(n, z(this.options.includePrerelease)), f("hyphen replace", e), e = e.replace(d[u.COMPARATORTRIM], y), f("comparator trim", e), e = e.replace(d[u.TILDETRIM], G), f("tilde trim", e), e = e.replace(d[u.CARETTRIM], m), f("caret trim", e);
+      let $ = e.split(" ").map((o) => I(o, this.options)).join(" ").split(/\s+/).map((o) => k(o, this.options));
+      s && ($ = $.filter((o) => (f("loose invalid filter", o, this.options), !!o.match(d[u.COMPARATORLOOSE])))), f("range list", $);
+      const a = /* @__PURE__ */ new Map(), c = $.map((o) => new p(o, this.options));
+      for (const o of c) {
+        if (S(o))
+          return [o];
+        a.set(o.value, o);
+      }
+      a.size > 1 && a.has("") && a.delete("");
+      const R = [...a.values()];
+      return O.set(t, R), R;
+    }
+    intersects(e, i) {
+      if (!(e instanceof E))
+        throw new TypeError("a Range is required");
+      return this.set.some((t) => q(t, i) && e.set.some((l) => q(l, i) && t.every((s) => l.every((n) => s.intersects(n, i)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(e) {
+      if (!e)
+        return !1;
+      if (typeof e == "string")
+        try {
+          e = new P(e, this.options);
+        } catch {
+          return !1;
+        }
+      for (let i = 0; i < this.set.length; i++)
+        if (F(this.set[i], e, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  A = E;
+  const L = U(), O = new L(), _ = V(), p = K(), f = B(), P = J(), {
+    safeRe: d,
+    t: u,
+    comparatorTrimReplace: y,
+    tildeTrimReplace: G,
+    caretTrimReplace: m
+  } = Q(), { FLAG_INCLUDE_PRERELEASE: v, FLAG_LOOSE: N } = W(), S = (r) => r.value === "<0.0.0-0", x = (r) => r.value === "", q = (r, e) => {
+    let i = !0;
+    const t = r.slice();
+    let l = t.pop();
+    for (; i && t.length; )
+      i = t.every((s) => l.intersects(s, e)), l = t.pop();
+    return i;
+  }, I = (r, e) => (f("comp", r, e), r = j(r, e), f("caret", r), r = X(r, e), f("tildes", r), r = D(r, e), f("xrange", r), r = Y(r, e), f("stars", r), r), h = (r) => !r || r.toLowerCase() === "x" || r === "*", X = (r, e) => r.trim().split(/\s+/).map((i) => g(i, e)).join(" "), g = (r, e) => {
+    const i = e.loose ? d[u.TILDELOOSE] : d[u.TILDE];
+    return r.replace(i, (t, l, s, n, $) => {
+      f("tilde", r, t, l, s, n, $);
+      let a;
+      return h(l) ? a = "" : h(s) ? a = `>=${l}.0.0 <${+l + 1}.0.0-0` : h(n) ? a = `>=${l}.${s}.0 <${l}.${+s + 1}.0-0` : $ ? (f("replaceTilde pr", $), a = `>=${l}.${s}.${n}-${$} <${l}.${+s + 1}.0-0`) : a = `>=${l}.${s}.${n} <${l}.${+s + 1}.0-0`, f("tilde return", a), a;
+    });
+  }, j = (r, e) => r.trim().split(/\s+/).map((i) => b(i, e)).join(" "), b = (r, e) => {
+    f("caret", r, e);
+    const i = e.loose ? d[u.CARETLOOSE] : d[u.CARET], t = e.includePrerelease ? "-0" : "";
+    return r.replace(i, (l, s, n, $, a) => {
+      f("caret", r, l, s, n, $, a);
+      let c;
+      return h(s) ? c = "" : h(n) ? c = `>=${s}.0.0${t} <${+s + 1}.0.0-0` : h($) ? s === "0" ? c = `>=${s}.${n}.0${t} <${s}.${+n + 1}.0-0` : c = `>=${s}.${n}.0${t} <${+s + 1}.0.0-0` : a ? (f("replaceCaret pr", a), s === "0" ? n === "0" ? c = `>=${s}.${n}.${$}-${a} <${s}.${n}.${+$ + 1}-0` : c = `>=${s}.${n}.${$}-${a} <${s}.${+n + 1}.0-0` : c = `>=${s}.${n}.${$}-${a} <${+s + 1}.0.0-0`) : (f("no pr"), s === "0" ? n === "0" ? c = `>=${s}.${n}.${$}${t} <${s}.${n}.${+$ + 1}-0` : c = `>=${s}.${n}.${$}${t} <${s}.${+n + 1}.0-0` : c = `>=${s}.${n}.${$} <${+s + 1}.0.0-0`), f("caret return", c), c;
+    });
+  }, D = (r, e) => (f("replaceXRanges", r, e), r.split(/\s+/).map((i) => H(i, e)).join(" ")), H = (r, e) => {
+    r = r.trim();
+    const i = e.loose ? d[u.XRANGELOOSE] : d[u.XRANGE];
+    return r.replace(i, (t, l, s, n, $, a) => {
+      f("xRange", r, t, l, s, n, $, a);
+      const c = h(s), R = c || h(n), o = R || h($), T = o;
+      return l === "=" && T && (l = ""), a = e.includePrerelease ? "-0" : "", c ? l === ">" || l === "<" ? t = "<0.0.0-0" : t = "*" : l && T ? (R && (n = 0), $ = 0, l === ">" ? (l = ">=", R ? (s = +s + 1, n = 0, $ = 0) : (n = +n + 1, $ = 0)) : l === "<=" && (l = "<", R ? s = +s + 1 : n = +n + 1), l === "<" && (a = "-0"), t = `${l + s}.${n}.${$}${a}`) : R ? t = `>=${s}.0.0${a} <${+s + 1}.0.0-0` : o && (t = `>=${s}.${n}.0${a} <${s}.${+n + 1}.0-0`), f("xRange return", t), t;
+    });
+  }, Y = (r, e) => (f("replaceStars", r, e), r.trim().replace(d[u.STAR], "")), k = (r, e) => (f("replaceGTE0", r, e), r.trim().replace(d[e.includePrerelease ? u.GTE0PRE : u.GTE0], "")), z = (r) => (e, i, t, l, s, n, $, a, c, R, o, T) => (h(t) ? i = "" : h(l) ? i = `>=${t}.0.0${r ? "-0" : ""}` : h(s) ? i = `>=${t}.${l}.0${r ? "-0" : ""}` : n ? i = `>=${i}` : i = `>=${i}${r ? "-0" : ""}`, h(c) ? a = "" : h(R) ? a = `<${+c + 1}.0.0-0` : h(o) ? a = `<${c}.${+R + 1}.0-0` : T ? a = `<=${c}.${R}.${o}-${T}` : r ? a = `<${c}.${R}.${+o + 1}-0` : a = `<=${a}`, `${i} ${a}`.trim()), F = (r, e, i) => {
+    for (let t = 0; t < r.length; t++)
+      if (!r[t].test(e))
+        return !1;
+    if (e.prerelease.length && !i.includePrerelease) {
+      for (let t = 0; t < r.length; t++)
+        if (f(r[t].semver), r[t].semver !== p.ANY && r[t].semver.prerelease.length > 0) {
+          const l = r[t].semver;
+          if (l.major === e.major && l.minor === e.minor && l.patch === e.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return A;
+}
+export {
+  le as __require
+};
+//# sourceMappingURL=range.js.map

package/dist/node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","sources":["../../../../../../../../../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js"],"sourcesContent":["'use strict'\n\nconst SPACE_CHARACTERS = /\\s+/g\n\n// hoisted class for cyclic dependency\nclass Range {\n  constructor (range, options) {\n    options = parseOptions(options)\n\n    if (range instanceof Range) {\n      if (\n        range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease\n      ) {\n        return range\n      } else {\n        return new Range(range.raw, options)\n      }\n    }\n\n    if (range instanceof Comparator) {\n      // just put it in the set and return\n      this.raw = range.value\n      this.set = [[range]]\n      this.formatted = undefined\n      return this\n    }\n\n    this.options = options\n    this.loose = !!options.loose\n    this.includePrerelease = !!options.includePrerelease\n\n    // First reduce all whitespace as much as possible so we do not have to rely\n    // on potentially slow regexes like \\s*. This is then stored and used for\n    // future error messages as well.\n    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ')\n\n    // First, split on ||\n    this.set = this.raw\n      .split('||')\n      // map the range to a 2d array of comparators\n      .map(r => this.parseRange(r.trim()))\n      // throw out any comparator lists that are empty\n      // this generally means that it was not a valid range, which is allowed\n      // in loose mode, but will still throw if the WHOLE range is invalid.\n      .filter(c => c.length)\n\n    if (!this.set.length) {\n      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)\n    }\n\n    // if we have any that are not the null set, throw out null sets.\n    if (this.set.length > 1) {\n      // keep the first one, in case they're all null sets\n      const first = this.set[0]\n      this.set = this.set.filter(c => !isNullSet(c[0]))\n      if (this.set.length === 0) {\n        this.set = [first]\n      } else if (this.set.length > 1) {\n        // if we have any that are *, then the range is just *\n        for (const c of this.set) {\n          if (c.length === 1 && isAny(c[0])) {\n            this.set = [c]\n            break\n          }\n        }\n      }\n    }\n\n    this.formatted = undefined\n  }\n\n  get range () {\n    if (this.formatted === undefined) {\n      this.formatted = ''\n      for (let i = 0; i < this.set.length; i++) {\n        if (i > 0) {\n          this.formatted += '||'\n        }\n        const comps = this.set[i]\n        for (let k = 0; k < comps.length; k++) {\n          if (k > 0) {\n            this.formatted += ' '\n          }\n          this.formatted += comps[k].toString().trim()\n        }\n      }\n    }\n    return this.formatted\n  }\n\n  format () {\n    return this.range\n  }\n\n  toString () {\n    return this.range\n  }\n\n  parseRange (range) {\n    // memoize range parsing for performance.\n    // this is a very hot path, and fully deterministic.\n    const memoOpts =\n      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |\n      (this.options.loose && FLAG_LOOSE)\n    const memoKey = memoOpts + ':' + range\n    const cached = cache.get(memoKey)\n    if (cached) {\n      return cached\n    }\n\n    const loose = this.options.loose\n    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]\n    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))\n    debug('hyphen replace', range)\n\n    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)\n    debug('comparator trim', range)\n\n    // `~ 1.2.3` => `~1.2.3`\n    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)\n    debug('tilde trim', range)\n\n    // `^ 1.2.3` => `^1.2.3`\n    range = range.replace(re[t.CARETTRIM], caretTrimReplace)\n    debug('caret trim', range)\n\n    // At this point, the range is completely trimmed and\n    // ready to be split into comparators.\n\n    let rangeList = range\n      .split(' ')\n      .map(comp => parseComparator(comp, this.options))\n      .join(' ')\n      .split(/\\s+/)\n      // >=0.0.0 is equivalent to *\n      .map(comp => replaceGTE0(comp, this.options))\n\n    if (loose) {\n      // in loose mode, throw out any that are not valid comparators\n      rangeList = rangeList.filter(comp => {\n        debug('loose invalid filter', comp, this.options)\n        return !!comp.match(re[t.COMPARATORLOOSE])\n      })\n    }\n    debug('range list', rangeList)\n\n    // if any comparators are the null set, then replace with JUST null set\n    // if more than one comparator, remove any * comparators\n    // also, don't include the same comparator more than once\n    const rangeMap = new Map()\n    const comparators = rangeList.map(comp => new Comparator(comp, this.options))\n    for (const comp of comparators) {\n      if (isNullSet(comp)) {\n        return [comp]\n      }\n      rangeMap.set(comp.value, comp)\n    }\n    if (rangeMap.size > 1 && rangeMap.has('')) {\n      rangeMap.delete('')\n    }\n\n    const result = [...rangeMap.values()]\n    cache.set(memoKey, result)\n    return result\n  }\n\n  intersects (range, options) {\n    if (!(range instanceof Range)) {\n      throw new TypeError('a Range is required')\n    }\n\n    return this.set.some((thisComparators) => {\n      return (\n        isSatisfiable(thisComparators, options) &&\n        range.set.some((rangeComparators) => {\n          return (\n            isSatisfiable(rangeComparators, options) &&\n            thisComparators.every((thisComparator) => {\n              return rangeComparators.every((rangeComparator) => {\n                return thisComparator.intersects(rangeComparator, options)\n              })\n            })\n          )\n        })\n      )\n    })\n  }\n\n  // if ANY of the sets match ALL of its comparators, then pass\n  test (version) {\n    if (!version) {\n      return false\n    }\n\n    if (typeof version === 'string') {\n      try {\n        version = new SemVer(version, this.options)\n      } catch (er) {\n        return false\n      }\n    }\n\n    for (let i = 0; i < this.set.length; i++) {\n      if (testSet(this.set[i], version, this.options)) {\n        return true\n      }\n    }\n    return false\n  }\n}\n\nmodule.exports = Range\n\nconst LRU = require('../internal/lrucache')\nconst cache = new LRU()\n\nconst parseOptions = require('../internal/parse-options')\nconst Comparator = require('./comparator')\nconst debug = require('../internal/debug')\nconst SemVer = require('./semver')\nconst {\n  safeRe: re,\n  t,\n  comparatorTrimReplace,\n  tildeTrimReplace,\n  caretTrimReplace,\n} = require('../internal/re')\nconst { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')\n\nconst isNullSet = c => c.value === '<0.0.0-0'\nconst isAny = c => c.value === ''\n\n// take a set of comparators and determine whether there\n// exists a version which can satisfy it\nconst isSatisfiable = (comparators, options) => {\n  let result = true\n  const remainingComparators = comparators.slice()\n  let testComparator = remainingComparators.pop()\n\n  while (result && remainingComparators.length) {\n    result = remainingComparators.every((otherComparator) => {\n      return testComparator.intersects(otherComparator, options)\n    })\n\n    testComparator = remainingComparators.pop()\n  }\n\n  return result\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nconst parseComparator = (comp, options) => {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nconst isX = id => !id || id.toLowerCase() === 'x' || id === '*'\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0\n// ~0.0.1 --> >=0.0.1 <0.1.0-0\nconst replaceTildes = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceTilde(c, options))\n    .join(' ')\n}\n\nconst replaceTilde = (comp, options) => {\n  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('tilde', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0-0\n      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = `>=${M}.${m}.${p}-${pr\n      } <${M}.${+m + 1}.0-0`\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0-0\n      ret = `>=${M}.${m}.${p\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0\n// ^1.2.3 --> >=1.2.3 <2.0.0-0\n// ^1.2.0 --> >=1.2.0 <2.0.0-0\n// ^0.0.1 --> >=0.0.1 <0.0.2-0\n// ^0.1.0 --> >=0.1.0 <0.2.0-0\nconst replaceCarets = (comp, options) => {\n  return comp\n    .trim()\n    .split(/\\s+/)\n    .map((c) => replaceCaret(c, options))\n    .join(' ')\n}\n\nconst replaceCaret = (comp, options) => {\n  debug('caret', comp, options)\n  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]\n  const z = options.includePrerelease ? '-0' : ''\n  return comp.replace(r, (_, M, m, p, pr) => {\n    debug('caret', comp, _, M, m, p, pr)\n    let ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`\n      } else {\n        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p}-${pr\n          } <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p}-${pr\n        } <${+M + 1}.0.0-0`\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${m}.${+p + 1}-0`\n        } else {\n          ret = `>=${M}.${m}.${p\n          }${z} <${M}.${+m + 1}.0-0`\n        }\n      } else {\n        ret = `>=${M}.${m}.${p\n        } <${+M + 1}.0.0-0`\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nconst replaceXRanges = (comp, options) => {\n  debug('replaceXRanges', comp, options)\n  return comp\n    .split(/\\s+/)\n    .map((c) => replaceXRange(c, options))\n    .join(' ')\n}\n\nconst replaceXRange = (comp, options) => {\n  comp = comp.trim()\n  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]\n  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    const xM = isX(M)\n    const xm = xM || isX(m)\n    const xp = xm || isX(p)\n    const anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    // if we're including prereleases in the match, then we need\n    // to fix this to -0, the lowest possible prerelease value\n    pr = options.includePrerelease ? '-0' : ''\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0-0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      if (gtlt === '<') {\n        pr = '-0'\n      }\n\n      ret = `${gtlt + M}.${m}.${p}${pr}`\n    } else if (xm) {\n      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`\n    } else if (xp) {\n      ret = `>=${M}.${m}.0${pr\n      } <${M}.${+m + 1}.0-0`\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nconst replaceStars = (comp, options) => {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp\n    .trim()\n    .replace(re[t.STAR], '')\n}\n\nconst replaceGTE0 = (comp, options) => {\n  debug('replaceGTE0', comp, options)\n  return comp\n    .trim()\n    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')\n}\n\n// This function is passed to string.replace(re[t.HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0-0\n// TODO build?\nconst hyphenReplace = incPr => ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr) => {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = `>=${fM}.0.0${incPr ? '-0' : ''}`\n  } else if (isX(fp)) {\n    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`\n  } else if (fpr) {\n    from = `>=${from}`\n  } else {\n    from = `>=${from}${incPr ? '-0' : ''}`\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = `<${+tM + 1}.0.0-0`\n  } else if (isX(tp)) {\n    to = `<${tM}.${+tm + 1}.0-0`\n  } else if (tpr) {\n    to = `<=${tM}.${tm}.${tp}-${tpr}`\n  } else if (incPr) {\n    to = `<${tM}.${tm}.${+tp + 1}-0`\n  } else {\n    to = `<=${to}`\n  }\n\n  return `${from} ${to}`.trim()\n}\n\nconst testSet = (set, version, options) => {\n  for (let i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (let i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === Comparator.ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        const allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n"],"names":["SPACE_CHARACTERS","Range","range","options","parseOptions","Comparator","r","c","first","isNullSet","isAny","i","comps","k","memoKey","FLAG_INCLUDE_PRERELEASE","FLAG_LOOSE","cached","cache","loose","hr","re","t","hyphenReplace","debug","comparatorTrimReplace","tildeTrimReplace","caretTrimReplace","rangeList","comp","parseComparator","replaceGTE0","rangeMap","comparators","result","thisComparators","isSatisfiable","rangeComparators","thisComparator","rangeComparator","version","SemVer","testSet","LRU","require$$0","require$$1","require$$2","require$$3","require$$4","require$$5","require$$6","remainingComparators","testComparator","otherComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","id","replaceTilde","_","M","m","p","pr","ret","replaceCaret","z","replaceXRange","gtlt","xM","xm","xp","anyX","incPr","$0","from","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","set","allowed"],"mappings":"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","x_google_ignoreList":[0]}