@mtkruto/browser 0.141.0 → 0.143.0

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

@@ -1,5 +1,38 @@
 import type { MemoizationCache } from "./memoize.js";
 export type { MemoizationCache };
+/**
+ * The reason an entry was removed from the cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * - `"evicted"` — removed automatically because the cache exceeded
+ *   {@linkcode LruCache.prototype.maxSize | maxSize}.
+ * - `"deleted"` — removed by an explicit
+ *   {@linkcode LruCache.prototype.delete | delete()} call.
+ * - `"cleared"` — removed by
+ *   {@linkcode LruCache.prototype.clear | clear()}.
+ */
+export type LruCacheEjectionReason = "evicted" | "deleted" | "cleared";
+/**
+ * Options for the {@linkcode LruCache} constructor.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export interface LruCacheOptions<K, V> {
+    /**
+     * Callback invoked when an entry is removed, whether by eviction,
+     * manual deletion, or clearing the cache. The entry is already removed
+     * from the cache when this callback fires. Overwriting an existing key
+     * via {@linkcode LruCache.prototype.set | set()} does **not** trigger
+     * this callback. The cache is not re-entrant during this callback:
+     * calling `set`, `delete`, or `clear` will throw.
+     *
+     * @param ejectedKey The key of the removed entry.
+     * @param ejectedValue The value of the removed entry.
+     * @param reason Why the entry was removed.
+     */
+    onEject?: (ejectedKey: K, ejectedValue: V, reason: LruCacheEjectionReason) => void;
+}
 /**
  * Least-recently-used cache.
  *
@@ -8,7 +41,7 @@ export type { MemoizationCache };
  * @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`, `set`, or `has`.
+ * last accessed with `get` or `set`.
  *
  * @typeParam K The type of the cache keys.
  * @typeParam V The type of the cache values.
@@ -35,32 +68,42 @@ export type { MemoizationCache };
  * assert(!cache.has("a"));
  * ```
  *
- * @example Adding a onEject function.
+ * @example Adding an onEject callback
  * ```ts
  * import { LruCache } from "@std/cache";
  * import { assertEquals } from "@std/assert";
  *
- * const cache = new LruCache<string, string>(3, { onEject: (key, value) => {
- *  console.log("Revoking: ", key)
- *  URL.revokeObjectURL(value)
- * }});
+ * const ejected: [string, number, string][] = [];
+ * const cache = new LruCache<string, number>(2, {
+ *   onEject: (key, value, reason) => ejected.push([key, value, reason]),
+ * });
  *
- * cache.set(
- *  "fast-url",
- *  URL.createObjectURL(new Blob(["Hello, World"], { type: "text/plain" }))
- * );
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
  *
- * cache.delete("fast-url") // "Revoking: fast-url"
- * assertEquals(cache.get("fast-url"), undefined)
+ * assertEquals(ejected, [["a", 1, "evicted"]]);
  * ```
  */
 export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
     #private;
+    /**
+     * 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: number, options?: LruCacheOptions<K, V>);
     /**
      * The maximum number of entries to store in the cache.
      *
+     * @returns The maximum number of entries in the cache.
+     *
      * @example Max size
-     * ```ts no-assert
+     * ```ts
      * import { LruCache } from "@std/cache";
      * import { assertEquals } from "@std/assert";
      *
@@ -68,18 +111,10 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * assertEquals(cache.maxSize, 100);
      * ```
      */
-    maxSize: number;
+    get maxSize(): number;
     /**
-     * Constructs a new `LruCache`.
-     *
-     * @param maxSize The maximum number of entries to store in the cache.
-     * @param options Additional options.
-     */
-    constructor(maxSize: number, options?: {
-        onEject: (ejectedKey: K, ejectedValue: V) => void;
-    });
-    /**
-     * Checks whether an element with the specified key exists or not.
+     * 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`.
@@ -100,7 +135,8 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * 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.
+     * @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
@@ -114,6 +150,35 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * ```
      */
     get(key: K): V | 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: K): V | undefined;
     /**
      * Sets the specified key to the specified value.
      *
@@ -151,5 +216,24 @@ export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCach
      * ```
      */
     delete(key: K): boolean;
