@mtkruto/browser 0.131.0 → 0.132.1

package/esm/connection/0_get_tls_header.js

@@ -0,0 +1,151 @@
+import { concat, decodeHex } from "../0_deps.js";
+import { hmacSha256, intFromBytes, intToBytes, modExp } from "../1_utilities.js";
+export async function getTlsHeader(secret) {
+    const array = serializeOps(ops, secret.slice(16));
+    secret = secret.slice(0, 16);
+    secret = await hmacSha256(array, secret);
+    array.set(secret.slice(0), 11);
+    const dataView = new DataView(array.buffer);
+    const old = dataView.getInt32(39, true);
+    dataView.setInt32(39, old ^ Math.floor(Date.now() / 1000), true);
+    return array;
+}
+const ops = [
+    { type: "string", data: new Uint8Array([0x16, 0x03, 0x01, 0x02, 0x00, 0x01, 0x00, 0x01, 0xfc, 0x03, 0x03]) },
+    { type: "zero", length: 32 },
+    { type: "string", data: new Uint8Array([0x20]) },
+    { type: "random", length: 32 },
+    { type: "string", data: new Uint8Array([0x00, 0x2a]) },
+    { type: "grease", seed: 0 },
+    { type: "string", data: new Uint8Array([0x13, 0x01, 0x13, 0x02, 0x13, 0x03, 0xc0, 0x2c, 0xc0, 0x2b, 0xcc, 0xa9, 0xc0, 0x30, 0xc0, 0x2f, 0xcc, 0xa8, 0xc0, 0x0a, 0xc0, 0x09, 0xc0, 0x14, 0xc0, 0x13, 0x00, 0x9d, 0x00, 0x9c, 0x00, 0x35, 0x00, 0x2f, 0xc0, 0x08, 0xc0, 0x12, 0x00, 0x0a, 0x01, 0x00, 0x01, 0x89]) },
+    { type: "grease", seed: 2 },
+    { type: "string", data: new Uint8Array([0x00, 0x00, 0x00, 0x00]) },
+    { type: "beginScope" },
+    { type: "beginScope" },
+    { type: "string", data: new Uint8Array([0x00]) },
+    { type: "beginScope" },
+    { type: "domain" },
+    { type: "endScope" },
+    { type: "endScope" },
+    { type: "endScope" },
+    { type: "string", data: new Uint8Array([0x00, 0x17, 0x00, 0x00, 0xff, 0x01, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x0c, 0x00, 0x0a]) },
+    { type: "grease", seed: 4 },
+    { type: "string", data: new Uint8Array([0x00, 0x1d, 0x00, 0x17, 0x00, 0x18, 0x00, 0x19, 0x00, 0x0b, 0x00, 0x02, 0x01, 0x00, 0x00, 0x10, 0x00, 0x0e, 0x00, 0x0c, 0x02, 0x68, 0x32, 0x08, 0x68, 0x74, 0x74, 0x70, 0x2f, 0x31, 0x2e, 0x31, 0x00, 0x05, 0x00, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x16, 0x00, 0x14, 0x04, 0x03, 0x08, 0x04, 0x04, 0x01, 0x05, 0x03, 0x08, 0x05, 0x08, 0x05, 0x05, 0x01, 0x08, 0x06, 0x06, 0x01, 0x02, 0x01, 0x00, 0x12, 0x00, 0x00, 0x00, 0x33, 0x00, 0x2b, 0x00, 0x29]) },
+    { type: "grease", seed: 4 },
+    { type: "string", data: new Uint8Array([0x00, 0x01, 0x00, 0x00, 0x1d, 0x00, 0x20]) },
+    { type: "key" },
+    { type: "string", data: new Uint8Array([0x00, 0x2d, 0x00, 0x02, 0x01, 0x01, 0x00, 0x2b, 0x00, 0x0b, 0x0a]) },
+    { type: "grease", seed: 6 },
+    { type: "string", data: new Uint8Array([0x03, 0x04, 0x03, 0x03, 0x03, 0x02, 0x03, 0x01, 0x00, 0x1b, 0x00, 0x03, 0x02, 0x00, 0x01]) },
+    { type: "grease", seed: 3 },
+    { type: "string", data: new Uint8Array([0x00, 0x01, 0x00]) },
+    { type: "padding" },
+];
+function getGrease() {
+    const res = crypto.getRandomValues(new Uint8Array(7));
+    for (let i = 0; i < res.length; ++i) {
+        res[i] = (res[i] & 0xF0) + 0x0A;
+    }
+    for (let i = 1; i < res.length; i += 2) {
+        if (res[i] === res[i - 1]) {
+            res[i] ^= 0x10;
+        }
+    }
+    return res;
+}
+function getY2(x, mod) {
+    let y = (x + 486662n) % mod;
+    y = y * x % mod;
+    y = (y + 1n) % mod;
+    return y * x % mod;
+}
+function getDoubleX(x, mod) {
+    const y2 = getY2(x, mod);
+    const denominator = (4n * y2) % mod;
+    let numerator = (x * x % mod - 1n + mod) % mod;
+    numerator = (numerator * numerator) % mod;
+    const denominatorInv = modExp(denominator, mod - 2n, mod);
+    numerator = (numerator * denominatorInv) % mod;
+    return numerator;
+}
+function isQuadraticResidue(a) {
+    const mod = 2n ** 255n - 19n;
+    const pow = 2n ** 254n - 10n;
+    const r = modExp(a, pow, mod);
+    return r === 1n;
+}
+function serializeOps(ops, domain) {
+    const GREASE = getGrease();
+    let buffer = new Uint8Array();
+    const scopes = new Array();
+    function serializeOp(op) {
+        switch (op.type) {
+            case "string":
+                buffer = concat([buffer, op.data]);
+                break;
+            case "random":
+                buffer = concat([
+                    buffer,
+                    crypto.getRandomValues(new Uint8Array(op.length)),
+                ]);
+                break;
+            case "zero":
+                buffer = concat([buffer, new Uint8Array(op.length)]);
+                break;
+            case "domain":
+                buffer = concat([buffer, domain]);
+                break;
+            case "grease": {
+                const grease = GREASE[op.seed];
+                buffer = concat([buffer, new Uint8Array([grease, grease])]);
+                break;
+            }
+            case "key": {
+                const mod = intFromBytes(decodeHex("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"), { byteOrder: "big", isSigned: false });
+                let key = new Uint8Array(32);
+                while (true) {
+                    crypto.getRandomValues(key);
+                    key[31] &= 127;
+                    let x = intFromBytes(key, { byteOrder: "big", isSigned: false });
+                    const y = getY2(x, mod);
+                    if (isQuadraticResidue(y)) {
+                        for (let i = 0; i < 3; ++i) {
+                            x = getDoubleX(x, mod);
+                        }
+                        key = intToBytes(x, 32, { byteOrder: "little", isSigned: false });
+                        break;
+                    }
+                }
+                buffer = concat([buffer, key]);
+                break;
+            }
+            case "beginScope":
+                scopes.push(buffer.length);
+                buffer = concat([buffer, new Uint8Array([0, 0])]);
+                break;
+            case "endScope": {
+                const beginOffset = scopes.pop();
+                if (beginOffset === undefined) {
+                    throw new TypeError("Invalid endScope");
+                }
+                const endOffset = buffer.length;
+                const size = endOffset - beginOffset - 2;
+                new DataView(buffer.buffer).setUint16(beginOffset, size);
+                break;
+            }
+            case "padding": {
+                const size = 513 - buffer.length;
+                if (size > 0) {
+                    serializeOp({ type: "string", data: new Uint8Array([0x00, 0x15]) });
+                    serializeOp({ type: "beginScope" });
+                    serializeOp({ type: "zero", length: size });
+                    serializeOp({ type: "endScope" });
+                }
+            }
+        }
+    }
+    for (const op of ops) {
+        serializeOp(op);
+    }
+    return buffer;
+}

