@mtkruto/browser 0.142.0 → 0.144.0

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/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"}