@mtkruto/node 0.1.124 → 0.1.126

package/esm/deps/deno.land/{std@0.208.0 → std@0.209.0}/path/_common/glob_to_reg_exp.d.ts

@@ -1,3 +1,4 @@
+/** Options for {@linkcode globToRegExp}. */
 export interface GlobOptions {
     /** Extended glob syntax.
      * See https://www.linuxjournal.com/content/bash-extended-globbing.

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

@@ -2,12 +2,22 @@ import { MaybePromise } from "../1_utilities.js";
 import { enums, TLObject, types } from "../2_tl.js";
 import { DC } from "../3_transport.js";
 export type StorageKeyPart = string | number | bigint;
+export type GetManyFilter = {
+    prefix: readonly StorageKeyPart[];
+} | {
+    start: readonly StorageKeyPart[];
+    end: readonly StorageKeyPart[];
+};
 export declare abstract class Storage {
     #private;
     abstract init(): MaybePromise<void>;
     abstract set(key: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
+    abstract incr(key: readonly StorageKeyPart[], by: number): MaybePromise<void>;
     abstract get<T>(key: readonly StorageKeyPart[]): MaybePromise<T | null>;
-    abstract getMany<T>(prefix: readonly StorageKeyPart[]): MaybePromise<Generator<[readonly StorageKeyPart[], T]> | AsyncGenerator<[readonly StorageKeyPart[], T]>>;
+    abstract getMany<T>(prefix: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }): MaybePromise<Generator<[readonly StorageKeyPart[], T]> | AsyncGenerator<[readonly StorageKeyPart[], T]>>;
     setDc(dc: DC | null): MaybePromise<void>;
     getDc(): MaybePromise<DC | null>;
     getAuthKey(): Promise<Uint8Array | null>;
@@ -20,13 +30,14 @@ export declare abstract class Storage {
     updateUsernames(type: "user" | "channel", id: bigint, usernames: string[]): Promise<void>;
     getUsername(username: string): Promise<["channel" | "user", bigint, Date] | null>;
     setTlObject(key: readonly StorageKeyPart[], value: TLObject | null): Promise<void>;
-    getTLObject(key: readonly StorageKeyPart[]): Promise<import("../2_tl.js").ReadObject | null>;
+    getTLObject(keyOrBuffer: Uint8Array | readonly StorageKeyPart[]): Promise<import("../2_tl.js").ReadObject | null>;
     setState(state: enums.updates.State): Promise<void>;
     getState(): Promise<import("../tl/2_types.js").updates_State_ | null>;
     setMessage(chatId: number, messageId: number, message: enums.Message | null): Promise<void>;
     deleteMessages(): Promise<void>;
     getMessageChat(messageId: number): MaybePromise<number | null>;
     getMessage(chatId: number, messageId: number): Promise<enums.Message | null>;
+    getLastMessage(chatId: number): Promise<enums.Message | null>;
     setChannelPts(channelId: bigint, pts: number): Promise<void>;
     getChannelPts(channelId: bigint): MaybePromise<number | null>;
     setEntity(peer: types.Channel): Promise<void>;
@@ -42,4 +53,17 @@ export declare abstract class Storage {
     getStickerSetName(id: bigint, accessHash: bigint): MaybePromise<[string, Date] | null>;
     setServerSalt(serverSalt: bigint): Promise<void>;
     getServerSalt(): MaybePromise<bigint | null>;
+    setChat(listId: number, chatId: number, pinned: number, topMessageId: number, topMessageDate: Date): Promise<void>;
+    getChats(listId: number): Promise<{
+        chatId: number;
+        pinned: number;
+        topMessageId: number;
+        topMessageDate: Date;
+    }[]>;
+    removeChats(listId: number): Promise<void>;
+    setHasAllChats(listId: number, hasAllChats: boolean): Promise<void>;
+    hasAllChats(listId: number): Promise<boolean>;
+    setPinnedChats(listId: number, chatIds: number[] | null): Promise<void>;
+    getPinnedChats(listId: number): Promise<number[] | null>;
+    getHistory(chatId: number, offsetId: number, limit: number): Promise<enums.Message[]>;
 }

package/esm/storage/0_storage.js

@@ -23,7 +23,13 @@ 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_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"];
 export class Storage {
     constructor() {
         _Storage_instances.add(this);
@@ -77,8 +83,8 @@ export class Storage {
             await this.set(key, rleEncode(value[serialize]()));
         }
     }
-    async getTLObject(key) {
-        const buffer = await this.get(key);
+    async getTLObject(keyOrBuffer) {
+        const buffer = keyOrBuffer instanceof Uint8Array ? keyOrBuffer : await this.get(keyOrBuffer);
         if (buffer != null) {
             return new TLReader(rleDecode(buffer)).readObject();
         }
@@ -100,7 +106,7 @@ export class Storage {
     }
     async deleteMessages() {
         const maybePromises = new Array();
-        for await (const [k, o] of await this.getMany(["messageRefs"])) {
+        for await (const [k, o] of await this.getMany({ prefix: ["messageRefs"] })) {
             maybePromises.push(Promise.all([this.set(k, null), o == null ? Promise.resolve() : this.set(KPARTS_MESSAGE(o, k[1]), null)]).then(() => { }));
         }
         await Promise.all(maybePromises.filter((v) => v instanceof Promise));
@@ -111,6 +117,12 @@ export class Storage {
     async getMessage(chatId, messageId) {
         return await this.getTLObject(KPARTS_MESSAGE(chatId, messageId));
     }
+    async getLastMessage(chatId) {
+        for await (const [_, buffer] of await this.getMany({ prefix: KPARTS_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);
     }
@@ -154,10 +166,53 @@ export class Storage {
         return this.get(KPARTS__STICKER_SET_NAME(id, accessHash));
     }
     async setServerSalt(serverSalt) {
-        await this.set(["serverSalt"], serverSalt);
+        await this.set(KPARTS_SERVER_SALT, serverSalt);
     }
     getServerSalt() {
-        return this.get(["serverSalt"]);
+        return this.get(KPARTS_SERVER_SALT);
+    }
+    async setChat(listId, chatId, pinned, topMessageId, topMessageDate) {
+        await this.set(KPARTS_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) })) {
+            if (key.length != 3 || typeof key[2] !== "number") {
+                continue;
+            }
+            chats.push({ chatId: key[2], pinned: value[0], topMessageId: value[1], topMessageDate: value[2] });
+        }
+        return chats;
+    }
+    async removeChats(listId) {
+        for await (const [key] of await this.getMany({ prefix: KPARTS_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);
+    }
+    async hasAllChats(listId) {
+        const v = await this.get(KPARTS_HAS_ALL_CHATS(listId));
+        return v == true;
+    }
+    async setPinnedChats(listId, chatIds) {
+        await this.set(KPARTS_PINNED_CHATS(listId), chatIds);
+    }
+    async getPinnedChats(listId) {
+        return await this.get(KPARTS_PINNED_CHATS(listId));
+    }
+    async getHistory(chatId, offsetId, limit) {
+        if (offsetId == 0) {
+            offsetId = Infinity;
+        }
+        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 })) {
+            messages.push(await this.getTLObject(buffer));
+        }
+        return messages;
     }
 }
 _Storage__authKeyId = new WeakMap(), _Storage_instances = new WeakSet(), _Storage_resetAuthKeyId = async function _Storage_resetAuthKeyId(authKey) {

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

@@ -11,4 +11,6 @@ export declare enum ValueType {
 export declare function toString(value: unknown): string;
 export declare function fromString<T>(string: string): T;
 export declare function fixKey(key: readonly StorageKeyPart[]): (string | number)[];
+export declare function restoreKey(key: readonly StorageKeyPart[]): (string | number | bigint)[];
 export declare function getPrefixKeyRange(prefix: any): IDBKeyRange;
+export declare function isInRange(key: StorageKeyPart[], start: readonly StorageKeyPart[], end: readonly StorageKeyPart[]): boolean;

package/esm/storage/0_utilities.js

@@ -90,6 +90,25 @@ export function fromString(string) {
 export function fixKey(key) {
     return key.map((v) => typeof v === "bigint" ? String(ValueType.BigInt) + String(v) : typeof v === "string" ? String(ValueType.String) + v : v);
 }
+export function restoreKey(key) {
+    return key.map((v) => {
+        if (typeof v === "string") {
+            const t = Number(v[0]);
+            if (t == ValueType.BigInt) {
+                return BigInt(v.slice(1));
+            }
+            else if (t == ValueType.String) {
+                return v.slice(1);
+            }
+            else {
+                return v;
+            }
+        }
+        else {
+            return v;
+        }
+    });
+}
 // Source: https://gist.github.com/inexorabletash/5462871
 // deno-lint-ignore no-explicit-any
 export function getPrefixKeyRange(prefix) {
@@ -153,3 +172,17 @@ function successor(key) {
     }
     throw new TypeError();
 }
+export function isInRange(key, start, end) {
+    for (const [i, part] of key.entries()) {
+        const left = start[i];
+        const right = end[i];
+        if (left === undefined || right === undefined) {
+            return false;
+        }
+        if (part >= left && part <= right) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}

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

@@ -1,10 +1,14 @@
-import { Storage, StorageKeyPart } from "./0_storage.js";
+import { GetManyFilter, 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: StorageKeyPart[], v: unknown): Promise<void>;
-    get<T>(k: readonly StorageKeyPart[]): Promise<T | null>;
-    getMany<T>(prefix: readonly StorageKeyPart[]): AsyncGenerator<[readonly StorageKeyPart[], T], void, unknown>;
+    set(k: readonly StorageKeyPart[], v: unknown, tx_?: IDBTransaction): Promise<void>;
+    get<T>(k: readonly StorageKeyPart[], tx_?: IDBTransaction): Promise<T | null>;
+    getMany<T>(filter: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }, tx_?: IDBTransaction): AsyncGenerator<[readonly StorageKeyPart[], T], void, unknown>;
+    incr(key: readonly StorageKeyPart[], by: number): Promise<void>;
 }

package/esm/storage/1_storage_indexed_db.js

@@ -1,5 +1,5 @@
 import { Storage } from "./0_storage.js";
-import { fixKey, getPrefixKeyRange } from "./0_utilities.js";
+import { fixKey, getPrefixKeyRange, restoreKey } from "./0_utilities.js";
 const VERSION = 1;
 const KV_OBJECT_STORE = "kv";
 export class StorageIndexedDB extends Storage {
@@ -35,12 +35,12 @@ export class StorageIndexedDB extends Storage {
             };
         });
     }
-    set(k, v) {
+    set(k, v, tx_) {
         if (!this.database) {
             throw new Error("Not initialized");
         }
-        const store = this.database
-            .transaction(KV_OBJECT_STORE, "readwrite")
+        const store = (tx_ ?? this.database
+            .transaction(KV_OBJECT_STORE, "readwrite"))
             .objectStore(KV_OBJECT_STORE);
         // deno-lint-ignore no-explicit-any
         let tx;
@@ -57,12 +57,12 @@ export class StorageIndexedDB extends Storage {
             };
         });
     }
-    get(k) {
+    get(k, tx_) {
         if (!this.database) {
             throw new Error("Not initialized");
         }
-        const tx = this.database
-            .transaction(KV_OBJECT_STORE, "readonly")
+        const tx = (tx_ ?? this.database
+            .transaction(KV_OBJECT_STORE, "readonly"))
             .objectStore(KV_OBJECT_STORE)
             .get(fixKey(k));
         return new Promise((res, rej) => {
@@ -72,21 +72,52 @@ export class StorageIndexedDB extends Storage {
             };
         });
     }
-    async *getMany(prefix) {
+    async *getMany(filter, params, tx_) {
         if (!this.database) {
             throw new Error("Not initialized");
         }
+        if (params?.limit !== undefined && params.limit <= 0) {
+            params.limit = 1;
+        }
+        let keyRange;
+        if ("prefix" in filter) {
+            keyRange = getPrefixKeyRange(fixKey(filter.prefix));
+        }
+        else {
+            keyRange = IDBKeyRange.bound(fixKey(filter.start), fixKey(filter.end), true, true);
+        }
         const keys = await new Promise((res, rej) => {
-            const tx = this.database.transaction(KV_OBJECT_STORE, "readonly")
+            const items = new Array();
+            const tx = (tx_ ?? this.database.transaction(KV_OBJECT_STORE, "readonly"))
                 .objectStore(KV_OBJECT_STORE)
-                .getAllKeys(getPrefixKeyRange(prefix));
+                .openKeyCursor(keyRange, params?.reverse ? "prev" : undefined);
             tx.onerror = rej;
             tx.onsuccess = () => {
-                res(tx.result);
+                const cursor = tx.result;
+                if (!cursor) {
+                    res(items);
+                    return;
+                }
+                items.push(restoreKey(cursor.key));
+                if (params?.limit !== undefined && items.length >= params.limit) {
+                    res(items);
+                }
+                else {
+                    cursor.continue();
+                }
             };
         });
         for (const key of keys) {
             yield [key, await this.get(key)];
         }
     }
+    async incr(key, by) {
+        if (!this.database) {
+            throw new Error("Not initialized");
+        }
+        const tx = this.database
+            .transaction(KV_OBJECT_STORE, "readwrite");
+        const currentValue = await this.get(key, tx);
+        await this.set(key, (currentValue || 0) + by, tx);
+    }
 }

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

@@ -1,10 +1,13 @@
-import { MaybePromise } from "../1_utilities.js";
-import { Storage, StorageKeyPart } from "./0_storage.js";
+import { GetManyFilter, Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageLocalStorage extends Storage implements Storage {
     private readonly prefix;
     constructor(prefix: string);
     init(): void;
     get<T>(key_: readonly StorageKeyPart[]): T | null;
-    getMany<T>(prefix: readonly StorageKeyPart[]): Generator<[readonly StorageKeyPart[], T], void, unknown>;
-    set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
+    getMany<T>(filter: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }): Generator<[readonly StorageKeyPart[], T], void, unknown>;
+    set(key_: readonly StorageKeyPart[], value: unknown): void;
+    incr(key: readonly StorageKeyPart[], by: number): void;
 }

package/esm/storage/1_storage_local_storage.js

@@ -1,5 +1,5 @@
 import { Storage } from "./0_storage.js";
-import { fromString, toString } from "./0_utilities.js";
+import { fromString, isInRange, toString } from "./0_utilities.js";
 export class StorageLocalStorage extends Storage {
     constructor(prefix) {
         if (typeof localStorage === "undefined") {
@@ -31,19 +31,33 @@ export class StorageLocalStorage extends Storage {
             return null;
         }
     }
-    *getMany(prefix) {
-        for (let [key, value] of Object.entries(localStorage)) {
+    *getMany(filter, params) {
+        let entries = Object.entries(localStorage).sort(([a], [b]) => a.localeCompare(b));
+        if (params?.reverse) {
+            entries.reverse();
+        }
+        if (params?.limit !== undefined) {
+            entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
+        }
+        for (let [key, value] of entries) {
             if (key.startsWith(this.prefix)) {
                 key = key.slice(this.prefix.length);
             }
             const parts = fromString(key);
             if (Array.isArray(parts)) {
-                for (const [i, p] of prefix.entries()) {
-                    if (toString(p) != toString(parts[i])) {
+                if ("prefix" in filter) {
+                    for (const [i, p] of filter.prefix.entries()) {
+                        if (toString(p) != toString(parts[i])) {
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    if (!isInRange(parts, filter.start, filter.end)) {
                         continue;
                     }
-                    yield [parts, fromString(value)];
                 }
+                yield [parts, fromString(value)];
             }
         }
     }
@@ -56,4 +70,7 @@ export class StorageLocalStorage extends Storage {
             localStorage.removeItem(key);
         }
     }
+    incr(key, by) {
+        this.set(key, (this.get(key) || 0) + by);
+    }
 }

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

@@ -1,9 +1,14 @@
 import { MaybePromise } from "../1_utilities.js";
-import { Storage, StorageKeyPart } from "./0_storage.js";
+import { GetManyFilter, Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageMemory extends Storage implements Storage {
+    #private;
     protected map: Map<string, unknown>;
     init(): void;
     get<T>(key: readonly StorageKeyPart[]): NonNullable<T> | null;
-    getMany<T>(prefix: readonly StorageKeyPart[]): Generator<[readonly StorageKeyPart[], T], void, unknown>;
+    getMany<T>(filter: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }): Generator<[readonly StorageKeyPart[], T], void, unknown>;
     set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
+    incr(key: readonly StorageKeyPart[], by: number): void;
 }

package/esm/storage/1_storage_memory.js

@@ -1,8 +1,15 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StorageMemory_instances, _StorageMemory_getEntries;
 import { Storage } from "./0_storage.js";
-import { fromString, toString } from "./0_utilities.js";
+import { fromString, isInRange, toString } from "./0_utilities.js";
 export class StorageMemory extends Storage {
     constructor() {
         super(...arguments);
+        _StorageMemory_instances.add(this);
         Object.defineProperty(this, "map", {
             enumerable: true,
             configurable: true,
@@ -15,16 +22,30 @@ export class StorageMemory extends Storage {
     get(key) {
         return this.map.get(toString(key)) ?? null;
     }
-    *getMany(prefix) {
-        for (const [key, value] of this.map.entries()) {
+    *getMany(filter, params) {
+        let entries = __classPrivateFieldGet(this, _StorageMemory_instances, "m", _StorageMemory_getEntries).call(this);
+        if (params?.reverse) {
+            entries.reverse();
+        }
+        if (params?.limit !== undefined) {
+            entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
+        }
+        for (const [key, value] of entries) {
             const parts = fromString(key);
             if (Array.isArray(parts)) {
-                for (const [i, p] of prefix.entries()) {
-                    if (toString(p) != toString(parts[i])) {
+                if ("prefix" in filter) {
+                    for (const [i, p] of filter.prefix.entries()) {
+                        if (toString(p) != toString(parts[i])) {
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    if (!isInRange(parts, filter.start, filter.end)) {
                         continue;
                     }
-                    yield [parts, value];
                 }
+                yield [parts, value];
             }
         }
     }
@@ -37,4 +58,14 @@ export class StorageMemory extends Storage {
             this.map.delete(key);
         }
     }
+    incr(key, by) {
+        this.set(key, (this.get(key) || 0) + by);
+    }
 }
+_StorageMemory_instances = new WeakSet(), _StorageMemory_getEntries = function _StorageMemory_getEntries() {
+    const entries = new Array();
+    for (const entry of this.map.entries()) {
+        entries.push(entry);
+    }
+    return entries;
+};

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

@@ -1,10 +1,14 @@
 import { MaybePromise } from "../1_utilities.js";
-import { Storage, StorageKeyPart } from "./0_storage.js";
+import { GetManyFilter, Storage, StorageKeyPart } from "./0_storage.js";
 export declare class StorageSessionStorage extends Storage implements Storage {
     private readonly prefix;
     constructor(prefix: string);
     init(): void;
     get<T>(key_: readonly StorageKeyPart[]): T | null;
-    getMany<T>(prefix: readonly StorageKeyPart[]): Generator<[readonly StorageKeyPart[], T], void, unknown>;
+    getMany<T>(filter: GetManyFilter, params?: {
+        limit?: number;
+        reverse?: boolean;
+    }): Generator<[readonly StorageKeyPart[], T], void, unknown>;
     set(key_: readonly StorageKeyPart[], value: unknown): MaybePromise<void>;
+    incr(key: readonly StorageKeyPart[], by: number): void;
 }

package/esm/storage/1_storage_session_storage.js

@@ -1,5 +1,5 @@
 import { Storage } from "./0_storage.js";
-import { fromString, toString } from "./0_utilities.js";
+import { fromString, isInRange, toString } from "./0_utilities.js";
 export class StorageSessionStorage extends Storage {
     constructor(prefix) {
         if (typeof sessionStorage === "undefined") {
@@ -31,19 +31,33 @@ export class StorageSessionStorage extends Storage {
             return null;
         }
     }
-    *getMany(prefix) {
-        for (let [key, value] of Object.entries(localStorage)) {
+    *getMany(filter, params) {
+        let entries = Object.entries(sessionStorage).sort(([a], [b]) => a.localeCompare(b));
+        if (params?.reverse) {
+            entries.reverse();
+        }
+        if (params?.limit !== undefined) {
+            entries = entries.slice(0, params.limit <= 0 ? 1 : params.limit);
+        }
+        for (let [key, value] of entries) {
             if (key.startsWith(this.prefix)) {
                 key = key.slice(this.prefix.length);
             }
             const parts = fromString(key);
             if (Array.isArray(parts)) {
-                for (const [i, p] of prefix.entries()) {
-                    if (toString(p) != toString(parts[i])) {
+                if ("prefix" in filter) {
+                    for (const [i, p] of filter.prefix.entries()) {
+                        if (toString(p) != toString(parts[i])) {
+                            continue;
+                        }
+                    }
+                }
+                else {
+                    if (!isInRange(parts, filter.start, filter.end)) {
                         continue;
                     }
-                    yield [parts, fromString(value)];
                 }
+                yield [parts, fromString(value)];
             }
         }
     }
@@ -56,4 +70,7 @@ export class StorageSessionStorage extends Storage {
             sessionStorage.removeItem(key);
         }
     }
+    incr(key, by) {
+        this.set(key, (this.get(key) || 0) + by);
+    }
 }

package/esm/tl/0_tl_raw_writer.d.ts

@@ -6,6 +6,7 @@ export declare class TLRawWriter {
     writeInt24(int: number, signed?: boolean): this;
     writeInt32(int: number, signed?: boolean): this;
     writeInt64(int: bigint, signed?: boolean): this;
+    writeDouble(double: number): this;
     writeInt128(int: bigint, signed?: boolean): this;
     writeInt256(int: bigint, signed?: boolean): this;
     writeBytes(bytes: Uint8Array): this;

package/esm/tl/0_tl_raw_writer.js

@@ -27,6 +27,12 @@ export class TLRawWriter {
         this.write(bufferFromBigInt(int, 64 / 8, true, signed));
         return this;
     }
+    writeDouble(double) {
+        const buf = new Uint8Array(8);
+        new DataView(buf.buffer).setFloat64(0, double, true);
+        this.write(buf);
+        return this;
+    }
     writeInt128(int, signed = true) {
         this.write(bufferFromBigInt(int, 128 / 8, true, signed));
         return this;

package/esm/tl/1_tl_object.js

@@ -78,7 +78,12 @@ function serializeSingleParam(writer, value, type, ntype, debugInfo) {
             }
             //
             if (typeof value === "number") {
-                writer.writeInt32(value);
+                if (ntype == "double") {
+                    writer.writeDouble(value);
+                }
+                else {
+                    writer.writeInt32(value);
+                }
             }
             else {
                 throw new TypeError(`Expected number but received ${valueRepr} ${debugInfo}`);

package/esm/tl/3_deserialize.js

@@ -6,7 +6,7 @@ function deserializeSingleParam(reader, type, ntype) {
         const cid = reader.readInt32(false);
         const constructor = map.get(cid);
         if (!constructor) {
-            throw new Error(`Constructor with ID ${cid} not found`);
+            throw new Error(`Constructor with ID ${cid.toString(16)} not found`);
         }
         return deserialize(reader, constructor[paramDesc], constructor);
     }

package/esm/transport/0_transport.d.ts

@@ -1,12 +1,12 @@
 import { CTR, MaybePromise } from "../1_utilities.js";
 export declare abstract class Transport {
-    protected initialized: boolean;
     protected obfuscationParameters: {
         encryptionCTR: CTR;
         decryptionCTR: CTR;
     } | null;
     protected encrypt(buffer: Uint8Array): void;
     protected decrypt(buffer: Uint8Array): void;
+    abstract get initialized(): boolean;
     abstract initialize(): MaybePromise<void>;
     abstract receive(): MaybePromise<Uint8Array>;
     abstract send(buffer: Uint8Array): MaybePromise<void>;

package/esm/transport/0_transport.js

@@ -1,11 +1,5 @@
 export class Transport {
     constructor() {
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
         Object.defineProperty(this, "obfuscationParameters", {
             enumerable: true,
             configurable: true,

package/esm/transport/1_transport_abridged.d.ts

@@ -7,4 +7,5 @@ export declare class TransportAbridged extends Transport implements Transport {
     receive(): Promise<Uint8Array>;
     send(buffer: Uint8Array): Promise<void>;
     deinitialize(): void;
+    get initialized(): boolean;
 }