sliftutils 0.10.0 → 0.12.0

package/storage/dist/PendingManager.tsx.cache

@@ -0,0 +1,73 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.PendingDisplay = exports.hasPending = exports.setPending = void 0;
+const misc_1 = require("socket-function/src/misc");
+const mobxTyped_1 = require("../misc/mobxTyped");
+const preact_1 = __importDefault(require("preact"));
+const typesafecss_1 = require("typesafecss");
+const observer_1 = require("../misc/observer");
+const format_1 = require("socket-function/src/formatting/format");
+let watchState = (0, mobxTyped_1.observable)({
+    pending: {}
+});
+let pendingLastSets = new Map();
+let pendingCache = new Map();
+// "" clears the pending value
+function setPending(group, message) {
+    pendingCache.set(group, message);
+    void setPendingBase();
+}
+exports.setPending = setPending;
+function hasPending() {
+    return Object.keys(watchState.pending).length > 0;
+}
+exports.hasPending = hasPending;
+// NOTE: This not only prevents render overload, but also means any pending that are < this
+//  delay don't show up (which is useful to reduce unnecessary pending messages).
+const setPendingBase = (0, misc_1.throttleFunction)(500, function setPendingBase() {
+    for (let [group, message] of pendingCache) {
+        if (!message) {
+            let lastSet = pendingLastSets.get(group);
+            if (lastSet) {
+                let duration = Date.now() - lastSet;
+                if (duration > 500) {
+                    console.log(`Finished slow task after ${(0, format_1.formatTime)(duration)}: ${JSON.stringify(group)}, last is ${JSON.stringify(watchState.pending[group])}`);
+                }
+                pendingLastSets.delete(group);
+            }
+            delete watchState.pending[group];
+        }
+        else {
+            //console.log("setPending", group, message);
+            if (!(group in watchState.pending)) {
+                pendingLastSets.set(group, Date.now());
+            }
+            watchState.pending[group] = message;
+        }
+    }
+    pendingCache.clear();
+});
+let PendingDisplay = class PendingDisplay extends preact_1.default.Component {
+    render() {
+        // Single line, giving equal space, and ellipsis for overflow
+        return preact_1.default.createElement("div", { className: typesafecss_1.css.hbox(10) }, Object.keys(watchState.pending).map(group => (preact_1.default.createElement("div", { className: typesafecss_1.css.center.textOverflow("ellipsis").border("1px solid black").pad2(6, 2) },
+            group,
+            ": ",
+            watchState.pending[group]))));
+    }
+};
+exports.PendingDisplay = PendingDisplay;
+exports.PendingDisplay = PendingDisplay = __decorate([
+    observer_1.observer
+], PendingDisplay);
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "8f559dbbe9527016120e06db80675bb022384607e057609b93840bc57618742e"; */

package/storage/dist/PendingStorage.ts.cache

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.PendingStorage = void 0;
+const misc_1 = require("socket-function/src/misc");
+const PendingManager_1 = require("./PendingManager");
+class PendingStorage {
+    constructor(pendingGroup, storage) {
+        this.pendingGroup = pendingGroup;
+        this.storage = storage;
+        this.pending = new Map();
+        this.updatePending = (0, misc_1.throttleFunction)(100, () => {
+            let text = Array.from(this.pending.entries()).map(([key, value]) => `${key}: ${value}`).join(", ");
+            (0, PendingManager_1.setPending)(this.pendingGroup, text);
+        });
+    }
+    async get(key) {
+        return this.watchPending("get", this.storage.get(key));
+    }
+    async set(key, value) {
+        return this.watchPending("set", this.storage.set(key, value));
+    }
+    async remove(key) {
+        return this.watchPending("remove", this.storage.remove(key));
+    }
+    async getKeys() {
+        return this.watchPending("getKeys", this.storage.getKeys());
+    }
+    async getInfo(key) {
+        return this.watchPending("getInfo", this.storage.getInfo(key));
+    }
+    watchPending(type, promise) {
+        this.pending.set(type, (this.pending.get(type) || 0) + 1);
+        void this.updatePending();
+        void promise.finally(() => {
+            this.pending.set(type, (this.pending.get(type) || 0) - 1);
+            if (this.pending.get(type) === 0) {
+                this.pending.delete(type);
+            }
+            void this.updatePending();
+        });
+        return promise;
+    }
+    async reset() {
+        return this.storage.reset();
+    }
+}
+exports.PendingStorage = PendingStorage;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "ed2840ea8600cecb451e492c01363588df0ab65b7e5c4231cffb60d15727a4b6"; */