package/esm/connection/1_connection_tcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_connection_tcp.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,qBAAa,aAAc,YAAW,UAAU;;IAU9C,OAAO,EAAE,OAAO,IAAI,CAAC,OAAO,CAAgB;IAC5C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;gBAEtB,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAK1C,IAAI,WAAW,IAAI,OAAO,CAEzB;IAQK,IAAI;IAiDJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAgBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IA4BzB,KAAK;CAON"}
+{"version":3,"file":"1_connection_tcp.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAIpD,qBAAa,aAAc,YAAW,UAAU;;IAQ9C,OAAO,EAAE,OAAO,IAAI,CAAC,OAAO,CAAgB;IAC5C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;gBAEtB,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAK1C,IAAI,WAAW,IAAI,OAAO,CAGzB;IAQK,IAAI;IAiBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAyBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IAsBzB,KAAK;CAMN"}

package/esm/connection/1_connection_tcp.js

@@ -17,7 +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/>.
  */
-import { concat, iterateReader } from "../0_deps.js";
 import { ConnectionError } from "../0_errors.js";
 import { getLogger, Mutex } from "../1_utilities.js";
 const L = getLogger("ConnectionTCP");
@@ -27,8 +26,6 @@ export class ConnectionTCP {
     #connection;
     #rMutex = new Mutex();
     #wMutex = new Mutex();
-    #buffer = new Uint8Array();
-    #nextResolve = null;
     #canRead = false;
     #canWrite = false;
     connect = Deno.connect;
@@ -39,6 +36,7 @@ export class ConnectionTCP {
         this.#port = port;
     }
     get isConnected() {
+        Deno.errors.BrokenPipe;
         return !!this.#connection && this.#canRead && this.#canWrite;
     }
     #assertConnected() {
@@ -59,48 +57,27 @@ export class ConnectionTCP {
         this.#canRead = this.#canWrite = true;
         this.stateChangeHandler?.(true);
         L.debug("connected to", this.#hostname, "port", this.#port);
-        Promise.resolve().then(async () => {
-            do {
-                try {
-                    for await (const chunk of iterateReader(connection)) {
-                        this.callback?.read(chunk.length);
-                        this.#buffer = concat([this.#buffer, chunk]);
-                        if (this.#nextResolve !== null && this.#buffer.length >= this.#nextResolve[0]) {
-                            this.#nextResolve[1].resolve();
-                            this.#nextResolve = null;
-                        }
-                    }
-                    this.#canRead = false;
-                    break;
-                }
-                catch (err) {
-                    this.#canRead = false;
-                    this.stateChangeHandler?.(false);
-                    this.#rejectRead();
-                    L.error(err);
-                }
-            } while (this.isConnected);
-            this.stateChangeHandler?.(false);
-        });
         this.#connection = connection;
     }
-    #rejectRead() {
-        if (this.#nextResolve !== null) {
-            this.#nextResolve[1].reject(new ConnectionError("The connection was closed."));
-            this.#nextResolve = null;
-        }
-    }
     async read(p) {
         this.#assertConnected();
         const unlock = await this.#rMutex.lock();
+        let offset = 0;
         try {
-            this.#assertConnected();
-            if (this.#buffer.length < p.length) {
-                await new Promise((resolve, reject) => this.#nextResolve = [p.length, { resolve, reject }]);
-            }
-            const slice = this.#buffer.slice(0, p.length);
-            p.set(slice);
-            this.#buffer = this.#buffer.slice(slice.length);
+            do {
+                const read = await this.#connection.read(p.subarray(offset));
+                if (read === null) {
+                    this.#canRead = false;
+                    this.stateChangeHandler?.(false);
+                    throw new ConnectionError("The connection was closed.");
+                }
+                offset += read;
+            } while (offset < p.byteLength);
+        }
+        catch {
+            this.#canRead = false;
+            this.stateChangeHandler?.(false);
+            throw new ConnectionError("The connection was closed.");
         }
         finally {
             unlock();
@@ -112,23 +89,16 @@ export class ConnectionTCP {
         try {
             this.#assertConnected();
             let written = 0;
-            while (written < p.length) {
+            while (written < p.byteLength) {
                 try {
                     const wrote = await this.#connection.write(p.subarray(written));
                     this.callback?.write(wrote);
                     written += wrote;
                 }
-                catch (err) {
-                    if (err instanceof Deno.errors.BrokenPipe || err instanceof Deno.errors.ConnectionReset) {
-                        this.#canWrite = false;
-                    }
-                    if (!this.isConnected) {
-                        this.stateChangeHandler?.(false);
-                        throw new ConnectionError("The connection was closed.");
-                    }
-                    else {
-                        throw err;
-                    }
+                catch {
+                    this.#canWrite = false;
+                    this.stateChangeHandler?.(false);
+                    throw new ConnectionError("The connection was closed.");
                 }
             }
         }
@@ -141,6 +111,5 @@ export class ConnectionTCP {
         this.#connection.close();
         this.#canRead = this.#canWrite = false;
         this.#connection = undefined;
-        this.#rejectRead();
     }
 }

package/esm/connection/1_connection_tls.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 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 type { Connection } from "./0_connection.js";
+export declare class ConnectionTLS implements Connection {
+    #private;
+    connect: typeof Deno.connect;
+    stateChangeHandler?: Connection["stateChangeHandler"];
+    callback?: Connection["callback"];
+    constructor(hostname: string, port: number, secret: Uint8Array<ArrayBuffer>);
+    get isConnected(): boolean;
+    open(): Promise<void>;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=1_connection_tls.d.ts.map

package/esm/connection/1_connection_tls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_connection_tls.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAQpD,qBAAa,aAAc,YAAW,UAAU;;IAW9C,OAAO,EAAE,OAAO,IAAI,CAAC,OAAO,CAAgB;IAC5C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;gBAEtB,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;IAM3E,IAAI,WAAW,IAAI,OAAO,CAEzB;IA+BK,IAAI;IAuGJ,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBzC,KAAK;CAON"}

package/esm/connection/1_connection_tls.js

@@ -0,0 +1,203 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2026 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 { concat, equals, startsWith, writeAll } from "../0_deps.js";
+import { ConnectionError } from "../0_errors.js";
+import { getLogger, hmacSha256, Mutex } from "../1_utilities.js";
+import { getTlsHeader } from "./0_get_tls_header.js";
+const HEADER_LENGTH = 5;
+const MAX_PACKET_LENGTH = 2878;
+const L = getLogger("ConnectionTLS");
+export class ConnectionTLS {
+    #hostname;
+    #port;
+    #secret;
+    #connection;
+    #rMutex = new Mutex();
+    #wMutex = new Mutex();
+    #buffer = new Uint8Array();
+    #canRead = false;
+    #canWrite = false;
+    #isFirstWrite = true;
+    connect = Deno.connect;
+    stateChangeHandler;
+    callback;
+    constructor(hostname, port, secret) {
+        this.#hostname = hostname;
+        this.#port = port;
+        this.#secret = (secret[0] === 0xDD || secret[0] === 0xEE) ? secret.slice(1) : secret;
+    }
+    get isConnected() {
+        return !!this.#connection && this.#canRead && this.#canWrite;
+    }
+    #assertConnected() {
+        if (!this.isConnected) {
+            throw new ConnectionError("The connection is not open.");
+        }
+    }
+    async #read(array) {
+        let offset = 0;
+        try {
+            while (offset < array.length) {
+                const n = await this.#connection.read(array.subarray(offset));
+                if (n === null) {
+                    this.#canRead = false;
+                    this.stateChangeHandler?.(false);
+                    throw new ConnectionError("The connection is not open.");
+                }
+                if (n <= 0) {
+                    continue;
+                }
+                this.callback?.read(n);
+                offset += n;
+            }
+        }
+        catch (err) {
+            this.stateChangeHandler?.(false);
+            this.#canRead = false;
+            throw err;
+        }
+    }
+    async open() {
+        if (this.isConnected) {
+            return;
+        }
+        const connection = await this.connect({
+            hostname: this.#hostname,
+            port: this.#port,
+        });
+        connection.setNoDelay(true);
+        connection.setKeepAlive(true);
+        this.#canRead = this.#canWrite = this.#isFirstWrite = true;
+        this.stateChangeHandler?.(true);
+        L.debug("connected to", this.#hostname, "port", this.#port);
+        this.#connection = connection;
+        const header = await getTlsHeader(this.#secret);
+        const helloRand = header.subarray(11, 43);
+        await writeAll(this.#connection, header);
+        let offset = 0;
+        let read = new Uint8Array();
+        for (const prefix of [
+            new Uint8Array([0x16, 0x03, 0x03]),
+            new Uint8Array([0x14, 0x03, 0x03, 0x00, 0x01, 0x01, 0x17, 0x03, 0x03]),
+        ]) {
+            while (true) {
+                if ((read.byteLength - offset) >= (prefix.byteLength + 2)) {
+                    if (!startsWith(read.subarray(offset), prefix)) {
+                        throw new TypeError("Received an invalid prefix.");
+                    }
+                    const dataView = new DataView(read.buffer, read.byteOffset, read.byteLength);
+                    const size = dataView.getUint16(offset + prefix.byteLength, false);
+                    const total = prefix.byteLength + 2 + size;
+                    if ((read.byteLength - offset) >= total) {
+                        offset += total;
+                        break;
+                    }
+                }
+                const buffer = new Uint8Array(4096);
+                const n = await connection.read(buffer);
+                if (n === null) {
+                    throw new TypeError("Failed to initialize TLS connection.");
+                }
+                if (n <= 0) {
+                    continue;
+                }
+                this.callback?.read(n);
+                read = concat([read, buffer.subarray(0, n)]);
+            }
+        }
+        const response = read.subarray(0, offset);
+        const actual = response.slice(11, 43);
+        const zeroed = response.slice();
+        zeroed.fill(0, 11, 43);
+        const expected = await hmacSha256(concat([helloRand, zeroed]), this.#secret.slice(0, 16));
+        if (!equals(actual, expected)) {
+            throw new TypeError("Failed to initialize TLS connection.");
+        }
+        L.debug(`initialized TLS connection with ${this.#hostname}`);
+    }
+    async #readPacket() {
+        const header = new Uint8Array(HEADER_LENGTH);
+        await this.#read(header);
+        if (!startsWith(header, new Uint8Array([0x17, 0x03, 0x03]))) {
+            throw new TypeError("Failed to read TLS packet.");
+        }
+        const length = new DataView(header.buffer).getUint16(3);
+        const packet = new Uint8Array(length);
+        await this.#read(packet);
+        this.#buffer = concat([this.#buffer, packet]);
+    }
+    async #writePacket(packet) {
+        const header = new Uint8Array([0x17, 0x03, 0x03, 0x00, 0x00]);
+        new DataView(header.buffer).setUint16(3, packet.byteLength);
+        let data = concat([header, packet]);
+        if (this.#isFirstWrite) {
+            this.#isFirstWrite = false;
+            data = concat([new Uint8Array([0x14, 0x03, 0x03, 0x00, 0x01, 0x01]), data]);
+        }
+        try {
+            await writeAll(this.#connection, data);
+            this.callback?.write(data.byteLength);
+        }
+        catch (err) {
+            this.#canWrite = false;
+            this.stateChangeHandler?.(false);
+            throw err;
+        }
+    }
+    async read(p) {
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
+        try {
+            while (this.#buffer.byteLength < p.byteLength) {
+                await this.#readPacket();
+            }
+            p.set(this.#buffer.subarray(0, p.byteLength));
+            this.#buffer = this.#buffer.slice(p.byteLength);
+        }
+        finally {
+            unlock();
+        }
+    }
+    async write(p) {
+        this.#assertConnected();
+        const unlock = await this.#wMutex.lock();
+        try {
+            let offset = 0;
+            while (true) {
+                const packet = p.subarray(offset, offset + MAX_PACKET_LENGTH - HEADER_LENGTH);
+                if (packet.byteLength === 0) {
+                    break;
+                }
+                await this.#writePacket(packet);
+                offset += packet.byteLength;
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+    close() {
+        this.#assertConnected();
+        this.#connection.close();
+        this.#canRead = this.#canWrite = false;
+        this.#isFirstWrite = true;
+        this.#connection = undefined;
+    }
+}

package/esm/deps/jsr.io/@std/io/0.225.3/write_all.d.ts

@@ -0,0 +1,52 @@
+import type { Writer, WriterSync } from "./types.js";
+export type { Writer, WriterSync } from "./types.js";
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example Writing to stdout
+ * ```ts no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', { write: true });
+ * await writeAll(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAll(writer: Writer, data: Uint8Array): Promise<void>;
+/**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @example "riting to stdout
+ * ```ts no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync("test.file", { write: true });
+ * writeAllSync(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export declare function writeAllSync(writer: WriterSync, data: Uint8Array): void;
+//# sourceMappingURL=write_all.d.ts.map

package/esm/deps/jsr.io/@std/io/0.225.3/write_all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write_all.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/write_all.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,iBAK9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,QAKhE"}

package/esm/deps/jsr.io/@std/io/0.225.3/write_all.js

@@ -0,0 +1,61 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example Writing to stdout
+ * ```ts no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAll } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', { write: true });
+ * await writeAll(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export async function writeAll(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += await writer.write(data.subarray(nwritten));
+    }
+}
+/**
+ * Synchronously write all the content of the array buffer (`arr`) to the
+ * writer (`w`).
+ *
+ * @example "riting to stdout
+ * ```ts no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ * ```
+ *
+ * @example Writing to file
+ * ```ts ignore no-assert
+ * import { writeAllSync } from "@std/io/write-all";
+ *
+ * const contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync("test.file", { write: true });
+ * writeAllSync(file, contentBytes);
+ * ```
+ *
+ * @param writer The writer to write to
+ * @param data The data to write
+ */
+export function writeAllSync(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += writer.writeSync(data.subarray(nwritten));
+    }
+}

package/esm/session/2_session_encrypted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAwD,OAAO,EAAuC,MAAM,YAAY,CAAC;AAChI,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAa7D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAED,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAiBZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAQpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAAC,WAAW,CAAC,CAErC;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9B,UAAU,IAAI,IAAI;IA6ErB,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAwX3D"}
+{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAwD,OAAO,EAAuC,MAAM,YAAY,CAAC;AAChI,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAa7D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAED,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAiBZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAQpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAAC,WAAW,CAAC,CAErC;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9B,UAAU,IAAI,IAAI;IA6ErB,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CA4X3D"}

package/esm/session/2_session_encrypted.js

@@ -190,10 +190,13 @@ export class SessionEncrypted extends Session {
         return messageWriter.buffer;
     }
     async #decryptMessage(buffer) {
-        const reader = new TLReader(buffer);
+        let reader = new TLReader(buffer);
         assertEquals(reader.readInt64(), this.#authKeyId);
         const messageKey_ = reader.readInt128();
         const messageKey = intToBytes(messageKey_, 16);
+        if (reader.buffer.length % 16 !== 0) {
+            reader = new TLReader(reader.buffer.subarray(0, -(reader.buffer.length % 16)));
+        }
         const a = await sha256(concat([messageKey, this.#authKey.subarray(8, 44)]));
         const b = await sha256(concat([this.#authKey.subarray(48, 84), messageKey]));
         const aesKey = concat([a.subarray(0, 8), b.subarray(8, 24), a.subarray(24, 32)]);

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

@@ -19,7 +19,11 @@
  */
 import { CTR } from "../1_utilities.js";
 import type { Connection } from "../2_connection.js";
-export declare function getObfuscationParameters(protocol: number, connection: Connection): Promise<{
+export interface GetObfuscationParametersParams {
+    dcId?: number;
+    secret?: Uint8Array;
+}
+export declare function getObfuscationParameters(protocol: number, connection: Connection, params?: GetObfuscationParametersParams): Promise<{
     encryptionCTR: CTR;
     decryptionCTR: CTR;
 }>;