@mtkruto/node 0.1.303 → 0.1.500

package/esm/types/4_inline_query_result.js

@@ -18,9 +18,190 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { unreachable } from "../0_deps.js";
-import { types } from "../2_tl.js";
-import { deserializeFileId } from "./_file_id.js";
-import { replyMarkupToTlObject } from "./3_reply_markup.js";
+import { as, types } from "../2_tl.js";
+import { cleanObject } from "../1_utilities.js";
+import { deserializeFileId, FileType, getPhotoFileId, serializeFileId } from "./_file_id.js";
+import { constructMessageEntity } from "./0_message_entity.js";
+import { getPhotoSizes } from "./1_photo.js";
+import { constructReplyMarkup, replyMarkupToTlObject } from "./3_reply_markup.js";
+import { constructThumbnail } from "./0_thumbnail.js";
+export function constructInlineQueryResult(result) {
+    const id = result.id, title = result.title ?? "", type = result.type, description = result.description;
+    if (result.send_message instanceof types.BotInlineMessageMediaGeo) {
+        const geoPoint = result.send_message.geo;
+        return cleanObject({
+            type: "location",
+            id,
+            title,
+            latitude: geoPoint.lat,
+            longitude: geoPoint.long,
+            horizontalAccuracy: geoPoint.accuracy_radius,
+            livePeriod: result.send_message.period,
+            heading: result.send_message.heading,
+            proximityAlertRadius: result.send_message.proximity_notification_radius,
+        });
+    }
+    else if (result.send_message instanceof types.BotInlineMessageMediaVenue) {
+        const geoPoint = result.send_message.geo;
+        return cleanObject({
+            type: "venue",
+            id,
+            title,
+            latitude: geoPoint.lat,
+            longitude: geoPoint.long,
+            address: result.send_message.address,
+            foursquareId: result.send_message.venue_id,
+            foursquareType: result.send_message.venue_type,
+        });
+    }
+    else if (result.send_message instanceof types.BotInlineMessageMediaWebPage || result.send_message instanceof types.BotInlineMessageText) {
+        return cleanObject({
+            type: "article",
+            id,
+            title,
+            description,
+            messageContent: cleanObject({
+                messageText: result.send_message.message,
+                entities: (result.send_message.entities ?? []).map(constructMessageEntity).filter((v) => v != null),
+                linkPreview: result.send_message instanceof types.InputBotInlineMessageMediaWebPage ? { url: result.send_message.url, smallMedia: result.send_message.force_small_media, largeMedia: result.send_message.force_large_media, aboveText: result.send_message.invert_media } : undefined,
+            }),
+            replyMarkup: result.send_message.reply_markup ? constructReplyMarkup(result.send_message.reply_markup) : undefined,
+        });
+    }
+    else if (result.send_message instanceof types.BotInlineMessageMediaAuto) {
+        let ref;
+        let attributes;
+        const thumbnailUrl = "thumb" in result ? result.thumb?.url : undefined;
+        let photoSizes;
+        let photo;
+        if (result instanceof types.BotInlineMediaResult) {
+            if (result.photo) {
+                photo = result.photo[as](types.Photo);
+                ref = { fileId: getPhotoFileId(photo).fileId };
+                const { largest } = photoSizes = getPhotoSizes(photo);
+                attributes = [new types.DocumentAttributeImageSize({ w: largest.w, h: largest.h })];
+            }
+            else if (result.document) {
+                const document = result.document[as](types.Document);
+                ref = {
+                    fileId: serializeFileId({
+                        type: FileType.Document,
+                        dcId: document.dc_id,
+                        fileReference: document.file_reference,
+                        location: { type: "common", id: document.id, accessHash: document.access_hash },
+                    }),
+                };
+                attributes = document.attributes;
+            }
+            else {
+                unreachable();
+            }
+        }
+        else if (result.content) {
+            ref = { url: result.content.url };
+            attributes = result.content.attributes;
+        }
+        else {
+            unreachable();
+        }
+        const messageContent = result.send_message.message
+            ? {
+                messageText: result.send_message.message,
+                entities: (result.send_message.entities ?? []).map(constructMessageEntity).filter((v) => v != null),
+            }
+            : undefined;
+        const replyMarkup = result.send_message.reply_markup ? constructReplyMarkup(result.send_message.reply_markup) : undefined;
+        switch (type) {
+            case "audio": {
+                const a = attributes?.find((v) => v instanceof types.DocumentAttributeAudio);
+                return cleanObject({
+                    id,
+                    type,
+                    title,
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    performer: a?.performer,
+                    audioDuration: a?.duration,
+                });
+            }
+            case "gif":
+            case "mpeg4Gif": {
+                const a = attributes.find((v) => v instanceof types.DocumentAttributeVideo);
+                return cleanObject({
+                    id,
+                    type,
+                    title,
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    thumbnailUrl,
+                    width: a?.w,
+                    height: a?.h,
+                    duration: a?.duration,
+                });
+            }
+            case "photo": {
+                const a = attributes.find((v) => v instanceof types.DocumentAttributeImageSize);
+                return cleanObject({
+                    id,
+                    type,
+                    title,
+                    description,
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    thumbnailUrl: thumbnailUrl,
+                    thumbnails: photo ? photoSizes?.sizes.slice(0, -1).map((v) => constructThumbnail(v, photo)) : undefined,
+                    width: a?.w,
+                    height: a?.h,
+                });
+            }
+            case "video": {
+                const a = attributes.find((v) => v instanceof types.DocumentAttributeVideo);
+                return cleanObject({
+                    id,
+                    type,
+                    title,
+                    description,
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    mimeType: "content" in result && result.content ? result.content.mime_type : "video/mp4",
+                    thumbnailUrl: thumbnailUrl,
+                    width: a?.w,
+                    height: a?.h,
+                    videoDuration: a?.duration,
+                });
+            }
+            case "voice": {
+                const a = attributes.find((v) => v instanceof types.DocumentAttributeAudio);
+                return cleanObject({
+                    id,
+                    type,
+                    title,
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    thumbnailUrl,
+                    voiceDuration: a?.duration,
+                });
+            }
+            case "document":
+            case "file": // Does it really return this?
+                return cleanObject({
+                    type: "document",
+                    id,
+                    title: result.title ?? "",
+                    ...ref,
+                    messageContent,
+                    replyMarkup,
+                    thumbnailUrl,
+                });
+        }
+    }
+    unreachable();
+}
 // deno-lint-ignore no-explicit-any
 export async function inlineQueryResultToTlObject(result_, parseText, usernameResolver) {
     let document = null;
@@ -28,9 +209,9 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
     let fileId_ = null;
     switch (result_.type) {
         case "audio":
-            if ("audioUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.audioUrl,
+                    url: result_.url,
                     size: 0,
                     mime_type: "audio/mpeg",
                     attributes: [
@@ -43,101 +224,101 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
                 });
             }
             else {
-                fileId_ = result_.audioFileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "video":
-            if ("videoUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.videoUrl,
+                    url: result_.url,
                     size: 0,
                     mime_type: result_.mimeType ?? "video/mp4",
                     attributes: [
                         new types.DocumentAttributeVideo({
                             duration: result_.videoDuration ?? 0,
-                            h: result_.videoHeight ?? 0,
-                            w: result_.videoWidth ?? 0,
+                            h: result_.height ?? 0,
+                            w: result_.width ?? 0,
                         }),
                     ],
                 });
             }
             else {
-                fileId_ = result_.videoFileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "document":
-            if ("documentUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.documentUrl,
+                    url: result_.url,
                     mime_type: "application/octet-stream",
                     attributes: [],
                     size: 0,
                 });
             }
             else {
-                fileId_ = result_.documentFileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "gif":
-            if ("gifUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.gifUrl,
+                    url: result_.url,
                     size: 0,
                     mime_type: "image/gif",
                     attributes: [
                         new types.DocumentAttributeVideo({
-                            duration: result_.gifDuration ?? 0,
-                            h: result_.gifHeight ?? 0,
-                            w: result_.gifWidth ?? 0,
+                            duration: result_.duration ?? 0,
+                            w: result_.width ?? 0,
+                            h: result_.height ?? 0,
                         }),
                     ],
                 });
             }
             else {
-                fileId_ = result_.gifFileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "mpeg4Gif":
-            if ("mpeg4Url" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.mpeg4Url,
+                    url: result_.url,
                     size: 0,
                     mime_type: "video/mp4",
                     attributes: [
                         new types.DocumentAttributeVideo({
                             nosound: true,
-                            duration: result_.mpeg4Duration ?? 0,
-                            w: result_.mpeg4Width ?? 0,
-                            h: result_.mpeg4Height ?? 0,
+                            duration: result_.duration ?? 0,
+                            w: result_.width ?? 0,
+                            h: result_.height ?? 0,
                             supports_streaming: true,
                         }),
                     ],
                 });
             }
             else {
-                fileId_ = result_.mpeg4FileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "photo":
-            if ("photoUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.photoUrl,
+                    url: result_.url,
                     size: 0,
                     mime_type: "image/jpeg",
-                    attributes: [new types.DocumentAttributeImageSize({ w: result_.photoWidth ?? 0, h: result_.photoHeight ?? 0 })],
+                    attributes: [new types.DocumentAttributeImageSize({ w: result_.width ?? 0, h: result_.height ?? 0 })],
                 });
             }
             else {
-                fileId_ = result_.photoFileId;
+                fileId_ = result_.fileId;
             }
             break;
         case "sticker":
