@mtkruto/browser 0.142.0 → 0.143.0

package/esm/deps/jsr.io/@std/cache/0.2.3/lru_cache.js

@@ -0,0 +1,299 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Least-recently-used cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU | Least-recently-used cache}
+ *
+ * Automatically removes entries above the max size based on when they were
+ * last accessed with `get` or `set`.
+ *
+ * @typeParam K The type of the cache keys.
+ * @typeParam V The type of the cache values.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { LruCache } from "@std/cache";
+ * import { assert, assertEquals } from "@std/assert";
+ *
+ * const MAX_SIZE = 3;
+ * const cache = new LruCache<string, number>(MAX_SIZE);
+ *
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
+ * cache.set("d", 4);
+ *
+ * // most recent values are stored up to `MAX_SIZE`
+ * assertEquals(cache.get("b"), 2);
+ * assertEquals(cache.get("c"), 3);
+ * assertEquals(cache.get("d"), 4);
+ *
+ * // less recent values are removed
+ * assert(!cache.has("a"));
+ * ```
+ *
+ * @example Adding an onEject callback
+ * ```ts
+ * import { LruCache } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const ejected: [string, number, string][] = [];
+ * const cache = new LruCache<string, number>(2, {
+ *   onEject: (key, value, reason) => ejected.push([key, value, reason]),
+ * });
+ *
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
+ *
+ * assertEquals(ejected, [["a", 1, "evicted"]]);
+ * ```
+ */
+export class LruCache extends Map {
+    #maxSize;
+    #ejecting = false;
+    #eject;
+    /**
+     * Constructs a new `LruCache`.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param maxSize The maximum number of entries to store in the cache. Must
+     * be a positive integer.
+     * @param options Additional options.
+     */
+    constructor(maxSize, options) {
+        super();
+        if (!Number.isInteger(maxSize) || maxSize < 1) {
+            throw new RangeError(`Cannot create LruCache: maxSize must be a positive integer: received ${maxSize}`);
+        }
+        this.#maxSize = maxSize;
+        this.#eject = options?.onEject;
+    }
+    /**
+     * The maximum number of entries to store in the cache.
+     *
+     * @returns The maximum number of entries in the cache.
+     *
+     * @example Max size
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(100);
+     * assertEquals(cache.maxSize, 100);
+     * ```
+     */
+    get maxSize() {
+        return this.#maxSize;
+    }
+    #setMostRecentlyUsed(key, value) {
+        super.delete(key);
+        super.set(key, value);
+    }
+    #pruneToMaxSize() {
+        if (this.size <= this.#maxSize)
+            return;
+        const key = this.keys().next().value;
+        const value = super.get(key);
+        super.delete(key);
+        if (this.#eject) {
+            this.#ejecting = true;
+            try {
+                this.#eject(key, value, "evicted");
+            }
+            finally {
+                this.#ejecting = false;
+            }
+        }
+    }
+    /**
+     * Checks whether an element with the specified key exists or not. Does
+     * **not** update the entry's position in the eviction order.
+     *
+     * @param key The key to check.
+     * @returns `true` if the cache contains the specified key, otherwise `false`.
+     *
+     * @example Checking for the existence of a key
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assert } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assert(cache.has("a"));
+     * ```
+     */
+    has(key) {
+        return super.has(key);
+    }
+    /**
+     * Gets the element with the specified key.
+     *
+     * @param key The key to get the value for.
+     * @returns The value associated with the specified key, or `undefined` if
+     * the key is not present in the cache.
+     *
+     * @example Getting a value from the cache
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * assertEquals(cache.get("a"), 1);
+     * ```
+     */
+    get(key) {
+        if (super.has(key)) {
+            const value = super.get(key);
+            this.#setMostRecentlyUsed(key, value);
+            return value;
+        }
+        return undefined;
+    }
+    /**
+     * Returns the value associated with the given key, or `undefined` if the
+     * key is not present, **without** updating its position in the eviction
+     * order.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to look up.
+     * @returns The value, or `undefined` if not present.
+     *
+     * @example Peeking at a value without promoting it
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(3);
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.set("c", 3);
+     *
+     * // peek does not promote "a"
+     * assertEquals(cache.peek("a"), 1);
+     *
+     * // "a" is still the least recently used and gets evicted
+     * cache.set("d", 4);
+     * assertEquals(cache.peek("a"), undefined);
+     * ```
+     */
+    peek(key) {
+        return super.get(key);
+    }
+    /**
+     * Sets the specified key to the specified value.
+     *
+     * @param key The key to set the value for.
+     * @param value The value to set.
+     * @returns `this` for chaining.
+     *
+     * @example Setting a value in the cache
+     * ```ts no-assert
+     * import { LruCache } from "@std/cache";
+     *
+     * const cache = new LruCache<string, number>(100);
+     * cache.set("a", 1);
+     * ```
+     */
+    set(key, value) {
+        if (this.#ejecting) {
+            throw new TypeError("Cannot set entry in LruCache: cache is not re-entrant during onEject callbacks");
+        }
+        this.#setMostRecentlyUsed(key, value);
+        this.#pruneToMaxSize();
+        return this;
+    }
+    /**
+     * Deletes the value associated with the given key.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @param key The key to delete.
+     * @returns `true` if the key was deleted, `false` otherwise.
+     *
+     * @example Deleting a key from the cache
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new LruCache<string, number>(1);
+     *
+     * cache.set("a", 1);
+     * cache.delete("a");
+     * assertEquals(cache.has("a"), false);
+     * ```
+     */
+    delete(key) {
+        if (this.#ejecting) {
+            throw new TypeError("Cannot delete entry in LruCache: cache is not re-entrant during onEject callbacks");
+        }
+        const value = super.get(key);
+        const existed = super.delete(key);
+        if (!existed)
+            return false;
+        if (this.#eject) {
+            this.#ejecting = true;
+            try {
+                this.#eject(key, value, "deleted");
+            }
+            finally {
+                this.#ejecting = false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Clears the cache.
+     *
+     * @experimental **UNSTABLE**: New API, yet to be vetted.
+     *
+     * @example Usage
+     * ```ts
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const cache = new LruCache<string, number>(100);
+     *
+     * cache.set("a", 1);
+     * cache.set("b", 2);
+     * cache.clear();
+     * assertEquals(cache.size, 0);
+     * ```
+     */
+    clear() {
+        if (this.#ejecting) {
+            throw new TypeError("Cannot clear LruCache: cache is not re-entrant during onEject callbacks");
+        }
+        if (!this.#eject) {
+            super.clear();
+            return;
+        }
+        const entries = [...super.entries()];
+        super.clear();
+        this.#ejecting = true;
+        let error;
+        try {
+            for (const [key, value] of entries) {
+                try {
+                    this.#eject(key, value, "cleared");
+                }
+                catch (e) {
+                    error ??= e;
+                }
+            }
+        }
+        finally {
+            this.#ejecting = false;
+        }
+        if (error !== undefined)
+            throw error;
+    }
+}

package/{script/deps/jsr.io/@std/cache/0.2.2 → esm/deps/jsr.io/@std/cache/0.2.3}/memoize.d.ts

@@ -3,12 +3,16 @@
  *
  * @experimental **UNSTABLE**: New API, yet to be vetted.
  */
-export type MemoizationCache<K, V> = {
-    has: (key: K) => boolean;
-    get: (key: K) => V | undefined;
-    set: (key: K, val: V) => unknown;
-    delete: (key: K) => unknown;
-};
+export interface MemoizationCache<K, V> {
+    /** Checks whether a value for the given key exists in the cache. */
+    has(key: K): boolean;
+    /** Returns the cached value associated with the given key, if present. */
+    get(key: K): V | undefined;
+    /** Stores a value in the cache under the given key. */
+    set(key: K, val: V): unknown;
+    /** Removes the value associated with the given key from the cache. */
+    delete(key: K): unknown;
+}
 /**
  * The result of a memoized function, as stored in its cache.
  *
@@ -39,8 +43,9 @@ export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache
      * {@linkcode Map} object is instantiated upon memoization and used as a cache, with no
      * limit on the number of results to be cached.
      *
-     * Alternatively, you can supply a {@linkcode LruCache} with a specified max
-     * size to limit memory usage.
+     * Alternatively, you can supply an
+     * {@link https://jsr.io/@std/cache/doc/lru-cache/~/LruCache | LruCache}
+     * with a specified max size to limit memory usage.
      */
     cache?: Cache;
     /**
@@ -84,7 +89,8 @@ export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache
  * @param fn The function to memoize
  * @param options Options for memoization
  *
- * @returns The memoized function.
+ * @returns The memoized function, with a `cache` property exposing the
+ * underlying cache for inspection or manual invalidation.
  *
  * @example Basic usage
  * ```ts
@@ -107,5 +113,7 @@ export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache
  * >   avoid this, you can pass a custom `getKey` option or use the memoized
  * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
  */
-export declare function memoize<Fn extends (...args: never[]) => unknown, Key = string, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>> = Map<Key, MemoizationCacheResult<ReturnType<Fn>>>>(fn: Fn, options?: MemoizeOptions<Fn, Key, Cache>): Fn;
+export declare function memoize<Fn extends (...args: never[]) => unknown, Key = string, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>> = Map<Key, MemoizationCacheResult<ReturnType<Fn>>>>(fn: Fn, options?: MemoizeOptions<Fn, Key, Cache>): Fn & {
+    cache: Cache;
+};
 //# sourceMappingURL=memoize.d.ts.map

package/esm/deps/jsr.io/@std/cache/0.2.3/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.3/memoize.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC;IACpC,oEAAoE;IACpE,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IACrB,0EAA0E;IAC1E,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAC3B,uDAAuD;IACvD,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAC7B,sEAAsE;IACtE,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAChC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG,KAAK,CAAC,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACxB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,EACH,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,IACzE;IACF;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC;IACvE;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CACrB,EAAE,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EACxC,GAAG,GAAG,MAAM,EACZ,KAAK,SAAS,gBAAgB,CAAC,GAAG,EAAE,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,GACzE,GAAG,CACD,GAAG,EACH,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CACvC,EAEH,EAAE,EAAE,EAAE,EACN,OAAO,CAAC,EAAE,cAAc,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,CAAC,GACvC,EAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CAkEvB"}

package/esm/deps/jsr.io/@std/cache/{0.2.2 → 0.2.3}/memoize.js

@@ -12,7 +12,8 @@ import { _serializeArgList } from "./_serialize_arg_list.js";
  * @param fn The function to memoize
  * @param options Options for memoization
  *
- * @returns The memoized function.
+ * @returns The memoized function, with a `cache` property exposing the
+ * underlying cache for inspection or manual invalidation.
  *
  * @example Basic usage
  * ```ts
@@ -36,20 +37,22 @@ import { _serializeArgList } from "./_serialize_arg_list.js";
  * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
  */
 export function memoize(fn, options) {
-    const cache = options?.cache ?? new Map();
+    const cache = (options?.cache ?? new Map());
     const getKey = options?.getKey ??
         _serializeArgList(cache);
     const errorIsCacheable = options?.errorIsCacheable ?? (() => false);
     const memoized = function (...args) {
         const key = getKey.apply(this, args);
-        if (cache.has(key)) {
-            const result = cache.get(key);
-            switch (result.kind) {
+        const cached = cache.get(key);
+        // `MemoizationCacheResult` is always a truthy object, so `undefined`
+        // reliably indicates a cache miss here.
+        if (cached !== undefined) {
+            switch (cached.kind) {
                 case "ok":
                 case "promise":
-                    return result.value;
+                    return cached.value;
                 case "error":
-                    throw result.error;
+                    throw cached.error;
             }
         }
         try {
@@ -78,5 +81,6 @@ export function memoize(fn, options) {
     return Object.defineProperties(memoized, {
         length: { value: fn.length },
         name: { value: fn.name },
+        cache: { value: cache },
     });
 }

package/esm/deps/jsr.io/@std/streams/1.1.0/to_array_buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_array_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/streams/1.1.0/to_array_buffer.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,aAAa,CACjC,cAAc,EAAE,cAAc,CAAC,UAAU,CAAC,GACzC,OAAO,CAAC,WAAW,CAAC,CAetB"}