@mtkruto/browser 0.132.1 → 0.134.0

package/script/deps/jsr.io/@std/net/1.0.6/unstable_ip.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Validates whether a given string is a valid IPv4 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr IPv4 address in a string format (e.g., "192.168.0.1").
+ * @returns A boolean indicating if the string is a valid IPv4 address.
+ *
+ * @example Check if the address is a IPv4
+ * ```ts
+ * import { isIPv4 } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * const correctIp = "192.168.0.1"
+ * const incorrectIp = "192.168.0.256"
+ *
+ * assert(isIPv4(correctIp))
+ * assertFalse(isIPv4(incorrectIp))
+ * ```
+ */
+export declare function isIPv4(addr: string): boolean;
+/**
+ * Validates whether a given string is a IPv6 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr IPv6 address in a string format (e.g., "2001:db8::1").
+ * @returns A boolean indicating if the string is a valid IPv6 address.
+ *
+ * @example Check if the address is a IPv6
+ * ```ts
+ * import { isIPv6 } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * const correctIp = "2001::db8:0:1"
+ * const incorrectIp = "2001::db8::1"
+ *
+ * assert(isIPv6(correctIp))
+ * assertFalse(isIPv6(incorrectIp))
+ * ```
+ */
+export declare function isIPv6(addr: string): boolean;
+/**
+ * Checks if an IP address matches a subnet or specific IP address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv4 or IPv6)
+ * @param subnetOrIps The subnet in CIDR notation (e.g., "192.168.1.0/24") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchSubnets } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchSubnets("192.168.1.10", ["192.168.1.0/24"]));
+ * assertFalse(matchSubnets("192.168.2.10", ["192.168.1.0/24"]));
+ *
+ * assert(matchSubnets("2001:db8::ffff", ["2001:db8::/64"]));
+ * assertFalse(matchSubnets("2001:db9::1", ["2001:db8::/64"]));
+ * ```
+ */
+export declare function matchSubnets(addr: string, subnetOrIps: string[]): boolean;
+/**
+ * Checks if an IPv4 address matches a subnet or specific IPv4 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv4)
+ * @param subnet The subnet in CIDR notation (e.g., "192.168.1.0/24") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchIPv4Subnet } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchIPv4Subnet("192.168.1.10", "192.168.1.0/24"));
+ * assertFalse(matchIPv4Subnet("192.168.2.10", "192.168.1.0/24"));
+ * ```
+ */
+export declare function matchIPv4Subnet(addr: string, subnet: string): boolean;
+/**
+ * Checks if an IPv6 address matches a subnet or specific IPv6 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv6)
+ * @param subnet The subnet in CIDR notation (e.g., "2001:db8::/64") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchIPv6Subnet } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchIPv6Subnet("2001:db8::ffff", "2001:db8::/64"));
+ * assertFalse(matchIPv6Subnet("2001:db9::1", "2001:db8::/64"));
+ * ```
+ */
+export declare function matchIPv6Subnet(addr: string, subnet: string): boolean;
+//# sourceMappingURL=unstable_ip.d.ts.map

package/script/deps/jsr.io/@std/net/1.0.6/unstable_ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unstable_ip.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/net/1.0.6/unstable_ip.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAU5C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAiC5C;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,OAAO,CAYzE;AAwCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CA6CrE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAoDrE"}

package/script/deps/jsr.io/@std/net/1.0.6/unstable_ip.js

