@mtkruto/node 0.1.147 → 0.1.149

package/esm/storage/0_storage.js

@@ -9,58 +9,89 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _Storage_instances, _Storage_authKeyId, _Storage_resetAuthKeyId, _Storage_getEntityType, _Storage_getUpdateId;
+var _Storage_instances, _Storage_authKeyId, _Storage_resetAuthKeyId, _Storage_accountType, _Storage_getUpdateId;
 import { bigIntFromBuffer, rleDecode, rleEncode, sha1, UNREACHABLE, ZERO_CHANNEL_ID } from "../1_utilities.js";
-import { serialize, TLReader, types } from "../2_tl.js";
-const KPARTS__DC = ["dc"];
-const KPARTS__AUTH_KEY = ["authKey"];
-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_MESSAGES = (chatId) => ["messages", chatId];
-const KPARTS_ALL_MESSAGE_REFS = ["messageRefs"];
-const KPARTS_MESSAGE_REF = (messageId) => ["messageRefs", messageId];
-const KPARTS_HAS_ALL_CHATS = (listId) => ["hasAllChats", listId];
-const KPARTS_CHATS = (listId) => ["chats", listId];
-const KPARTS_CHAT = (listId, chatId) => ["chats", listId, chatId];
-const KPARTS_PINNED_CHATS = (listId) => ["pinnedChats", listId];
-const KPARTS_SERVER_SALT = ["serverSalt"];
-const KPARTS_FILE = (fileId) => ["files", fileId];
-const KPARTS_FILE_PART = (fileId, n) => ["fileParts", fileId, n];
-const KPARTS_CEMOJI = (id) => ["customEmojiDocuments", id];
-const KPARTS_ALL_UPDATES = ["updates"];
-const KPARTS_UPDATES = (boxId) => ["updates", boxId];
-const KPARTS_UPDATE = (boxId, id) => ["updates", boxId, id];
+import { peerToChatId, serialize, TLReader, types } from "../2_tl.js";
+// key parts
+export const K = {
+    session: {
+        P: (string) => `session.${string}`,
+        serverSalt: () => [K.session.P("serverSalt")],
+    },
+    auth: {
+        P: (string) => `auth.${string}`,
+        dc: () => [K.auth.P("dc")],
+        key: () => [K.auth.P("key")],
+        accountType: () => [K.auth.P("accountType")],
+    },
+    updates: {
+        P: (string) => `updates.${string}`,
+        state: () => [K.updates.P("state")],
+        all: () => [K.updates.P("updates")],
+        updates: (boxId) => [...K.updates.all(), boxId],
+        update: (boxId, id) => [...K.updates.updates(boxId), id],
+        channelPts: (channelId) => [K.updates.P("channelPts"), channelId],
+    },
+    cache: {
+        P: (string) => `cache.${string}`,
+        usernames: () => [K.cache.P("username")],
+        username: (v) => [...K.cache.usernames(), v],
+        peers: () => [K.cache.P("peer")],
+        peer: (id) => [...K.cache.peers(), id],
+        stickerSetNames: () => [K.cache.P("stickerSetNames")],
+        stickerSetName: (id, accessHash) => [...K.cache.stickerSetNames(), id, accessHash],
+        files: () => [K.cache.P("files")],
+        file: (fileId) => [...K.cache.files(), fileId],
+        fileParts: () => [K.cache.P("fileParts")],
+        filePart: (fileId, n) => [...K.cache.fileParts(), fileId, n],
+        customEmojiDocuments: () => [K.cache.P("customEmojiDocuments")],
+        customEmojiDocument: (id) => [...K.cache.customEmojiDocuments(), id],
+    },
+    messages: {
+        P: (string) => `messages.${string}`,
+        messages: (chatId) => [K.messages.P("messages"), chatId],
+        message: (chatId, messageId) => [...K.messages.messages(chatId), messageId],
+        allMessageRefs: () => [K.messages.P("messageRefs")],
+        messageRef: (messageId) => [...K.messages.allMessageRefs(), messageId],
+    },
+    chatlists: {
+        P: (string) => `chatlists.${string}`,
+        hasAllChats: (listId) => [K.chatlists.P("hasAllChats"), listId],
+        chats: (listId) => [K.chatlists.P("chats"), listId],
+        chat: (listId, chatId) => [...K.chatlists.chats(listId), chatId],
+        pinnedChats: (listId) => [K.chatlists.P("pinnedChats"), listId],
+    },
+};
 export class Storage {
     constructor() {
         _Storage_instances.add(this);
         _Storage_authKeyId.set(this, null);
+        _Storage_accountType.set(this, null);
     }
     setDc(dc) {
-        return this.set(KPARTS__DC, dc);
+        return this.set(K.auth.dc(), dc);
     }
     getDc() {
-        return this.get(KPARTS__DC);
+        return this.get(K.auth.dc());
     }
     async getAuthKey() {
-        const authKey = await this.get(KPARTS__AUTH_KEY);
+        const authKey = await this.get(K.auth.key());
         await __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_resetAuthKeyId).call(this, authKey);
         return authKey;
     }
     async setAuthKey(authKey) {
-        await this.set(KPARTS__AUTH_KEY, authKey);
+        await this.set(K.auth.key(), authKey);
         await __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_resetAuthKeyId).call(this, authKey);
     }
     get authKeyId() {
         return __classPrivateFieldGet(this, _Storage_authKeyId, "f");
     }
     async getChannelAccessHash(id) {
-        const channel = await this.getEntity("channel", id);
+        const channel = await this.getEntity(id);
         if (channel) {
+            if (!(channel instanceof types.Channel) && !(channel instanceof types.ChannelForbidden)) {
+                UNREACHABLE();
+            }
             return typeof channel.access_hash === "bigint" ? channel.access_hash : null;
         }
         else {
@@ -68,23 +99,26 @@ export class Storage {
         }
     }
     async getUserAccessHash(id) {
-        const user = await this.getEntity("user", id);
+        const user = await this.getEntity(id);
         if (user) {
+            if (!(user instanceof types.User)) {
+                UNREACHABLE();
+            }
             return typeof user.access_hash === "bigint" ? user.access_hash : null;
         }
         else {
             return null;
         }
     }
-    async updateUsernames(type, id, usernames) {
+    async updateUsernames(id, usernames) {
         for (let username of usernames) {
             username = username.toLowerCase();
-            await this.set(KPARTS__USERNAME(username), [type, id, new Date()]);
+            await this.set(K.cache.username(username), [id, new Date()]);
         }
     }
     async getUsername(username) {
         username = username.toLowerCase();
-        return await this.get(KPARTS__USERNAME(username));
+        return await this.get(K.cache.username(username));
     }
     async setTlObject(key, value) {
         if (value == null) {
@@ -104,50 +138,51 @@ export class Storage {
         }
     }
     async setState(state) {
-        await this.setTlObject(KPARTS__STATE, state);
+        await this.setTlObject(K.updates.state(), state);
     }
     async getState() {
-        return await this.getTlObject(KPARTS__STATE);
+        return await this.getTlObject(K.updates.state());
     }
     async setMessage(chatId, messageId, message) {
         if (chatId > ZERO_CHANNEL_ID) {
-            await this.set(KPARTS_MESSAGE_REF(messageId), message == null ? null : chatId);
+            await this.set(K.messages.messageRef(messageId), message == null ? null : chatId);
         }
-        await this.setTlObject(KPARTS_MESSAGE(chatId, messageId), message);
+        await this.setTlObject(K.messages.message(chatId, messageId), message);
     }
     async deleteMessages() {
         const maybePromises = new Array();
-        for await (const [k, o] of await this.getMany({ prefix: KPARTS_ALL_MESSAGE_REFS })) {
-            maybePromises.push(Promise.all([this.set(k, null), o == null ? Promise.resolve() : this.set(KPARTS_MESSAGE(o, k[1]), null)]).then(() => { }));
+        for await (const [k, o] of await this.getMany({ prefix: K.messages.allMessageRefs() })) {
+            maybePromises.push(Promise.all([this.set(k, null), o == null ? Promise.resolve() : this.set(K.messages.message(o, k[1]), null)]).then(() => { }));
         }
         await Promise.all(maybePromises.filter((v) => v instanceof Promise));
     }
     getMessageChat(messageId) {
-        return this.get(KPARTS_MESSAGE_REF(messageId));
+        return this.get(K.messages.messageRef(messageId));
     }
     async getMessage(chatId, messageId) {
-        return await this.getTlObject(KPARTS_MESSAGE(chatId, messageId));
+        return await this.getTlObject(K.messages.message(chatId, messageId));
     }
     async getLastMessage(chatId) {
-        for await (const [_, buffer] of await this.getMany({ prefix: KPARTS_MESSAGES(chatId) }, { limit: 1, reverse: true })) {
+        for await (const [_, buffer] of await this.getMany({ prefix: K.messages.messages(chatId) }, { limit: 1, reverse: true })) {
             return await this.getTlObject(buffer);
         }
         return null;
     }
     async setChannelPts(channelId, pts) {
-        await this.set(KPARTS__CHANNEL_PTS(channelId), pts);
+        await this.set(K.updates.channelPts(channelId), pts);
     }
     getChannelPts(channelId) {
-        return this.get(KPARTS__CHANNEL_PTS(channelId));
+        return this.get(K.updates.channelPts(channelId));
     }
     async setEntity(entity) {
-        const type = __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_getEntityType).call(this, entity);
-        await this.set(KPARTS__PEER(type, entity.id), rleEncode(entity[serialize]()));
+        await this.set(K.cache.peer(peerToChatId(entity)), [rleEncode(entity[serialize]()), new Date()]);
     }
-    async getEntity(type, id) {
-        const peer_ = await this.get(KPARTS__PEER(type, id));
+    async getEntity(key) {
+        const peer_ = await this.get(K.cache.peer(key));
         if (peer_ != null) {
-            return new TLReader(rleDecode(peer_)).readObject();
+            const [obj_] = peer_;
+            const entity = new TLReader(rleDecode(obj_)).readObject();
+            return entity;
         }
         else {
             return null;
@@ -163,31 +198,36 @@ export class Storage {
                 throw err;
             }
             else {
-                await this.set(KPARTS__ACCOUNT_TYPE, type);
+                await this.set(K.auth.accountType(), type);
             }
         }
     }
-    getAccountType() {
-        return this.get(KPARTS__ACCOUNT_TYPE);
+    async getAccountType() {
+        if (__classPrivateFieldGet(this, _Storage_accountType, "f") != null) {
+            return __classPrivateFieldGet(this, _Storage_accountType, "f");
+        }
+        else {
+            return __classPrivateFieldSet(this, _Storage_accountType, await this.get(K.auth.accountType()), "f");
+        }
     }
     async updateStickerSetName(id, accessHash, name) {
-        await this.set(KPARTS__STICKER_SET_NAME(id, accessHash), [name, new Date()]);
+        await this.set(K.cache.stickerSetName(id, accessHash), [name, new Date()]);
     }
     getStickerSetName(id, accessHash) {
-        return this.get(KPARTS__STICKER_SET_NAME(id, accessHash));
+        return this.get(K.cache.stickerSetName(id, accessHash));
     }
     async setServerSalt(serverSalt) {
-        await this.set(KPARTS_SERVER_SALT, serverSalt);
+        await this.set(K.session.serverSalt(), serverSalt);
     }
     getServerSalt() {
-        return this.get(KPARTS_SERVER_SALT);
+        return this.get(K.session.serverSalt());
     }
     async setChat(listId, chatId, pinned, topMessageId, topMessageDate) {
-        await this.set(KPARTS_CHAT(listId, chatId), [pinned, topMessageId, topMessageDate]);
+        await this.set(K.chatlists.chat(listId, chatId), [pinned, topMessageId, topMessageDate]);
     }
     async getChats(listId) {
         const chats = new Array();
-        for await (const [key, value] of await this.getMany({ prefix: KPARTS_CHATS(listId) })) {
+        for await (const [key, value] of await this.getMany({ prefix: K.chatlists.chats(listId) })) {
             if (key.length != 3 || typeof key[2] !== "number") {
                 continue;
             }
@@ -196,24 +236,24 @@ export class Storage {
         return chats;
     }
     async removeChats(listId) {
-        for await (const [key] of await this.getMany({ prefix: KPARTS_CHATS(listId) })) {
+        for await (const [key] of await this.getMany({ prefix: K.chatlists.chats(listId) })) {
             await this.set(key, null);
         }
         await this.setHasAllChats(listId, false);
         await this.setPinnedChats(listId, null);
     }
     async setHasAllChats(listId, hasAllChats) {
-        await this.set(KPARTS_HAS_ALL_CHATS(listId), hasAllChats);
+        await this.set(K.chatlists.hasAllChats(listId), hasAllChats);
     }
     async hasAllChats(listId) {
-        const v = await this.get(KPARTS_HAS_ALL_CHATS(listId));
+        const v = await this.get(K.chatlists.hasAllChats(listId));
         return v == true;
     }
     async setPinnedChats(listId, chatIds) {
-        await this.set(KPARTS_PINNED_CHATS(listId), chatIds);
+        await this.set(K.chatlists.pinnedChats(listId), chatIds);
     }
     async getPinnedChats(listId) {
-        return await this.get(KPARTS_PINNED_CHATS(listId));
+        return await this.get(K.chatlists.pinnedChats(listId));
     }
     async getHistory(chatId, offsetId, limit) {
         if (offsetId == 0) {
@@ -221,7 +261,7 @@ export class Storage {
         }
         ++limit;
         const messages = new Array();
-        for await (const [_, buffer] of await this.getMany({ start: KPARTS_MESSAGE(chatId, 0), end: KPARTS_MESSAGE(chatId, offsetId) }, { limit, reverse: true })) {
+        for await (const [_, buffer] of await this.getMany({ start: K.messages.message(chatId, 0), end: K.messages.message(chatId, offsetId) }, { limit, reverse: true })) {
             const message = await this.getTlObject(buffer);
             if ("id" in message && message.id == offsetId) {
                 continue;
@@ -234,14 +274,14 @@ export class Storage {
         if (!this.supportsFiles) {
             return null;
         }
-        return await this.get(KPARTS_FILE(id));
+        return await this.get(K.cache.file(id));
     }
     async *iterFileParts(id, partCount, offset) {
         if (!this.supportsFiles) {
             return;
         }
         for (let i = offset; i < partCount; i++) {
-            const part = await this.get(KPARTS_FILE_PART(id, i));
+            const part = await this.get(K.cache.filePart(id, i));
             if (part == null) {
                 continue;
             }
@@ -252,19 +292,19 @@ export class Storage {
         if (!this.supportsFiles) {
             return;
         }
-        await this.set(KPARTS_FILE_PART(id, index), bytes);
+        await this.set(K.cache.filePart(id, index), bytes);
     }
     async setFilePartCount(id, partCount, chunkSize) {
         if (!this.supportsFiles) {
             return;
         }
-        await this.set(KPARTS_FILE(id), [partCount, chunkSize]);
+        await this.set(K.cache.file(id), [partCount, chunkSize]);
     }
     async setCustomEmojiDocument(id, document) {
-        await this.set(KPARTS_CEMOJI(id), [rleEncode(document[serialize]()), new Date()]);
+        await this.set(K.cache.customEmojiDocument(id), [rleEncode(document[serialize]()), new Date()]);
     }
     async getCustomEmojiDocument(id) {
-        const v = await this.get(KPARTS_CEMOJI(id));
+        const v = await this.get(K.cache.customEmojiDocument(id));
         if (v != null) {
             return [await this.getTlObject([0]), v[1]];
         }
@@ -273,17 +313,17 @@ export class Storage {
         }
     }
     async setUpdate(boxId, update) {
-        await this.setTlObject(KPARTS_UPDATE(boxId, __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_getUpdateId).call(this, update)), update);
+        await this.setTlObject(K.updates.update(boxId, __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_getUpdateId).call(this, update)), update);
     }
     async deleteUpdates() {
         const maybePromises = new Array();
-        for await (const [k] of await this.getMany({ prefix: KPARTS_ALL_UPDATES })) {
+        for await (const [k] of await this.getMany({ prefix: K.updates.all() })) {
             maybePromises.push(this.set(k, null));
         }
         await Promise.all(maybePromises.filter((v) => v instanceof Promise));
     }
     async getFirstUpdate(boxId) {
-        for await (const [key, update] of await this.getMany({ prefix: KPARTS_UPDATES(boxId) }, { limit: 1 })) {
+        for await (const [key, update] of await this.getMany({ prefix: K.updates.updates(boxId) }, { limit: 1 })) {
             return [key, await this.getTlObject(update).then((v) => v)];
         }
         return null;
@@ -298,26 +338,57 @@ export class Storage {
             throw new Error(`${source}: not a bot client`);
         }
     }
-}
-_Storage_authKeyId = new WeakMap(), _Storage_instances = new WeakSet(), _Storage_resetAuthKeyId = async function _Storage_resetAuthKeyId(authKey) {
-    if (authKey != null) {
-        __classPrivateFieldSet(this, _Storage_authKeyId, await sha1(authKey).then((hash) => bigIntFromBuffer(hash.subarray(-8), true, false)), "f");
+    async deleteFiles() {
+        if (!this.supportsFiles) {
+            return;
+        }
+        for await (const [key] of await this.getMany({ prefix: K.cache.fileParts() })) {
+            await this.set(key, null);
+        }
+        for await (const [key] of await this.getMany({ prefix: K.cache.files() })) {
+            await this.set(key, null);
+        }
     }
-    else {
-        __classPrivateFieldSet(this, _Storage_authKeyId, null, "f");
+    async deleteCustomEmojiDocuments() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.customEmojiDocuments() })) {
+            await this.set(key, null);
+        }
+    }
+    async deleteStickerSetNames() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.stickerSetNames() })) {
+            await this.set(key, null);
+        }
+    }
+    async deletePeers() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.peers() })) {
+            await this.set(key, null);
+        }
     }
-}, _Storage_getEntityType = function _Storage_getEntityType(entity) {
-    if (entity instanceof types.Channel || entity instanceof types.ChannelForbidden) {
-        return "channel";
+    async deleteUsernames() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.usernames() })) {
+            await this.set(key, null);
+        }
     }
-    else if (entity instanceof types.Chat || entity instanceof types.ChatForbidden) {
-        return "chat";
+    async clear() {
+        await Promise.all([
+            this.deleteMessages(),
+            this.removeChats(0),
+            this.removeChats(1),
+            this.deleteUpdates(),
+            this.deleteFiles(),
+            this.deleteCustomEmojiDocuments(),
+            this.deleteStickerSetNames(),
+            this.deletePeers(),
+            this.deleteUsernames(),
+        ]);
     }
-    else if (entity instanceof types.User) {
-        return "user";
+}
+_Storage_authKeyId = new WeakMap(), _Storage_accountType = new WeakMap(), _Storage_instances = new WeakSet(), _Storage_resetAuthKeyId = async function _Storage_resetAuthKeyId(authKey) {
+    if (authKey != null) {
+        __classPrivateFieldSet(this, _Storage_authKeyId, await sha1(authKey).then((hash) => bigIntFromBuffer(hash.subarray(-8), true, false)), "f");
     }
     else {
-        UNREACHABLE();
+        __classPrivateFieldSet(this, _Storage_authKeyId, null, "f");
     }
 }, _Storage_getUpdateId = function _Storage_getUpdateId(update) {
     let id = BigInt(Date.now()) << 32n;

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

@@ -1,9 +1,12 @@
-import { MaybePromise } from "../1_utilities.js";
+import { CacheMap, MaybePromise } from "../1_utilities.js";
 import { GetManyFilter, Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageMemory extends Storage implements Storage {
     #private;
     protected map: Map<string, unknown>;
+    protected messageMap: CacheMap<string, unknown>;
     initialize(): void;
+    getMap(key: readonly StorageKeyPart[]): Map<string, unknown>;
+    getMaps(): Map<string, unknown>[];
     branch(id: string): Storage;
     get supportsFiles(): boolean;
     get<T>(key: readonly StorageKeyPart[]): NonNullable<T> | null;

package/esm/storage/1_storage_memory.js

@@ -10,6 +10,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _StorageMemory_instances, _StorageMemory_id, _StorageMemory_fixKey, _StorageMemory_getEntries;
+import { CacheMap } from "../1_utilities.js";
 import { Storage } from "./0_storage.js";
 import { fromString, isInRange, toString } from "./0_utilities.js";
 export class StorageMemory extends Storage {
@@ -22,10 +23,27 @@ export class StorageMemory extends Storage {
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "messageMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new CacheMap(30000)
+        });
         _StorageMemory_id.set(this, null);
     }
     initialize() {
     }
+    getMap(key) {
+        if (key[0] == "messages.messages") {
+            return this.messageMap;
+        }
+        else {
+            return this.map;
+        }
+    }
+    getMaps() {
+        return [this.map, this.messageMap];
+    }
     branch(id) {
         const storage = new StorageMemory();
         __classPrivateFieldSet(storage, _StorageMemory_id, id, "f");
@@ -36,7 +54,7 @@ export class StorageMemory extends Storage {
     }
     get(key) {
         key = __classPrivateFieldGet(this, _StorageMemory_instances, "m", _StorageMemory_fixKey).call(this, key);
-        return this.map.get(toString(key)) ?? null;
+        return this.getMap(key).get(toString(key)) ?? null;
     }
     *getMany(filter, params) {
         let entries = __classPrivateFieldGet(this, _StorageMemory_instances, "m", _StorageMemory_getEntries).call(this);
@@ -46,13 +64,13 @@ export class StorageMemory extends Storage {
         if (params?.limit !== undefined) {
             entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
         }
-        for (const [key, value] of entries) {
+        entries: for (const [key, value] of entries) {
             const parts = fromString(key);
             if (Array.isArray(parts)) {
                 if ("prefix" in filter) {
                     for (const [i, p] of filter.prefix.entries()) {
                         if (toString(p) != toString(parts[i])) {
-                            continue;
+                            continue entries;
                         }
                     }
                 }
@@ -69,10 +87,10 @@ export class StorageMemory extends Storage {
         key_ = __classPrivateFieldGet(this, _StorageMemory_instances, "m", _StorageMemory_fixKey).call(this, key_);
         const key = toString(key_);
         if (value != null) {
-            this.map.set(key, value);
+            this.getMap(key_).set(key, value);
         }
         else {
-            this.map.delete(key);
+            this.getMap(key_).delete(key);
         }
     }
     incr(key, by) {
@@ -88,11 +106,13 @@ _StorageMemory_id = new WeakMap(), _StorageMemory_instances = new WeakSet(), _St
     }
 }, _StorageMemory_getEntries = function _StorageMemory_getEntries() {
     const entries = new Array();
-    for (const entry of this.map.entries()) {
-        if (__classPrivateFieldGet(this, _StorageMemory_id, "f") !== null && !entry[0].startsWith("__S" + __classPrivateFieldGet(this, _StorageMemory_id, "f"))) {
-            continue;
+    for (const map of this.getMaps()) {
+        for (const entry of map.entries()) {
+            if (__classPrivateFieldGet(this, _StorageMemory_id, "f") !== null && !entry[0].startsWith("__S" + __classPrivateFieldGet(this, _StorageMemory_id, "f"))) {
+                continue;
+            }
+            entries.push(entry);
         }
-        entries.push(entry);
     }
     return entries;
 };

package/esm/tl/3_utilities.d.ts

@@ -1,5 +1,8 @@
-import { enums } from "./2_types.js";
+import { enums, types } from "./2_types.js";
 export declare function getChannelChatId(channelId: bigint): number;
-export declare function peerToChatId(peer: enums.Peer | enums.InputPeer): number;
+export type AnyEntity = types.User | types.Channel | types.ChannelForbidden | types.Chat | types.ChatForbidden;
+export declare function peerToChatId(peer: enums.Peer | enums.InputPeer | AnyEntity): number;
 export declare function chatIdToPeer(chatId: number): import("./2_types.js").PeerUser_ | import("./2_types.js").PeerChat_ | import("./2_types.js").PeerChannel_;
+export declare function chatIdToPeerId(chatId: number): bigint;
+export declare function getChatIdPeerType(chatId: number): "chat" | "channel" | "user";
 export declare function inputPeerToPeer(inputPeer: enums.InputPeer): import("./2_types.js").PeerUser_ | import("./2_types.js").PeerChat_ | import("./2_types.js").PeerChannel_;

package/esm/tl/3_utilities.js

@@ -4,14 +4,14 @@ 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.user_id);
+    if (peer instanceof types.PeerUser || peer instanceof types.InputPeerUser || peer instanceof types.User) {
+        return Number("id" in peer ? peer.id : peer.user_id);
     }
-    else if (peer instanceof types.PeerChat || peer instanceof types.InputPeerChat) {
-        return -Number(peer.chat_id);
+    else if (peer instanceof types.PeerChat || peer instanceof types.InputPeerChat || peer instanceof types.Chat || peer instanceof types.ChatForbidden) {
+        return -Number("id" in peer ? peer.id : peer.chat_id);
     }
-    else if (peer instanceof types.PeerChannel || peer instanceof types.InputPeerChannel) {
-        return getChannelChatId(peer.channel_id);
+    else if (peer instanceof types.PeerChannel || peer instanceof types.InputPeerChannel || peer instanceof types.Channel || peer instanceof types.ChannelForbidden) {
+        return getChannelChatId("id" in peer ? peer.id : peer.channel_id);
     }
     else {
         UNREACHABLE();
@@ -28,6 +28,32 @@ export function chatIdToPeer(chatId) {
         return new types.PeerChannel({ channel_id: BigInt(ZERO_CHANNEL_ID - chatId) });
     }
 }
+export function chatIdToPeerId(chatId) {
+    const peer = chatIdToPeer(chatId);
+    if ("user_id" in peer) {
+        return peer.user_id;
+    }
+    else if ("chat_id" in peer) {
+        return peer.chat_id;
+    }
+    else if ("channel_id" in peer) {
+        return peer.channel_id;
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export function getChatIdPeerType(chatId) {
+    if (chatId > 0) {
+        return "user";
+    }
+    else if (chatId > ZERO_CHANNEL_ID) {
+        return "chat";
+    }
+    else {
+        return "channel";
+    }
+}
 export function inputPeerToPeer(inputPeer) {
     if ("user_id" in inputPeer) {
         return new types.PeerUser(inputPeer);

package/esm/types/0_giveaway_parameters.d.ts

@@ -1,4 +1,5 @@
 import { types } from "../2_tl.js";
+/** Giveaway parameters. */
 export interface GiveawayParameters {
     boostedChatId: number;
     additionalChatIds: number[];

package/esm/types/0_login_url.d.ts

@@ -1,3 +1,4 @@
+/** A login URL. */
 export interface LoginUrl {
     url: string;
     forwardText?: string;

package/esm/types/0_mask_position.d.ts

@@ -1,4 +1,5 @@
 import { enums } from "../2_tl.js";
+/** A mask position. */
 export interface MaskPosition {
     point: "forehead" | "eyes" | "mouth" | "chin";
     xShift: number;

package/esm/types/0_message_reference.d.ts

@@ -0,0 +1,5 @@
+/** Reference to a message. */
+export interface MessageReference {
+    chatId: number;
+    messageId: number;
+}

package/esm/types/0_poll_option.d.ts

@@ -1,4 +1,5 @@
 import { enums } from "../2_tl.js";
+/** A poll option. */
 export interface PollOption {
     /** The option's text (1-100 characters). */
     text: string;

package/esm/types/0_price_tag.d.ts

@@ -0,0 +1,5 @@
+/** A price tag. */
+export interface PriceTag {
+    label: string;
+    amount: number;
+}

package/esm/types/0_restriction_reason.d.ts

@@ -1,4 +1,5 @@
 import { enums } from "../2_tl.js";
+/** The reason for restricting an entity. */
 export interface RestrictionReason {
     platform: string;
     reason: string;