-            fileId_ = result_.stickerFileId;
+            fileId_ = result_.fileId;
             break;
         case "voice":
-            if ("voiceUrl" in result_) {
+            if ("url" in result_) {
                 document = new types.InputWebDocument({
-                    url: result_.voiceUrl,
+                    url: result_.url,
                     size: 0,
                     mime_type: "audio/mpeg",
                     attributes: [
@@ -149,7 +330,7 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
                 });
             }
             else {
-                fileId_ = result_.voiceFileId;
+                fileId_ = result_.fileId;
             }
             break;
     }
@@ -241,18 +422,18 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
         });
     }
     else if (result_.type == "article") {
-        if (!("messageText" in result_.inputMessageContent)) {
+        if (!("messageText" in result_.messageContent)) {
             unreachable();
         }
-        const [message, entities] = await parseText(result_.inputMessageContent.messageText, { entities: result_.inputMessageContent.entities, parseMode: result_.inputMessageContent.parseMode });
-        const noWebpage = result_.inputMessageContent?.linkPreview?.disable ? true : undefined;
-        const invertMedia = result_.inputMessageContent?.linkPreview?.aboveText ? true : undefined;
+        const [message, entities] = await parseText(result_.messageContent.messageText, { entities: result_.messageContent.entities, parseMode: result_.messageContent.parseMode });
+        const noWebpage = result_.messageContent?.linkPreview?.disable ? true : undefined;
+        const invertMedia = result_.messageContent?.linkPreview?.aboveText ? true : undefined;
         let sendMessage;
-        if (result_.inputMessageContent.linkPreview?.url) {
+        if (result_.messageContent.linkPreview?.url) {
             sendMessage = new types.InputBotInlineMessageMediaWebPage({
-                url: result_.inputMessageContent.linkPreview.url,
-                force_large_media: result_.inputMessageContent.linkPreview.largeMedia ? true : undefined,
-                force_small_media: result_.inputMessageContent.linkPreview.smallMedia ? true : undefined,
+                url: result_.messageContent.linkPreview.url,
+                force_large_media: result_.messageContent.linkPreview.largeMedia ? true : undefined,
+                force_small_media: result_.messageContent.linkPreview.smallMedia ? true : undefined,
                 optional: message.length ? undefined : true,
                 message,
                 entities,
@@ -279,7 +460,7 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
         });
     }
     else if (result_.type == "venue") {
-        if (!result_.fourSquareId || !result_.foursquareType) {
+        if (!result_.foursquareId || !result_.foursquareType) {
             unreachable();
         }
         return new types.InputBotInlineResult({
@@ -293,7 +474,7 @@ export async function inlineQueryResultToTlObject(result_, parseText, usernameRe
                 address: result_.address,
                 provider: "foursquare",
                 title: result_.title,
-                venue_id: result_.fourSquareId,
+                venue_id: result_.foursquareId,
                 venue_type: result_.foursquareType,
                 reply_markup: replyMarkup,
             }),

package/esm/types/5_inline_query_answer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { types } from "../2_tl.js";
+import { InlineQueryResult } from "./4_inline_query_result.js";
+/** An answer to an inline query. */
+export interface InlineQueryAnswer {
+    /** The ID of the inline query that yielded these results. */
+    id: string;
+    /** The inline query results. */
+    results: InlineQueryResult[];
+    /** A parameter that can be passed to next queries with the same text to yield more results. */
+    nextOffset?: string;
+}
+export declare function constructInlineQueryAnswer(results: types.messages.BotResults): InlineQueryAnswer;

package/esm/types/5_inline_query_answer.js

@@ -0,0 +1,28 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { cleanObject } from "../1_utilities.js";
+import { constructInlineQueryResult } from "./4_inline_query_result.js";
+export function constructInlineQueryAnswer(results) {
+    return cleanObject({
+        id: results.query_id + "",
+        results: results.results.map(constructInlineQueryResult),
+        nextOffset: results.next_offset,
+    });
+}

package/esm/types/_file_id.d.ts

@@ -17,6 +17,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
+import { types } from "../2_tl.js";
 export declare enum FileType {
     Thumbnail = 0,
     ProfilePhoto = 1,
@@ -118,4 +119,8 @@ export interface FileId {
 export declare function deserializeFileId(fileId: string): FileId;
 export declare function serializeFileId(fileId: FileId): string;
 export declare function toUniqueFileId(fileId: FileId): string;
+export declare function getPhotoFileId(photo: types.Photo): {
+    fileId: string;
+    fileUniqueId: string;
+};
 export {};

package/esm/types/_file_id.js

@@ -20,7 +20,7 @@
 import { unreachable } from "../0_deps.js";
 import { InputError } from "../0_errors.js";
 import { base64DecodeUrlSafe, base64EncodeUrlSafe, rleDecode, rleEncode } from "../1_utilities.js";
-import { TLReader, TLWriter } from "../2_tl.js";
+import { TLReader, TLWriter, types } from "../2_tl.js";
 const NEXT_VERSION = 53;
 const PERSISTENT_ID_VERSION = 4;
 const WEB_LOCATION_FLAG = 1 << 24;
@@ -321,3 +321,34 @@ export function toUniqueFileId(fileId) {
     }
     return base64EncodeUrlSafe(rleEncode(writer.buffer));
 }
+export function getPhotoFileId(photo) {
+    const sizes = photo.sizes
+        .map((v) => {
+        if (v instanceof types.PhotoSizeProgressive) {
+            return new types.PhotoSize({ type: v.type, w: v.w, h: v.h, size: Math.max(...v.sizes) });
+        }
+        else {
+            return v;
+        }
+    })
+        .filter((v) => v instanceof types.PhotoSize)
+        .sort((a, b) => a.size - b.size);
+    const largest = sizes.slice(-1)[0];
+    const { dc_id: dcId, id, access_hash: accessHash, file_reference: fileReference } = photo;
+    const fileId = {
+        type: FileType.Photo,
+        dcId,
+        fileReference,
+        location: {
+            type: "photo",
+            id,
+            accessHash,
+            source: {
+                type: PhotoSourceType.Thumbnail,
+                fileType: FileType.Photo,
+                thumbnailType: largest.type.charCodeAt(0),
+            },
+        },
+    };
+    return { fileId: serializeFileId(fileId), fileUniqueId: toUniqueFileId(fileId) };
+}

package/esm/utilities/0_buffer.d.ts

@@ -17,5 +17,4 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-export declare function concat(...buffers: [Uint8Array, Uint8Array, ...Uint8Array[]]): Uint8Array;
 export declare function bufferFromBigInt(int: bigint | number, byteCount: number, littleEndian?: boolean, signed?: boolean): Uint8Array;

package/esm/utilities/0_buffer.js

@@ -17,19 +17,6 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-export function concat(...buffers) {
-    let length = 0;
-    for (const b of buffers) {
-        length += b.length;
-    }
-    const buffer = new Uint8Array(length);
-    let offset = 0;
-    for (const b of buffers) {
-        buffer.set(b, offset);
-        offset += b.length;
-    }
-    return buffer;
-}
 const bufferFromHexString = (hexString) => Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
 export function bufferFromBigInt(int, byteCount, littleEndian = true, signed = false) {
     const actualByteCount = Math.ceil(int.toString(2).length / 8);

package/esm/utilities/0_crypto.d.ts

@@ -18,9 +18,9 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 export declare class CTR {
-    readonly key: Uint8Array;
-    iv: Uint8Array;
-    state: Uint8Array;
+    #private;
     constructor(key: Uint8Array, iv: Uint8Array);
+    /** This must not be called after destroying. */
     call(data: Uint8Array): void;
+    destroy(): void;
 }

package/esm/utilities/0_crypto.js

@@ -17,29 +17,32 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { ctr256 } from "../0_deps.js";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+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 _CTR_key, _CTR_state;
+import { createCtr256State, ctr256, destroyCtr256State } from "../0_deps.js";
 export class CTR {
     constructor(key, iv) {
-        Object.defineProperty(this, "key", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: key
-        });
-        Object.defineProperty(this, "iv", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: iv
-        });
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Uint8Array(1)
-        });
+        _CTR_key.set(this, void 0);
+        _CTR_state.set(this, void 0);
+        __classPrivateFieldSet(this, _CTR_state, createCtr256State(iv), "f");
+        __classPrivateFieldSet(this, _CTR_key, key, "f");
     }
+    /** This must not be called after destroying. */
     call(data) {
-        ctr256(data, this.key, this.iv, this.state);
+        ctr256(data, __classPrivateFieldGet(this, _CTR_key, "f"), __classPrivateFieldGet(this, _CTR_state, "f"));
+    }
+    destroy() {
+        destroyCtr256State(__classPrivateFieldGet(this, _CTR_state, "f"));
     }
 }
+_CTR_key = new WeakMap(), _CTR_state = new WeakMap();

package/esm/utilities/0_part_stream.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+export interface Part {
+    small: boolean;
+    part: number;
+    totalParts: number;
+    bytes: Uint8Array;
+}
+export declare class PartStream extends TransformStream<Uint8Array, Part> {
+    #private;
+    constructor(chunkSize: number);
+}