@mtkruto/node 0.69.0 → 0.70.0

package/esm/deps/jsr.io/@std/cache/0.2.0/_serialize_arg_list.d.ts

@@ -0,0 +1,12 @@
+import type { MemoizationCache } from "./memoize.js";
+/**
+ * Default serialization of arguments list for use as cache keys. Equivalence
+ * follows [`SameValueZero`](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero)
+ * reference equality, such that `getKey(x, y) === getKey(x, y)` for all values
+ * of `x` and `y`, but `getKey({}) !== getKey({})`.
+ *
+ * @param cache The cache for which the keys will be used.
+ * @returns `getKey`, the function for getting cache keys.
+ */
+export declare function _serializeArgList<Return>(cache: MemoizationCache<unknown, Return>): (this: unknown, ...args: unknown[]) => string;
+//# sourceMappingURL=_serialize_arg_list.d.ts.map

package/esm/deps/jsr.io/@std/cache/0.2.0/_serialize_arg_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_serialize_arg_list.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/_serialize_arg_list.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;GAQG;AAEH,wBAAgB,iBAAiB,CAAC,MAAM,EACtC,KAAK,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,GACvC,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAmE/C"}

package/esm/deps/jsr.io/@std/cache/0.2.0/_serialize_arg_list.js

@@ -0,0 +1,69 @@
+/**
+ * Default serialization of arguments list for use as cache keys. Equivalence
+ * follows [`SameValueZero`](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero)
+ * reference equality, such that `getKey(x, y) === getKey(x, y)` for all values
+ * of `x` and `y`, but `getKey({}) !== getKey({})`.
+ *
+ * @param cache The cache for which the keys will be used.
+ * @returns `getKey`, the function for getting cache keys.
+ */
+export function _serializeArgList(cache) {
+    const weakKeyToKeySegmentCache = new WeakMap();
+    const weakKeySegmentToKeyCache = new Map();
+    let i = 0;
+    const registry = new FinalizationRegistry((keySegment) => {
+        for (const key of weakKeySegmentToKeyCache.get(keySegment) ?? []) {
+            cache.delete(key);
+        }
+        weakKeySegmentToKeyCache.delete(keySegment);
+    });
+    return function getKey(...args) {
+        const weakKeySegments = [];
+        const keySegments = [this, ...args].map((arg) => {
+            if (typeof arg === "undefined")
+                return "undefined";
+            if (typeof arg === "bigint")
+                return `${arg}n`;
+            if (typeof arg === "number") {
+                return String(arg);
+            }
+            if (arg === null ||
+                typeof arg === "string" ||
+                typeof arg === "boolean") {
+                // This branch will need to be updated if further types are added to
+                // the language that support value equality,
+                // e.g. https://github.com/tc39/proposal-record-tuple
+                return JSON.stringify(arg);
+            }
+            try {
+                assertWeakKey(arg);
+            }
+            catch {
+                if (typeof arg === "symbol") {
+                    return `Symbol.for(${JSON.stringify(arg.description)})`;
+                }
+                // Non-weak keys other than `Symbol.for(...)` are handled by the branches above.
+                throw new Error("Should be unreachable: please open an issue at https://github.com/denoland/std/issues/new");
+            }
+            if (!weakKeyToKeySegmentCache.has(arg)) {
+                const keySegment = `{${i++}}`;
+                weakKeySegments.push(keySegment);
+                registry.register(arg, keySegment);
+                weakKeyToKeySegmentCache.set(arg, keySegment);
+            }
+            const keySegment = weakKeyToKeySegmentCache.get(arg);
+            weakKeySegments.push(keySegment);
+            return keySegment;
+        });
+        const key = keySegments.join(",");
+        for (const keySegment of weakKeySegments) {
+            const keys = weakKeySegmentToKeyCache.get(keySegment) ?? [];
+            keys.push(key);
+            weakKeySegmentToKeyCache.set(keySegment, keys);
+        }
+        return key;
+    };
+}
+function assertWeakKey(arg) {
+    new WeakRef(arg);
+}

package/esm/deps/jsr.io/@std/cache/0.2.0/lru_cache.d.ts

