dl-once 0.0.1 → 0.0.2

package/dist/indexeddb-cache-storage.js

@@ -0,0 +1,573 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _IndexedDbCacheHandle_instances, _IndexedDbCacheHandle_storage, _IndexedDbCacheHandle_db, _IndexedDbCacheHandle_mux, _IndexedDbCacheHandle_cacheKey, _IndexedDbCacheHandle_assertOk, _IndexedDbCacheStorage_instances, _IndexedDbCacheStorage_db, _IndexedDbCacheStorage_mux, _IndexedDbCacheStorage_dbName, _IndexedDbCacheStorage_assertOk;
+import { Asyncmux, asyncmux } from "asyncmux";
+import { openDB } from "idb";
+import { tryCaptureStackTrace } from "try-capture-stack-trace";
+/**
+ * IndexedDB を開くためのユーティリティー関数です。
+ */
+const openIdb = (openDB);
+/**
+ * 中断理由が設定されていないことを示すための初期値シンボルです。
+ */
+const NONE = Symbol();
+/**
+ * 指定された非同期破棄処理を実行する AsyncDisposable オブジェクトを作成します。
+ *
+ * @param onAsyncDispose 破棄時に実行される非同期関数です。
+ * @returns 非同期破棄インターフェースを実装したオブジェクトです。
+ */
+function defer(onAsyncDispose) {
+    return { [Symbol.asyncDispose]: onAsyncDispose };
+}
+/**
+ * IndexedDB に対してキャッシュデータの書き込みを行うクラスです。
+ */
+let IndexedDbCacheWriter = (() => {
+    var _IndexedDbCacheWriter_instances, _a, _IndexedDbCacheWriter_storage, _IndexedDbCacheWriter_db, _IndexedDbCacheWriter_cacheKey, _IndexedDbCacheWriter_reason, _IndexedDbCacheWriter_isClosed, _IndexedDbCacheWriter_chunkCounter, _IndexedDbCacheWriter_assertOk;
+    let _instanceExtraInitializers = [];
+    let _write_decorators;
+    let _close_decorators;
+    let _abort_decorators;
+    return _a = class IndexedDbCacheWriter {
+            /**
+             * IndexedDbCacheWriter のインスタンスを初期化します。
+             *
+             * @param storage 親となるストレージインスタンスです。
+             * @param db 操作対象のデータベースです。
+             * @param cacheKey キャッシュの識別キーです。
+             */
+            constructor(storage, db, cacheKey) {
+                _IndexedDbCacheWriter_instances.add(this);
+                /**
+                 * ストレージ本体への参照です。
+                 */
+                _IndexedDbCacheWriter_storage.set(this, __runInitializers(this, _instanceExtraInitializers));
+                /**
+                 * 使用する IndexedDB インスタンスです。
+                 */
+                _IndexedDbCacheWriter_db.set(this, void 0);
+                /**
+                 * 対象となるキャッシュキーです。
+                 */
+                _IndexedDbCacheWriter_cacheKey.set(this, void 0);
+                /**
+                 * 中断された際の理由です。
+                 */
+                _IndexedDbCacheWriter_reason.set(this, void 0);
+                /**
+                 * ライターが閉じられているかどうかを示すフラグです。
+                 */
+                _IndexedDbCacheWriter_isClosed.set(this, void 0);
+                /**
+                 * チャンクのカウンターです。
+                 */
+                _IndexedDbCacheWriter_chunkCounter.set(this, void 0);
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_storage, storage, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_db, db, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_cacheKey, cacheKey, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_reason, NONE, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_isClosed, false, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_chunkCounter, 0, "f");
+            }
+            /**
+             * チャンクデータを IndexedDB に書き込みます。
+             *
+             * @param chunkData 書き込むバイナリーデータです。
+             */
+            async write(chunkData) {
+                __classPrivateFieldGet(this, _IndexedDbCacheWriter_instances, "m", _IndexedDbCacheWriter_assertOk).call(this);
+                // インデックスをインクリメントしながら、各チャンクを個別のキーで保存します。
+                const index = __classPrivateFieldGet(this, _IndexedDbCacheWriter_chunkCounter, "f");
+                await __classPrivateFieldGet(this, _IndexedDbCacheWriter_db, "f").put("buff", chunkData, `${__classPrivateFieldGet(this, _IndexedDbCacheWriter_cacheKey, "f")}:${index}`);
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_chunkCounter, __classPrivateFieldGet(this, _IndexedDbCacheWriter_chunkCounter, "f") + 1, "f");
+            }
+            /**
+             * 書き込みを完了し、メタデータを保存してライターを閉じます。
+             */
+            async close() {
+                __classPrivateFieldGet(this, _IndexedDbCacheWriter_instances, "m", _IndexedDbCacheWriter_assertOk).call(this);
+                // これまでに書き込んだチャンクの総数をメタデータとして保存します。
+                const chunkCount = __classPrivateFieldGet(this, _IndexedDbCacheWriter_chunkCounter, "f");
+                const meta = {
+                    chunkCount,
+                };
+                await __classPrivateFieldGet(this, _IndexedDbCacheWriter_db, "f").put("meta", meta, __classPrivateFieldGet(this, _IndexedDbCacheWriter_cacheKey, "f"));
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_isClosed, true, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_chunkCounter, 0, "f");
+            }
+            /**
+             * 書き込みを中断し、これまでに書き込んだ一時的なチャンクデータを削除します。
+             *
+             * @param reason 中断した理由です。
+             */
+            async abort(reason) {
+                __classPrivateFieldGet(this, _IndexedDbCacheWriter_instances, "m", _IndexedDbCacheWriter_assertOk).call(this);
+                const chunkCount = __classPrivateFieldGet(this, _IndexedDbCacheWriter_chunkCounter, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_reason, reason, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_isClosed, true, "f");
+                __classPrivateFieldSet(this, _IndexedDbCacheWriter_chunkCounter, 0, "f");
+                // 書き込まれたチャンクがない場合は削除処理をスキップします。
+                if (chunkCount === 0) {
+                    return;
+                }
+                // 0 から chunkCount - 1 までの範囲キーを作成し、一括削除します。
+                const range = IDBKeyRange.bound(`${__classPrivateFieldGet(this, _IndexedDbCacheWriter_cacheKey, "f")}:0`, `${__classPrivateFieldGet(this, _IndexedDbCacheWriter_cacheKey, "f")}:${chunkCount - 1}`);
+                await __classPrivateFieldGet(this, _IndexedDbCacheWriter_db, "f").delete("buff", range);
+            }
+        },
+        _IndexedDbCacheWriter_storage = new WeakMap(),
+        _IndexedDbCacheWriter_db = new WeakMap(),
+        _IndexedDbCacheWriter_cacheKey = new WeakMap(),
+        _IndexedDbCacheWriter_reason = new WeakMap(),
+        _IndexedDbCacheWriter_isClosed = new WeakMap(),
+        _IndexedDbCacheWriter_chunkCounter = new WeakMap(),
+        _IndexedDbCacheWriter_instances = new WeakSet(),
+        _IndexedDbCacheWriter_assertOk = function _IndexedDbCacheWriter_assertOk() {
+            // 親ストレージの稼働状態を確認します。
+            if (!__classPrivateFieldGet(this, _IndexedDbCacheWriter_storage, "f").isOpen) {
+                const error = new Error("IndexedDbCacheStorage is closed");
+                tryCaptureStackTrace(error, __classPrivateFieldGet(this, _IndexedDbCacheWriter_instances, "m", _IndexedDbCacheWriter_assertOk));
+                throw error;
+            }
+            // このライター自体の状態を確認します。
+            if (__classPrivateFieldGet(this, _IndexedDbCacheWriter_isClosed, "f")) {
+                // 正常に閉じられたのか、エラーで中断されたのかを判定します。
+                if (__classPrivateFieldGet(this, _IndexedDbCacheWriter_reason, "f") === NONE) {
+                    const error = new Error("IndexedDbCacheWriter is closed");
+                    tryCaptureStackTrace(error, __classPrivateFieldGet(this, _IndexedDbCacheWriter_instances, "m", _IndexedDbCacheWriter_assertOk));
+                    throw error;
+                }
+                // 中断理由がある場合は、その理由（エラー等）をそのまま投げます。
+                throw __classPrivateFieldGet(this, _IndexedDbCacheWriter_reason, "f");
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _write_decorators = [asyncmux];
+            _close_decorators = [asyncmux];
+            _abort_decorators = [asyncmux];
+            __esDecorate(_a, null, _write_decorators, { kind: "method", name: "write", static: false, private: false, access: { has: obj => "write" in obj, get: obj => obj.write }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _close_decorators, { kind: "method", name: "close", static: false, private: false, access: { has: obj => "close" in obj, get: obj => obj.close }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _abort_decorators, { kind: "method", name: "abort", static: false, private: false, access: { has: obj => "abort" in obj, get: obj => obj.abort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+/**
+ * キャッシュされたデータへのアクセス（読み取り・書き込み）を管理するハンドルクラスです。
+ */
+class IndexedDbCacheHandle {
+    /**
+     * IndexedDbCacheHandle のインスタンスを初期化します。
+     *
+     * @param storage ストレージインスタンスです。
+     * @param db データベースです。
+     * @param mux 同期用オブジェクトです。
+     * @param cacheKey キーです。
+     */
+    constructor(storage, db, mux, cacheKey) {
+        _IndexedDbCacheHandle_instances.add(this);
+        /**
+         * 親ストレージへの参照です。
+         */
+        _IndexedDbCacheHandle_storage.set(this, void 0);
+        /**
+         * データベースインスタンスです。
+         */
+        _IndexedDbCacheHandle_db.set(this, void 0);
+        /**
+         * 排他制御用のミューテックスです。
+         */
+        _IndexedDbCacheHandle_mux.set(this, void 0);
+        /**
+         * キャッシュキーです。
+         */
+        _IndexedDbCacheHandle_cacheKey.set(this, void 0);
+        __classPrivateFieldSet(this, _IndexedDbCacheHandle_storage, storage, "f");
+        __classPrivateFieldSet(this, _IndexedDbCacheHandle_db, db, "f");
+        __classPrivateFieldSet(this, _IndexedDbCacheHandle_mux, mux, "f");
+        __classPrivateFieldSet(this, _IndexedDbCacheHandle_cacheKey, cacheKey, "f");
+    }
+    /**
+     * キャッシュデータを読み取るためのジェネレーターを取得します。
+     *
+     * @param args 読み取りオプション（Signal 等）です。
+     * @returns キャッシュが存在する場合は AsyncGenerator、存在しない場合は null を返します。
+     */
+    async getReader(args) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = args;
+            // 読み取りロックを取得します。
+            const _1 = __addDisposableResource(env_1, await __classPrivateFieldGet(this, _IndexedDbCacheHandle_mux, "f").rLock({ signal }), false);
+            __classPrivateFieldGet(this, _IndexedDbCacheHandle_instances, "m", _IndexedDbCacheHandle_assertOk).call(this);
+            // メタデータを取得するために読み取り専用トランザクションを開始します。
+            const tx = __classPrivateFieldGet(this, _IndexedDbCacheHandle_db, "f").transaction(["meta"], "readonly");
+            // 外部からの中断シグナルをトランザクションの中断に連携させます。
+            signal?.addEventListener("abort", tx.abort, { once: true });
+            const _2 = __addDisposableResource(env_1, defer(async () => {
+                signal?.removeEventListener("abort", tx.abort);
+            }), true);
+            const metaStore = tx.objectStore("meta");
+            const meta = await metaStore.get(__classPrivateFieldGet(this, _IndexedDbCacheHandle_cacheKey, "f"));
+            // キャッシュ（メタデータ）が存在しない場合は null を返して終了します。
+            if (!meta) {
+                return null;
+            }
+            const db = __classPrivateFieldGet(this, _IndexedDbCacheHandle_db, "f");
+            const storage = __classPrivateFieldGet(this, _IndexedDbCacheHandle_storage, "f");
+            const cacheKey = __classPrivateFieldGet(this, _IndexedDbCacheHandle_cacheKey, "f");
+            const { chunkCount } = meta;
+            /**
+             * 実際のチャンク読み取りを行う内部非同期ジェネレーターです。
+             */
+            async function* createReader() {
+                // チャンク取得用のトランザクションを開始します。
+                const tx = db.transaction(["buff"], "readonly");
+                const buffStore = tx.objectStore("buff");
+                for (let index = 0; index < chunkCount; index++) {
+                    // 読み取りの途中でストレージが閉じられていないか毎ステップ確認します。
+                    if (!storage.isOpen) {
+                        throw new Error("IndexedDbCacheStorage is closed");
+                    }
+                    const chunk = await buffStore.get(`${cacheKey}:${index}`);
+                    if (!chunk) {
+                        throw new Error(`Missing chunk at index ${index}`);
+                    }
+                    yield chunk;
+                }
+            }
+            return createReader();
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    /**
+     * キャッシュにデータを書き込むためのライターを取得します。
+     *
+     * @param args 書き込みオプションです。
+     * @returns IWriter インターフェースを実装したライターインスタンスです。
+     */
+    async getWriter(args) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = args;
+            // 書き込みの排他制御のためにロックを取得します。
+            const _1 = __addDisposableResource(env_2, await __classPrivateFieldGet(this, _IndexedDbCacheHandle_mux, "f").rLock({ signal }), false);
+            __classPrivateFieldGet(this, _IndexedDbCacheHandle_instances, "m", _IndexedDbCacheHandle_assertOk).call(this);
+            return new IndexedDbCacheWriter(__classPrivateFieldGet(this, _IndexedDbCacheHandle_storage, "f"), __classPrivateFieldGet(this, _IndexedDbCacheHandle_db, "f"), __classPrivateFieldGet(this, _IndexedDbCacheHandle_cacheKey, "f"));
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+}
+_IndexedDbCacheHandle_storage = new WeakMap(), _IndexedDbCacheHandle_db = new WeakMap(), _IndexedDbCacheHandle_mux = new WeakMap(), _IndexedDbCacheHandle_cacheKey = new WeakMap(), _IndexedDbCacheHandle_instances = new WeakSet(), _IndexedDbCacheHandle_assertOk = function _IndexedDbCacheHandle_assertOk() {
+    if (!__classPrivateFieldGet(this, _IndexedDbCacheHandle_storage, "f").isOpen) {
+        const error = new Error("IndexedDbCacheStorage is closed");
+        tryCaptureStackTrace(error, __classPrivateFieldGet(this, _IndexedDbCacheHandle_instances, "m", _IndexedDbCacheHandle_assertOk));
+        throw error;
+    }
+};
+/**
+ * IndexedDB をバックエンドとしたキャッシュストレージの実装クラスです。
+ */
+export default class IndexedDbCacheStorage {
+    /**
+     * IndexedDbCacheStorage のインスタンスを初期化します。
+     *
+     * @param dbName データベース名です。指定されない場合はデフォルト名が使用されます。
+     */
+    constructor(dbName) {
+        _IndexedDbCacheStorage_instances.add(this);
+        /**
+         * データベース接続インスタンスです。閉じられているときは null になります。
+         */
+        _IndexedDbCacheStorage_db.set(this, void 0);
+        /**
+         * クラス全体での非同期操作の整合性を保つためのミューテックスです。
+         */
+        _IndexedDbCacheStorage_mux.set(this, void 0);
+        /**
+         * 使用する IndexedDB のデータベース名です。
+         */
+        _IndexedDbCacheStorage_dbName.set(this, void 0);
+        __classPrivateFieldSet(this, _IndexedDbCacheStorage_db, null, "f");
+        __classPrivateFieldSet(this, _IndexedDbCacheStorage_mux, new Asyncmux(), "f");
+        __classPrivateFieldSet(this, _IndexedDbCacheStorage_dbName, dbName ?? "dl-once", "f");
+    }
+    /**
+     * ストレージが開いているかどうかを返します。
+     */
+    get isOpen() {
+        return !!__classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f");
+    }
+    /**
+     * データベースを開き、初期化を行います。
+     *
+     * @param options オープン時のオプション（Signal 等）です。
+     */
+    async open(options = {}) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = options;
+            // 二重オープンを防止するためロックを取得します。
+            const _ = __addDisposableResource(env_3, await __classPrivateFieldGet(this, _IndexedDbCacheStorage_mux, "f").lock({ signal }), false);
+            if (__classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f")) {
+                throw new Error("Storage is already open");
+            }
+            // データベースを開き、必要に応じてオブジェクトストアを作成します。
+            __classPrivateFieldSet(this, _IndexedDbCacheStorage_db, await openIdb(__classPrivateFieldGet(this, _IndexedDbCacheStorage_dbName, "f"), 1, {
+                upgrade(db) {
+                    if (!db.objectStoreNames.contains("meta")) {
+                        db.createObjectStore("meta");
+                    }
+                    if (!db.objectStoreNames.contains("buff")) {
+                        db.createObjectStore("buff");
+                    }
+                },
+            }), "f");
+        }
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    /**
+     * データベース接続を閉じます。
+     *
+     * @param options クローズ時のオプションです。
+     */
+    async close(options = {}) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { signal } = options;
+            const _ = __addDisposableResource(env_4, await __classPrivateFieldGet(this, _IndexedDbCacheStorage_mux, "f").lock({ signal }), false);
+            __classPrivateFieldGet(this, _IndexedDbCacheStorage_instances, "m", _IndexedDbCacheStorage_assertOk).call(this);
+            __classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f").close();
+            __classPrivateFieldSet(this, _IndexedDbCacheStorage_db, null, "f");
+        }
+        catch (e_4) {
+            env_4.error = e_4;
+            env_4.hasError = true;
+        }
+        finally {
+            __disposeResources(env_4);
+        }
+    }
+    /**
+     * `using` 構文等で利用される非同期破棄メソッドです。
+     *
+     * 接続が開いている場合は閉じます。
+     */
+    async [(_IndexedDbCacheStorage_db = new WeakMap(), _IndexedDbCacheStorage_mux = new WeakMap(), _IndexedDbCacheStorage_dbName = new WeakMap(), _IndexedDbCacheStorage_instances = new WeakSet(), _IndexedDbCacheStorage_assertOk = function _IndexedDbCacheStorage_assertOk() {
+        if (!this.isOpen) {
+            const error = new Error("IndexedDbCacheStorage is closed");
+            tryCaptureStackTrace(error, __classPrivateFieldGet(this, _IndexedDbCacheStorage_instances, "m", _IndexedDbCacheStorage_assertOk));
+            throw error;
+        }
+    }, Symbol.asyncDispose)]() {
+        const env_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_5, await __classPrivateFieldGet(this, _IndexedDbCacheStorage_mux, "f").lock(), false);
+            __classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f")?.close();
+            __classPrivateFieldSet(this, _IndexedDbCacheStorage_db, null, "f");
+        }
+        catch (e_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    }
+    async clear(cacheKeyOrOptions, options = {}) {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            // 引数の型に応じてオプションを正規化します。
+            const { signal, cacheKey, } = typeof cacheKeyOrOptions === "object"
+                ? cacheKeyOrOptions
+                : {
+                    ...options,
+                    cacheKey: cacheKeyOrOptions,
+                };
+            // 削除操作の整合性を保つためロックを取得します。
+            const _1 = __addDisposableResource(env_6, await __classPrivateFieldGet(this, _IndexedDbCacheStorage_mux, "f").lock({ signal }), false);
+            __classPrivateFieldGet(this, _IndexedDbCacheStorage_instances, "m", _IndexedDbCacheStorage_assertOk).call(this);
+            // 読み書きトランザクションを開始します。
+            const tx = __classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f").transaction(["buff", "meta"], "readwrite");
+            signal?.addEventListener("abort", tx.abort, { once: true });
+            // トランザクション完了の待機とイベントリスナーの解除を行います。
+            const _2 = __addDisposableResource(env_6, defer(async () => {
+                try {
+                    await tx.done;
+                }
+                finally {
+                    signal?.removeEventListener("abort", tx.abort);
+                }
+            }), true);
+            if (cacheKey !== undefined) {
+                // 特定のキャッシュキーのみを削除する場合のロジックです。
+                const metaStore = tx.objectStore("meta");
+                const meta = await metaStore.get(cacheKey);
+                if (!meta) {
+                    return;
+                }
+                // まずメタデータを削除します。
+                await metaStore.delete(cacheKey);
+                const { chunkCount } = meta;
+                const buffStore = tx.objectStore("buff");
+                // チャンク数に応じて削除戦略を切り替えます。
+                if (chunkCount === 0) {
+                    // 削除するバッファーはありません。
+                }
+                else if (chunkCount === 1) {
+                    // チャンクが 1 つだけなら直接削除します。
+                    await buffStore.delete(`${cacheKey}:0`);
+                }
+                else {
+                    // チャンクが複数あるなら、範囲指定で一括削除します。
+                    const keyRange = IDBKeyRange.bound(`${cacheKey}:0`, `${cacheKey}:${chunkCount - 1}`);
+                    await buffStore.delete(keyRange);
+                }
+            }
+            else {
+                // キャッシュキーが指定されていない場合は、すべてのストアの内容を消去します。
+                const metaStore = tx.objectStore("meta");
+                await metaStore.clear();
+                const buffStore = tx.objectStore("buff");
+                await buffStore.clear();
+            }
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_6);
+            if (result_2)
+                await result_2;
+        }
+    }
+    /**
+     * 指定したキーに対するキャッシュ操作ハンドルを作成します。
+     *
+     * @param key キャッシュキーです。
+     * @returns キャッシュハンドルインスタンスです。
+     */
+    createCacheHandle(key) {
+        __classPrivateFieldGet(this, _IndexedDbCacheStorage_instances, "m", _IndexedDbCacheStorage_assertOk).call(this);
+        return new IndexedDbCacheHandle(this, __classPrivateFieldGet(this, _IndexedDbCacheStorage_db, "f"), __classPrivateFieldGet(this, _IndexedDbCacheStorage_mux, "f"), key);
+    }
+}

package/dist/md5-verification-hook.d.ts

@@ -0,0 +1,15 @@
+import HashVerificationHook from "./hash-verification-hook.js";
+/**
+ * ダウンロードされたデータの MD5 ハッシュ値を検証するためのフッククラスです。
+ *
+ * `hash-wasm` ライブラリーを使用して、ストリーム読み込みに合わせて逐次的にハッシュ計算を行い、完了時に期待されるハッシュ値と一致するかを判定します。
+ */
+export default class Md5VerificationHook extends HashVerificationHook {
+    /**
+     * Md5VerificationHook の新しいインスタンスを生成します。
+     *
+     * @param expectedHash 比較対象となる 16 進数形式の期待されるハッシュ値です。
+     */
+    constructor(expectedHash: string);
+}
+//# sourceMappingURL=md5-verification-hook.d.ts.map

package/dist/md5-verification-hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5-verification-hook.d.ts","sourceRoot":"","sources":["../src/md5-verification-hook.ts"],"names":[],"mappings":"AACA,OAAO,oBAAoB,MAAM,6BAA6B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,oBAAoB;IACnE;;;;OAIG;gBACgB,YAAY,EAAE,MAAM;CAGxC"}

package/dist/md5-verification-hook.js

@@ -0,0 +1,17 @@
+import { createMD5 } from "hash-wasm";
+import HashVerificationHook from "./hash-verification-hook.js";
+/**
+ * ダウンロードされたデータの MD5 ハッシュ値を検証するためのフッククラスです。
+ *
+ * `hash-wasm` ライブラリーを使用して、ストリーム読み込みに合わせて逐次的にハッシュ計算を行い、完了時に期待されるハッシュ値と一致するかを判定します。
+ */
+export default class Md5VerificationHook extends HashVerificationHook {
+    /**
+     * Md5VerificationHook の新しいインスタンスを生成します。
+     *
+     * @param expectedHash 比較対象となる 16 進数形式の期待されるハッシュ値です。
+     */
+    constructor(expectedHash) {
+        super(createMD5, expectedHash);
+    }
+}

package/dist/memory-cache-storage.d.ts

@@ -0,0 +1,41 @@
+import type { ClearOptions, CloseOptions, ICacheStorage, OpenOptions } from "./cache-storage.js";
+import type { ICacheHandle } from "./dl-once.js";
+/**
+ * メモリー上でのデータキャッシュを管理するストレージクラスです。
+ *
+ * Map を使用してキーごとにキャッシュハンドルを保持します。
+ */
+export default class MemoryCacheStorage implements ICacheStorage, Disposable {
+    #private;
+    /**
+     * ストレージが現在開いているかどうかを返します。
+     */
+    get isOpen(): boolean;
+    /**
+     * ストレージを開き、利用可能な状態にします。
+     */
+    open(options?: OpenOptions | undefined): void;
+    /**
+     * ストレージを閉じ、すべてのキャッシュデータを破棄します。
+     */
+    close(options?: CloseOptions | undefined): void;
+    /**
+     * Explicit Resource Management (Using 構文) をサポートするための破棄メソッドです。
+     */
+    [Symbol.dispose](): void;
+    /**
+     * キャッシュをクリアします。引数が指定された場合はそのキーのみ、指定されない場合は全てのキャッシュを削除します。
+     *
+     * @param cacheKey キャッシュを一意に識別する文字列です。
+     */
+    clear(cacheKey?: string | undefined, options?: Omit<ClearOptions, "cacheKey"> | undefined): void;
+    clear(options?: ClearOptions | undefined): void;
+    /**
+     * 指定したキーに対応するキャッシュハンドルを取得、または新規作成します。
+     *
+     * @param key キャッシュを一意に識別する文字列です。
+     * @returns ICacheHandle を実装したオブジェクトを返します。
+     */
+    createCacheHandle(key: string): ICacheHandle;
+}
+//# sourceMappingURL=memory-cache-storage.d.ts.map

package/dist/memory-cache-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-cache-storage.d.ts","sourceRoot":"","sources":["../src/memory-cache-storage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjG,OAAO,KAAK,EAAgC,YAAY,EAAW,MAAM,cAAc,CAAC;AA2NxF;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,YAAW,aAAa,EAAE,UAAU;;IAoB1E;;OAEG;IACH,IAAW,MAAM,IAAI,OAAO,CAE3B;IAED;;OAEG;IACI,IAAI,CAAC,OAAO,GAAE,WAAW,GAAG,SAAc,GAAG,IAAI;IAYxD;;OAEG;IACI,KAAK,CAAC,OAAO,GAAE,YAAY,GAAG,SAAc,GAAG,IAAI;IAY1D;;OAEG;IACI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;IAM/B;;;;OAIG;IACI,KAAK,CACV,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,GAAG,SAAS,GACnD,IAAI;IAEA,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI;IAsCtD;;;;;OAKG;IACI,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;CAcpD"}