@@ -0,0 +1,303 @@
+"use strict";
+// Copyright 2018-2025 the Deno authors. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIPv4 = isIPv4;
+exports.isIPv6 = isIPv6;
+exports.matchSubnets = matchSubnets;
+exports.matchIPv4Subnet = matchIPv4Subnet;
+exports.matchIPv6Subnet = matchIPv6Subnet;
+/**
+ * Validates whether a given string is a valid IPv4 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr IPv4 address in a string format (e.g., "192.168.0.1").
+ * @returns A boolean indicating if the string is a valid IPv4 address.
+ *
+ * @example Check if the address is a IPv4
+ * ```ts
+ * import { isIPv4 } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * const correctIp = "192.168.0.1"
+ * const incorrectIp = "192.168.0.256"
+ *
+ * assert(isIPv4(correctIp))
+ * assertFalse(isIPv4(incorrectIp))
+ * ```
+ */
+function isIPv4(addr) {
+    const octets = addr.split(".");
+    return (octets.length === 4 &&
+        octets.every((octet) => {
+            const n = Number(octet);
+            return n >= 0 && n <= 255 && !isNaN(n);
+        }));
+}
+/**
+ * Validates whether a given string is a IPv6 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr IPv6 address in a string format (e.g., "2001:db8::1").
+ * @returns A boolean indicating if the string is a valid IPv6 address.
+ *
+ * @example Check if the address is a IPv6
+ * ```ts
+ * import { isIPv6 } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * const correctIp = "2001::db8:0:1"
+ * const incorrectIp = "2001::db8::1"
+ *
+ * assert(isIPv6(correctIp))
+ * assertFalse(isIPv6(incorrectIp))
+ * ```
+ */
+function isIPv6(addr) {
+    // more than one use of ::
+    if (addr.split("::").length > 2)
+        return false;
+    const hextets = addr.split(":");
+    // x:x:x:x:x:x:d.d.d.d (https://www.rfc-editor.org/rfc/rfc4291#section-2.2)
+    // check if has ipv4 on
+    if (addr.includes(".")) {
+        // is just an ipv4
+        if (hextets.length === 1)
+            return false;
+        const last = hextets.pop();
+        if (!last || !isIPv4(last))
+            return false;
+        // just to maintain the length to 8
+        hextets.push("");
+    }
+    // expand ::
+    while (hextets.length < 8) {
+        const idx = hextets.indexOf("");
+        if (idx === -1)
+            break;
+        hextets.splice(idx, 0, "");
+    }
+    return (hextets.length === 8 &&
+        hextets.every((hextet) => {
+            const n = hextet === "" ? 0 : parseInt(hextet, 16);
+            return n >= 0 && n <= 65535 && !isNaN(n);
+        }));
+}
+/**
+ * Checks if an IP address matches a subnet or specific IP address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv4 or IPv6)
+ * @param subnetOrIps The subnet in CIDR notation (e.g., "192.168.1.0/24") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchSubnets } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchSubnets("192.168.1.10", ["192.168.1.0/24"]));
+ * assertFalse(matchSubnets("192.168.2.10", ["192.168.1.0/24"]));
+ *
+ * assert(matchSubnets("2001:db8::ffff", ["2001:db8::/64"]));
+ * assertFalse(matchSubnets("2001:db9::1", ["2001:db8::/64"]));
+ * ```
+ */
+function matchSubnets(addr, subnetOrIps) {
+    if (!isValidIP(addr)) {
+        return false;
+    }
+    for (const subnetOrIp of subnetOrIps) {
+        if (matchSubnet(addr, subnetOrIp)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchSubnet(addr, subnet) {
+    // If the subnet doesn't contain "/", treat it as a specific IP address
+    if (!subnet.includes("/")) {
+        return addr === subnet;
+    }
+    // Parse subnet into IP address and prefix length
+    const [subnetIP, prefixLengthStr] = subnet.split("/");
+    if (!subnetIP ||
+        subnetIP === "" ||
+        !prefixLengthStr ||
+        prefixLengthStr === "") {
+        return false;
+    }
+    // Check if both IP and subnet are the same type (IPv4 or IPv6)
+    const ipIsV4 = isIPv4(addr);
+    const subnetIsV4 = isIPv4(subnetIP);
+    // IP and subnet must be the same version (both IPv4 or both IPv6)
+    if (ipIsV4 !== subnetIsV4) {
+        return false;
+    }
+    // Delegate to the appropriate subnet matching function
+    if (ipIsV4) {
+        return matchIPv4Subnet(addr, subnet);
+    }
+    else {
+        return matchIPv6Subnet(addr, subnet);
+    }
+}
+function isValidIP(ip) {
+    return isIPv4(ip) || isIPv6(ip);
+}
+/**
+ * Checks if an IPv4 address matches a subnet or specific IPv4 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv4)
+ * @param subnet The subnet in CIDR notation (e.g., "192.168.1.0/24") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchIPv4Subnet } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchIPv4Subnet("192.168.1.10", "192.168.1.0/24"));
+ * assertFalse(matchIPv4Subnet("192.168.2.10", "192.168.1.0/24"));
+ * ```
+ */
+function matchIPv4Subnet(addr, subnet) {
+    const [subnetIP, prefixLengthStr] = subnet.split("/");
+    const prefix = parseInt(prefixLengthStr, 10);
+    if (isNaN(prefix)) {
+        return false;
+    }
+    if (!subnetIP ||
+        subnetIP === "" ||
+        !prefixLengthStr ||
+        prefixLengthStr === "") {
+        return false;
+    }
+    if (prefix < 0 || prefix > 32) {
+        return false;
+    }
+    // Special case: /0 matches all IPv4 addresses
+    if (prefix === 0) {
+        return true;
+    }
+    const ipBytes = addr.split(".").map(Number);
+    const subnetBytes = subnetIP.split(".").map(Number);
+    if (ipBytes.length !== 4 || subnetBytes.length !== 4) {
+        return false;
+    }
+    const mask = (0xffffffff << (32 - prefix)) >>> 0;
+    const ipInt = (ipBytes[0] << 24) |
+        (ipBytes[1] << 16) |
+        (ipBytes[2] << 8) |
+        ipBytes[3];
+    const subnetInt = (subnetBytes[0] << 24) |
+        (subnetBytes[1] << 16) |
+        (subnetBytes[2] << 8) |
+        subnetBytes[3];
+    return ((ipInt >>> 0) & mask) === ((subnetInt >>> 0) & mask);
+}
+/**
+ * Checks if an IPv6 address matches a subnet or specific IPv6 address.
+ *
+ * @experimental **UNSTABLE**: New API, yet to be vetted.
+ *
+ * @param addr The IP address to check (IPv6)
+ * @param subnet The subnet in CIDR notation (e.g., "2001:db8::/64") or a specific IP address
+ * @returns true if the IP address matches the subnet or IP, false otherwise
+ * @example Check if the address is a IPv6
+ *
+ * ```ts
+ * import { matchIPv6Subnet } from "@std/net/unstable-ip"
+ * import { assert, assertFalse } from "@std/assert"
+ *
+ * assert(matchIPv6Subnet("2001:db8::ffff", "2001:db8::/64"));
+ * assertFalse(matchIPv6Subnet("2001:db9::1", "2001:db8::/64"));
+ * ```
+ */
+function matchIPv6Subnet(addr, subnet) {
+    const [subnetIP, prefixLengthStr] = subnet.split("/");
+    const prefix = parseInt(prefixLengthStr, 10);
+    if (isNaN(prefix)) {
+        return false;
+    }
+    if (!subnetIP ||
+        subnetIP === "" ||
+        !prefixLengthStr ||
+        prefixLengthStr === "") {
+        return false;
+    }
+    if (prefix < 0 || prefix > 128) {
+        return false;
+    }
+    if (prefix === 0) {
+        return true;
+    }
+    const ipExpanded = expandIPv6(addr);
+    const subnetExpanded = expandIPv6(subnetIP);
+    if (!ipExpanded || !subnetExpanded) {
+        return false;
+    }
+    const ipBytes = ipv6ToBytes(ipExpanded);
+    const subnetBytes = ipv6ToBytes(subnetExpanded);
+    const fullBytes = Math.floor(prefix / 8);
+    const remainingBits = prefix % 8;
+    for (let i = 0; i < fullBytes; i++) {
+        if (ipBytes[i] !== subnetBytes[i]) {
+            return false;
+        }
+    }
+    if (remainingBits > 0) {
+        const mask = 0xff << (8 - remainingBits);
+        const ipByte = ipBytes[fullBytes];
+        const subnetByte = subnetBytes[fullBytes];
+        return (ipByte & mask) === (subnetByte & mask);
+    }
+    return true;
+}
+function expandIPv6(addr) {
+    if (addr.includes(".")) {
+        const parts = addr.split(":");
+        const ipv4Part = parts.pop();
+        if (!ipv4Part) {
+            return null;
+        }
+        const ipv4Bytes = ipv4Part.split(".").map(Number);
+        if (ipv4Bytes.length !== 4) {
+            return null;
+        }
+        const ipv4Hex = ((ipv4Bytes[0] << 8) | ipv4Bytes[1]).toString(16).padStart(4, "0") +
+            ":" +
+            ((ipv4Bytes[2] << 8) | ipv4Bytes[3]).toString(16).padStart(4, "0");
+        addr = parts.join(":") + ":" + ipv4Hex;
+    }
+    let expanded = addr;
+    // Handle ::
+    if (expanded.includes("::")) {
+        const parts = expanded.split("::");
+        const leftParts = parts[0] ? parts[0].split(":") : [];
+        const rightParts = parts[1] ? parts[1].split(":") : [];
+        const missingParts = 8 - leftParts.length - rightParts.length;
+        expanded = leftParts
+            .concat(new Array(missingParts).fill("0"))
+            .concat(rightParts)
+            .join(":");
+    }
+    // Pad each hextet to 4 digits
+    return expanded
+        .split(":")
+        .map((hextet) => hextet.padStart(4, "0"))
+        .join(":");
+}
+function ipv6ToBytes(expandedIPv6) {
+    const hextets = expandedIPv6.split(":");
+    const bytes = [];
+    for (const hextet of hextets) {
+        const value = parseInt(hextet, 16);
+        bytes.push((value >> 8) & 0xff, value & 0xff);
+    }
+    return bytes;
+}

package/script/transport/2_transport_provider_mtproxy.d.ts

@@ -18,6 +18,6 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { type TransportProvider } from "./1_transport_provider.js";
-export declare function transportProviderMtproxy(link: string): TransportProvider;
+export declare function transportProviderMtproxy(url: string): TransportProvider;
 export declare function transportProviderMtproxy(hostname: string, port: number, secret: Uint8Array<ArrayBuffer>): TransportProvider;
 //# sourceMappingURL=2_transport_provider_mtproxy.d.ts.map

package/script/transport/2_transport_provider_mtproxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_transport_provider_mtproxy.d.ts","sourceRoot":"","sources":["../../src/transport/2_transport_provider_mtproxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,EAAW,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE5E,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC;AAC1E,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,iBAAiB,CAAC"}
+{"version":3,"file":"2_transport_provider_mtproxy.d.ts","sourceRoot":"","sources":["../../src/transport/2_transport_provider_mtproxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,EAAW,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE5E,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC;AACzE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,iBAAiB,CAAC"}

package/script/transport/2_transport_provider_mtproxy.js

@@ -25,10 +25,10 @@ const _1_connection_tcp_js_1 = require("../connection/1_connection_tcp.js");
 const _1_connection_tls_js_1 = require("../connection/1_connection_tls.js");
 const _1_transport_intermediate_js_1 = require("./1_transport_intermediate.js");
 const _1_transport_provider_js_1 = require("./1_transport_provider.js");
-function transportProviderMtproxy(hostnameOrLink, port, secret) {
-    let hostname = hostnameOrLink;
+function transportProviderMtproxy(urlOrHostname, port, secret) {
+    let hostname = urlOrHostname;
     if (port === undefined && secret === undefined) {
-        const url = new URL(hostnameOrLink);
+        const url = new URL(urlOrHostname);
         const hostname_ = url.searchParams.get("server");
         const port_ = url.searchParams.get("port");
         const secret_ = url.searchParams.get("secret");

package/script/transport/2_transport_provider_socks5.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 TransportProvider } from "./1_transport_provider.js";
+export interface TransportProviderSocks5Params {
+    username: string;
+    password: string;
+}
+export declare function transportProviderSocks5(url: string): TransportProvider;
+export declare function transportProviderSocks5(hostname: string, port: number, params?: TransportProviderSocks5Params): TransportProvider;
+//# sourceMappingURL=2_transport_provider_socks5.d.ts.map

package/script/transport/2_transport_provider_socks5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"2_transport_provider_socks5.d.ts","sourceRoot":"","sources":["../../src/transport/2_transport_provider_socks5.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEtF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC;AACxE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,6BAA6B,GAAG,iBAAiB,CAAC"}

package/script/transport/2_transport_provider_socks5.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * 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/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportProviderSocks5 = transportProviderSocks5;
+const _1_connection_socks5_node_js_1 = require("../connection/1_connection_socks5.node.js");
+const _0_deps_js_1 = require("../0_deps.js");
+const _1_transport_abridged_js_1 = require("./1_transport_abridged.js");
+const _1_transport_provider_js_1 = require("./1_transport_provider.js");
+function transportProviderSocks5(urlOrHostname, port, params) {
+    let hostname = urlOrHostname;
+    if (port === undefined && params === undefined) {
+        const url = new URL(urlOrHostname);
+        const hostname_ = url.hostname;
+        const port_ = url.port || "1080";
+        const username = url.username;
+        const password = url.password;
+        if (!hostname_ || !port_) {
+            throw new TypeError("Invalid SOCKS5 URL.");
+        }
+        hostname = hostname_;
+        port = parseInt(port_);
+        params = { ...(params ?? {}), username, password };
+    }
+    return ({ dc, isCdn }) => {
+        const dcId = (0, _1_transport_provider_js_1.getDcId)(dc, isCdn);
+        const connection = new _1_connection_socks5_node_js_1.ConnectionSocks5((0, _1_transport_provider_js_1.getDcIps)(dc, (0, _0_deps_js_1.isIPv6)(hostname) ? "ipv6" : "ipv4")[0], 80, hostname, port, params);
+        const transport = new _1_transport_abridged_js_1.TransportAbridged(connection, false);
+        return { connection, transport, dcId };
+    };
+}

package/script/types/5_star_transaction.js

@@ -57,7 +57,7 @@ function constructStarTransaction(starTransaction, getPeer) {
         description: starTransaction.description,
         transactionDate: starTransaction.transaction_date,
         transactionUrl: starTransaction.transaction_url,
-        botPayload: new TextDecoder().decode(starTransaction.bot_payload),
+        botPayload: starTransaction.bot_payload ? (0, _1_utilities_js_1.decodeText)(starTransaction.bot_payload) : undefined,
         messageId: starTransaction.msg_id,
         subscriptionPeriod: starTransaction.subscription_period,
         giveawayMessageId: starTransaction.giveaway_post_id,

package/script/utilities/0_ip.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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/>.
+ */
+export declare function ipv4ToBytes(ipv4: string): number[];
+export declare function ipv6ToBytes(ipv6: string): number[];
+//# sourceMappingURL=0_ip.d.ts.map

package/script/utilities/0_ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0_ip.d.ts","sourceRoot":"","sources":["../../src/utilities/0_ip.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAElD;AAGD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOlD"}

package/script/utilities/0_ip.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * 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/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipv4ToBytes = ipv4ToBytes;
+exports.ipv6ToBytes = ipv6ToBytes;
+function ipv4ToBytes(ipv4) {
+    return ipv4.split(".").map(Number);
+}
+// https://jsr.io/@std/net/1.0.6/unstable_ip.ts
+function ipv6ToBytes(ipv6) {
+    const expandedIpv6 = expandIpv6(ipv6);
+    if (expandedIpv6 === null) {
+        throw new TypeError("Invalid IPv6");
+    }
+    return expandedIpv6ToBytes(expandedIpv6);
+}
+function expandIpv6(addr) {
+    if (addr.includes(".")) {
+        const parts = addr.split(":");
+        const ipv4Part = parts.pop();
+        if (!ipv4Part) {
+            return null;
+        }
+        const ipv4Bytes = ipv4Part.split(".").map(Number);
+        if (ipv4Bytes.length !== 4) {
+            return null;
+        }
+        const ipv4Hex = ((ipv4Bytes[0] << 8) | ipv4Bytes[1]).toString(16).padStart(4, "0") +
+            ":" +
+            ((ipv4Bytes[2] << 8) | ipv4Bytes[3]).toString(16).padStart(4, "0");
+        addr = parts.join(":") + ":" + ipv4Hex;
+    }
+    let expanded = addr;
+    // Handle ::
+    if (expanded.includes("::")) {
+        const parts = expanded.split("::");
+        const leftParts = parts[0] ? parts[0].split(":") : [];
+        const rightParts = parts[1] ? parts[1].split(":") : [];
+        const missingParts = 8 - leftParts.length - rightParts.length;
+        expanded = leftParts
+            .concat(new Array(missingParts).fill("0"))
+            .concat(rightParts)
+            .join(":");
+    }
+    // Pad each hextet to 4 digits
+    return expanded
+        .split(":")
+        .map((hextet) => hextet.padStart(4, "0"))
+        .join(":");
+}
+function expandedIpv6ToBytes(expandedIPv6) {
+    const hextets = expandedIPv6.split(":");
+    const bytes = [];
+    for (const hextet of hextets) {
+        const value = parseInt(hextet, 16);
+        bytes.push((value >> 8) & 0xff, value & 0xff);
+    }
+    return bytes;
+}