@mtkruto/node 0.1.125 → 0.1.127

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 {
@@ -72,17 +72,39 @@ export class StorageIndexedDB extends Storage {
             };
         });
     }
-    async *getMany(prefix, tx_) {
+    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 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) {

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

@@ -1,10 +1,13 @@
-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>;
+    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)];
             }
         }
     }

package/esm/storage/1_storage_memory.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 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];
             }
         }
     }
@@ -41,3 +62,10 @@ export class StorageMemory extends Storage {
         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,11 +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)];
             }
         }
     }

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/types/{1_chat.d.ts → 1_chat_p.d.ts}

@@ -1,7 +1,7 @@
 import { types } from "../2_tl.js";
 import { RestrictionReason } from "./0_restriction_reason.js";
 export type ChatType = "private" | "group" | "supergroup" | "channel";
-export declare namespace Chat {
+export declare namespace ChatP {
     interface Base {
         /** The identifier of the chat. */
         id: number;
@@ -66,7 +66,7 @@ export declare namespace Chat {
     }
 }
 /** This object represents a chat. */
-export type Chat = Chat.Private | Chat.Group | Chat.Supergroup | Chat.Channel;
-export declare function constructChat(chat: types.User): Chat.Private;
-export declare function constructChat(chat: types.Chat): Chat.Group;
-export declare function constructChat(chat: types.Channel): Chat.Supergroup | Chat.Channel;
+export type ChatP = ChatP.Private | ChatP.Group | ChatP.Supergroup | ChatP.Channel;
+export declare function constructChatP(chat: types.User): ChatP.Private;
+export declare function constructChatP(chat: types.Chat): ChatP.Group;
+export declare function constructChatP(chat: types.Channel): ChatP.Supergroup | ChatP.Channel;

package/esm/types/{1_chat.js → 1_chat_p.js}

@@ -1,7 +1,7 @@
 import { cleanObject, getColorFromPeerId, UNREACHABLE, ZERO_CHANNEL_ID } from "../1_utilities.js";
 import { types } from "../2_tl.js";
 import { constructRestrictionReason } from "./0_restriction_reason.js";
-export function constructChat(chat) {
+export function constructChatP(chat) {
     if (chat instanceof types.User) {
         const id = Number(chat.id);
         const chat_ = {

package/esm/types/3_message.d.ts

@@ -11,7 +11,7 @@ import { Venue } from "./0_venue.js";
 import { Voice } from "./0_voice.js";
 import { EntityGetter } from "./1__getters.js";
 import { Animation } from "./1_animation.js";
-import { Chat } from "./1_chat.js";
+import { ChatP } from "./1_chat_p.js";
 import { Document } from "./1_document.js";
 import { Photo } from "./1_photo.js";
 import { Poll } from "./1_poll.js";
@@ -33,17 +33,17 @@ export interface Message {
     /** Sender of the message; empty for messages sent to channels. For backward compatibility, the field contains a fake sender user in non-channel chats, if the message was sent on behalf of a chat. */
     from?: User;
     /** Sender of the message, sent on behalf of a chat. For example, the channel itself for channel posts, the supergroup itself for messages from anonymous group administrators, the linked channel for messages automatically forwarded to the discussion group. For backward compatibility, the field from contains a fake sender user in non-channel chats, if the message was sent on behalf of a chat. */
-    senderChat?: Chat;
+    senderChat?: ChatP;
     /** Date the message was sent in Unix time */
-    date?: Date;
+    date: Date;
     /** Conversation the message belongs to */
-    chat: Chat;
+    chat: ChatP;
     /** A link to the message */
     link?: string;
     /** For forwarded messages, sender of the original message */
     forwardFrom?: User;
     /** For messages forwarded from channels or from anonymous administrators, information about the original sender chat */
-    forwardFromChat?: Chat;
+    forwardFromChat?: ChatP;
     /** For messages forwarded from channels, identifier of the original message in the channel */
     forwardId?: number;
     /** For forwarded messages that were originally sent in channels or by an anonymous chat administrator, signature of the message sender if present */
@@ -58,6 +58,7 @@ export interface Message {
     isAutomaticForward?: boolean;
     /** For replies, the original message. Note that the Message object in this field will not contain further reply_to_message fields even if it itself is a reply. */
     replyToMessage?: Omit<Message, "replyToMessage">;
+    replyToMessageId?: number;
     /** Bot through which the message was sent */
     viaBot?: User;
     /** Date the message was last edited in Unix time */
@@ -172,8 +173,8 @@ export interface Message {
     };
 }
 export interface MessageGetter<O extends keyof Message | null = null> {
-    (chatId: number, messageId: number): MaybePromise<(O extends null ? Message : Omit<Message, "replyToMessage">) | null>;
+    (chatId: number, messageId: number): MaybePromise<(O extends keyof Message ? Omit<Message, O> : Message) | null>;
 }
 type Message_MessageGetter = MessageGetter<"replyToMessage"> | null;
-export declare function constructMessage(message_: enums.Message, getEntity: EntityGetter, getMessage: Message_MessageGetter, getStickerSetName: StickerSetNameGetter): Promise<Message>;
+export declare function constructMessage(message_: enums.Message, getEntity: EntityGetter, getMessage: Message_MessageGetter, getStickerSetName: StickerSetNameGetter, getReply_?: boolean): Promise<Message>;
 export {};

package/esm/types/3_message.js

@@ -12,7 +12,7 @@ import { constructReplyKeyboardRemove } from "./0_reply_keyboard_remove.js";
 import { constructVenue } from "./0_venue.js";
 import { constructVoice } from "./0_voice.js";
 import { constructAnimation } from "./1_animation.js";
-import { constructChat } from "./1_chat.js";
+import { constructChatP } from "./1_chat_p.js";
 import { constructDocument } from "./1_document.js";
 import { constructPhoto } from "./1_photo.js";
 import { constructPoll } from "./1_poll.js";
@@ -37,7 +37,7 @@ async function getSender(message_, getEntity) {
     else if (message_.from_id instanceof types.PeerChannel) {
         const entity = await getEntity(message_.from_id);
         if (entity) {
-            return { senderChat: constructChat(entity) };
+            return { senderChat: constructChatP(entity) };
         }
         else {
             UNREACHABLE();
@@ -181,7 +181,7 @@ async function constructServiceMessage(message_, chat, getEntity, getMessage) {
     }
     return cleanObject(message);
 }
-export async function constructMessage(message_, getEntity, getMessage, getStickerSetName) {
+export async function constructMessage(message_, getEntity, getMessage, getStickerSetName, getReply_ = true) {
     if (!(message_ instanceof types.Message) && !(message_ instanceof types.MessageService)) {
         UNREACHABLE();
     }
@@ -190,7 +190,7 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
     if (message_.peer_id instanceof types.PeerUser) {
         const entity = await getEntity(message_.peer_id);
         if (entity) {
-            chat_ = constructChat(entity);
+            chat_ = constructChatP(entity);
         }
         else {
             UNREACHABLE();
@@ -199,7 +199,7 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
     else if (message_.peer_id instanceof types.PeerChat) {
         const entity = await getEntity(message_.peer_id);
         if (entity) {
-            chat_ = constructChat(entity);
+            chat_ = constructChatP(entity);
         }
         else {
             UNREACHABLE();
@@ -209,7 +209,7 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
         link = `https://t.me/c/${message_.peer_id.channel_id}/${message_.id}`;
         const entity = await getEntity(message_.peer_id);
         if (entity) {
-            chat_ = constructChat(entity);
+            chat_ = constructChatP(entity);
         }
         else {
             UNREACHABLE();
@@ -231,7 +231,12 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
         isTopicMessage: false,
         hasProtectedContent: message_.noforwards || false,
     };
-    Object.assign(message, await getReply(message_, chat_, getMessage));
+    if (message_.reply_to instanceof types.MessageReplyHeader && message_.reply_to.reply_to_msg_id) {
+        message.replyToMessageId = message_.reply_to.reply_to_msg_id;
+    }
+    if (getReply_) {
+        Object.assign(message, await getReply(message_, chat_, getMessage));
+    }
     Object.assign(message, await getSender(message_, getEntity));
     if (message_.media instanceof types.MessageMediaPhoto || message_.media instanceof types.MessageMediaDocument) {
         message.hasMediaSpoiler = message_.media.spoiler || false;
@@ -292,32 +297,23 @@ export async function constructMessage(message_, getEntity, getMessage, getStick
         message.forwardSenderName = message_.fwd_from.from_name;
         message.forwardId = message_.fwd_from.channel_post;
         message.forwardSignature = message_.fwd_from.post_author;
-        message.forwardDate = new Date(message_.date * 1000);
+        message.forwardDate = new Date(message_.fwd_from.date * 1000);
         if (message_.fwd_from.from_id instanceof types.PeerUser) {
             const entity = await getEntity(message_.fwd_from.from_id);
             if (entity) {
                 message.forwardFrom = constructUser(entity);
             }
-            else {
-                UNREACHABLE();
-            }
         }
         else if (message_.fwd_from.from_id instanceof types.PeerChat) {
             const entity = await getEntity(message_.fwd_from.from_id);
             if (entity) {
-                message.forwardFromChat = constructChat(entity);
-            }
-            else {
-                UNREACHABLE();
+                message.forwardFromChat = constructChatP(entity);
             }
         }
         else if (message_.fwd_from.from_id instanceof types.PeerChannel) {
             const entity = await getEntity(message_.fwd_from.from_id);
             if (entity) {
-                message.forwardFromChat = constructChat(entity);
-            }
-            else {
-                UNREACHABLE();
+                message.forwardFromChat = constructChatP(entity);
             }
         }
     }

package/esm/types/4_chat.d.ts

@@ -0,0 +1,33 @@
+import { enums, types } from "../2_tl.js";
+import { ChatP } from "./1_chat_p.js";
+import { ChatPhoto } from "./0_chat_photo.js";
+import { Message, MessageGetter } from "./3_message.js";
+import { StickerSetNameGetter } from "./1_sticker.js";
+import { EntityGetter } from "./1__getters.js";
+export declare namespace Chat {
+    interface Base {
+        order: string;
+        lastMessage?: Message;
+        pinned: number;
+    }
+    interface Channel extends Base, ChatP.Channel {
+        also?: string[];
+        photo?: ChatPhoto.Chat;
+    }
+    interface Supergroup extends Base, ChatP.Supergroup {
+        also?: string[];
+        photo?: ChatPhoto.Chat;
+    }
+    interface Group extends Base, ChatP.Group {
+        photo?: ChatPhoto.Chat;
+    }
+    interface Private extends Base, ChatP.Private {
+        also?: string[];
+        photo?: ChatPhoto.User;
+    }
+}
+export type Chat = Chat.Channel | Chat.Supergroup | Chat.Group | Chat.Private;
+export declare function getChatOrder(lastMessage: Message | undefined, pinned: number): string;
+export declare function constructChat(dialog: enums.Dialog, dialogs: types.messages.Dialogs | types.messages.DialogsSlice, pinnedChats: number[], getEntity: EntityGetter, getMessage: MessageGetter<"replyToMessage">, getStickerSetName: StickerSetNameGetter): Promise<Chat>;
+export declare function constructChat2(chatId: number, pinned: number, lastMessage: Message | undefined, getEntity: EntityGetter): Promise<Chat | null>;
+export declare function constructChat3(chatId: number, pinned: number, lastMessageId: number, getEntity: EntityGetter, getMessage: MessageGetter<"replyToMessage">): Promise<Chat | null>;

package/esm/types/4_chat.js

@@ -0,0 +1,117 @@
+import { cleanObject, UNREACHABLE, ZERO_CHANNEL_ID } from "../1_utilities.js";
+import { peerToChatId, types } from "../2_tl.js";
+import { constructChatP } from "./1_chat_p.js";
+import { constructChatPhoto } from "./0_chat_photo.js";
+import { constructMessage } from "./3_message.js";
+function getChatPAlsoPhoto(entity) {
+    let chatP;
+    let also = undefined;
+    if (entity instanceof types.User) {
+        chatP = constructChatP(entity);
+        also = "usernames" in entity ? entity.usernames?.map((v) => v.username).filter((v) => v != ("username" in chatP ? chatP.username : "")) : undefined;
+    }
+    else if (entity instanceof types.Chat) {
+        chatP = constructChatP(entity);
+    }
+    else if (entity instanceof types.Channel) {
+        chatP = constructChatP(entity);
+        also = "usernames" in entity ? entity.usernames?.map((v) => v.username).filter((v) => v != ("username" in chatP ? chatP.username : "")) : undefined;
+    }
+    else {
+        UNREACHABLE();
+    }
+    let photo = undefined;
+    if (entity.photo instanceof types.UserProfilePhoto) {
+        photo = constructChatPhoto(entity.photo, chatP.id, "access_hash" in entity ? entity.access_hash ?? 0n : 0n);
+    }
+    else if (entity.photo instanceof types.ChatPhoto) {
+        photo = constructChatPhoto(entity.photo, chatP.id, "access_hash" in entity ? entity.access_hash ?? 0n : 0n);
+    }
+    return { chatP, also, photo };
+}
+export function getChatOrder(lastMessage, pinned) {
+    const p = pinned == -1 ? "" : `P${100 - pinned}`;
+    if (!lastMessage) {
+        return p + "0";
+    }
+    return p + String((BigInt(Math.floor(lastMessage.date.getTime())) << 32n) + BigInt(lastMessage.id));
+}
+export async function constructChat(dialog, dialogs, pinnedChats, getEntity, getMessage, getStickerSetName) {
+    const topMessage_ = dialogs.messages.find((v) => "id" in v && v.id == dialog.top_message);
+    if (!topMessage_) {
+        UNREACHABLE();
+    }
+    const pinned = pinnedChats.indexOf(peerToChatId(dialog.peer));
+    const lastMessage = await constructMessage(topMessage_, getEntity, getMessage, getStickerSetName, false);
+    const order = getChatOrder(lastMessage, pinned);
+    const userId = "user_id" in dialog.peer ? dialog.peer.user_id : null;
+    const chatId = "chat_id" in dialog.peer ? dialog.peer.chat_id : null;
+    const channelId = "channel_id" in dialog.peer ? dialog.peer.channel_id : null;
+    const chat__ = chatId != null ? dialogs.chats.find((v) => v instanceof types.Chat && v.id == chatId) : channelId != null ? dialogs.chats.find((v) => v instanceof types.Channel && v.id == channelId) : userId != null ? dialogs.users.find((v) => v instanceof types.User && v.id == userId) : UNREACHABLE();
+    if (!chat__) {
+        UNREACHABLE();
+    }
+    const chat_ = chat__;
+    const { chatP, also, photo } = getChatPAlsoPhoto(chat_);
+    if (chatP.type == "group") {
+        return cleanObject({ ...chatP, order, lastMessage, photo, pinned });
+    }
+    else if (chatP.type == "supergroup") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo, pinned });
+    }
+    else if (chatP.type == "channel") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo, pinned });
+    }
+    else if (chatP.type == "private") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo: photo, pinned });
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export async function constructChat2(chatId, pinned, lastMessage, getEntity) {
+    let chatPAlsoPhoto = null;
+    if (chatId < ZERO_CHANNEL_ID) {
+        const entity = await getEntity(new types.PeerChannel({ channel_id: BigInt(Math.abs(chatId - ZERO_CHANNEL_ID)) }));
+        if (entity != null) {
+            chatPAlsoPhoto = getChatPAlsoPhoto(entity);
+        }
+    }
+    else if (chatId < 0) {
+        const entity = await getEntity(new types.PeerChat({ chat_id: BigInt(Math.abs(chatId)) }));
+        if (entity != null) {
+            chatPAlsoPhoto = getChatPAlsoPhoto(entity);
+        }
+    }
+    else {
+        const entity = await getEntity(new types.PeerUser({ user_id: BigInt(chatId) }));
+        if (entity != null) {
+            chatPAlsoPhoto = getChatPAlsoPhoto(entity);
+        }
+    }
+    if (chatPAlsoPhoto == null) {
+        return null;
+    }
+    const order = getChatOrder(lastMessage, pinned);
+    const { also, photo, chatP } = chatPAlsoPhoto;
+    if (chatP.type == "group") {
+        return cleanObject({ ...chatP, order, lastMessage, photo, pinned });
+    }
+    else if (chatP.type == "supergroup") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo, pinned });
+    }
+    else if (chatP.type == "channel") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo, pinned });
+    }
+    else if (chatP.type == "private") {
+        return cleanObject({ ...chatP, order, lastMessage, also, photo: photo, pinned });
+    }
+    else {
+        UNREACHABLE();
+    }
+}
+export async function constructChat3(chatId, pinned, lastMessageId, getEntity, getMessage) {
+    const lastMessage_ = lastMessageId > 0 ? await getMessage(chatId, lastMessageId) : null;
+    const lastMessage = lastMessage_ == null ? undefined : lastMessage_;
+    return await constructChat2(chatId, pinned, lastMessage, getEntity);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtkruto/node",
-  "version": "0.1.125",
+  "version": "0.1.127",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "repository": {