@mtkruto/node 0.0.957 → 0.0.960

package/esm/client/0_utilities.d.ts

@@ -0,0 +1,3 @@
+import * as types from "../tl/2_types.js";
+export declare function getChannelChatId(channelId: bigint): number;
+export declare function peerToChatId(peer: types.TypePeer | types.TypeInputPeer): number;

package/esm/client/0_utilities.js

@@ -0,0 +1,20 @@
+import { ZERO_CHANNEL_ID } from "../constants.js";
+import * as types from "../tl/2_types.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+export function getChannelChatId(channelId) {
+    return ZERO_CHANNEL_ID + -Number(channelId);
+}
+export function peerToChatId(peer) {
+    if (peer instanceof types.PeerUser || peer instanceof types.InputPeerUser) {
+        return Number(peer.userId);
+    }
+    else if (peer instanceof types.PeerChat || peer instanceof types.InputPeerChat) {
+        return -Number(peer.chatId);
+    }
+    else if (peer instanceof types.PeerChannel || peer instanceof types.InputPeerChannel) {
+        return getChannelChatId(peer.channelId);
+    }
+    else {
+        UNREACHABLE();
+    }
+}

package/esm/client/3_client.d.ts

@@ -172,11 +172,11 @@ export declare class Client extends ClientAbstract {
         sendAs?: number | string;
         replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
     }): Promise<Message>;
-    getMessages(chatId: number | string, messageIds: number[]): Promise<Omit<Message, "replyToMessage">[]>;
+    getMessages(chatId_: number | string, messageIds: number[]): Promise<Omit<Message, "replyToMessage">[]>;
     getMessage(chatId: number | string, messageId: number): Promise<Omit<Message, "replyToMessage"> | null>;
     private downloadInner;
     download(fileId_: string): Promise<AsyncGenerator<Uint8Array, void, unknown>>;
     [getStickerSetName](inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
     forwardMessages(from: number | string, to: number | string, messageIds: number[], params?: ForwardMessagesParams): Promise<Message[]>;
-    forwardMessage(from: number | string, to: number | string, messageId: number, params?: ForwardMessagesParams): Promise<Message[]>;
+    forwardMessage(from: number | string, to: number | string, messageId: number, params?: ForwardMessagesParams): Promise<Message>;
 }

package/esm/client/3_client.js

@@ -23,6 +23,7 @@ import { parseHtml } from "./0_html.js";
 import { checkPassword } from "./0_password.js";
 import { ClientAbstract } from "./1_client_abstract.js";
 import { ClientPlain } from "./2_client_plain.js";
+import { getChannelChatId, peerToChatId } from "./0_utilities.js";
 const d = debug("Client");
 const dGap = debug("Client/recoverUpdateGap");
 const dGapC = debug("Client/recoverChannelUpdateGap");
@@ -507,7 +508,7 @@ export class Client extends ClientAbstract {
                             this.promises.delete(messageId);
                         }
                     };
-                    if (result instanceof types.Updates || result instanceof types.TypeUpdate) {
+                    if (result instanceof types.TypeUpdates || result instanceof types.TypeUpdate) {
                         this.processUpdates(result).then(resolvePromise);
                     }
                     else {
@@ -663,6 +664,24 @@ export class Client extends ClientAbstract {
                 d("applied update with pts %d", update.pts);
                 await this.storage.setChannelPts(channelId, update.pts);
             }
+            if (update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewMessage || update instanceof types.UpdateNewChannelMessage || update instanceof types.UpdateNewChannelMessage) {
+                if (update.message instanceof types.Message || update.message instanceof types.MessageService) {
+                    await this.storage.setMessage(peerToChatId(update.message.peerId), update.message.id, update.message);
+                }
+            }
+            else if (update instanceof types.UpdateDeleteChannelMessages) {
+                for (const message of update.messages) {
+                    await this.storage.setMessage(getChannelChatId(update.channelId), message, null);
+                }
+            }
+            else if (update instanceof types.UpdateDeleteMessages) {
+                for (const message of update.messages) {
+                    const chatId = await this.storage.getMessageChat(message);
+                    if (chatId) {
+                        await this.storage.setMessage(chatId, message, null);
+                    }
+                }
+            }
             // apply update (call listeners)
             this.updateHandler?.(this, update);
         }
@@ -1040,6 +1059,13 @@ export class Client extends ClientAbstract {
             await this.processChats(result.chats);
             await this.processUsers(result.users);
         }
+        if (result instanceof types.MessagesMessages) {
+            for (const message of result.messages) {
+                if (message instanceof types.Message || message instanceof types.MessageService) {
+                    await this.storage.setMessage(peerToChatId(message.peerId), message.id, message);
+                }
+            }
+        }
     }
     async updatesToMessages(chatId, updates) {
         const messages = new Array();
@@ -1121,22 +1147,37 @@ export class Client extends ClientAbstract {
         }));
         return await this.updatesToMessages(chatId, result).then((v) => v[0]);
     }
