@mtkruto/node 0.1.303 → 0.1.500

package/esm/deps/deno.land/x/{tgcrypto@0.4.0 → tgcrypto@0.4.1}/mod.js

@@ -6,16 +6,16 @@ export async function init() {
     await promise;
 }
 function checkIgeParams(data, key, iv) {
-    if (data.length == 0) {
+    if (data.byteLength == 0) {
         throw new TypeError("data must not be empty");
     }
-    else if (data.length % 16 != 0) {
+    else if (data.byteLength % 16 != 0) {
         throw new TypeError("data must consist of a number of bytes that is divisible by 16");
     }
-    else if (key.length != 32) {
+    else if (key.byteLength != 32) {
         throw new TypeError("key must be 32 bytes");
     }
-    else if (iv.length != 32) {
+    else if (iv.byteLength != 32) {
         throw new TypeError("iv must be 32 bytes");
     }
 }
@@ -28,12 +28,12 @@ function checkIgeParams(data, key, iv) {
  */
 export function ige256Encrypt(data, key, iv) {
     checkIgeParams(data, key, iv);
-    const out = module_._malloc(data.length);
-    const datap = module_._malloc(data.length);
+    const out = module_._malloc(data.byteLength);
+    const datap = module_._malloc(data.byteLength);
     module_.HEAPU8.set(data, datap);
-    module_.ccall("ige256_encrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    module_.ccall("ige256_encrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.byteLength, key, iv]);
     try {
-        return module_.HEAPU8.slice(out, out + data.length);
+        return module_.HEAPU8.slice(out, out + data.byteLength);
     }
     finally {
         module_._free(out);
@@ -49,31 +49,53 @@ export function ige256Encrypt(data, key, iv) {
  */
 export function ige256Decrypt(data, key, iv) {
     checkIgeParams(data, key, iv);
-    const out = module_._malloc(data.length);
-    const datap = module_._malloc(data.length);
+    const out = module_._malloc(data.byteLength);
+    const datap = module_._malloc(data.byteLength);
     module_.HEAPU8.set(data, datap);
-    module_.ccall("ige256_decrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.length, key, iv]);
+    module_.ccall("ige256_decrypt", "void", ["pointer", "pointer", "number", "array", "array"], [datap, out, data.byteLength, key, iv]);
     try {
-        return module_.HEAPU8.slice(out, out + data.length);
+        return module_.HEAPU8.slice(out, out + data.byteLength);
     }
     finally {
         module_._free(out);
         module_._free(datap);
     }
 }
-function checkCtrParams(data, key, iv, state) {
-    if (data.length == 0) {
+function checkCtrParams(data, key) {
+    if (data.byteLength == 0) {
         throw new TypeError("data must not be empty");
     }
-    else if (key.length != 32) {
+    else if (key.byteLength != 32) {
         throw new TypeError("key must be 32 bytes");
     }
-    else if (iv.length != 16) {
+}
+export function createCtr256State(iv) {
+    if (iv.byteLength != 16) {
         throw new TypeError("iv must be 16 bytes");
     }
-    else if (state.length != 1) {
-        throw new TypeError("state must be 1 byte");
+    const state = {
+        ivp: module_._malloc(16),
+        statep: module_._malloc(1),
+    };
+    module_.HEAPU8.set(iv, state.ivp);
+    module_.HEAPU8[state.statep] = 0;
+    return state;
+}
+export function destroyCtr256State(state) {
+    module_._free(state.ivp);
+    module_._free(state.statep);
+}
+export function __getCtr256StateValues(state) {
+    return {
+        iv: module_.HEAPU8.slice(state.ivp, state.ivp + 16),
+        state: module_.HEAPU8.slice(state.statep, state.statep + 1),
+    };
+}
+export function __settCtr256StateState(state, state_) {
+    if (state_.byteLength != 1) {
+        throw new Error("state_ must be 1 byte");
     }
+    module_.HEAPU8.set(state_, state.statep);
 }
 /**
  * Performs CTR-256 encryption/decryption.
@@ -81,35 +103,27 @@ function checkCtrParams(data, key, iv, state) {
  * @param data The data, larger than a byte
  * @param key 32-byte encryption key
  * @param iv 16-byte initialization vector
- * @param state 1-byte state
+ * @param state Result of `createCtr256State()`
  */
-export function ctr256(data, key, iv, state) {
-    checkCtrParams(data, key, iv, state);
-    const datap = module_._malloc(data.length);
+export function ctr256(data, key, state) {
+    checkCtrParams(data, key);
+    const datap = module_._malloc(data.byteLength);
     module_.HEAPU8.set(data, datap);
-    const ivp = module_._malloc(iv.length);
-    module_.HEAPU8.set(iv, ivp);
-    const statep = module_._malloc(state.length);
-    module_.HEAPU8.set(state, statep);
-    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.length, key, ivp, statep]);
-    data.set(module_.HEAPU8.slice(datap, datap + data.length));
-    iv.set(module_.HEAPU8.slice(ivp, ivp + iv.length));
-    state.set(module_.HEAPU8.slice(statep, statep + state.length));
+    module_.ccall("ctr256", "void", ["pointer", "number", "array", "pointer", "pointer"], [datap, data.byteLength, key, state.ivp, state.statep]);
+    data.set(module_.HEAPU8.slice(datap, datap + data.byteLength));
     module_._free(datap);
-    module_._free(ivp);
-    module_._free(statep);
 }
 function checkCbcParams(data, key, iv) {
-    if (data.length == 0) {
+    if (data.byteLength == 0) {
         throw new TypeError("data must not be empty");
     }
-    else if (data.length % 16 != 0) {
+    else if (data.byteLength % 16 != 0) {
         throw new TypeError("data must consist of a number of bytes that is divisible by 16");
     }
-    else if (key.length != 32) {
+    else if (key.byteLength != 32) {
         throw new TypeError("key must be 32 bytes");
     }
-    else if (iv.length != 16) {
+    else if (iv.byteLength != 16) {
         throw new TypeError("iv must be 16 bytes");
     }
 }
@@ -122,11 +136,11 @@ function checkCbcParams(data, key, iv) {
  */
 export function cbc256Encrypt(data, key, iv) {
     checkCbcParams(data, key, iv);
-    const datap = module_._malloc(data.length);
+    const datap = module_._malloc(data.byteLength);
     module_.HEAPU8.set(data, datap);
-    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    module_.ccall("cbc256_encrypt", "void", ["pointer", "number", "array", "array"], [datap, data.byteLength, key, iv]);
     try {
-        return module_.HEAPU8.slice(datap, datap + data.length);
+        return module_.HEAPU8.slice(datap, datap + data.byteLength);
     }
     finally {
         module_._free(datap);
@@ -141,11 +155,11 @@ export function cbc256Encrypt(data, key, iv) {
  */
 export function cbc256Decrypt(data, key, iv) {
     checkCbcParams(data, key, iv);
-    const datap = module_._malloc(data.length);
+    const datap = module_._malloc(data.byteLength);
     module_.HEAPU8.set(data, datap);
-    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.length, key, iv]);
+    module_.ccall("cbc256_decrypt", "void", ["pointer", "number", "array", "array"], [datap, data.byteLength, key, iv]);
     try {
-        return module_.HEAPU8.slice(datap, datap + data.length);
+        return module_.HEAPU8.slice(datap, datap + data.byteLength);
     }
     finally {
         module_._free(datap);

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

@@ -60,6 +60,10 @@ export declare const K: {
         customEmojiDocument: (id: bigint) => StorageKeyPart[];
         businessConnections: () => StorageKeyPart[];
         businessConnection: (id: string) => StorageKeyPart[];
+        inlineQueryAnswers: () => StorageKeyPart[];
+        inlineQueryAnswer: (userId: number, chatId: number, query: string, offset: string) => StorageKeyPart[];
+        callbackQueryAnswers: () => StorageKeyPart[];
+        callbackQueryAnswer: (chatId: number, messageId: number, question: string) => StorageKeyPart[];
     };
     messages: {
         P: (string: string) => string;
@@ -149,6 +153,10 @@ export declare abstract class Storage {
     getCustomEmojiDocument(id: bigint): Promise<[types.Document, Date] | null>;
     setBusinessConnection(id: string, connection: types.BotBusinessConnection | null): Promise<void>;
     getBusinessConnection(id: string): Promise<types.BotBusinessConnection | null>;
+    setInlineQueryAnswer(userId: number, chatId: number, query: string, offset: string, results: types.messages.BotResults, date: Date): Promise<void>;
+    getInlineQueryAnswer(userId: number, chatId: number, query: string, offset: string): Promise<[types.messages.BotResults, Date] | null>;
+    setCallbackQueryAnswer(chatId: number, messageId: number, question: string, answer: types.messages.BotCallbackAnswer): Promise<void>;
+    getCallbackQueryAnswer(chatId: number, messageId: number, question: string): Promise<[types.messages.BotCallbackAnswer, Date] | null>;
     setUpdate(boxId: bigint, update: enums.Update): Promise<void>;
     deleteUpdates(): Promise<void>;
     getFirstUpdate(boxId: bigint): Promise<[readonly StorageKeyPart[], enums.Update] | null>;
@@ -157,6 +165,8 @@ export declare abstract class Storage {
     deleteFiles(): Promise<void>;
     deleteCustomEmojiDocuments(): Promise<void>;
     deleteBusinessConnections(): Promise<void>;
+    deleteInlineQueryAnswers(): Promise<void>;
+    deleteCallbackQueryAnswers(): Promise<void>;
     deleteStickerSetNames(): Promise<void>;
     deletePeers(): Promise<void>;
     deleteUsernames(): Promise<void>;

package/esm/storage/0_storage.js

@@ -73,6 +73,10 @@ export const K = {
         customEmojiDocument: (id) => [...K.cache.customEmojiDocuments(), id],
         businessConnections: () => [K.cache.P("businessConnections")],
         businessConnection: (id) => [...K.cache.businessConnections(), id],
+        inlineQueryAnswers: () => [K.cache.P("inlineQueryResults")],
+        inlineQueryAnswer: (userId, chatId, query, offset) => [...K.cache.inlineQueryAnswers(), userId, chatId, query, offset],
+        callbackQueryAnswers: () => [K.cache.P("callbackQueryAnswers")],
+        callbackQueryAnswer: (chatId, messageId, question) => [...K.cache.callbackQueryAnswers(), chatId, messageId, question],
     },
     messages: {
         P: (string) => `messages.${string}`,
@@ -401,6 +405,32 @@ export class Storage {
             return null;
         }
     }
+    async setInlineQueryAnswer(userId, chatId, query, offset, results, date) {
+        await this.set(K.cache.inlineQueryAnswer(userId, chatId, query, offset), [this.isMemoryStorage ? results : rleEncode(results[serialize]()), date]);
+    }
+    async getInlineQueryAnswer(userId, chatId, query, offset) {
+        const peer_ = await this.get(K.cache.inlineQueryAnswer(userId, chatId, query, offset));
+        if (peer_ != null) {
+            const [obj_, date] = peer_;
+            return [await this.getTlObject(obj_), date];
+        }
+        else {
+            return null;
+        }
+    }
+    async setCallbackQueryAnswer(chatId, messageId, question, answer) {
+        await this.set(K.cache.callbackQueryAnswer(chatId, messageId, question), [this.isMemoryStorage ? answer : rleEncode(answer[serialize]()), new Date()]);
+    }
+    async getCallbackQueryAnswer(chatId, messageId, question) {
+        const peer_ = await this.get(K.cache.callbackQueryAnswer(chatId, messageId, question));
+        if (peer_ != null) {
+            const [obj_, date] = peer_;
+            return [await this.getTlObject(obj_), date];
+        }
+        else {
+            return null;
+        }
+    }
     async setUpdate(boxId, update) {
         await this.setTlObject(K.updates.update(boxId, __classPrivateFieldGet(this, _Storage_instances, "m", _Storage_getUpdateId).call(this, update)), update);
     }
@@ -448,6 +478,16 @@ export class Storage {
             await this.set(key, null);
         }
     }
+    async deleteInlineQueryAnswers() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.inlineQueryAnswers() })) {
+            await this.set(key, null);
+        }
+    }
+    async deleteCallbackQueryAnswers() {
+        for await (const [key] of await this.getMany({ prefix: K.cache.callbackQueryAnswers() })) {
+            await this.set(key, null);
+        }
+    }
     async deleteStickerSetNames() {
         for await (const [key] of await this.getMany({ prefix: K.cache.stickerSetNames() })) {
             await this.set(key, null);
@@ -472,6 +512,8 @@ export class Storage {
             this.deleteFiles(),
             this.deleteCustomEmojiDocuments(),
             this.deleteBusinessConnections(),
+            this.deleteInlineQueryAnswers(),
+            this.deleteCallbackQueryAnswers(),
             this.deleteStickerSetNames(),
             this.deletePeers(),
             this.deleteUsernames(),

package/esm/tl/0_tl_raw_writer.js

@@ -17,7 +17,8 @@
  * 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 { bufferFromBigInt, concat } from "../1_utilities.js";
+import { concat } from "../0_deps.js";
+import { bufferFromBigInt } from "../1_utilities.js";
 export class TLRawWriter {
     constructor() {
         Object.defineProperty(this, "_buffer", {
@@ -31,7 +32,7 @@ export class TLRawWriter {
         return this._buffer;
     }
     write(buffer) {
-        this._buffer = concat(this._buffer, buffer);
+        this._buffer = concat([this._buffer, buffer]);
         return this;
     }
     writeInt24(int, signed = true) {

package/esm/transport/0_obfuscation.js

@@ -18,11 +18,12 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import * as dntShim from "../_dnt.shims.js";
-import { bufferFromBigInt, concat, CTR } from "../1_utilities.js";
+import { concat } from "../0_deps.js";
+import { bufferFromBigInt, CTR } from "../1_utilities.js";
 export async function getObfuscationParameters(protocol, connection) {
     let init;
     while (true) {
-        init = concat(dntShim.crypto.getRandomValues(new Uint8Array(56)), bufferFromBigInt(protocol, 4, false), dntShim.crypto.getRandomValues(new Uint8Array(4)));
+        init = concat([dntShim.crypto.getRandomValues(new Uint8Array(56)), bufferFromBigInt(protocol, 4, false), dntShim.crypto.getRandomValues(new Uint8Array(4))]);
         if (init[0] == 0xEF) {
             continue;
         }
@@ -46,6 +47,6 @@ export async function getObfuscationParameters(protocol, connection) {
     const decryptKey = initRev.slice(8, 8 + 32);
     const decryptIv = initRev.slice(40, 40 + 16);
     const decryptionCTR = new CTR(decryptKey, decryptIv);
-    await connection.write(concat(init.subarray(0, 56), encryptedInit.subarray(56, 56 + 8)));
+    await connection.write(concat([init.subarray(0, 56), encryptedInit.subarray(56, 56 + 8)]));
     return { encryptionCTR, decryptionCTR };
 }

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

@@ -29,5 +29,5 @@ export declare abstract class Transport {
     abstract initialize(): MaybePromise<void>;
     abstract receive(): MaybePromise<Uint8Array>;
     abstract send(buffer: Uint8Array): MaybePromise<void>;
-    abstract deinitialize(): MaybePromise<void>;
+    deinitialize(): MaybePromise<void>;
 }

package/esm/transport/0_transport.js

@@ -36,4 +36,11 @@ export class Transport {
             this.obfuscationParameters.decryptionCTR.call(buffer);
         }
     }
+    deinitialize() {
+        if (this.obfuscationParameters) {
+            this.obfuscationParameters.encryptionCTR.destroy();
+            this.obfuscationParameters.decryptionCTR.destroy();
+            this.obfuscationParameters = null;
+        }
+    }
 }

package/esm/transport/1_transport_abridged.js

@@ -29,7 +29,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _TransportAbridged_initialized, _TransportAbridged_connection, _TransportAbridged_obfuscated;
-import { bufferFromBigInt, concat } from "../1_utilities.js";
+import { concat } from "../0_deps.js";
+import { bufferFromBigInt } from "../1_utilities.js";
 import { getObfuscationParameters } from "./0_obfuscation.js";
 import { Transport } from "./0_transport.js";
 export class TransportAbridged extends Transport {
@@ -85,11 +86,12 @@ export class TransportAbridged extends Transport {
         const bufferLength = buffer.length / 4;
         const header = new Uint8Array([bufferLength >= 0x7F ? 0x7F : bufferLength]);
         const length = bufferLength >= 0x7F ? bufferFromBigInt(bufferLength, 3) : new Uint8Array();
-        const data = concat(header, length, buffer);
+        const data = concat([header, length, buffer]);
         this.encrypt(data);
         await __classPrivateFieldGet(this, _TransportAbridged_connection, "f").write(data);
     }
     deinitialize() {
+        super.deinitialize();
         __classPrivateFieldSet(this, _TransportAbridged_initialized, false, "f");
     }
     get initialized() {

package/esm/transport/1_transport_intermediate.js

@@ -29,7 +29,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _TransportIntermediate_connection, _TransportIntermediate_initialized, _TransportIntermediate_obfuscated;
-import { bufferFromBigInt, concat } from "../1_utilities.js";
+import { concat } from "../0_deps.js";
+import { bufferFromBigInt } from "../1_utilities.js";
 import { getObfuscationParameters } from "./0_obfuscation.js";
 import { Transport } from "./0_transport.js";
 export class TransportIntermediate extends Transport {
@@ -74,11 +75,12 @@ export class TransportIntermediate extends Transport {
             throw new Error("Transport not initialized");
         }
         const length = bufferFromBigInt(buffer.length, 4);
-        const data = concat(length, buffer);
+        const data = concat([length, buffer]);
         this.encrypt(data);
         await __classPrivateFieldGet(this, _TransportIntermediate_connection, "f").write(data);
     }
     deinitialize() {
+        super.deinitialize();
         __classPrivateFieldSet(this, _TransportIntermediate_initialized, false, "f");
     }
     get initialized() {

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

@@ -0,0 +1,30 @@
+/**
+ * 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";
+/** An answer to a callback query. */
+export interface CallbackQueryAnswer {
+    /** Whether the answer should be shown as an alert. */
+    alert: boolean;
+    /** The text of the answer. */
+    text: string;
+    /** A potential URL that is to be opened. */
+    url: string;
+}
+export declare function constructCallbackQueryAnswer(answer: types.messages.BotCallbackAnswer): CallbackQueryAnswer;

package/esm/types/0_callback_query_answer.js

@@ -0,0 +1,26 @@
+/**
+ * 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 function constructCallbackQueryAnswer(answer) {
+    return {
+        alert: !!answer.alert,
+        text: answer.message ?? "",
+        url: answer.url ?? "",
+    };
+}

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

@@ -0,0 +1,49 @@
+/**
+ * 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/>.
+ */
+/**
+ * A reference to a button for opening the bot's game.
+ * @unlisted
+ */
+export interface CallbackQueryQuestionGame {
+    type: "game";
+}
+/**
+ * A reference to a password confirmation button.
+ * @unlisted
+ */
+export interface CallbackQueryQuestionPassword {
+    type: "password";
+    /** The target button's callback data. */
+    data: string;
+    /** The account's password. */
+    password: string;
+}
+/**
+ * A reference to a usual button.
+ * @unlisted
+ */
+export interface CallbackQueryQuestionButton {
+    type: "button";
+    /** The target button's callback data. */
+    data: string;
+}
+/** A reference to a button that is to be clicked by a user. */
+export type CallbackQueryQuestion = CallbackQueryQuestionGame | CallbackQueryQuestionPassword | CallbackQueryQuestionButton;
+export declare function validateCallbackQueryQuestion(q: CallbackQueryQuestion): void;

package/esm/types/0_callback_query_question.js

@@ -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 { InputError } from "../0_errors.js";
+export function validateCallbackQueryQuestion(q) {
+    if (!["game", "password", "button"].includes(q.type)) {
+        throw new InputError("Got invalid callback query question type.");
+    }
+    if (q.type == "password" && (typeof q.password !== "string" || !q.password)) {
+        throw new InputError("Got empty password.");
+    }
+    if ((q.type == "button" || q.type == "password") && (typeof q.data !== "string" || !q.data)) {
+        throw new InputError("Got empty button data.");
+    }
+}

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

@@ -18,7 +18,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 /**
- * Source to a file. Can be a file ID, a file path, URL, or a `Uint8Array`, unless otherwise noted.
+ * Source to a file. Can be a file ID, a file path, URL, a `Uint8Array`, a potentially async `Uint8Array` iterator, or a readable stream of `Uint8Array`, unless otherwise noted.
  * @unlisted
  */
-export type FileSource = string | URL | Uint8Array;
+export type FileSource = string | URL | Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>;

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

@@ -0,0 +1,25 @@
+/**
+ * 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/>.
+ */
+/** @unlisted */
+export type SelfDestructAfterOpen = "afterOpen";
+/** @unlisted */
+export type SelfDestructAfterSeconds = number;
+export type SelfDestructOption = SelfDestructAfterOpen | SelfDestructAfterSeconds;
+export declare function selfDestructOptionToInt(option: SelfDestructOption): number;

package/esm/types/0_self_destruct_option.js

@@ -0,0 +1,39 @@
+/**
+ * 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 { InputError } from "../0_errors.js";
+export function selfDestructOptionToInt(option) {
+    if (option == "afterOpen") {
+        return 2147483647;
+    }
+    else if (typeof option === "number") {
+        if (option == 0) {
+            throw new InputError("Self destruct option cannot be zero.");
+        }
+        else if (option < 0) {
+            throw new InputError("Self destruct option cannot be negative.");
+        }
+        else {
+            return option;
+        }
+    }
+    else {
+        throw new InputError("Invalid self destruct option.");
+    }
+}