@somewhere-tech/cli 0.25.0 → 0.27.0

package/node_modules/lru-cache/dist/commonjs/browser/index.min.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/diagnostics-channel-browser.ts", "../../../src/perf.ts", "../../../src/index.ts"],
+  "sourcesContent": ["// this is used in ESM environments that follow the 'browser' import\n// condition, to avoid even trying to load node:diagnostics_channel\nimport {\n  type Channel,\n  type TracingChannel,\n} from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\n\nconst dummy = { hasSubscribers: false }\nexport const metrics = dummy as Channel<unknown>\nexport const tracing = dummy as TracingChannel<unknown>\n", "/**\n * this provides the default Perf object source, either the\n * `performance` global, or the `Date` constructor.\n *\n * it can be passed in via configuration to override it\n * for a single LRU object.\n */\nexport type Perf = { now: () => number }\nexport const defaultPerf: Perf =\n  (\n    typeof performance === 'object' &&\n    performance &&\n    typeof performance.now === 'function'\n  ) ?\n    /* c8 ignore start - this gets covered, but c8 gets confused */\n    performance\n  : /* c8 ignore stop */ Date\n", "/**\n * @module LRUCache\n */\n\nimport { metrics, tracing } from './diagnostics-channel.js'\nimport { defaultPerf } from './perf.js'\nimport type { Perf } from './perf.js'\nexport type { Perf } from './perf.js'\n\nconst hasSubscribers = () =>\n  metrics.hasSubscribers || tracing.hasSubscribers\n\nconst warned = new Set<string>()\n\n// either a function or a class\n// oxlint-disable-next-line no-explicit-any\ntype ForC = ((...a: any[]) => any) | { new (...a: any[]): any }\n\n/* c8 ignore start */\nconst PROCESS = (\n  typeof process === 'object' && !!process ?\n    process\n  : {}) as { [k: string]: unknown }\n/* c8 ignore stop */\n\nconst emitWarning = (\n  msg: string,\n  type: string,\n  code: string,\n  fn: ForC,\n) => {\n  if (typeof PROCESS.emitWarning === 'function') {\n    PROCESS.emitWarning(msg, type, code, fn)\n  } else {\n    //oxlint-disable-next-line no-console\n    console.error(`[${code}] ${type}: ${msg}`)\n  }\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: unknown): n is PosInt =>\n  !!n && n === Math.floor(n as number) && n > 0 && isFinite(n)\n\nexport type UintArray = Uint8Array | Uint16Array | Uint32Array\nexport type NumberArray = UintArray | number[]\n\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.\n/* c8 ignore start */\nconst getUintArray = (max: number) =>\n  !isPosInt(max) ? null\n  : max <= Math.pow(2, 8) ? Uint8Array\n  : max <= Math.pow(2, 16) ? Uint16Array\n  : max <= Math.pow(2, 32) ? Uint32Array\n  : max <= Number.MAX_SAFE_INTEGER ? 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  /* c8 ignore start - not sure why this is showing up uncovered?? */\n  heap: NumberArray\n  /* c8 ignore stop */\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(max: number, HeapCls: { new (n: number): NumberArray }) {\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   * These objects are also the context objects passed to listeners on the\n   * `lru-cache:metrics` diagnostic channel, and the `lru-cache` tracing\n   * channels, in platforms that support them.\n   */\n  export interface Status<K, V, FC = unknown> {\n    /**\n     * The operation being performed\n     */\n    op?: 'get' | 'set' | 'memo' | 'fetch' | 'delete' | 'has' | 'peek'\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' | 'deleted'\n\n    /**\n     * The status of a delete() operation.\n     */\n    delete?: LRUCache.DisposeReason\n\n    /**\n     * The result of a peek() operation\n     *\n     * - hit: the item was found and returned\n     * - stale: the item is in the cache, but past its ttl and not returned\n     * - miss: item not in the cache\n     */\n    peek?: 'hit' | 'miss' | 'stale'\n\n    /**\n     * The status of a memo() operation.\n     *\n     * - 'hit': the item was found in the cache and returned\n     * - 'miss': the `memoMethod` function was called\n     */\n    memo?: 'hit' | 'miss'\n\n    /**\n     * The `context` option provided to a memo or fetch operation\n     *\n     * In practice, of course, this will be the same type as the `FC`\n     * fetch context param used to instantiate the LRUCache, but the\n     * convolutions of threading that through would get quite complicated,\n     * and preclude forcing/forbidding the passing of a `context` param\n     * where it is/isn't expected, which is more valuable for error\n     * prevention.\n     */\n    context?: unknown\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 key that was set or retrieved\n     */\n    key?: K\n\n    /**\n     * The value that was set\n     */\n    value?: V\n\n    /**\n     * The old value, specified in the case of `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     * `forceRefresh` option was used for either a fetch or memo operation\n     */\n    forceRefresh?: boolean\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 in the background.\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. If it was returned,\n     *   then the `returnedStale` flag will be set.\n     * - stale-fetching: The value is being fetched in the background, but is\n     *   currently stale. If the stale value was returned, then the\n     *   `returnedStale` flag will be set.\n     * - hit: the item is in the cache\n     * - miss: the item is not in the cache\n     */\n    get?: 'stale' | 'hit' | 'miss' | 'fetching' | 'stale-fetching'\n\n    /**\n     * A fetch or get operation returned a stale value.\n     */\n    returnedStale?: true\n\n    /**\n     * A tracingChannel trace was started for this operation\n     */\n    trace?: boolean\n\n    /**\n     * A reference to the cache instance associated with this operation\n     */\n    cache?: LRUCache<K & {}, V & {}, FC>\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> 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<K, V, FC>\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> extends FetcherFetchOptions<\n    K,\n    V,\n    FC\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.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<K, V, FC>\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> extends FetchOptions<\n    K,\n    V,\n    FC\n  > {\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<\n    K,\n    V,\n    FC extends undefined | void = undefined,\n  > extends FetchOptions<K, V, FC> {\n    context?: FC\n  }\n\n  export interface MemoOptions<K, V, FC = unknown> 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<K, V, FC>\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> extends MemoOptions<\n    K,\n    V,\n    FC\n  > {\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<\n    K,\n    V,\n    FC extends undefined | void = undefined,\n  > extends MemoOptions<K, V, FC> {\n    context?: FC\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> 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<K, V, FC>\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> extends Pick<\n    OptionsBase<K, V, FC>,\n    'updateAgeOnHas'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#get} method.\n   */\n  export interface GetOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'allowStale' | 'updateAgeOnGet' | 'noDeleteOnStaleGet'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#peek} method.\n   */\n  export interface PeekOptions<K, V, FC> extends Pick<\n    OptionsBase<K, V, FC>,\n    'allowStale'\n  > {\n    status?: Status<K, V, FC>\n  }\n\n  /**\n   * Options that may be passed to the {@link LRUCache#set} method.\n   */\n  export interface SetOptions<K, V, FC> 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<K, V, FC>\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 effective size for background fetch promises.\n     *\n     * This has no effect unless `maxSize` and `sizeCalculation` are used,\n     * and a {@link LRUCache.OptionsBase.fetchMethod} is provided to\n     * support {@link LRUCache#fetch}.\n     *\n     * If a stale value is present in the cache, then the effective size of\n     * the background fetch is the size of the stale item it will eventually\n     * replace. If not, then this value is used as its effective size.\n     *\n     * @default 1\n     */\n    backgroundFetchSize?: number\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     * In some cases, you may want to swap out the performance/Date object\n     * used for TTL tracking. This should almost certainly NOT be done in\n     * production environments!\n     *\n     * This value defaults to `global.performance` if it has a `now()` method,\n     * or the `global.Date` object otherwise.\n     */\n    perf?: Perf\n  }\n\n  export interface OptionsMaxLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\n    max: Count\n  }\n  export interface OptionsTTLLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\n    ttl: Milliseconds\n    ttlAutopurge: boolean\n  }\n  export interface OptionsSizeLimit<K, V, FC> extends OptionsBase<\n    K,\n    V,\n    FC\n  > {\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  readonly #perf: Perf\n\n  /**\n   * {@link LRUCache.OptionsBase.perf}\n   */\n  get perf() {\n    return this.#perf\n  }\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  /** {@link LRUCache.OptionsBase.backgroundFetchSize} */\n  backgroundFetchSize: number\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  #autopurgeTimers?: (undefined | ReturnType<typeof setTimeout>)[]\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      autopurgeTimers: c.#autopurgeTimers,\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: unknown) => c.#isBackgroundFetch(p),\n      backgroundFetch: (\n        k: K,\n        index: number | undefined,\n        options: LRUCache.FetchOptions<K, V, FC>,\n        context: unknown,\n      ): BackgroundFetch<V> =>\n        c.#backgroundFetch(\n          k,\n          index as Index | undefined,\n          options,\n          context as FC,\n        ),\n      moveToTail: (index: number): void => c.#moveToTail(index as Index),\n      indexes: (options?: { allowStale: boolean }) => c.#indexes(options),\n      rindexes: (options?: { allowStale: boolean }) =>\n        c.#rindexes(options),\n      isStale: (index: number | undefined) => 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(options: LRUCache.Options<K, V, FC> | LRUCache<K, V, FC>) {\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      backgroundFetchSize = 1,\n      perf,\n    } = options\n\n    this.backgroundFetchSize = backgroundFetchSize\n\n    if (perf !== undefined) {\n      if (typeof perf?.now !== 'function') {\n        throw new TypeError(\n          'perf option must have a now() method if specified',\n        )\n      }\n    }\n\n    this.#perf = perf ?? defaultPerf\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 (memoMethod !== undefined && typeof memoMethod !== 'function') {\n      throw new TypeError('memoMethod must be a function if defined')\n    }\n    this.#memoMethod = memoMethod\n\n    if (fetchMethod !== undefined && typeof fetchMethod !== 'function') {\n      throw new TypeError('fetchMethod must be a function if specified')\n    }\n    this.#fetchMethod = fetchMethod\n    this.#hasFetchMethod = !!fetchMethod\n\n    this.#keyMap = new Map()\n    this.#keyList = Array.from({ length: max }).fill(undefined) as (\n      | K\n      | undefined\n    )[]\n    this.#valList = Array.from({ length: max }).fill(undefined) as (\n      | V\n      | undefined\n    )[]\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 ? ttlResolution : 1\n    this.ttlAutopurge = !!ttlAutopurge\n    this.ttl = ttl || 0\n    if (this.ttl) {\n      if (!isPosInt(this.ttl)) {\n        throw new TypeError('ttl must be a positive integer if specified')\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    const purgeTimers =\n      this.ttlAutopurge ?\n        Array.from<undefined | ReturnType<typeof setTimeout>>({\n          length: this.#max,\n        })\n      : undefined\n    this.#autopurgeTimers = purgeTimers\n\n    this.#setItemTTL = (index, ttl, start = this.#perf.now()) => {\n      starts[index] = ttl !== 0 ? start : 0\n      ttls[index] = ttl\n      setPurgeTimer(index, ttl)\n    }\n\n    this.#updateItemAge = index => {\n      starts[index] = ttls[index] !== 0 ? this.#perf.now() : 0\n      setPurgeTimer(index, ttls[index])\n    }\n\n    // clear out the purge timer if we're setting TTL to 0, and\n    // previously had a ttl purge timer running, so it doesn't\n    // fire unnecessarily. Don't need to do this if we're not doing\n    // autopurge.\n    const setPurgeTimer =\n      !this.ttlAutopurge ?\n        () => {}\n      : (index: Index, ttl?: number) => {\n          if (purgeTimers?.[index]) {\n            clearTimeout(purgeTimers[index])\n            purgeTimers[index] = undefined\n          }\n          if (ttl && ttl !== 0 && purgeTimers) {\n            const t = setTimeout(() => {\n              if (this.#isStale(index)) {\n                this.#delete(this.#keyList[index] as K, 'expire')\n                purgeTimers[index] = undefined\n              } else {\n                setPurgeTimer(index, getRemainingTTL(index))\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            purgeTimers[index] = t\n          }\n        }\n\n    this.#statusTTL = (status, index) => {\n      if (ttls[index]) {\n        const ttl = ttls[index]\n        const start = starts[index]\n        /* c8 ignore start */\n        if (!ttl || !start) {\n          return\n        }\n        /* c8 ignore stop */\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 = this.#perf.now()\n      if (this.ttlResolution > 0) {\n        cachedNow = n\n        const t = setTimeout(() => (cachedNow = 0), this.ttlResolution)\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      return getRemainingTTL(index)\n    }\n    const getRemainingTTL = (index: Index) => {\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<K, V, FC>, 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      if (!isPosInt(size)) {\n        // provisionally accept background fetches.\n        // actual value size will be checked when they return.\n        if (this.#isBackgroundFetch(v)) {\n          // NB: this cannot occur if v.__staleWhileFetching is set,\n          // because in that case, it would take on the size of the\n          // existing entry that it temporarily replaces.\n          return this.backgroundFetchSize\n        }\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\n    this.#addItemSize = (\n      index: Index,\n      size: LRUCache.Size,\n      status?: LRUCache.Status<K, V, FC>,\n    ) => {\n      sizes[index] = size\n      if (this.#maxSize) {\n        const maxSize = this.#maxSize - sizes[index]\n        while (this.#calculatedSize > maxSize) {\n          this.#evict(true)\n        }\n      }\n      this.#calculatedSize += sizes[index]\n      if (status) {\n        status.entrySize = size\n        status.totalCalculatedSize = this.#calculatedSize\n      }\n    }\n  }\n\n  #removeItemSize: (index: Index) => void = _i => {}\n\n  #addItemSize: (\n    index: Index,\n    size: LRUCache.Size,\n    status?: LRUCache.Status<K, V, FC>,\n  ) => void = (_i, _s, _st) => {}\n\n  #requireSize: (\n    k: K,\n    v: V | BackgroundFetch<V>,\n    size?: LRUCache.Size,\n    sizeCalculation?: LRUCache.SizeCalculator<K, V>,\n    status?: LRUCache.Status<K, V, FC>,\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; this.#isValidIndex(i); ) {\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; this.#isValidIndex(i); ) {\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 (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\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 (k !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\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 (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\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 (v !== undefined && !this.#isBackgroundFetch(this.#valList[i])) {\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) ? v.__staleWhileFetching : 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>) => unknown,\n    thisp: unknown = this,\n  ) {\n    for (const i of this.#indexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : 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>) => unknown,\n    thisp: unknown = this,\n  ) {\n    for (const i of this.#rindexes()) {\n      const v = this.#valList[i]\n      const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : 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    /* c8 ignore start - this isn't tested for the info function,\n     * but it's the same logic as found in other places. */\n    const value: V | undefined =\n      this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n    if (value === undefined) return undefined\n    /* c8 ignore stop */\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 - (this.#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 =\n        this.#isBackgroundFetch(v) ? v.__staleWhileFetching : 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 = this.#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 = this.#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 | undefined,\n    setOptions: LRUCache.SetOptions<K, V, FC> = {},\n  ) {\n    const { status = metrics.hasSubscribers ? {} : undefined } = setOptions\n    setOptions.status = status\n    if (status) {\n      status.op = 'set'\n      status.key = k\n      if (v !== undefined) status.value = v\n      status.cache = this\n    }\n    const result = this.#set(k, v, setOptions)\n    if (status && metrics.hasSubscribers) {\n      metrics.publish(status)\n    }\n    return result\n  }\n\n  #set(\n    k: K,\n    v: V | BackgroundFetch<V> | undefined,\n    setOptions: LRUCache.SetOptions<K, V, FC>,\n    bf?: BackgroundFetch<V>,\n  ) {\n    const {\n      ttl = this.ttl,\n      start,\n      noDisposeOnSet = this.noDisposeOnSet,\n      sizeCalculation = this.sizeCalculation,\n      status,\n    } = setOptions\n\n    const isBF = this.#isBackgroundFetch(v)\n    if (v === undefined) {\n      if (status) status.set = 'deleted'\n      this.delete(k)\n      return this\n    }\n    let { noUpdateTTL = this.noUpdateTTL } = setOptions\n\n    if (status && !isBF) status.value = v\n\n    const size = this.#requireSize(\n      k,\n      v,\n      setOptions.size || 0,\n      sizeCalculation,\n      status,\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      // have to delete, in case something is there already.\n      this.#delete(k, 'set')\n      if (status) {\n        status.set = 'miss'\n        status.maxEntrySizeExceeded = true\n      }\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 ? this.#tail\n        : this.#free.length !== 0 ? this.#free.pop()\n        : this.#size === this.#max ? this.#evict(false)\n        : this.#size) 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 && !isBF) {\n        this.#onInsert?.(v, k, 'add')\n      }\n    } else {\n      // update\n      // might be updating a background fetch!\n      this.#moveToTail(index)\n      const oldVal = this.#valList[index]!\n      if (v !== oldVal) {\n        if (!noDisposeOnSet) {\n          if (this.#isBackgroundFetch(oldVal)) {\n            if (oldVal !== bf) {\n              // setting over a background fetch, not merely resolving it.\n              oldVal.__abortController.abort(new Error('replaced'))\n            }\n            const { __staleWhileFetching: s } = oldVal\n            if (s !== undefined && s !== v) {\n              if (this.#hasDispose) {\n                this.#dispose?.(s, k, 'set')\n              }\n              if (this.#hasDisposeAfter) {\n                this.#disposed?.push([s, k, 'set'])\n              }\n            }\n          } else {\n            if (this.#hasDispose) {\n              this.#dispose?.(oldVal, k, 'set')\n            }\n            if (this.#hasDisposeAfter) {\n              this.#disposed?.push([oldVal, k, 'set'])\n            }\n          }\n        }\n        this.#removeItemSize(index)\n        this.#addItemSize(index, size, status)\n        this.#valList[index] = v\n        if (!isBF) {\n          const oldValue =\n            oldVal && this.#isBackgroundFetch(oldVal) ?\n              oldVal.__staleWhileFetching\n            : oldVal\n          const setType =\n            oldValue === undefined ? 'add'\n            : v !== oldValue ? 'replace'\n            : 'update'\n          if (status) {\n            status.set = setType\n            if (oldValue !== undefined) status.oldValue = oldValue\n          }\n          if (this.#hasOnInsert) {\n            this.onInsert?.(v, k, setType)\n          }\n        }\n      } else if (!isBF) {\n        if (status) {\n          status.set = 'update'\n        }\n        if (this.#hasOnInsert) {\n          this.onInsert?.(v, k, 'update')\n        }\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]!\n    const v = this.#valList[head]!\n    const isBF = this.#isBackgroundFetch(v)\n    if (isBF) {\n      v.__abortController.abort(new Error('evicted'))\n    }\n    const oldValue = isBF ? v.__staleWhileFetching : v\n    if (\n      (this.#hasDispose || this.#hasDisposeAfter) &&\n      oldValue !== undefined\n    ) {\n      if (this.#hasDispose) {\n        this.#dispose?.(oldValue, k, 'evict')\n      }\n      if (this.#hasDisposeAfter) {\n        this.#disposed?.push([oldValue, k, 'evict'])\n      }\n    }\n    this.#removeItemSize(head)\n    if (this.#autopurgeTimers?.[head]) {\n      clearTimeout(this.#autopurgeTimers[head])\n      this.#autopurgeTimers[head] = undefined\n    }\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 { status = metrics.hasSubscribers ? {} : undefined } = hasOptions\n    hasOptions.status = status\n    if (status) {\n      status.op = 'has'\n      status.key = k\n      status.cache = this\n    }\n    const result = this.#has(k, hasOptions)\n    if (metrics.hasSubscribers) metrics.publish(status)\n    return result\n  }\n  #has(k: K, hasOptions: LRUCache.HasOptions<K, V, FC> = {}) {\n    const { updateAgeOnHas = this.updateAgeOnHas, status } = 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 { status = hasSubscribers() ? {} : undefined } = peekOptions\n    if (status) {\n      status.op = 'peek'\n      status.key = k\n      status.cache = this\n    }\n    peekOptions.status = status\n    const result = this.#peek(k, peekOptions)\n    if (metrics.hasSubscribers) {\n      metrics.publish(status)\n    }\n    return result\n  }\n  #peek(k: K, peekOptions: LRUCache.PeekOptions<K, V, FC>) {\n    const { status, allowStale = this.allowStale } = peekOptions\n    const index = this.#keyMap.get(k)\n    if (index === undefined || (!allowStale && this.#isStale(index))) {\n      if (status) status.peek = index === undefined ? 'miss' : 'stale'\n      return undefined\n    }\n    const v = this.#valList[index]\n    const val = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v\n    if (status) {\n      if (val !== undefined) {\n        status.peek = 'hit'\n        status.value = val\n      } else {\n        status.peek = 'miss'\n      }\n    }\n    return val\n  }\n\n  #backgroundFetch(\n    k: K,\n    index: Index | undefined,\n    options: LRUCache.FetchOptions<K, V, FC>,\n    context: FC,\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 AbortController()\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 = (v: V | undefined, updateCache = false): V | undefined => {\n      const { aborted } = ac.signal\n      const ignoreAbort = options.ignoreFetchAbort && v !== undefined\n      const proceed =\n        options.ignoreFetchAbort ||\n        !!(options.allowStaleOnFetchAbort && 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, proceed)\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 nothing else has been written there but we're set to update the\n      // cache and ignore the abort, or if it's still pending on this specific\n      // background request, then write it to the cache.\n      const vl = this.#valList[index as Index]\n      if (vl === p || (vl === undefined && ignoreAbort && updateCache)) {\n        if (v === undefined) {\n          if (bf.__staleWhileFetching !== undefined) {\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, bf)\n        }\n      }\n      return v\n    }\n\n    const eb = (er: unknown) => {\n      if (options.status) {\n        options.status.fetchRejected = true\n        options.status.fetchError = er as Error\n      }\n      // do not pass go, do not collect $200\n      return fetchFail(er, false)\n    }\n\n    const fetchFail = (er: unknown, proceed: boolean): V | undefined => {\n      const { aborted } = ac.signal\n      const allowStaleAborted = 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 =\n          !noDelete || (!proceed && 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: unknown) => void,\n    ) => {\n      const fmp = this.#fetchMethod?.(k, v, fetchOpts)\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 (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {\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      if (fmp && fmp instanceof Promise) {\n        fmp.then(v => res(v === undefined ? undefined : v), rej)\n      } else if (fmp !== undefined) {\n        res(fmp)\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      // do not call #set, because we do not want to adjust its place\n      // in the lru queue, as it has not yet been \"used\". Also, we don't\n      // need to worry about evicting for size, because a background fetch\n      // over a stale value is treated as the same size as its stale value.\n      this.#valList[index] = bf\n    }\n    return bf\n  }\n\n  #isBackgroundFetch(p: unknown): 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 AbortController\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 ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\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 ? K\n    : FC extends undefined | void ? K\n    : never,\n    fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : never,\n  ): Promise<undefined | V>\n  fetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ): Promise<undefined | V> {\n    const ths = tracing.hasSubscribers\n    const { status = hasSubscribers() ? {} : undefined } = fetchOptions\n    fetchOptions.status = status\n    if (status && fetchOptions.context) {\n      status.context = fetchOptions.context\n    }\n    const p = this.#fetch(k, fetchOptions)\n    if (status && ths) {\n      status.trace = true\n      tracing.tracePromise(() => p, status).catch(() => {})\n    }\n    return p\n  }\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    if (status) {\n      status.op = 'fetch'\n      status.key = k\n      if (forceRefresh) status.forceRefresh = true\n      status.cache = this\n    }\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 as FC)\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 = 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 as FC)\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 ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\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 ? K\n    : FC extends undefined | void ? K\n    : never,\n    fetchOptions?: unknown extends FC ? LRUCache.FetchOptions<K, V, FC>\n    : FC extends undefined | void ?\n      LRUCache.FetchOptionsNoContext<K, V, FC>\n    : never,\n  ): Promise<V>\n  forceFetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ): Promise<V> {\n    const ths = tracing.hasSubscribers\n    const { status = hasSubscribers() ? {} : undefined } = fetchOptions\n    fetchOptions.status = status\n    if (status && fetchOptions.context) {\n      status.context = fetchOptions.context\n    }\n    const p = this.#forceFetch(k, fetchOptions)\n    if (status && ths) {\n      status.trace = true\n      tracing.tracePromise(() => p, status).catch(() => {})\n    }\n    return p\n  }\n\n  async #forceFetch(\n    k: K,\n    fetchOptions: LRUCache.FetchOptions<K, V, FC> = {},\n  ) {\n    const v = await this.#fetch(k, fetchOptions)\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 ? LRUCache.MemoOptions<K, V, FC>\n    : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V, FC>\n    : LRUCache.MemoOptionsWithContext<K, V, FC>,\n  ): V\n  // this overload not allowed if context is required\n  memo(\n    k: unknown extends FC ? K\n    : FC extends undefined | void ? K\n    : never,\n    memoOptions?: unknown extends FC ? LRUCache.MemoOptions<K, V, FC>\n    : FC extends undefined | void ? LRUCache.MemoOptionsNoContext<K, V, FC>\n    : never,\n  ): V\n  memo(k: K, memoOptions: LRUCache.MemoOptions<K, V, FC> = {}) {\n    const { status = metrics.hasSubscribers ? {} : undefined } =\n      memoOptions\n    memoOptions.status = status\n    if (status) {\n      status.op = 'memo'\n      status.key = k\n      if (memoOptions.context) {\n        status.context = memoOptions.context\n      }\n      status.cache = this\n    }\n    const result = this.#memo(k, memoOptions)\n    if (status) status.value = result\n    if (metrics.hasSubscribers) metrics.publish(status)\n    return result\n  }\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, status, forceRefresh, ...options } = memoOptions\n    if (status && forceRefresh) status.forceRefresh = true\n    const v = this.#get(k, options)\n    const refresh = forceRefresh || v === undefined\n    if (status) {\n      status.memo = refresh ? 'miss' : 'hit'\n      if (!refresh) status.value = v\n    }\n    if (!refresh) return v\n    const vv = memoMethod(k, v, {\n      options,\n      context,\n    } as LRUCache.MemoizerOptions<K, V, FC>)\n    if (status) status.value = vv\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 { status = metrics.hasSubscribers ? {} : undefined } = getOptions\n    getOptions.status = status\n    if (status) {\n      status.op = 'get'\n      status.key = k\n      status.cache = this\n    }\n    const result = this.#get(k, getOptions)\n    if (status) {\n      if (result !== undefined) status.value = result\n      if (metrics.hasSubscribers) metrics.publish(status)\n    }\n    return result\n  }\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      if (status) status.get = 'miss'\n      return undefined\n    }\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      // delete only if not an in-flight background fetch\n      if (!fetching) {\n        if (!noDeleteOnStaleGet) {\n          this.#delete(k, 'expire')\n        }\n        if (status) status.get = 'stale'\n        if (allowStale) {\n          if (status) status.returnedStale = true\n          return value\n        }\n        return undefined\n      }\n      if (status) status.get = 'stale-fetching'\n      if (allowStale && value.__staleWhileFetching !== undefined) {\n        if (status) status.returnedStale = true\n        return value.__staleWhileFetching\n      }\n      return undefined\n    }\n    // not stale\n    if (status) status.get = fetching ? 'fetching' : '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    this.#moveToTail(index)\n    if (updateAgeOnGet) {\n      this.#updateItemAge(index)\n    }\n    return fetching ? value.__staleWhileFetching : value\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    if (metrics.hasSubscribers) {\n      metrics.publish({\n        op: 'delete',\n        delete: reason,\n        key: k,\n        cache: this,\n      })\n    }\n    let deleted = false\n    if (this.#size !== 0) {\n      const index = this.#keyMap.get(k)\n      if (index !== undefined) {\n        if (this.#autopurgeTimers?.[index]) {\n          clearTimeout(this.#autopurgeTimers[index])\n          this.#autopurgeTimers[index] = undefined\n        }\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    void 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      for (const t of this.#autopurgeTimers ?? []) {\n        if (t !== undefined) clearTimeout(t)\n      }\n      this.#autopurgeTimers?.fill(undefined)\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"],
+  "mappings": "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",
+  "names": ["dummy", "exports", "exports", "diagnostics_channel_js_1", "perf_js_1", "hasSubscribers", "warned", "PROCESS", "emitWarning", "msg", "type", "code", "fn", "shouldWarn", "isPosInt", "n", "getUintArray", "max", "ZeroArray", "size", "Stack", "_Stack", "#constructing", "HeapCls", "s", "LRUCache", "_LRUCache", "#max", "#maxSize", "#dispose", "#onInsert", "#disposeAfter", "#fetchMethod", "#memoMethod", "#perf", "#size", "#calculatedSize", "#keyMap", "#keyList", "#valList", "#next", "#prev", "#head", "#tail", "#free", "#disposed", "#sizes", "#starts", "#ttls", "#autopurgeTimers", "#hasDispose", "#hasFetchMethod", "#hasDisposeAfter", "#hasOnInsert", "c", "p", "#isBackgroundFetch", "k", "index", "options", "context", "#backgroundFetch", "#moveToTail", "#indexes", "#rindexes", "#isStale", "ttl", "ttlResolution", "ttlAutopurge", "updateAgeOnGet", "updateAgeOnHas", "allowStale", "dispose", "onInsert", "disposeAfter", "noDisposeOnSet", "noUpdateTTL", "maxSize", "maxEntrySize", "sizeCalculation", "fetchMethod", "memoMethod", "noDeleteOnFetchRejection", "noDeleteOnStaleGet", "allowStaleOnFetchRejection", "allowStaleOnFetchAbort", "ignoreFetchAbort", "backgroundFetchSize", "perf", "perf_js_1", "UintArray", "#initializeSizeTracking", "#initializeTTLTracking", "code", "shouldWarn", "warned", "emitWarning", "key", "ttls", "starts", "purgeTimers", "#setItemTTL", "start", "setPurgeTimer", "#updateItemAge", "t", "#delete", "getRemainingTTL", "#statusTTL", "status", "cachedNow", "getNow", "age", "sizes", "#removeItemSize", "#requireSize", "v", "#addItemSize", "#evict", "_i", "_s", "_st", "_k", "_v", "i", "#isValidIndex", "fn", "getOptions", "value", "#get", "thisp", "deleted", "entry", "remain", "arr", "#set", "setOptions", "diagnostics_channel_js_1", "result", "bf", "isBF", "oldVal", "oldValue", "setType", "dt", "task", "val", "free", "head", "hasOptions", "#has", "peekOptions", "hasSubscribers", "#peek", "ac", "signal", "fetchOpts", "cb", "updateCache", "aborted", "ignoreAbort", "proceed", "fetchFail", "vl", "eb", "er", "allowStaleAborted", "noDelete", "pcall", "res", "rej", "fmp", "b", "fetchOptions", "ths", "#fetch", "forceRefresh", "stale", "isStale", "staleVal", "#forceFetch", "memoOptions", "#memo", "refresh", "vv", "fetching", "#connect", "reason", "#clear", "pi", "ni"]
+}