-    async getMessages(chatId, messageIds) {
-        const peer = await this.getInputPeer(chatId);
-        let messages_;
-        if (peer instanceof types.InputPeerChannel) {
-            messages_ = await this.invoke(new functions.ChannelsGetMessages({
-                channel: new types.InputChannel({ channelId: peer.channelId, accessHash: peer.accessHash }),
-                id: messageIds.map((v) => new types.InputMessageID({ id: v })),
-            })).then((v) => v[as](types.MessagesChannelMessages));
+    async getMessages(chatId_, messageIds) {
+        const peer = await this.getInputPeer(chatId_);
+        let messages_ = new Array();
+        const chatId = peerToChatId(peer);
+        let shouldFetch = false;
+        for (const messageId of messageIds) {
+            const message = await this.storage.getMessage(chatId, messageId);
+            if (message == null) {
+                messages_ = [];
+                shouldFetch = true;
+                break;
+            }
+            else {
+                messages_.push(message);
+            }
         }
-        else {
-            messages_ = await this.invoke(new functions.MessagesGetMessages({
-                id: messageIds.map((v) => new types.InputMessageID({ id: v })),
-            })).then((v) => v[as](types.MessagesMessages));
+        if (shouldFetch) {
+            if (peer instanceof types.InputPeerChannel) {
+                messages_ = await this.invoke(new functions.ChannelsGetMessages({
+                    channel: new types.InputChannel({ channelId: peer.channelId, accessHash: peer.accessHash }),
+                    id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+                })).then((v) => v[as](types.MessagesChannelMessages).messages);
+            }
+            else {
+                messages_ = await this.invoke(new functions.MessagesGetMessages({
+                    id: messageIds.map((v) => new types.InputMessageID({ id: v })),
+                })).then((v) => v[as](types.MessagesMessages).messages);
+            }
         }
         const messages = new Array();
-        for (const message_ of messages_.messages) {
+        for (const message_ of messages_) {
             messages.push(await constructMessage(message_, this[getEntity].bind(this), null, this[getStickerSetName].bind(this)));
         }
         return messages;
@@ -1236,7 +1277,7 @@ export class Client extends ClientAbstract {
         }));
         return await this.updatesToMessages(to, result);
     }
-    forwardMessage(from, to, messageId, params) {
-        return this.forwardMessages(from, to, [messageId], params);
+    async forwardMessage(from, to, messageId, params) {
+        return await this.forwardMessages(from, to, [messageId], params).then((v) => v[0]);
     }
 }

package/esm/constants.d.ts

@@ -4,7 +4,7 @@ export declare const publicKeys: Map<bigint, [bigint, bigint]>;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const DEFAULT_INITIAL_DC: DC;
 export declare const LAYER = 158;
-export declare const DEFAULT_APP_VERSION = "MTKruto 0.0.957";
+export declare const DEFAULT_APP_VERSION = "MTKruto 0.0.960";
 export declare const DEFAULT_DEVICE_MODEL: string;
 export declare const DEFAULT_LANG_CODE: string;
 export declare const DEFAULT_LANG_PACK = "";

package/esm/constants.js

@@ -62,7 +62,7 @@ export const publicKeys = new Map([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const DEFAULT_INITIAL_DC = "2-test";
 export const LAYER = 158;
-export const DEFAULT_APP_VERSION = "MTKruto 0.0.957";
+export const DEFAULT_APP_VERSION = "MTKruto 0.0.960";
 // @ts-ignore: lib
 export const DEFAULT_DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const DEFAULT_LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/storage/0_storage.d.ts

@@ -1,33 +1,34 @@
 import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/2_transport_provider.js";
+import { TLObject } from "../tl/1_tl_object.js";
 import * as types from "../tl/2_types.js";
+export type StorageKeyPart = string | number | bigint | Uint8Array;
 export declare abstract class Storage {
     private _authKeyId;
     abstract init(): MaybePromise<void>;
-    abstract set(key: string, value: string | null): MaybePromise<void>;
-    abstract get(key: string): MaybePromise<string | null>;
+    abstract set(key: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
+    abstract get<T>(key: readonly StorageKeyPart[]): MaybePromise<T | null>;
     setDc(dc: DC | null): MaybePromise<void>;
-    getDc(): Promise<DC | null>;
+    getDc(): MaybePromise<DC | null>;
     private resetAuthKeyId;
     getAuthKey(): Promise<Uint8Array | null>;
     setAuthKey(authKey: Uint8Array | null): Promise<void>;
     get authKeyId(): bigint | null;
-    private readonly channelAccessHash__;
     setChannelAccessHash(id: bigint, accessHash: bigint): MaybePromise<void>;
-    getChannelAccessHash(id: bigint): Promise<bigint | null>;
-    private readonly userAccessHash__;
+    getChannelAccessHash(id: bigint): MaybePromise<bigint | null>;
     setUserAccessHash(id: bigint, accessHash: bigint): MaybePromise<void>;
-    getUserAccessHash(id: bigint): Promise<bigint | null>;
-    private readonly username__;
+    getUserAccessHash(id: bigint): MaybePromise<bigint | null>;
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
-    getUsername(username: string): Promise<readonly ["channel" | "user", bigint, Date] | null>;
-    private readonly state__;
+    getUsername(username: string): MaybePromise<["channel" | "user", bigint, Date] | null>;
+    setTlObject(key: readonly StorageKeyPart[], value: TLObject | null): Promise<void>;
+    getTLObject(key: readonly StorageKeyPart[]): Promise<import("../tl/3_tl_reader.js").ReadObject | null>;
     setState(state: types.UpdatesState): Promise<void>;
     getState(): Promise<types.UpdatesState | null>;
-    private readonly channelPts__;
+    setMessage(chatId: number, messageId: number, message: types.TypeMessage | null): Promise<void>;
+    getMessageChat(messageId: number): MaybePromise<number | null>;
+    getMessage(chatId: number, messageId: number): Promise<types.TypeMessage | null>;
     setChannelPts(channelId: bigint, pts: number): Promise<void>;
-    getChannelPts(channelId: bigint): Promise<number | null>;
-    private readonly peer__;
+    getChannelPts(channelId: bigint): MaybePromise<number | null>;
     setEntity(peer: types.Channel): Promise<void>;
     setEntity(peer: types.Chat): Promise<void>;
     setEntity(peer: types.User): Promise<void>;
@@ -35,10 +36,8 @@ export declare abstract class Storage {
     getEntity(type: "chat", id: bigint): Promise<types.Chat | null>;
     getEntity(type: "user", id: bigint): Promise<types.User | null>;
     getEntity(type: "channel" | "chat" | "user", id: bigint): Promise<types.Channel | types.Chat | types.User | null>;
-    private readonly accountType__;
     setAccountType(type: "user" | "bot"): Promise<void>;
-    getAccountType(): Promise<"bot" | "user">;
-    private readonly stickerSetName__;
+    getAccountType(): MaybePromise<"bot" | "user" | null>;
     updateStickerSetName(id: bigint, accessHash: bigint, name: string): Promise<void>;
-    getStickerSetName(id: bigint, accessHash: bigint): Promise<[string, Date] | null>;
+    getStickerSetName(id: bigint, accessHash: bigint): MaybePromise<[string, Date] | null>;
 }

package/esm/storage/0_storage.js

@@ -1,4 +1,3 @@
-import { base64Decode, base64Encode } from "../deps.js";
 import { UNREACHABLE } from "../utilities/0_control.js";
 import { sha1 } from "../utilities/0_hash.js";
 import { bigIntFromBuffer } from "../utilities/0_bigint.js";
@@ -6,6 +5,19 @@ import { serialize } from "../tl/1_tl_object.js";
 import * as types from "../tl/2_types.js";
 import { TLReader } from "../tl/3_tl_reader.js";
 import { rleDecode, rleEncode } from "../utilities/0_rle.js";
+import { ZERO_CHANNEL_ID } from "../constants.js";
+const KPARTS__DC = ["dc"];
+const KPARTS__AUTH_KEY = ["authKey"];
+const KPARTS__CHANNEL_ACCESS_HASH = (v) => ["channelAccessHash", v];
+const KPARTS__USER_ACCESS_HASH = (v) => ["userAccessHash", v];
+const KPARTS__USERNAME = (v) => ["username", v];
+const KPARTS__STATE = ["state"];
+const KPARTS__CHANNEL_PTS = (v) => ["channelPts", v];
+const KPARTS__PEER = (type, id) => ["peer", type, id];
+const KPARTS__ACCOUNT_TYPE = ["accountType"];
+const KPARTS__STICKER_SET_NAME = (id, accessHash) => ["stickerSetName", id, accessHash];
+const KPARTS_MESSAGE = (chatId, messageId) => ["messages", chatId, messageId];
+const KPARTS_MESSAGE_REF = (messageId) => ["messageRefs", messageId];
 export class Storage {
     constructor() {
         Object.defineProperty(this, "_authKeyId", {
@@ -14,60 +26,12 @@ export class Storage {
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "channelAccessHash__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "channelAccessHash__"
-        });
-        Object.defineProperty(this, "userAccessHash__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "userAccessHash__"
-        });
-        Object.defineProperty(this, "username__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "username__"
-        });
-        Object.defineProperty(this, "state__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "state__"
-        });
-        Object.defineProperty(this, "channelPts__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "channelPts__"
-        });
-        Object.defineProperty(this, "peer__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "peer__"
-        });
-        Object.defineProperty(this, "accountType__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "accountType__"
-        });
-        Object.defineProperty(this, "stickerSetName__", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "stickerSetName__"
-        });
     }
     setDc(dc) {
-        return this.set("dc", dc);
+        return this.set(KPARTS__DC, dc);
     }
-    async getDc() {
-        return await this.get("dc");
+    getDc() {
+        return this.get(KPARTS__DC);
     }
     async resetAuthKeyId(authKey) {
         if (authKey != null) {
@@ -78,105 +42,88 @@ export class Storage {
         }
     }
     async getAuthKey() {
-        const authKey_ = await this.get("authKey");
-        const authKey = authKey_ == null ? null : new Uint8Array(authKey_.split(/([0-9a-f]{2})/).filter((v) => v).map((v) => parseInt(v, 16)));
+        const authKey = await this.get(KPARTS__AUTH_KEY);
         await this.resetAuthKeyId(authKey);
         return authKey;
     }
     async setAuthKey(authKey) {
-        await this.set("authKey", authKey == null ? null : Array.from(authKey).map((v) => v.toString(16)).map((v) => v.padStart(2, "0")).join(""));
+        await this.set(KPARTS__AUTH_KEY, authKey);
         await this.resetAuthKeyId(authKey);
     }
     get authKeyId() {
         return this._authKeyId;
     }
     setChannelAccessHash(id, accessHash) {
-        return this.set(`${this.channelAccessHash__}${id}`, String(accessHash));
+        return this.set(KPARTS__CHANNEL_ACCESS_HASH(id), accessHash);
     }
-    async getChannelAccessHash(id) {
-        const accessHash = await this.get(`${this.channelAccessHash__}${id}`);
-        if (accessHash != null) {
-            return BigInt(accessHash);
-        }
-        else {
-            return null;
-        }
+    getChannelAccessHash(id) {
+        return this.get(KPARTS__CHANNEL_ACCESS_HASH(id));
     }
     setUserAccessHash(id, accessHash) {
-        return this.set(`${this.userAccessHash__}${id}`, String(accessHash));
+        return this.set(KPARTS__USER_ACCESS_HASH(id), accessHash);
     }
-    async getUserAccessHash(id) {
-        const accessHash = await this.get(`${this.userAccessHash__}${id}`);
-        if (accessHash != null) {
-            return BigInt(accessHash);
-        }
-        else {
-            return null;
-        }
+    getUserAccessHash(id) {
+        return this.get(KPARTS__USER_ACCESS_HASH(id));
     }
     async updateUsernames(type, id, usernames) {
         for (let username of usernames) {
             username = username.toLowerCase();
-            await this.set(`${this.username__}${username}`, JSON.stringify([type, String(id), new Date()]));
+            await this.set(KPARTS__USERNAME(username), [type, String(id), new Date()]);
         }
     }
-    async getUsername(username) {
+    getUsername(username) {
         username = username.toLowerCase();
-        const username_ = await this.get(`${this.username__}${username}`);
-        if (username_ != null) {
-            const [type, id, updatedAt] = JSON.parse(username_);
-            return [type, BigInt(id), new Date(updatedAt)];
+        return this.get(KPARTS__USERNAME(username));
+    }
+    async setTlObject(key, value) {
+        if (value == null) {
+            await this.set(key, null);
+        }
+        else {
+            await this.set(key, rleEncode(value[serialize]()));
+        }
+    }
+    async getTLObject(key) {
+        const buffer = await this.get(key);
+        if (buffer != null) {
+            return new TLReader(rleDecode(buffer)).readObject();
         }
         else {
             return null;
         }
     }
     async setState(state) {
-        await this.set(this.state__, JSON.stringify({
-            date: state.date,
-            pts: state.pts,
-            qts: state.qts,
-            seq: state.seq,
-            unreadCount: state.unreadCount,
-        }));
+        await this.setTlObject(KPARTS__STATE, state);
     }
     async getState() {
-        const state__ = await this.get(this.state__);
-        if (state__ != null) {
-            const state_ = JSON.parse(state__);
-            return new types.UpdatesState({
-                date: state_.date,
-                pts: state_.pts,
-                qts: state_.qts,
-                seq: state_.seq,
-                unreadCount: state_.unreadCount,
-            });
-        }
-        else {
-            return null;
+        return await this.getTLObject(KPARTS__STATE);
+    }
+    async setMessage(chatId, messageId, message) {
+        if (chatId > ZERO_CHANNEL_ID) {
+            await this.set(KPARTS_MESSAGE_REF(messageId), message == null ? null : chatId);
         }
+        await this.setTlObject(KPARTS_MESSAGE(chatId, messageId), message);
+    }
+    getMessageChat(messageId) {
+        return this.get(KPARTS_MESSAGE_REF(messageId));
+    }
+    async getMessage(chatId, messageId) {
+        return await this.getTLObject(KPARTS_MESSAGE(chatId, messageId));
     }
     async setChannelPts(channelId, pts) {
-        await this.set(`${this.channelPts__}${channelId}`, String(pts));
+        await this.set(KPARTS__CHANNEL_PTS(channelId), pts);
     }
-    async getChannelPts(channelId) {
-        const pts = await this.get(`${this.channelPts__}${channelId}`);
-        if (pts != null) {
-            return Number(pts);
-        }
-        else {
-            return null;
-        }
+    getChannelPts(channelId) {
+        return this.get(KPARTS__CHANNEL_PTS(channelId));
     }
     async setEntity(peer) {
         const type = peer instanceof types.Channel ? "channel" : peer instanceof types.Chat ? "chat" : peer instanceof types.User ? "user" : UNREACHABLE();
-        await this.set(`${this.peer__}${type}${peer.id}`, base64Encode(rleEncode(peer[serialize]())));
+        await this.set(KPARTS__PEER(type, peer.id), peer[serialize]());
     }
     async getEntity(type, id) {
-        const peer_ = await this.get(`${this.peer__}${type}${id}`);
+        const peer_ = await this.get(KPARTS__PEER(type, id));
         if (peer_ != null) {
-            const reader = new TLReader(rleDecode(base64Decode(peer_)));
-            return reader.readObject();
+            return new TLReader(peer_).readObject();
         }
         else {
             return null;
@@ -192,30 +139,17 @@ export class Storage {
                 throw err;
             }
             else {
-                await this.set(this.accountType__, type);
+                await this.set(KPARTS__ACCOUNT_TYPE, type);
             }
         }
     }
-    async getAccountType() {
-        const accountType = await this.get(this.accountType__);
-        if (accountType != null) {
-            return accountType;
-        }
-        else {
-            UNREACHABLE();
-        }
+    getAccountType() {
+        return this.get(KPARTS__ACCOUNT_TYPE);
     }
     async updateStickerSetName(id, accessHash, name) {
-        await this.set(`${this.stickerSetName__}${id}${accessHash}`, JSON.stringify([name, new Date()]));
+        await this.set(KPARTS__STICKER_SET_NAME(id, accessHash), [name, new Date()]);
     }
-    async getStickerSetName(id, accessHash) {
-        const stickerSetName_ = await this.get(`${this.stickerSetName__}${id}${accessHash}`);
-        if (stickerSetName_ != null) {
-            const [name, updatedAt] = JSON.parse(stickerSetName_);
-            return [name, new Date(updatedAt)];
-        }
-        else {
-            return null;
-        }
+    getStickerSetName(id, accessHash) {
+        return this.get(KPARTS__STICKER_SET_NAME(id, accessHash));
     }
 }

package/esm/storage/0_utilities.d.ts

@@ -0,0 +1,13 @@
+import { StorageKeyPart } from "./0_storage.js";
+export declare enum ValueType {
+    Boolean = 0,
+    Number = 1,
+    String = 2,
+    BigInt = 3,
+    Date = 4,
+    Uint8Array = 5,
+    Array = 6
+}
+export declare function toString(value: unknown): string;
+export declare function fromString<T>(string: string): any;
+export declare function fixKey(key: StorageKeyPart[]): (string | number | Uint8Array)[];

package/esm/storage/0_utilities.js

@@ -0,0 +1,62 @@
+import { base64Decode, base64Encode } from "../deps.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+export var ValueType;
+(function (ValueType) {
+    ValueType[ValueType["Boolean"] = 0] = "Boolean";
+    ValueType[ValueType["Number"] = 1] = "Number";
+    ValueType[ValueType["String"] = 2] = "String";
+    ValueType[ValueType["BigInt"] = 3] = "BigInt";
+    ValueType[ValueType["Date"] = 4] = "Date";
+    ValueType[ValueType["Uint8Array"] = 5] = "Uint8Array";
+    ValueType[ValueType["Array"] = 6] = "Array";
+})(ValueType || (ValueType = {}));
+export function toString(value) {
+    if (typeof value === "boolean") {
+        return JSON.stringify([ValueType.Boolean, value]);
+    }
+    else if (typeof value === "number") {
+        return JSON.stringify([ValueType.Number, value]);
+    }
+    else if (typeof value === "string") {
+        return JSON.stringify([ValueType.String, value]);
+    }
+    else if (typeof value == "bigint") {
+        return JSON.stringify([ValueType.BigInt, String(value)]);
+    }
+    else if (value instanceof Date) {
+        return JSON.stringify([ValueType.Date, value.getTime()]);
+    }
+    else if (value instanceof Uint8Array) {
+        return JSON.stringify([ValueType.Uint8Array, base64Encode(value)]);
+    }
+    else if (Array.isArray(value)) {
+        return JSON.stringify([ValueType.Array, value.map(toString)]);
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export function fromString(string) {
+    const [type, value] = JSON.parse(string);
+    if (type == ValueType.Boolean || type == ValueType.Number || type == ValueType.String) {
+        return value;
+    }
+    else if (type == ValueType.BigInt) {
+        return BigInt(value);
+    }
+    else if (type == ValueType.Date) {
+        return new Date(value);
+    }
+    else if (type == ValueType.Uint8Array) {
+        return base64Decode(value);
+    }
+    else if (type == ValueType.Array) {
+        return value.map(fromString);
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export function fixKey(key) {
+    return key.map((v) => typeof v === "bigint" ? String(v) : v);
+}

package/esm/storage/1_storage_indexed_db.d.ts

@@ -1,9 +1,9 @@
-import { Storage } from "./0_storage.js";
+import { Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageIndexedDB extends Storage {
     readonly name: string;
     database: IDBDatabase | null;
     constructor(name: string);
     init(): Promise<void>;
-    set(k: string, v: string | null): Promise<void>;
-    get(k: string): Promise<string | null>;
+    set(k: StorageKeyPart[], v: unknown): Promise<void>;
+    get<T>(k: StorageKeyPart[]): Promise<T | null>;
 }

package/esm/storage/1_storage_indexed_db.js

@@ -1,4 +1,5 @@
 import { Storage } from "./0_storage.js";
+import { fixKey } from "./0_utilities.js";
 const VERSION = 1;
 const KV_OBJECT_STORE = "kv";
 export class StorageIndexedDB extends Storage {
@@ -44,10 +45,10 @@ export class StorageIndexedDB extends Storage {
         // deno-lint-ignore no-explicit-any
         let tx;
         if (v == null) {
-            tx = store.delete(k);
+            tx = store.delete(fixKey(k));
         }
         else {
-            tx = store.put(v, k);
+            tx = store.put(v, fixKey(k));
         }
         return new Promise((res, rej) => {
             tx.onerror = rej;
@@ -63,7 +64,7 @@ export class StorageIndexedDB extends Storage {
         const tx = this.database
             .transaction(KV_OBJECT_STORE, "readonly")
             .objectStore(KV_OBJECT_STORE)
-            .get(k);
+            .get(fixKey(k));
         return new Promise((res, rej) => {
             tx.onerror = rej;
             tx.onsuccess = () => {

package/esm/storage/1_storage_local_storage.d.ts

@@ -1,9 +1,9 @@
 import { MaybePromise } from "../utilities/0_types.js";
-import { Storage } from "./0_storage.js";
+import { Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;
     constructor(prefix: string);
     init(): void;
-    get(key: string): string | null;
-    set(key: string, value: string | null): MaybePromise<void>;
+    get(key_: readonly StorageKeyPart[]): any;
+    set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
 }