@mtkruto/node 0.0.956 → 0.0.958

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

@@ -59,6 +59,14 @@ export interface ClientParams {
      */
     systemVersion?: string;
 }
+export interface ForwardMessagesParams {
+    messageThreadId?: number;
+    disableNotification?: boolean;
+    protectContent?: boolean;
+    sendAs?: number | string;
+    dropSenderName?: boolean;
+    dropCaption?: boolean;
+}
 export declare class Client extends ClientAbstract {
     readonly storage: Storage;
     readonly apiId: number;
@@ -152,6 +160,7 @@ export declare class Client extends ClientAbstract {
     [getEntity](peer: types.PeerChat): Promise<types.Chat | null>;
     [getEntity](peer: types.PeerChannel): Promise<types.Channel | null>;
     processResult(result: ReadObject): Promise<void>;
+    private updatesToMessages;
     sendMessage(chatId: number | string, text: string, params?: {
         parseMode?: ParseMode;
         entities?: MessageEntity[];
@@ -162,10 +171,12 @@ export declare class Client extends ClientAbstract {
         messageThreadId?: number;
         sendAs?: number | string;
         replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
-    }): Promise<Omit<Message, "replyToMessage">>;
+    }): Promise<Message>;
     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>;
 }

package/esm/client/3_client.js

@@ -1041,6 +1041,26 @@ export class Client extends ClientAbstract {
             await this.processUsers(result.users);
         }
     }
+    async updatesToMessages(chatId, updates) {
+        const messages = new Array();
+        if (updates instanceof types.Updates) {
+            for (const update of updates.updates) {
+                if (update instanceof types.UpdateNewMessage) {
+                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+                }
+                else if (update instanceof types.UpdateNewChannelMessage) {
+                    messages.push(await constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this)));
+                }
+            }
+        }
+        else if (updates instanceof types.UpdateShortSentMessage || updates instanceof types.UpdateShortSentMessage) {
+            const message = await this.getMessage(chatId, updates.id);
+            if (message != null) {
+                messages.push(message);
+            }
+        }
+        return messages;
+    }
     async sendMessage(chatId, text, params) {
         const entities_ = params?.entities ?? [];
         const parseMode = params?.parseMode ?? this.parseMode;
@@ -1099,23 +1119,7 @@ export class Client extends ClientAbstract {
             entities,
             replyMarkup,
         }));
-        if (result instanceof types.Updates) {
-            for (const update of result.updates) {
-                if (update instanceof types.UpdateNewMessage) {
-                    return constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this));
-                }
-                else if (update instanceof types.UpdateNewChannelMessage) {
-                    return constructMessage(update.message, this[getEntity].bind(this), this.getMessage.bind(this), this[getStickerSetName].bind(this));
-                }
-            }
-        }
-        else if (result instanceof types.UpdateShortSentMessage || result instanceof types.UpdateShortSentMessage) {
-            const message = await this.getMessage(chatId, result.id);
-            if (message != null) {
-                return message;
-            }
-        }
-        UNREACHABLE();
+        return await this.updatesToMessages(chatId, result).then((v) => v[0]);
     }
     async getMessages(chatId, messageIds) {
         const peer = await this.getInputPeer(chatId);
@@ -1217,4 +1221,22 @@ export class Client extends ClientAbstract {
             return name;
         }
     }
+    async forwardMessages(from, to, messageIds, params) {
+        const result = await this.invoke(new functions.MessagesForwardMessages({
+            fromPeer: await this.getInputPeer(from),
+            toPeer: await this.getInputPeer(to),
+            id: messageIds,
+            randomId: messageIds.map(() => getRandomId()),
+            silent: params?.disableNotification || undefined,
+            topMsgId: params?.messageThreadId,
+            noforwards: params?.disableNotification || undefined,
+            sendAs: params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined,
+            dropAuthor: params?.dropSenderName || undefined,
+            dropMediaCaptions: params?.dropCaption || undefined,
+        }));
+        return await this.updatesToMessages(to, result);
+    }
+    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.956";
+export declare const DEFAULT_APP_VERSION = "MTKruto 0.0.958";
 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.956";
+export const DEFAULT_APP_VERSION = "MTKruto 0.0.958";
 // @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,28 @@
 import { MaybePromise } from "../utilities/0_types.js";
 import { DC } from "../transport/2_transport_provider.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>;
     setState(state: types.UpdatesState): Promise<void>;
     getState(): Promise<types.UpdatesState | null>;
-    private readonly channelPts__;
     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 +30,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,11 +1,19 @@
-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";
 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";
+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];
 export class Storage {
     constructor() {
         Object.defineProperty(this, "_authKeyId", {
@@ -14,60 +22,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 +38,65 @@ 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)];
-        }
-        else {
-            return null;
-        }
+        return this.get(KPARTS__USERNAME(username));
     }
     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.set(KPARTS__STATE, state[serialize]());
     }
     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,
-            });
+        const state = await this.get(KPARTS__STATE);
+        if (state != null) {
+            return new TLReader(state).readObject();
         }
         else {
             return null;
         }
     }
     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 +112,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>;
 }

package/esm/storage/1_storage_local_storage.js

@@ -1,4 +1,5 @@
 import { Storage } from "./0_storage.js";
+import { fromString, toString } from "./0_utilities.js";
 export class StorageLocalStorage extends Storage {
     constructor(prefix) {
         if (typeof localStorage === "undefined") {
@@ -20,14 +21,20 @@ export class StorageLocalStorage extends Storage {
     }
     init() {
     }
-    get(key) {
-        key = this.prefix + key;
-        return localStorage.getItem(key);
+    get(key_) {
+        const key = this.prefix + toString(key_);
+        const value = localStorage.getItem(key);
+        if (value != null) {
+            return fromString(value);
+        }
+        else {
+            return null;
+        }
     }
-    set(key, value) {
-        key = this.prefix + key;
+    set(key_, value) {
+        const key = this.prefix + toString(key_);
         if (value != null) {
-            localStorage.setItem(key, value);
+            localStorage.setItem(key, toString(value));
         }
         else {
             localStorage.removeItem(key);

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

@@ -1,8 +1,8 @@
 import { MaybePromise } from "../utilities/0_types.js";
-import { Storage } from "./0_storage.js";
+import { Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageMemory extends Storage implements Storage {
-    protected map: Map<string, string>;
+    protected map: Map<string, unknown>;
     init(): void;
-    get(key: string): string | null;
-    set(key: string, value: string | null): MaybePromise<void>;
+    get<T>(key: readonly StorageKeyPart[]): NonNullable<T> | null;
+    set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
 }

package/esm/storage/1_storage_memory.js

@@ -1,4 +1,5 @@
 import { Storage } from "./0_storage.js";
+import { toString } from "./0_utilities.js";
 export class StorageMemory extends Storage {
     constructor() {
         super(...arguments);
@@ -12,9 +13,10 @@ export class StorageMemory extends Storage {
     init() {
     }
     get(key) {
-        return this.map.get(key) ?? null;
+        return this.map.get(toString(key)) ?? null;
     }
-    set(key, value) {
+    set(key_, value) {
+        const key = toString(key_);
         if (value != null) {
             this.map.set(key, value);
         }

package/esm/storage/1_storage_session_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 StorageSessionStorage 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>;
 }