package/node_modules/lru-cache/dist/commonjs/browser/perf.d.ts

@@ -0,0 +1,12 @@
+/**
+ * this provides the default Perf object source, either the
+ * `performance` global, or the `Date` constructor.
+ *
+ * it can be passed in via configuration to override it
+ * for a single LRU object.
+ */
+export type Perf = {
+    now: () => number;
+};
+export declare const defaultPerf: Perf;
+//# sourceMappingURL=perf.d.ts.map

package/node_modules/lru-cache/dist/commonjs/browser/perf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf.d.ts","sourceRoot":"","sources":["../../../src/perf.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GAAG;IAAE,GAAG,EAAE,MAAM,MAAM,CAAA;CAAE,CAAA;AACxC,eAAO,MAAM,WAAW,EAAE,IAQG,CAAA"}

package/node_modules/lru-cache/dist/commonjs/browser/perf.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPerf = void 0;
+exports.defaultPerf = (typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function') ?
+    /* c8 ignore start - this gets covered, but c8 gets confused */
+    performance
+    : /* c8 ignore stop */ Date;
+//# sourceMappingURL=perf.js.map

package/node_modules/lru-cache/dist/commonjs/browser/perf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perf.js","sourceRoot":"","sources":["../../../src/perf.ts"],"names":[],"mappings":";;;AAQa,QAAA,WAAW,GACtB,CACE,OAAO,WAAW,KAAK,QAAQ;IAC/B,WAAW;IACX,OAAO,WAAW,CAAC,GAAG,KAAK,UAAU,CACtC,CAAC,CAAC;IACD,+DAA+D;IAC/D,WAAW;IACb,CAAC,CAAC,oBAAoB,CAAC,IAAI,CAAA","sourcesContent":["/**\n * this provides the default Perf object source, either the\n * `performance` global, or the `Date` constructor.\n *\n * it can be passed in via configuration to override it\n * for a single LRU object.\n */\nexport type Perf = { now: () => number }\nexport const defaultPerf: Perf =\n  (\n    typeof performance === 'object' &&\n    performance &&\n    typeof performance.now === 'function'\n  ) ?\n    /* c8 ignore start - this gets covered, but c8 gets confused */\n    performance\n  : /* c8 ignore stop */ Date\n"]}

package/node_modules/lru-cache/dist/commonjs/diagnostics-channel-cjs.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-cjs.cjs","sourceRoot":"","sources":["../../src/diagnostics-channel-cjs.cts"],"names":[],"mappings":";;;AAQA,MAAM,KAAK,GAAG,EAAE,cAAc,EAAE,KAAK,EAAE,CAAA;AAC1B,QAAA,OAAO,GAAG,KAAyB,CAAA;AACnC,QAAA,OAAO,GAAG,KAAgC,CAAA","sourcesContent":["// this is used in CJS environments that do NOT follow the 'node' import\n// condition, to avoid even trying to load node:diagnostics_channel\nimport {\n  type Channel,\n  type TracingChannel,\n} from 'node:diagnostics_channel'\nexport type { TracingChannel, Channel }\n\nconst dummy = { hasSubscribers: false }\nexport const metrics = dummy as Channel<unknown>\nexport const tracing = dummy as TracingChannel<unknown>\n"]}

package/node_modules/lru-cache/dist/commonjs/diagnostics-channel-cjs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-channel-cjs.d.cts","sourceRoot":"","sources":["../../src/diagnostics-channel-cjs.cts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,cAAc,EACpB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,CAAA;AAGvC,eAAO,MAAM,OAAO,EAAY,OAAO,CAAC,OAAO,CAAC,CAAA;AAChD,eAAO,MAAM,OAAO,EAAY,cAAc,CAAC,OAAO,CAAC,CAAA"}

package/node_modules/lru-cache/dist/commonjs/diagnostics-channel.d.ts

@@ -0,0 +1,5 @@
+import { type Channel, type TracingChannel } from 'node:diagnostics_channel';
+export type { TracingChannel, Channel };
+export declare const metrics: Channel<unknown>;
+export declare const tracing: TracingChannel<unknown>;
+//# sourceMappingURL=diagnostics-channel-cjs.d.cts.map

package/node_modules/lru-cache/dist/commonjs/diagnostics-channel.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracing = exports.metrics = void 0;
+const dummy = { hasSubscribers: false };
+exports.metrics = dummy;
+exports.tracing = dummy;
+//# sourceMappingURL=diagnostics-channel-cjs.cjs.map