+    /**
+     * 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(): void;
 }
 //# sourceMappingURL=lru_cache.d.ts.map

package/script/deps/jsr.io/@std/cache/0.2.3/lru_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru_cache.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.3/lru_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,CAAC;IACnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,CACR,UAAU,EAAE,CAAC,EACb,YAAY,EAAE,CAAC,EACf,MAAM,EAAE,sBAAsB,KAC3B,IAAI,CAAC;CACX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IAOjC;;;;;;;;OAQG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC;IAYjC;;;;;;;;;;;;;OAaG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAsBD;;;;;;;;;;;;;;;;;OAiBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAI7B;;;;;;;;;;;;;;;;;OAiBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAUnC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI3B;;;;;;;;;;;;;;OAcG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAYpC;;;;;;;;;;;;;;;;;;;OAmBG;IACM,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAqBhC;;;;;;;;;;;;;;;;;OAiBG;IACM,KAAK,IAAI,IAAI;CA2BvB"}

package/script/deps/jsr.io/@std/cache/{0.2.2 → 0.2.3}/lru_cache.js

@@ -11,7 +11,7 @@ exports.LruCache = void 0;
  * @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`, `set`, or `has`.
+ * last accessed with `get` or `set`.
  *
  * @typeParam K The type of the cache keys.
  * @typeParam V The type of the cache values.
@@ -38,31 +38,51 @@ exports.LruCache = void 0;
  * assert(!cache.has("a"));
  * ```
  *
- * @example Adding a onEject function.
+ * @example Adding an onEject callback
  * ```ts
  * import { LruCache } from "@std/cache";
  * import { assertEquals } from "@std/assert";
  *
- * const cache = new LruCache<string, string>(3, { onEject: (key, value) => {
- *  console.log("Revoking: ", key)
- *  URL.revokeObjectURL(value)
- * }});
+ * const ejected: [string, number, string][] = [];
+ * const cache = new LruCache<string, number>(2, {
+ *   onEject: (key, value, reason) => ejected.push([key, value, reason]),
+ * });
  *
- * cache.set(
- *  "fast-url",
- *  URL.createObjectURL(new Blob(["Hello, World"], { type: "text/plain" }))
- * );
+ * cache.set("a", 1);
+ * cache.set("b", 2);
+ * cache.set("c", 3);
  *
- * cache.delete("fast-url") // "Revoking: fast-url"
- * assertEquals(cache.get("fast-url"), undefined)
+ * assertEquals(ejected, [["a", 1, "evicted"]]);
  * ```
  */
 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 no-assert
+     * ```ts
      * import { LruCache } from "@std/cache";
      * import { assertEquals } from "@std/assert";
      *
@@ -70,31 +90,32 @@ class LruCache extends Map {
      * assertEquals(cache.maxSize, 100);
      * ```
      */
-    maxSize;
-    #eject;
-    /**
-     * Constructs a new `LruCache`.
-     *
-     * @param maxSize The maximum number of entries to store in the cache.
-     * @param options Additional options.
-     */
-    constructor(maxSize, options) {
-        super();
-        this.maxSize = maxSize;
-        this.#eject = options?.onEject ?? (() => { });
+    get maxSize() {
+        return this.#maxSize;
     }
     #setMostRecentlyUsed(key, value) {
-        // delete then re-add to ensure most recently accessed elements are last
         super.delete(key);
         super.set(key, value);
     }
     #pruneToMaxSize() {
