@mtkruto/browser 0.132.0 → 0.133.0

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.js";
+export * from "./connection/1_connection_tls.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,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,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.js";
+export * from "./connection/1_connection_tls.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":"AAGA,wBAAsB,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,oCASjE"}

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.byteLength > 16 ? 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;
+    }
+}