@mtkruto/node 0.132.0 → 0.132.1

package/esm/0_deps.d.ts

@@ -33,11 +33,11 @@ export { concat } from "./deps/jsr.io/@std/bytes/1.0.6/concat.js";
 export { equals } from "./deps/jsr.io/@std/bytes/1.0.6/equals.js";
 export { startsWith } from "./deps/jsr.io/@std/bytes/1.0.6/starts_with.js";
 export { LruCache } from "./deps/jsr.io/@std/cache/0.2.2/lru_cache.js";
-export { iterateReader } from "./deps/jsr.io/@std/io/0.225.3/iterate_reader.js";
+export { writeAll } from "./deps/jsr.io/@std/io/0.225.3/write_all.js";
 export { format } from "./deps/jsr.io/@std/datetime/0.225.7/format.js";
 export { MINUTE, SECOND } from "./deps/jsr.io/@std/datetime/0.225.7/constants.js";
 export { toArrayBuffer } from "./deps/jsr.io/@std/streams/1.0.17/to_array_buffer.js";
-export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.10/hex.js";
+export { decodeHex, encodeHex } from "./deps/jsr.io/@std/encoding/1.0.10/hex.js";
 export { decodeBase64, encodeBase64 } from "./deps/jsr.io/@std/encoding/1.0.10/base64.js";
 import { contentType as contentType_ } from "./deps/jsr.io/@std/media-types/1.1.0/content_type.js";
 export declare const contentType: typeof contentType_;