-        if (this.size > this.maxSize) {
-            this.delete(this.keys().next().value);
+        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.
+     * 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`.
@@ -111,17 +132,14 @@ class LruCache extends Map {
      * ```
      */
     has(key) {
-        const exists = super.has(key);
-        if (exists) {
-            this.#setMostRecentlyUsed(key, super.get(key));
-        }
-        return exists;
+        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.
+     * @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
@@ -142,6 +160,37 @@ class LruCache extends Map {
         }
         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.
      *
@@ -158,6 +207,9 @@ class LruCache extends Map {
      * ```
      */
     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;
@@ -183,10 +235,69 @@ class LruCache extends Map {
      * ```
      */
     delete(key) {
-        if (super.has(key)) {
-            this.#eject(key, super.get(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;
         }
-        return super.delete(key);
+        if (error !== undefined)
+            throw error;
     }
 }
 exports.LruCache = LruCache;

package/{esm/deps/jsr.io/@std/cache/0.2.2 → script/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/script/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/script/deps/jsr.io/@std/cache/{0.2.2 → 0.2.3}/memoize.js

@@ -15,7 +15,8 @@ const _serialize_arg_list_js_1 = require("./_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
@@ -39,20 +40,22 @@ const _serialize_arg_list_js_1 = require("./_serialize_arg_list.js");
  * >   function inside an anonymous callback like `arr.map((x) => func(x))`.
  */
 function memoize(fn, options) {
-    const cache = options?.cache ?? new Map();
+    const cache = (options?.cache ?? new Map());
     const getKey = options?.getKey ??
         (0, _serialize_arg_list_js_1._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 {
@@ -81,5 +84,6 @@ function memoize(fn, options) {
     return Object.defineProperties(memoized, {
         length: { value: fn.length },
         name: { value: fn.name },
+        cache: { value: cache },
     });
 }

package/script/deps/jsr.io/@std/internal/1.0.13/_os.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/_os.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,IAAI,OAAO,CAUtC"}

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/_os.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkWindows = checkWindows;
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
 function checkWindows() {
     // deno-lint-ignore no-explicit-any

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/build_message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAWvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,EACjC,YAAY,CAAC,EAAE,CACb,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,UAAU,EAAE,OAAO,EACnB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,KAC1B,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,GACrC,MAAM,EAAE,CA8BV"}
+{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAWvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,EACjC,YAAY,CAAC,EAAE,CACb,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,UAAU,EAAE,OAAO,EACnB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,KAC1B,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,GACrC,MAAM,EAAE,CA8BV"}

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/build_message.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createColor = createColor;

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/diff.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCommon = createCommon;

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/diff_str.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/diff_str.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAC;AAGhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/C;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}
+{"version":3,"file":"diff_str.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/diff_str.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,YAAY,CAAC;AAGhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/C;AAKD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,MAAM,EAAE,CAiBnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,CAAC,MAAM,CAAC,EACxB,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,GAC3B,UAAU,CAAC,MAAM,CAAC,EAAE,CAetB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAkDlE"}

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/diff_str.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unescape = unescape;
@@ -34,7 +34,7 @@ function unescape(string) {
         // This does not remove line breaks
         .replaceAll(/\r\n|\r|\n/g, (str) => str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
 }
-const WHITESPACE_SYMBOLS = /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
+const WHITESPACE_SYMBOLS_REGEXP = /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b)/;
 /**
  * Tokenizes a string into an array of tokens.
  *
@@ -54,7 +54,7 @@ const WHITESPACE_SYMBOLS = /((?:\\[bftv]|[^\S\r\n])+|\\[rn\\]|[()[\]{}'"\r\n]|\b
 function tokenize(string, wordDiff = false) {
     if (wordDiff) {
         return string
-            .split(WHITESPACE_SYMBOLS)
+            .split(WHITESPACE_SYMBOLS_REGEXP)
             .filter((token) => token);
     }
     const tokens = [];

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/format.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,CACtB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACE,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBzC"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/format.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,SAAS,GAAG,CACtB,CAAC,EAAE,OAAO,EACV,OAAO,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,KACE,MAAM,CAAC;AAEZ;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAmBzC"}

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/format.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copyright 2018-2025 the Deno authors. MIT license.
+// Copyright 2018-2026 the Deno authors. MIT license.
 // This module is browser compatible.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/script/deps/jsr.io/@std/internal/{1.0.12 → 1.0.13}/os.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.12/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}
+{"version":3,"file":"os.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.13/os.ts"],"names":[],"mappings":"AAKA,8CAA8C;AAC9C,eAAO,MAAM,SAAS,EAAE,OAAwB,CAAC"}