package/storage/dist/PrivateFileSystemStorage.ts.cache

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.PrivateFileSystemStorage = void 0;
+class PrivateFileSystemStorage {
+    constructor(path) {
+        this.path = path;
+    }
+    async ensureInitialized() {
+        var _a;
+        if (!this.rootHandle) {
+            if (!((_a = navigator.storage) === null || _a === void 0 ? void 0 : _a.getDirectory)) {
+                throw new Error("Private File System Access API not supported in this browser");
+            }
+            this.rootHandle = await navigator.storage.getDirectory();
+        }
+        return this.rootHandle;
+    }
+    async directoryExists() {
+        try {
+            const root = await this.ensureInitialized();
+            if (!this.path || this.path === "" || this.path === "/") {
+                return true; // Root always exists
+            }
+            const pathParts = this.path.split("/").filter(part => part.length > 0);
+            let currentHandle = root;
+            for (const part of pathParts) {
+                try {
+                    currentHandle = await currentHandle.getDirectoryHandle(part);
+                }
+                catch (error) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getDirectoryHandle(createPath = true) {
+        const root = await this.ensureInitialized();
+        if (!this.path || this.path === "" || this.path === "/") {
+            return root;
+        }
+        const pathParts = this.path.split("/").filter(part => part.length > 0);
+        let currentHandle = root;
+        for (const part of pathParts) {
+            try {
+                currentHandle = await currentHandle.getDirectoryHandle(part, { create: createPath });
+            }
+            catch (error) {
+                if (!createPath) {
+                    throw new Error(`Directory not found: ${this.path}`);
+                }
+                throw error;
+            }
+        }
+        return currentHandle;
+    }
+    async getFileHandle(key, create = false) {
+        try {
+            const dirHandle = await this.getDirectoryHandle(create);
+            return await dirHandle.getFileHandle(key, { create });
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async fileExists(key) {
+        try {
+            // First check if directory exists
+            if (!(await this.directoryExists())) {
+                return false;
+            }
+            const dirHandle = await this.getDirectoryHandle(false);
+            await dirHandle.getFileHandle(key);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async get(key) {
+        // Check if file exists first to avoid unnecessary errors
+        if (!(await this.fileExists(key))) {
+            return undefined;
+        }
+        try {
+            const fileHandle = await this.getFileHandle(key, false);
+            if (!fileHandle) {
+                return undefined;
+            }
+            const file = await fileHandle.getFile();
+            const arrayBuffer = await file.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        catch (error) {
+            console.warn(`Error reading file ${key}:`, error);
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        try {
+            const fileHandle = await this.getFileHandle(key, true);
+            if (!fileHandle) {
+                throw new Error(`Failed to create file handle for key: ${key}`);
+            }
+            const writable = await fileHandle.createWritable();
+            await writable.write(value);
+            await writable.close();
+        }
+        catch (error) {
+            throw new Error(`Failed to write file ${key}: ${error}`);
+        }
+    }
+    async append(key, value) {
+        const existingContent = await this.get(key);
+        let newContent;
+        if (existingContent) {
+            newContent = Buffer.concat([existingContent, value]);
+        }
+        else {
+            newContent = value;
+        }
+        await this.set(key, newContent);
+    }
+    async remove(key) {
+        // Check if file exists first to avoid unnecessary errors
+        if (!(await this.fileExists(key))) {
+            return; // File doesn't exist, nothing to remove
+        }
+        try {
+            const dirHandle = await this.getDirectoryHandle(false);
+            await dirHandle.removeEntry(key);
+        }
+        catch (_a) { }
+    }
+    async getKeys() {
+        // Check if directory exists first to avoid unnecessary errors
+        if (!(await this.directoryExists())) {
+            return [];
+        }
+        try {
+            const dirHandle = await this.getDirectoryHandle(false);
+            const keys = [];
+            // Use the async iterator protocol for FileSystemDirectoryHandle
+            for await (const [name, handle] of dirHandle.entries()) {
+                if (handle.kind === "file") {
+                    keys.push(name);
+                }
+            }
+            return keys.sort();
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("Directory not found")) {
+                return [];
+            }
+            throw new Error(`Failed to list files: ${error}`);
+        }
+    }
+    async getInfo(key) {
+        let fileHandle = await this.getFileHandle(key, false);
+        if (!fileHandle) {
+            return undefined;
+        }
+        let file = await fileHandle.getFile();
+        return {
+            size: file.size,
+            lastModified: file.lastModified,
+        };
+    }
+    async reset() {
+        throw new Error("Not implemented");
+    }
+}
+exports.PrivateFileSystemStorage = PrivateFileSystemStorage;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PrivateFileSystemStorage.js","sourceRoot":"","sources":["PrivateFileSystemStorage.ts"],"names":[],"mappings":"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","sourcesContent":["import { IStorageRaw } from \"./IStorage\";\n\nexport class PrivateFileSystemStorage implements IStorageRaw {\n    private rootHandle: FileSystemDirectoryHandle | undefined;\n\n    constructor(private path: string) { }\n\n    private async ensureInitialized(): Promise<FileSystemDirectoryHandle> {\n        if (!this.rootHandle) {\n            if (!navigator.storage?.getDirectory) {\n                throw new Error(\"Private File System Access API not supported in this browser\");\n            }\n            this.rootHandle = await navigator.storage.getDirectory();\n        }\n        return this.rootHandle;\n    }\n\n    private async directoryExists(): Promise<boolean> {\n        try {\n            const root = await this.ensureInitialized();\n\n            if (!this.path || this.path === \"\" || this.path === \"/\") {\n                return true; // Root always exists\n            }\n\n            const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n            let currentHandle = root;\n\n            for (const part of pathParts) {\n                try {\n                    currentHandle = await currentHandle.getDirectoryHandle(part);\n                } catch (error) {\n                    return false;\n                }\n            }\n\n            return true;\n        } catch (error) {\n            return false;\n        }\n    }\n\n    private async getDirectoryHandle(createPath: boolean = true): Promise<FileSystemDirectoryHandle> {\n        const root = await this.ensureInitialized();\n\n        if (!this.path || this.path === \"\" || this.path === \"/\") {\n            return root;\n        }\n\n        const pathParts = this.path.split(\"/\").filter(part => part.length > 0);\n        let currentHandle = root;\n\n        for (const part of pathParts) {\n            try {\n                currentHandle = await currentHandle.getDirectoryHandle(part, { create: createPath });\n            } catch (error) {\n                if (!createPath) {\n                    throw new Error(`Directory not found: ${this.path}`);\n                }\n                throw error;\n            }\n        }\n\n        return currentHandle;\n    }\n\n    private async getFileHandle(key: string, create: boolean = false): Promise<FileSystemFileHandle | undefined> {\n        try {\n            const dirHandle = await this.getDirectoryHandle(create);\n            return await dirHandle.getFileHandle(key, { create });\n        } catch (error) {\n            return undefined;\n        }\n    }\n\n    private async fileExists(key: string): Promise<boolean> {\n        try {\n            // First check if directory exists\n            if (!(await this.directoryExists())) {\n                return false;\n            }\n\n            const dirHandle = await this.getDirectoryHandle(false);\n            await dirHandle.getFileHandle(key);\n            return true;\n        } catch (error) {\n            return false;\n        }\n    }\n\n    public async get(key: string): Promise<Buffer | undefined> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return undefined;\n        }\n\n        try {\n            const fileHandle = await this.getFileHandle(key, false);\n            if (!fileHandle) {\n                return undefined;\n            }\n\n            const file = await fileHandle.getFile();\n            const arrayBuffer = await file.arrayBuffer();\n            return Buffer.from(arrayBuffer);\n        } catch (error) {\n            console.warn(`Error reading file ${key}:`, error);\n            return undefined;\n        }\n    }\n\n    public async set(key: string, value: Buffer): Promise<void> {\n        try {\n            const fileHandle = await this.getFileHandle(key, true);\n            if (!fileHandle) {\n                throw new Error(`Failed to create file handle for key: ${key}`);\n            }\n\n            const writable = await fileHandle.createWritable();\n            await writable.write(value);\n            await writable.close();\n        } catch (error) {\n            throw new Error(`Failed to write file ${key}: ${error}`);\n        }\n    }\n\n    public async append(key: string, value: Buffer): Promise<void> {\n        const existingContent = await this.get(key);\n        let newContent: Buffer;\n        if (existingContent) {\n            newContent = Buffer.concat([existingContent, value]);\n        } else {\n            newContent = value;\n        }\n        await this.set(key, newContent);\n    }\n\n    public async remove(key: string): Promise<void> {\n        // Check if file exists first to avoid unnecessary errors\n        if (!(await this.fileExists(key))) {\n            return; // File doesn't exist, nothing to remove\n        }\n\n        try {\n            const dirHandle = await this.getDirectoryHandle(false);\n            await dirHandle.removeEntry(key);\n        } catch { }\n    }\n\n    public async getKeys(): Promise<string[]> {\n        // Check if directory exists first to avoid unnecessary errors\n        if (!(await this.directoryExists())) {\n            return [];\n        }\n\n        try {\n            const dirHandle = await this.getDirectoryHandle(false);\n            const keys: string[] = [];\n\n            // Use the async iterator protocol for FileSystemDirectoryHandle\n            for await (const [name, handle] of (dirHandle as any).entries()) {\n                if (handle.kind === \"file\") {\n                    keys.push(name);\n                }\n            }\n\n            return keys.sort();\n        } catch (error) {\n            if (error instanceof Error && error.message.includes(\"Directory not found\")) {\n                return [];\n            }\n            throw new Error(`Failed to list files: ${error}`);\n        }\n    }\n    public async getInfo(key: string): Promise<undefined | {\n        size: number;\n        lastModified: number;\n    }> {\n        let fileHandle = await this.getFileHandle(key, false);\n        if (!fileHandle) {\n            return undefined;\n        }\n        let file = await fileHandle.getFile();\n        return {\n            size: file.size,\n            lastModified: file.lastModified,\n        };\n    }\n    public async reset(): Promise<void> {\n        throw new Error(\"Not implemented\");\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "148396348ae7c1ec76d652412f67620680447daaa3a8cfe83212b76412f8bc73"; */

package/storage/dist/StorageObservable.ts.cache

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.StorageSync = void 0;
+const mobxTyped_1 = require("../misc/mobxTyped");
+const types_1 = require("../misc/types");
+// NOTE: At around 500K values (depending on their size to some degree), this will take about 2 minutes to load. But once it does it will be fast. So... keep that in mind. I recommend not exceeding 100K
+class StorageSync {
+    constructor(storage) {
+        this.storage = storage;
+        this.cached = mobxTyped_1.observable.map(undefined, { deep: false });
+        this.infoCached = mobxTyped_1.observable.map(undefined, { deep: false });
+        this.keys = new Set();
+        this.synced = (0, mobxTyped_1.observable)({
+            keySeqNum: 0,
+        }, undefined, { deep: false });
+        this.loadedKeys = false;
+    }
+    get(key) {
+        if (!this.cached.has(key)) {
+            this.cached.set(key, undefined);
+            void this.getPromise(key);
+        }
+        if (this.cached.get(key) === undefined) {
+            this.synced.keySeqNum;
+        }
+        return this.cached.get(key);
+    }
+    set(key, value) {
+        if (!this.keys.has(key)) {
+            this.keys.add(key);
+            this.synced.keySeqNum++;
+        }
+        this.cached.set(key, value);
+        void this.storage.set(key, value);
+    }
+    remove(key) {
+        if (this.keys.has(key)) {
+            this.keys.delete(key);
+            this.synced.keySeqNum++;
+        }
+        this.cached.delete(key);
+        void this.storage.remove(key);
+    }
+    getKeys() {
+        void this.getKeysPromise();
+        this.synced.keySeqNum;
+        return Array.from(this.keys);
+    }
+    getInfo(key) {
+        if (!this.infoCached.has(key)) {
+            this.infoCached.set(key, { size: 0, lastModified: 0 });
+            void this.storage.getInfo(key).then(info => {
+                this.infoCached.set(key, info);
+            });
+        }
+        return this.infoCached.get(key);
+    }
+    getValues() {
+        let keys = this.getKeys();
+        return keys.map(key => this.get(key)).filter(types_1.isDefined);
+    }
+    getEntries() {
+        let keys = this.getKeys();
+        return keys.map(key => [key, this.get(key)]).filter(([_, value]) => (0, types_1.isDefined)(value));
+    }
+    async getPromise(key) {
+        let value = this.cached.get(key);
+        if (value === undefined) {
+            value = await this.storage.get(key);
+            if (this.cached.get(key) === undefined) {
+                this.cached.set(key, value);
+            }
+        }
+        return value;
+    }
+    async getKeysPromise() {
+        if (this.pendingGetKeys) {
+            return this.pendingGetKeys;
+        }
+        if (this.loadedKeys)
+            return Array.from(this.keys);
+        this.loadedKeys = true;
+        this.pendingGetKeys = this.storage.getKeys();
+        void this.pendingGetKeys.finally(() => {
+            this.pendingGetKeys = undefined;
+        });
+        let keys = await this.pendingGetKeys;
+        if (keys.length > 0) {
+            this.keys = new Set(keys);
+            this.synced.keySeqNum++;
+        }
+        return Array.from(this.keys);
+    }
+    reload() {
+        this.loadedKeys = false;
+        this.synced.keySeqNum++;
+        this.cached.clear();
+        this.infoCached.clear();
+        this.keys.clear();
+    }
+    reloadKeys() {
+        this.loadedKeys = false;
+        this.synced.keySeqNum++;
+    }
+    reloadKey(key) {
+        this.cached.delete(key);
+        this.infoCached.delete(key);
+        this.keys.delete(key);
+    }
+    async reset() {
+        this.cached.clear();
+        this.infoCached.clear();
+        this.keys.clear();
+        this.synced.keySeqNum++;
+        await this.storage.reset();
+    }
+}
+exports.StorageSync = StorageSync;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StorageObservable.js","sourceRoot":"","sources":["StorageObservable.ts"],"names":[],"mappings":"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","sourcesContent":["import { observable } from \"../misc/mobxTyped\";\nimport { isDefined } from \"../misc/types\";\nimport { IStorage, IStorageSync } from \"./IStorage\";\n\n// NOTE: At around 500K values (depending on their size to some degree), this will take about 2 minutes to load. But once it does it will be fast. So... keep that in mind. I recommend not exceeding 100K\nexport class StorageSync<T> implements IStorageSync<T> {\n    cached = observable.map<string, T | undefined>(undefined, { deep: false });\n    infoCached = observable.map<string, { size: number; lastModified: number } | undefined>(undefined, { deep: false });\n    keys = new Set<string>();\n    synced = observable({\n        keySeqNum: 0,\n    }, undefined, { deep: false });\n\n    constructor(public storage: IStorage<T>) { }\n\n    public get(key: string): T | undefined {\n        if (!this.cached.has(key)) {\n            this.cached.set(key, undefined);\n            void this.getPromise(key);\n        }\n        if (this.cached.get(key) === undefined) {\n            this.synced.keySeqNum;\n        }\n        return this.cached.get(key);\n    }\n    public set(key: string, value: T): void {\n        if (!this.keys.has(key)) {\n            this.keys.add(key);\n            this.synced.keySeqNum++;\n        }\n        this.cached.set(key, value);\n        void this.storage.set(key, value);\n    }\n    public remove(key: string): void {\n        if (this.keys.has(key)) {\n            this.keys.delete(key);\n            this.synced.keySeqNum++;\n        }\n        this.cached.delete(key);\n        void this.storage.remove(key);\n    }\n    private loadedKeys = false;\n    public getKeys(): string[] {\n        void this.getKeysPromise();\n        this.synced.keySeqNum;\n        return Array.from(this.keys);\n    }\n\n    public getInfo(key: string): { size: number; lastModified: number } | undefined {\n        if (!this.infoCached.has(key)) {\n            this.infoCached.set(key, { size: 0, lastModified: 0 });\n            void this.storage.getInfo(key).then(info => {\n                this.infoCached.set(key, info);\n            });\n        }\n        return this.infoCached.get(key);\n    }\n\n    public getValues(): T[] {\n        let keys = this.getKeys();\n        return keys.map(key => this.get(key)).filter(isDefined);\n    }\n    public getEntries(): [string, T][] {\n        let keys = this.getKeys();\n        return keys.map(key => [key, this.get(key)]).filter(([_, value]) => isDefined(value)) as [string, T][];\n    }\n\n\n    public async getPromise(key: string): Promise<T | undefined> {\n        let value = this.cached.get(key);\n        if (value === undefined) {\n            value = await this.storage.get(key);\n            if (this.cached.get(key) === undefined) {\n                this.cached.set(key, value);\n            }\n        }\n        return value;\n    }\n    private pendingGetKeys: Promise<string[]> | undefined;\n    public async getKeysPromise(): Promise<string[]> {\n        if (this.pendingGetKeys) {\n            return this.pendingGetKeys;\n        }\n        if (this.loadedKeys) return Array.from(this.keys);\n        this.loadedKeys = true;\n        this.pendingGetKeys = this.storage.getKeys();\n        void this.pendingGetKeys.finally(() => {\n            this.pendingGetKeys = undefined;\n        });\n        let keys = await this.pendingGetKeys;\n        if (keys.length > 0) {\n            this.keys = new Set(keys);\n            this.synced.keySeqNum++;\n        }\n        return Array.from(this.keys);\n    }\n\n    public reload() {\n        this.loadedKeys = false;\n        this.synced.keySeqNum++;\n        this.cached.clear();\n        this.infoCached.clear();\n        this.keys.clear();\n    }\n    public reloadKeys() {\n        this.loadedKeys = false;\n        this.synced.keySeqNum++;\n    }\n    public reloadKey(key: string) {\n        this.cached.delete(key);\n        this.infoCached.delete(key);\n        this.keys.delete(key);\n    }\n\n    public async reset() {\n        this.cached.clear();\n        this.infoCached.clear();\n        this.keys.clear();\n        this.synced.keySeqNum++;\n        await this.storage.reset();\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "83f7e3709b75068426ee34cfb27c8af75bbde2d429ccc896355bd2c176744eaa"; */