tiny-essentials 1.29.1 → 1.29.2

package/dist/v1/libs/html/loader/utils/TinyMediaCache.mjs

@@ -0,0 +1,734 @@
+/**
+ * @fileoverview Shared memory cache for media blobs and object URLs.
+ * Instances are tracked statically so a blob survives until the last cache
+ * releases it, which prevents revoking an object URL that another part of the
+ * application is still rendering.
+ */
+/**
+ * Cleanup strategy applied when an entry reaches zero references.
+ * @typedef {'auto'|'manual'|'ttl'} MediaCacheStrategy
+ */
+/**
+ * @typedef {Object} MediaCacheOptions
+ * @property {number} [maxItems] - Maximum number of entries (Infinity by default).
+ * @property {number} [maxBytes] - Maximum cache size in bytes (Infinity by default).
+ * @property {number} [ttl] - Entry lifetime in milliseconds (0 = never expires).
+ * @property {MediaCacheStrategy} [strategy] - Cleanup strategy at zero references.
+ * @property {boolean} [ignoreSearch] - Whether the query string is ignored when building keys.
+ * @property {number} [sweepInterval] - Interval in milliseconds for active TTL sweeping (0 = disabled).
+ */
+/**
+ * @typedef {Object} MediaCacheEntry
+ * @property {string} key - The normalized cache key.
+ * @property {string} url - The original URL.
+ * @property {Blob} blob - The cached blob.
+ * @property {string} objectUrl - The shared object URL.
+ * @property {number} size - The blob size in bytes.
+ * @property {string} type - The blob MIME type.
+ * @property {number} refs - The number of active consumers.
+ * @property {number} createdAt - The epoch timestamp when the entry was created.
+ * @property {number} lastAccess - The epoch timestamp of the last access.
+ * @property {number} expiresAt - The epoch timestamp when the entry expires (0 = never).
+ * @property {boolean} pinned - Whether the entry is protected from eviction.
+ * @property {string|null} parent - The key of the entry that owns this one, or null.
+ * @property {Record<string, any>} metadata - The probe metadata captured with the blob.
+ */
+/**
+ * @typedef {Object} MediaCacheStats
+ * @property {number} size - The number of entries in this cache.
+ * @property {number} bytes - The total size in bytes held by this cache.
+ * @property {number} refs - The total number of active references.
+ * @property {number} hits - The number of successful lookups.
+ * @property {number} misses - The number of failed lookups.
+ * @property {number} evictions - The number of evicted entries.
+ * @property {number} links - The number of entries that currently own at least one child.
+ * @property {number} instances - The number of live cache instances.
+ * @property {number} blobs - The number of blobs in the shared registry.
+ */
+/**
+ * @typedef {Object} MediaCacheRecord
+ * @property {string} objectUrl - The shared object URL.
+ * @property {number} refs - The number of cache instances holding the key.
+ * @property {number} size - The blob size in bytes.
+ */
+/**
+ * Checks whether a value is a plain object (not an array, not a class instance).
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} True when the value is a plain object.
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Memory cache shared by every media loader.
+ */
+class TinyMediaCache {
+    /**
+     * Cleanup strategies applied when an entry reaches zero references.
+     */
+    static Strategy = Object.freeze({
+        AUTO: 'auto',
+        MANUAL: 'manual',
+        TTL: 'ttl',
+    });
+    /** @type {Set<TinyMediaCache>} */
+    static #instances = new Set();
+    /** @type {Map<string, MediaCacheRecord>} */
+    static #blobs = new Map();
+    /** @type {number} */
+    #evictions = 0;
+    /** @type {Map<string, MediaCacheEntry>} */
+    #entries = new Map();
+    /** @type {Map<string, Set<string>>} */
+    #children = new Map();
+    /** @type {number} */
+    #maxItems;
+    /** @type {number} */
+    #maxBytes;
+    /** @type {number} */
+    #ttl;
+    /** @type {MediaCacheStrategy} */
+    #strategy;
+    /** @type {boolean} */
+    #ignoreSearch;
+    /** @type {number} */
+    #hits = 0;
+    /** @type {number} */
+    #misses = 0;
+    /** @type {ReturnType<typeof setInterval>|null} */
+    #timer = null;
+    /** @type {boolean} */
+    #destroyed = false;
+    /**
+     * The number of failed lookups recorded by this cache.
+     * @returns {number} The current miss count.
+     */
+    get misses() {
+        return this.#misses;
+    }
+    /**
+     * Whether the query string is ignored when building cache keys.
+     * @returns {boolean} True when the query string is ignored.
+     */
+    get ignoreSearch() {
+        return this.#ignoreSearch;
+    }
+    /**
+     * The cleanup strategy applied when an entry reaches zero references.
+     * @returns {MediaCacheStrategy} The active cleanup strategy used by the cache.
+     */
+    get strategy() {
+        return this.#strategy;
+    }
+    /**
+     * The entry lifetime in milliseconds.
+     * @returns {number} The entry lifetime in milliseconds (0 = never expires).
+     */
+    get ttl() {
+        return this.#ttl;
+    }
+    /**
+     * The maximum number of entries allowed in this cache.
+     * @returns {number} The maximum number of entries.
+     */
+    get maxItems() {
+        return this.#maxItems;
+    }
+    /**
+     * The maximum size in bytes allowed in this cache.
+     * @returns {number} The maximum size in bytes.
+     */
+    get maxBytes() {
+        return this.#maxBytes;
+    }
+    /**
+     * The number of entries evicted by the limit enforcement.
+     * @returns {number} The current eviction count.
+     */
+    get evictions() {
+        return this.#evictions;
+    }
+    /**
+     * @param {MediaCacheOptions} [options] - The cache configuration.
+     * @throws {TypeError} If `options` is not a plain object.
+     * @throws {RangeError} If `maxItems` is not a positive number.
+     * @throws {RangeError} If `maxBytes` is not a positive number.
+     * @throws {RangeError} If `ttl` is not a positive number.
+     * @throws {TypeError} If `strategy` is not a known strategy.
+     * @throws {TypeError} If `ignoreSearch` is not a boolean.
+     * @throws {RangeError} If `sweepInterval` is not a positive number.
+     */
+    constructor(options = {}) {
+        if (!isPlainObject(options)) {
+            throw new TypeError('The "options" argument must be a plain object.');
+        }
+        const { maxItems = Infinity, maxBytes = Infinity, ttl = 0, strategy = TinyMediaCache.Strategy.MANUAL, ignoreSearch = false, sweepInterval = 0, } = options;
+        if (typeof maxItems !== 'number' || Number.isNaN(maxItems) || maxItems < 1) {
+            throw new RangeError('The "maxItems" option must be a positive number.');
+        }
+        if (maxItems !== Infinity && !Number.isInteger(maxItems)) {
+            throw new RangeError('The "maxItems" option must be an integer or Infinity.');
+        }
+        if (typeof maxBytes !== 'number' || Number.isNaN(maxBytes) || maxBytes < 0) {
+            throw new RangeError('The "maxBytes" option must be a positive number.');
+        }
+        if (typeof ttl !== 'number' || Number.isNaN(ttl) || ttl < 0) {
+            throw new RangeError('The "ttl" option must be a positive number.');
+        }
+        if (!Object.values(TinyMediaCache.Strategy).includes(strategy)) {
+            throw new TypeError(`Unknown cache strategy: ${strategy}`);
+        }
+        if (typeof ignoreSearch !== 'boolean') {
+            throw new TypeError('The "ignoreSearch" option must be a boolean.');
+        }
+        if (typeof sweepInterval !== 'number' || Number.isNaN(sweepInterval) || sweepInterval < 0) {
+            throw new RangeError('The "sweepInterval" option must be a positive number.');
+        }
+        this.#maxItems = maxItems;
+        this.#maxBytes = maxBytes;
+        this.#ttl = ttl;
+        this.#strategy = strategy;
+        this.#ignoreSearch = ignoreSearch;
+        TinyMediaCache.#instances.add(this);
+        if (sweepInterval > 0) {
+            this.#timer = setInterval(() => this.prune(), sweepInterval);
+            if (typeof this.#timer.unref === 'function') {
+                this.#timer.unref();
+            }
+        }
+    }
+    /**
+     * A read-only snapshot of the shared blob registry.
+     * @returns {Array<{ key: string, objectUrl: string, refs: number, size: number }>} One record per cached blob.
+     */
+    static get registry() {
+        return Array.from(TinyMediaCache.#blobs, ([key, record]) => ({ key, ...record }));
+    }
+    /**
+     * Every live cache instance.
+     * @returns {TinyMediaCache[]}
+     */
+    static get instances() {
+        return Array.from(TinyMediaCache.#instances);
+    }
+    /**
+     * The number of blobs held by the shared registry.
+     * @returns {number}
+     */
+    static get size() {
+        return TinyMediaCache.#blobs.size;
+    }
+    /**
+     * The total number of bytes held by the shared registry.
+     * @returns {number}
+     */
+    static get bytes() {
+        let total = 0;
+        for (const record of TinyMediaCache.#blobs.values()) {
+            total += record.size;
+        }
+        return total;
+    }
+    /**
+     * Checks the shared registry without touching any instance.
+     * @param {string} url - The media URL.
+     * @param {boolean} [ignoreSearch] - Whether the query string is ignored.
+     * @returns {boolean}
+     */
+    static has(url, ignoreSearch = false) {
+        return TinyMediaCache.#blobs.has(TinyMediaCache.#normalize(url, ignoreSearch));
+    }
+    /**
+     * Revokes every object URL in the shared registry.
+     * @returns {void}
+     */
+    static clear() {
+        for (const record of TinyMediaCache.#blobs.values()) {
+            URL.revokeObjectURL(record.objectUrl);
+        }
+        TinyMediaCache.#blobs.clear();
+    }
+    /**
+     * Destroys every live cache instance.
+     * @returns {void}
+     */
+    static destroyAll() {
+        for (const instance of Array.from(TinyMediaCache.#instances)) {
+            instance.destroy();
+        }
+    }
+    /**
+     * The number of entries currently stored in this cache instance.
+     * @returns {number} The number of entries in this cache.
+     */
+    get size() {
+        return this.#entries.size;
+    }
+    /**
+     * The number of children's currently stored in this cache instance.
+     * @returns {number} The number of children's in this cache.
+     */
+    get links() {
+        return this.#children.size;
+    }
+    /**
+     * @returns {number} The total size in bytes held by this cache.
+     */
+    get bytes() {
+        let total = 0;
+        for (const entry of this.#entries.values()) {
+            total += entry.size;
+        }
+        return total;
+    }
+    /**
+     * Indicates whether the cache instance has been destroyed.
+     * @returns {boolean} True if the cache was destroyed, false otherwise.
+     */
+    get destroyed() {
+        return this.#destroyed;
+    }
+    /**
+     * Returns a snapshot of the cache's internal performance counters.
+     * @returns {MediaCacheStats} A snapshot of the cache counters.
+     */
+    get stats() {
+        let refs = 0;
+        for (const entry of this.#entries.values()) {
+            refs += entry.refs;
+        }
+        return {
+            size: this.#entries.size,
+            bytes: this.bytes,
+            refs,
+            hits: this.#hits,
+            misses: this.#misses,
+            evictions: this.#evictions,
+            links: this.#children.size,
+            instances: TinyMediaCache.#instances.size,
+            blobs: TinyMediaCache.#blobs.size,
+        };
+    }
+    /**
+     * A read-only snapshot of every entry held by this cache.
+     * @returns {MediaCacheEntry[]} A shallow copy of the entries.
+     */
+    entries() {
+        this.#assertAlive();
+        return Array.from(this.#entries.values(), (entry) => ({
+            ...entry,
+            metadata: { ...entry.metadata },
+        }));
+    }
+    /**
+     * Stores a blob and returns its entry.
+     * @param {string} url - The media URL.
+     * @param {Blob} blob - The blob to cache.
+     * @param {boolean} [pinned] - Whether the entry is protected from eviction.
+     * @param {Record<string, any>} [metadata] - The probe metadata captured with the blob.
+     * @param {string|null} [parent] - The key of the entry that owns this one.
+     * @returns {MediaCacheEntry} The stored entry.
+     * @throws {TypeError} If `blob` is not a Blob.
+     * @throws {TypeError} If `parent` is neither a string nor null.
+     * @throws {Error} If the cache was destroyed.
+     */
+    set(url, blob, pinned = false, metadata = {}, parent = null) {
+        this.#assertAlive();
+        if (!(blob instanceof Blob)) {
+            throw new TypeError('The "blob" argument must be a Blob.');
+        }
+        if (typeof pinned !== 'boolean') {
+            throw new TypeError('The "pinned" argument must be a boolean.');
+        }
+        if (!isPlainObject(metadata)) {
+            throw new TypeError('The "metadata" argument must be a plain object.');
+        }
+        if (parent !== null && typeof parent !== 'string') {
+            throw new TypeError('The "parent" argument must be a string or null.');
+        }
+        const key = this.#key(url);
+        this.#discard(key, false);
+        const record = TinyMediaCache.#acquire(key, blob);
+        const now = Date.now();
+        /** @type {MediaCacheEntry} */
+        const entry = {
+            key,
+            url,
+            blob,
+            objectUrl: record.objectUrl,
+            size: blob.size,
+            type: blob.type,
+            refs: 0,
+            createdAt: now,
+            lastAccess: now,
+            expiresAt: this.#ttl > 0 ? now + this.#ttl : 0,
+            pinned: Boolean(pinned),
+            parent,
+            metadata: { ...metadata },
+        };
+        this.#entries.set(key, entry);
+        if (parent !== null) {
+            this.#link(parent, key);
+        }
+        this.#enforceLimit();
+        return entry;
+    }
+    /**
+     * Reads an entry without changing its reference count.
+     * @param {string} url - The media URL.
+     * @returns {MediaCacheEntry|null}
+     */
+    get(url) {
+        this.#assertAlive();
+        const key = this.#key(url);
+        const entry = this.#entries.get(key);
+        if (!entry) {
+            this.#misses += 1;
+            return null;
+        }
+        if (this.#isExpired(entry)) {
+            this.delete(key);
+            this.#misses += 1;
+            return null;
+        }
+        entry.lastAccess = Date.now();
+        this.#hits += 1;
+        return entry;
+    }
+    /**
+     * Checks whether a live entry exists for the given URL.
+     * @param {string} url - The media URL.
+     * @returns {boolean} True when a non-expired entry exists.
+     */
+    has(url) {
+        this.#assertAlive();
+        const entry = this.#entries.get(this.#key(url));
+        return entry !== undefined && !this.#isExpired(entry);
+    }
+    /**
+     * Increments the reference count of an entry.
+     * @param {string} url - The media URL.
+     * @returns {MediaCacheEntry|null} The acquired entry, or null when missing.
+     */
+    acquire(url) {
+        this.#assertAlive();
+        const entry = this.get(url);
+        if (!entry) {
+            return null;
+        }
+        entry.refs += 1;
+        return entry;
+    }
+    /**
+     * Decrements the reference count and applies the cleanup strategy.
+     * @param {string} url - The media URL.
+     * @returns {boolean} True when the entry was released.
+     */
+    release(url) {
+        this.#assertAlive();
+        const key = this.#key(url);
+        const entry = this.#entries.get(key);
+        if (!entry) {
+            return false;
+        }
+        entry.refs = Math.max(0, entry.refs - 1);
+        if (entry.refs === 0 && this.#strategy === TinyMediaCache.Strategy.AUTO) {
+            this.delete(key);
+        }
+        return true;
+    }
+    /**
+     * Removes an entry and releases its share of the shared registry. When the
+     * entry is the last child of a parent, the parent is removed as well.
+     * @param {string} url - The media URL.
+     * @returns {boolean} True when an entry was removed.
+     */
+    delete(url) {
+        this.#assertAlive();
+        return this.#discard(this.#key(url), true);
+    }
+    /**
+     * The keys of the entries owned by the given key.
+     * @param {string} url - The media URL of the owner.
+     * @returns {string[]} The normalized keys of the children, in insertion order.
+     */
+    children(url) {
+        return Array.from(this.#children.get(this.#key(url)) ?? []);
+    }
+    /**
+     * Removes an entry, releases its share of the shared registry and, when it
+     * was the last child, removes the parent that owns it.
+     * @param {string} key - The normalized cache key.
+     * @param {boolean} cascade - Whether removing the last child also removes the parent.
+     * @returns {boolean} True when an entry was removed.
+     * @throws {TypeError} If `key` is not a string or `cascade` is not a boolean.
+     */
+    #discard(key, cascade) {
+        if (typeof key !== 'string') {
+            throw new TypeError('The "key" argument must be a string.');
+        }
+        if (typeof cascade !== 'boolean') {
+            throw new TypeError('The "cascade" argument must be a boolean.');
+        }
+        const entry = this.#entries.get(key);
+        if (!entry) {
+            return false;
+        }
+        this.#entries.delete(key);
+        TinyMediaCache.#release(key);
+        this.#children.delete(key);
+        if (entry.parent === null) {
+            return true;
+        }
+        const siblings = this.#children.get(entry.parent);
+        if (!siblings) {
+            return true;
+        }
+        siblings.delete(key);
+        if (siblings.size > 0) {
+            return true;
+        }
+        this.#children.delete(entry.parent);
+        const owner = this.#entries.get(entry.parent);
+        if (cascade && owner && owner.refs === 0) {
+            this.#discard(entry.parent, true);
+        }
+        return true;
+    }
+    /**
+     * Registers a child entry under the entry that owns it.
+     * @param {string} parent - The normalized key of the owner.
+     * @param {string} child - The normalized key of the child.
+     * @returns {void}
+     * @throws {TypeError} If `parent` or `child` is not a string.
+     */
+    #link(parent, child) {
+        if (typeof parent !== 'string') {
+            throw new TypeError('The "parent" argument must be a string.');
+        }
+        if (typeof child !== 'string') {
+            throw new TypeError('The "child" argument must be a string.');
+        }
+        let children = this.#children.get(parent);
+        if (!children) {
+            children = new Set();
+            this.#children.set(parent, children);
+        }
+        children.add(child);
+    }
+    /**
+     * Reads an entry without changing its reference count and without touching
+     * the hit/miss counters. Expired entries are reported as missing but are not
+     * removed, so a read-only probe never mutates the cache.
+     * @param {string} url - The media URL.
+     * @returns {MediaCacheEntry|null} The live entry, or null when absent or expired.
+     * @throws {TypeError} If `url` is not a string.
+     * @throws {Error} If the cache was destroyed.
+     */
+    peek(url) {
+        this.#assertAlive();
+        if (typeof url !== 'string') {
+            throw new TypeError('The "url" argument must be a string.');
+        }
+        const entry = this.#entries.get(this.#key(url));
+        if (!entry || this.#isExpired(entry)) {
+            return null;
+        }
+        return entry;
+    }
+    /**
+     * Pins an entry so the limit enforcement skips it.
+     * @param {string} url - The media URL.
+     * @param {boolean} [value] - The new pinned state.
+     * @returns {boolean} True when the entry exists.
+     */
+    pin(url, value = true) {
+        this.#assertAlive();
+        if (typeof value !== 'boolean') {
+            throw new TypeError('The "value" argument must be a boolean.');
+        }
+        const entry = this.#entries.get(this.#key(url));
+        if (!entry) {
+            return false;
+        }
+        entry.pinned = value;
+        return true;
+    }
+    /**
+     * Removes every expired entry.
+     * @returns {number} The number of removed entries.
+     */
+    prune() {
+        this.#assertAlive();
+        const expired = [];
+        for (const [key, entry] of this.#entries) {
+            if (this.#isExpired(entry)) {
+                expired.push(key);
+            }
+        }
+        let removed = 0;
+        for (const key of expired) {
+            if (this.#discard(key, true)) {
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Removes every entry, regardless of its reference count.
+     * @returns {void}
+     */
+    clear() {
+        this.#assertAlive();
+        for (const key of Array.from(this.#entries.keys())) {
+            this.#entries.delete(key);
+            TinyMediaCache.#release(key);
+        }
+        this.#children.clear();
+    }
+    /**
+     * Detaches this instance from the shared registry.
+     * @returns {void}
+     */
+    destroy() {
+        if (this.#destroyed) {
+            return;
+        }
+        if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = null;
+        }
+        this.clear();
+        TinyMediaCache.#instances.delete(this);
+        this.#destroyed = true;
+    }
+    /**
+     * Evicts the least recently used entries until both the quantity limit
+     * and the byte limit are respected.
+     * @returns {void}
+     */
+    #enforceLimit() {
+        if (this.#entries.size <= this.#maxItems && this.bytes <= this.#maxBytes) {
+            return;
+        }
+        const candidates = Array.from(this.#entries.values())
+            .filter((entry) => !entry.pinned && entry.refs === 0 && !this.#children.has(entry.key))
+            .sort((a, b) => a.lastAccess - b.lastAccess);
+        let currentBytes = this.bytes;
+        let currentItems = this.#entries.size;
+        for (const entry of candidates) {
+            if (currentItems <= this.#maxItems && currentBytes <= this.#maxBytes) {
+                break;
+            }
+            this.delete(entry.key);
+            this.#evictions += 1;
+            currentBytes -= entry.size;
+            currentItems -= 1;
+        }
+    }
+    /**
+     * Checks whether an entry has passed its expiration time.
+     * @param {MediaCacheEntry} entry - The entry to test.
+     * @returns {boolean} True when the entry has expired.
+     * @throws {TypeError} If `entry` is not an object.
+     */
+    #isExpired(entry) {
+        if (entry === null || typeof entry !== 'object') {
+            throw new TypeError('The "entry" argument must be a MediaCacheEntry.');
+        }
+        return entry.expiresAt > 0 && Date.now() >= entry.expiresAt;
+    }
+    /**
+     * Builds the normalized cache key for a URL.
+     * @param {string} url - The media URL.
+     * @returns {string} The normalized cache key.
+     */
+    #key(url) {
+        return TinyMediaCache.#normalize(url, this.#ignoreSearch);
+    }
+    /**
+     * Ensures the cache has not been destroyed before performing an operation.
+     * @returns {void}
+     * @throws {Error} If the cache was destroyed.
+     */
+    #assertAlive() {
+        if (this.#destroyed) {
+            throw new Error('Cannot use a destroyed media cache.');
+        }
+    }
+    /**
+     * Normalizes a URL into a cache key.
+     * @param {string} url - The media URL.
+     * @param {boolean} ignoreSearch - Whether the query string is ignored.
+     * @returns {string} The normalized cache key.
+     * @throws {TypeError} If `url` is not a string.
+     * @throws {TypeError} If `ignoreSearch` is not a boolean.
+     */
+    static #normalize(url, ignoreSearch) {
+        if (typeof url !== 'string') {
+            throw new TypeError('The "url" argument must be a string.');
+        }
+        if (typeof ignoreSearch !== 'boolean') {
+            throw new TypeError('The "ignoreSearch" argument must be a boolean.');
+        }
+        if (!ignoreSearch) {
+            return url;
+        }
+        const clean = url.split('#')[0];
+        const query = clean.indexOf('?');
+        return query === -1 ? clean : clean.slice(0, query);
+    }
+    /**
+     * Registers a blob in the shared registry and returns its record.
+     * @param {string} key - The normalized cache key.
+     * @param {Blob} blob - The blob to register.
+     * @returns {MediaCacheRecord} The shared registry record.
+     * @throws {TypeError} If `key` is not a string or `blob` is not a Blob.
+     */
+    static #acquire(key, blob) {
+        if (typeof key !== 'string') {
+            throw new TypeError('The "key" argument must be a string.');
+        }
+        if (!(blob instanceof Blob)) {
+            throw new TypeError('The "blob" argument must be a Blob.');
+        }
+        const existing = TinyMediaCache.#blobs.get(key);
+        if (existing) {
+            existing.refs += 1;
+            return existing;
+        }
+        /** @type {MediaCacheRecord} */
+        const record = {
+            objectUrl: URL.createObjectURL(blob),
+            refs: 1,
+            size: blob.size,
+        };
+        TinyMediaCache.#blobs.set(key, record);
+        return record;
+    }
+    /**
+     * Releases a reference in the shared registry and revokes the object URL when unused.
+     * @param {string} key - The normalized cache key.
+     * @returns {void}
+     * @throws {TypeError} If `key` is not a string.
+     */
+    static #release(key) {
+        if (typeof key !== 'string') {
+            throw new TypeError('The "key" argument must be a string.');
+        }
+        const record = TinyMediaCache.#blobs.get(key);
+        if (!record) {
+            return;
+        }
+        record.refs -= 1;
+        if (record.refs > 0) {
+            return;
+        }
+        URL.revokeObjectURL(record.objectUrl);
+        TinyMediaCache.#blobs.delete(key);
+    }
+}
+export default TinyMediaCache;