package/esm/0_deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"0_deps.d.ts","sourceRoot":"","sources":["../src/0_deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,4CAA4C,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAErF,OAAO,EAAE,IAAI,EAAE,MAAM,uCAAuC,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,0CAA0C,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAEnE,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAC;AAE3E,OAAO,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAEhF,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kDAAkD,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,sDAAsD,CAAC;AAErF,OAAO,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC;AAE1F,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,sDAAsD,CAAC;AACnG,eAAO,MAAM,WAAW,EAAE,OAAO,YAMhC,CAAC;AAEF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,UAMzC;AAED,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,+CAA+C,CAAC"}
+{"version":3,"file":"0_deps.d.ts","sourceRoot":"","sources":["../src/0_deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,4CAA4C,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAErF,OAAO,EAAE,IAAI,EAAE,MAAM,uCAAuC,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,0CAA0C,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AAEnE,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAClE,OAAO,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAC;AAE3E,OAAO,EAAE,QAAQ,EAAE,MAAM,6CAA6C,CAAC;AAEvE,OAAO,EAAE,QAAQ,EAAE,MAAM,4CAA4C,CAAC;AAEtE,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAC;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kDAAkD,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,sDAAsD,CAAC;AAErF,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,8CAA8C,CAAC;AAE1F,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,sDAAsD,CAAC;AACnG,eAAO,MAAM,WAAW,EAAE,OAAO,YAMhC,CAAC;AAEF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,UAMzC;AAED,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,+CAA+C,CAAC"}

package/esm/0_deps.js

@@ -33,11 +33,11 @@ export { concat } from "./deps/jsr.io/@std/bytes/1.0.6/concat.js";
 export { equals } from "./deps/jsr.io/@std/bytes/1.0.6/equals.js";
 export { startsWith } from "./deps/jsr.io/@std/bytes/1.0.6/starts_with.js";
 export { LruCache } from "./deps/jsr.io/@std/cache/0.2.2/lru_cache.js";
-export { iterateReader } from "./deps/jsr.io/@std/io/0.225.3/iterate_reader.js";
+export { writeAll } from "./deps/jsr.io/@std/io/0.225.3/write_all.js";
 export { format } from "./deps/jsr.io/@std/datetime/0.225.7/format.js";
 export { MINUTE, SECOND } from "./deps/jsr.io/@std/datetime/0.225.7/constants.js";
 export { toArrayBuffer } from "./deps/jsr.io/@std/streams/1.0.17/to_array_buffer.js";
-export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.10/hex.js";
+export { decodeHex, encodeHex } from "./deps/jsr.io/@std/encoding/1.0.10/hex.js";
 export { decodeBase64, encodeBase64 } from "./deps/jsr.io/@std/encoding/1.0.10/base64.js";
 import { contentType as contentType_ } from "./deps/jsr.io/@std/media-types/1.1.0/content_type.js";
 export const contentType = (extentionOrType) => {

package/esm/2_connection.d.ts

@@ -18,5 +18,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 export * from "./connection/0_connection.js";
+export * from "./connection/1_connection_tcp.node.js";
+export * from "./connection/1_connection_tls.node.js";
 export * from "./connection/1_connection_web_socket.js";
 //# sourceMappingURL=2_connection.d.ts.map

package/esm/2_connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_connection.d.ts","sourceRoot":"","sources":["../src/2_connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC"}
+{"version":3,"file":"2_connection.d.ts","sourceRoot":"","sources":["../src/2_connection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC"}

package/esm/2_connection.js

@@ -18,4 +18,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 export * from "./connection/0_connection.js";
+export * from "./connection/1_connection_tcp.node.js";
+export * from "./connection/1_connection_tls.node.js";
 export * from "./connection/1_connection_web_socket.js";

package/esm/3_transport.d.ts

@@ -21,6 +21,7 @@ export * from "./transport/0_transport.js";
 export * from "./transport/1_transport_abridged.js";
 export * from "./transport/1_transport_intermediate.js";
 export * from "./transport/1_transport_provider.js";
+export * from "./transport/2_transport_provider_mtproxy.js";
 export * from "./transport/2_transport_provider_tcp.js";
 export * from "./transport/2_transport_provider_web_socket.js";
 //# sourceMappingURL=3_transport.d.ts.map

package/esm/3_transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"3_transport.d.ts","sourceRoot":"","sources":["../src/3_transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC"}
+{"version":3,"file":"3_transport.d.ts","sourceRoot":"","sources":["../src/3_transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qCAAqC,CAAC;AACpD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,yCAAyC,CAAC;AACxD,cAAc,gDAAgD,CAAC"}

package/esm/3_transport.js

@@ -21,5 +21,6 @@ export * from "./transport/0_transport.js";
 export * from "./transport/1_transport_abridged.js";
 export * from "./transport/1_transport_intermediate.js";
 export * from "./transport/1_transport_provider.js";
+export * from "./transport/2_transport_provider_mtproxy.js";
 export * from "./transport/2_transport_provider_tcp.js";
 export * from "./transport/2_transport_provider_web_socket.js";

package/esm/connection/0_get_tls_header.d.ts

@@ -0,0 +1,2 @@
+export declare function getTlsHeader(secret: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+//# sourceMappingURL=0_get_tls_header.d.ts.map

package/esm/connection/0_get_tls_header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0_get_tls_header.d.ts","sourceRoot":"","sources":["../../src/connection/0_get_tls_header.ts"],"names":[],"mappings":"AAIA,wBAAsB,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,oCASjE"}

package/esm/connection/0_get_tls_header.js

@@ -0,0 +1,152 @@
+import * as dntShim from "../_dnt.shims.js";
+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 = dntShim.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,
+                    dntShim.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) {
+                    dntShim.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.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_connection_tcp.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,aAAc,YAAW,UAAU;;IAW9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAY1C,IAAI;IA2CJ,IAAI,WAAW,YAEd;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}
+{"version":3,"file":"1_connection_tcp.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tcp.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAKpD,qBAAa,aAAc,YAAW,UAAU;;IAW9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAY1C,IAAI;IA0CJ,IAAI,WAAW,YAEd;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}

package/esm/connection/1_connection_tcp.node.js

@@ -50,9 +50,10 @@ export class ConnectionTCP {
             this.#rejectRead();
             this.stateChangeHandler?.(false);
         });
-        const mutex = new Mutex();
-        this.#socket.on("data", async (data) => {
-            const unlock = await mutex.lock();
+        this.#socket.on("data", (data) => {
+            if (typeof data === "string") {
+                return;
+            }
             for (const byte of data) {
                 this.#buffer.push(byte);
             }
@@ -61,7 +62,6 @@ export class ConnectionTCP {
                 this.#nextResolve = null;
                 resolve();
             }
-            unlock();
         });
         return new Promise((resolve, reject) => {
             this.#socket.connect(this.#port, this.#hostname);

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

@@ -0,0 +1,31 @@
+/**
+ * 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;
+    stateChangeHandler?: Connection["stateChangeHandler"];
+    constructor(hostname: string, port: number, secret: Uint8Array<ArrayBuffer>);
+    open(): Promise<void>;
+    get isConnected(): boolean;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=1_connection_tls.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"1_connection_tls.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_tls.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AASpD,qBAAa,aAAc,YAAW,UAAU;;IAY9C,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC;IAarE,IAAI;IAyFV,IAAI,WAAW,YAEd;IAsDK,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAclC,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBzC,KAAK;CAKN"}

package/esm/connection/1_connection_tls.node.js

@@ -0,0 +1,199 @@
+/**
+ * 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 { Socket } from "node:net";
+import { concat, equals, startsWith } 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("ConnectionTCP");
+const errConnectionNotOpen = new ConnectionError("The connection is not open.");
+export class ConnectionTLS {
+    #hostname;
+    #port;
+    #secret;
+    #socket;
+    #rMutex = new Mutex();
+    #wMutex = new Mutex();
+    #buffer = new Array();
+    #nextResolve = null;
+    stateChangeHandler;
+    constructor(hostname, port, secret) {
+        this.#hostname = hostname;
+        this.#port = port;
+        this.#secret = (secret[0] === 0xDD || secret[0] === 0xEE) ? secret.slice(1) : secret;
+    }
+    #rejectRead() {
+        if (this.#nextResolve !== null) {
+            this.#nextResolve[1].reject(errConnectionNotOpen);
+            this.#nextResolve = null;
+        }
+    }
+    async open() {
+        if (this.isConnected) {
+            return;
+        }
+        this.#socket = new Socket();
+        this.#socket.on("close", () => {
+            this.#rejectRead();
+            this.stateChangeHandler?.(false);
+        });
+        this.#socket.on("data", (data) => {
+            if (typeof data === "string") {
+                return;
+            }
+            for (const byte of data) {
+                this.#buffer.push(byte);
+            }
+            if (this.#nextResolve !== null && this.#buffer.length >= this.#nextResolve[0]) {
+                const resolve = this.#nextResolve[1].resolve;
+                this.#nextResolve = null;
+                resolve();
+            }
+        });
+        await new Promise((resolve, reject) => {
+            this.#socket.connect(this.#port, this.#hostname);
+            this.#socket.once("error", reject);
+            this.#socket.once("connect", () => {
+                this.#socket.off("error", reject);
+                resolve();
+                this.stateChangeHandler?.(true);
+                L.debug("connected to", this.#hostname, "port", this.#port);
+            });
+        });
+        const header = await getTlsHeader(this.#secret);
+        const helloRand = header.subarray(11, 43);
+        await this.#write(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;
+                    }
+                }
+                await new Promise((resolve, reject) => this.#nextResolve = [0, { resolve, reject }]);
+                read = concat([read, new Uint8Array(this.#buffer.splice(0, this.#buffer.length))]);
+            }
+        }
+        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}`);
+    }
+    get isConnected() {
+        return this.#socket?.readyState === "open";
+    }
+    #assertConnected() {
+        if (!this.isConnected) {
+            throw errConnectionNotOpen;
+        }
+    }
+    #packetBuffer = new Uint8Array();
+    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.#packetBuffer = concat([this.#packetBuffer, packet]);
+    }
+    #isFirstWrite = false;
+    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]);
+        }
+        await this.#write(data);
+    }
+    async #read(p) {
+        if (this.#buffer.length < p.length) {
+            await new Promise((resolve, reject) => this.#nextResolve = [p.length, { resolve, reject }]);
+        }
+        p.set(this.#buffer.splice(0, p.length));
+    }
+    async #write(p) {
+        await new Promise((resolve, reject) => {
+            this.#socket.write(p, (err) => {
+                (err === undefined || err === null) ? resolve() : reject(err);
+            });
+        });
+    }
+    async read(p) {
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
+        try {
+            while (this.#packetBuffer.byteLength < p.byteLength) {
+                await this.#readPacket();
+            }
+            p.set(this.#packetBuffer.subarray(0, p.byteLength));
+            this.#packetBuffer = this.#packetBuffer.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.#socket.destroy();
+        this.#socket = 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)]);