@@ -0,0 +1,112 @@
+import type { MemoizationCache } from "./memoize.js";
+export type { MemoizationCache };
+/**
+ * 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`, `set`, or `has`.
+ *
+ * @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"));
+ * ```
+ */
+export declare class LruCache<K, V> extends Map<K, V> implements MemoizationCache<K, V> {
+    #private;
+    /**
+     * The maximum number of entries to store in the cache.
+     *
+     * @example Max size
+     * ```ts no-assert
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(100);
+     * assertEquals(cache.maxSize, 100);
+     * ```
+     */
+    maxSize: number;
+    /**
+     * Constructs a new `LruCache`.
+     *
+     * @param maxSize The maximum number of entries to store in the cache.
+     */
+    constructor(maxSize: number);
+    /**
+     * Checks whether an element with the specified key exists or not.
+     *
+     * @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: K): boolean;
+    /**
+     * 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: K): V | undefined;
+    /**
+     * 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: K, value: V): this;
+}
+//# sourceMappingURL=lru_cache.d.ts.map

package/esm/deps/jsr.io/@std/cache/0.2.0/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.0/lru_cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAC1C,YAAW,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;;IACjC;;;;;;;;;;;OAWG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;;OAIG;gBACS,OAAO,EAAE,MAAM;IAiB3B;;;;;;;;;;;;;;;;OAgBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAU7B;;;;;;;;;;;;;;;;OAgBG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAUnC;;;;;;;;;;;;;;OAcG;IACM,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAMrC"}

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

@@ -0,0 +1,140 @@
+// Copyright 2018-2025 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`, `set`, or `has`.
+ *
+ * @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"));
+ * ```
+ */
+export class LruCache extends Map {
+    /**
+     * The maximum number of entries to store in the cache.
+     *
+     * @example Max size
+     * ```ts no-assert
+     * import { LruCache } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const cache = new LruCache<string, number>(100);
+     * assertEquals(cache.maxSize, 100);
+     * ```
+     */
+    maxSize;
+    /**
+     * Constructs a new `LruCache`.
+     *
+     * @param maxSize The maximum number of entries to store in the cache.
+     */
+    constructor(maxSize) {
+        super();
+        this.maxSize = 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);
+        }
+    }
+    /**
+     * Checks whether an element with the specified key exists or not.
+     *
+     * @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) {
+        const exists = super.has(key);
+        if (exists) {
+            this.#setMostRecentlyUsed(key, super.get(key));
+        }
+        return exists;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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) {
+        this.#setMostRecentlyUsed(key, value);
+        this.#pruneToMaxSize();
+        return this;
+    }
+}

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

@@ -0,0 +1,111 @@
+/**
+ * A cache suitable for use with {@linkcode memoize}.
+ *
+ * @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;
+};
+/**
+ * The result of a memoized function, as stored in its cache.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ */
+export type MemoizationCacheResult<T> = {
+    kind: "ok";
+    value: T;
+} | {
+    kind: "error";
+    error: unknown;
+} | (T extends Promise<unknown> ? {
+    kind: "promise";
+    value: T;
+} : never);
+/**
+ * Options for {@linkcode memoize}.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ */
+export type MemoizeOptions<Fn extends (...args: never[]) => unknown, Key, Cache extends MemoizationCache<Key, MemoizationCacheResult<ReturnType<Fn>>>> = {
+    /**
+     * Provide a custom cache for getting previous results. By default, a new
+     * {@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.
+     */
+    cache?: Cache;
+    /**
+     * Function to get a unique cache key from the function's arguments. By
+     * default, a composite key is created from all the arguments plus the `this`
+     * value, using reference equality to check for equivalence.
+     *
+     * @example
+     * ```ts
+     * import { memoize } from "@std/cache";
+     * import { assertEquals } from "@std/assert";
+     *
+     * const fn = memoize(({ value }: { cacheKey: number; value: number }) => {
+     *   return value;
+     * }, { getKey: ({ cacheKey }) => cacheKey });
+     *
+     * assertEquals(fn({ cacheKey: 1, value: 2 }), 2);
+     * assertEquals(fn({ cacheKey: 1, value: 99 }), 2);
+     * assertEquals(fn({ cacheKey: 2, value: 99 }), 99);
+     * ```
+     */
+    getKey?: (this: ThisParameterType<Fn>, ...args: Parameters<Fn>) => Key;
+    /**
+     * Callback to determine if an error or other thrown value is cacheable.
+     *
+     * @default {() => false}
+     *
+     * @param err The thrown error or other value.
+     * @returns `true` if the error is cacheable, `false` otherwise.
+     */
+    errorIsCacheable?: (err: unknown) => boolean;
+};
+/**
+ * Cache the results of a function based on its arguments.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ * @param fn The function to memoize
+ * @param options Options for memoization
+ *
+ * @returns The memoized function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { memoize } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * > [!NOTE]
+ * > * By default, memoization is on the basis of all arguments passed to the
+ * >   function, with equality determined by reference. This means that, for
+ * >   example, passing a memoized function as `arr.map(func)` will not use the
+ * >   cached results, as the index is implicitly passed as an argument. To
+ * >   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;
+//# sourceMappingURL=memoize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/cache/0.2.0/memoize.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,IAAI;IACnC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACzB,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC/B,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;IACjC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;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;;;;;;;OAOG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;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,CA+DJ"}

package/esm/deps/jsr.io/@std/cache/0.2.0/memoize.js

@@ -0,0 +1,82 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { _serializeArgList } from "./_serialize_arg_list.js";
+/**
+ * Cache the results of a function based on its arguments.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @typeParam Fn The type of the function to memoize.
+ * @typeParam Key The type of the cache key.
+ * @typeParam Cache The type of the cache.
+ * @param fn The function to memoize
+ * @param options Options for memoization
+ *
+ * @returns The memoized function.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { memoize } from "@std/cache";
+ * import { assertEquals } from "@std/assert";
+ *
+ * // fibonacci function, which is very slow for n > ~30 if not memoized
+ * const fib = memoize((n: bigint): bigint => {
+ *   return n <= 2n ? 1n : fib(n - 1n) + fib(n - 2n);
+ * });
+ *
+ * assertEquals(fib(100n), 354224848179261915075n);
+ * ```
+ *
+ * > [!NOTE]
+ * > * By default, memoization is on the basis of all arguments passed to the
+ * >   function, with equality determined by reference. This means that, for
+ * >   example, passing a memoized function as `arr.map(func)` will not use the
+ * >   cached results, as the index is implicitly passed as an argument. To
+ * >   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 function memoize(fn, options) {
+    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) {
+                case "ok":
+                case "promise":
+                    return result.value;
+                case "error":
+                    throw result.error;
+            }
+        }
+        try {
+            let value = fn.apply(this, args);
+            if (value instanceof Promise) {
+                value = value.catch((reason) => {
+                    if (!errorIsCacheable(reason)) {
+                        cache.delete(key);
+                    }
+                    throw reason;
+                });
+                cache.set(key, { kind: "promise", value });
+            }
+            else {
+                cache.set(key, { kind: "ok", value });
+            }
+            return value;
+        }
+        catch (e) {
+            if (errorIsCacheable(e)) {
+                cache.set(key, { kind: "error", error: e });
+            }
+            throw e;
+        }
+    };
+    return Object.defineProperties(memoized, {
+        length: { value: fn.length },
+        name: { value: fn.name },
+    });
+}

package/esm/deps/jsr.io/@std/encoding/1.0.7/hex.d.ts

@@ -0,0 +1,39 @@
+import type { Uint8Array_ } from "./_types.js";
+export type { Uint8Array_ };
+/**
+ * Converts data into a hex-encoded string.
+ *
+ * @param src The data to encode.
+ *
+ * @returns The hex-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeHex("abc"), "616263");
+ * ```
+ */
+export declare function encodeHex(src: string | Uint8Array | ArrayBuffer): string;
+/**
+ * Decodes the given hex-encoded string. If the input is malformed, an error is
+ * thrown.
+ *
+ * @param src The hex-encoded string to decode.
+ *
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
+ * ```
+ */
+export declare function decodeHex(src: string): Uint8Array_;
+//# sourceMappingURL=hex.d.ts.map

package/esm/deps/jsr.io/@std/encoding/1.0.7/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/encoding/1.0.7/hex.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,CAAC;AA4B5B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,CAUxE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAiBlD"}