@mtkruto/browser 0.133.0 → 0.135.0

package/script/connection/1_connection_socks5.js

@@ -0,0 +1,196 @@
+"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.ConnectionSocks5 = void 0;
+const _0_deps_js_1 = require("../0_deps.js");
+const _0_errors_js_1 = require("../0_errors.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const VERSION_SOCKS = 5;
+const VERSION_USERNAME_PASSWORD_AUTH = 1;
+const AUTH_MEHTOD_NONE = 0;
+const AUTH_METHOD_USERNAME_PASSWORD = 2;
+const RESULT_SUCCESS = 0;
+const COMMAND_CONNECT = 1;
+const ADDRESS_TYPE_4 = 1;
+const ADDRESS_TYPE_DOMAIN_NAME = 3;
+const ADDRESS_TYPE_6 = 4;
+const L = (0, _1_utilities_js_1.getLogger)("ConnectionSocks5");
+class ConnectionSocks5 {
+    #hostname;
+    #port;
+    #socks5Hostname;
+    #socks5Port;
+    #credentials;
+    #connection;
+    #rMutex = new _1_utilities_js_1.Mutex();
+    #wMutex = new _1_utilities_js_1.Mutex();
+    #canRead = false;
+    #canWrite = false;
+    stateChangeHandler;
+    callback;
+    constructor(hostname, port, socks5Hostname, socks5Port, params) {
+        this.#hostname = hostname.slice(0, 255);
+        this.#port = port;
+        this.#socks5Hostname = socks5Hostname;
+        this.#socks5Port = socks5Port;
+        this.#credentials = params?.username && params.password ? { username: params.username.slice(0, 255), password: params.password.slice(0, 255) } : undefined;
+    }
+    get isConnected() {
+        return !!this.#connection && this.#canRead && this.#canWrite;
+    }
+    #assertConnected() {
+        if (!this.isConnected) {
+            throw new _0_errors_js_1.ConnectionError("The connection is not open.");
+        }
+    }
+    async open() {
+        if (this.isConnected) {
+            return;
+        }
+        const connection = await Deno.connect({
+            hostname: this.#socks5Hostname,
+            port: this.#socks5Port,
+        });
+        connection.setNoDelay(true);
+        connection.setKeepAlive(true);
+        this.#canRead = this.#canWrite = true;
+        this.#connection = connection;
+        const header = new Uint8Array([VERSION_SOCKS, 2, AUTH_MEHTOD_NONE, AUTH_METHOD_USERNAME_PASSWORD]);
+        await this.write(header);
+        const negotiation = new Uint8Array(2);
+        await this.read(negotiation);
+        if (negotiation[0] !== VERSION_SOCKS || (negotiation[1] !== AUTH_MEHTOD_NONE && negotiation[1] !== AUTH_METHOD_USERNAME_PASSWORD)) {
+            throw new _0_errors_js_1.ConnectionError("Negotiation with SOCKS5 server failed.");
+        }
+        if (negotiation[1] === AUTH_METHOD_USERNAME_PASSWORD && !this.#credentials) {
+            throw new _0_errors_js_1.ConnectionError("Username and password are required for connecting to SOCKS5 server.");
+        }
+        else if (this.#credentials) {
+            await this.write((0, _0_deps_js_1.concat)([new Uint8Array([VERSION_USERNAME_PASSWORD_AUTH, this.#credentials.username.length]), (0, _1_utilities_js_1.encodeText)(this.#credentials.username), new Uint8Array([this.#credentials.password.length]), (0, _1_utilities_js_1.encodeText)(this.#credentials.password)]));
+            const status = new Uint8Array(2);
+            await this.read(status);
+            if (status[0] !== VERSION_USERNAME_PASSWORD_AUTH || status[1] !== RESULT_SUCCESS) {
+                throw new _0_errors_js_1.ConnectionError("SOCKS5 username and password authentication failed.");
+            }
+        }
+        let hostnameType;
+        let hostname;
+        if ((0, _0_deps_js_1.isIPv4)(this.#hostname)) {
+            hostnameType = ADDRESS_TYPE_4;
+            hostname = new Uint8Array((0, _1_utilities_js_1.ipv4ToBytes)(this.#hostname));
+        }
+        else if ((0, _0_deps_js_1.isIPv6)(this.#hostname)) {
+            hostnameType = ADDRESS_TYPE_6;
+            hostname = new Uint8Array((0, _1_utilities_js_1.ipv6ToBytes)(this.#hostname));
+        }
+        else {
+            hostnameType = ADDRESS_TYPE_DOMAIN_NAME;
+            hostname = (0, _0_deps_js_1.concat)([new Uint8Array([this.#hostname.length]), (0, _1_utilities_js_1.encodeText)(this.#hostname)]);
+        }
+        const address = (0, _0_deps_js_1.concat)([new Uint8Array([hostnameType]), hostname, new Uint8Array(2)]);
+        new DataView(address.buffer).setUint16(hostname.byteLength + 1, this.#port);
+        await this.write((0, _0_deps_js_1.concat)([new Uint8Array([VERSION_SOCKS, COMMAND_CONNECT, 0]), address]));
+        const status = new Uint8Array(3);
+        await this.read(status);
+        if (status[0] !== VERSION_SOCKS || status[1] !== RESULT_SUCCESS) {
+            throw new _0_errors_js_1.ConnectionError("Connection with SOCKS5 server failed.");
+        }
+        const addressType = new Uint8Array(1);
+        await this.read(addressType);
+        switch (addressType[0]) {
+            case ADDRESS_TYPE_4: {
+                const ipv4 = new Uint8Array(4);
+                await this.read(ipv4);
+                break;
+            }
+            case ADDRESS_TYPE_6: {
+                const ipv4 = new Uint8Array(16);
+                await this.read(ipv4);
+                break;
+            }
+            case ADDRESS_TYPE_DOMAIN_NAME: {
+                const length = new Uint8Array(1);
+                await this.read(length);
+                const domainName = new Uint8Array(length[0]);
+                await this.read(domainName);
+                break;
+            }
+        }
+        const port = new Uint8Array(2);
+        await this.read(port);
+        this.stateChangeHandler?.(true);
+        L.debug("connected to", this.#hostname, "port", this.#port, "through socks5 server", this.#socks5Hostname, "port", this.#socks5Port);
+    }
+    async read(p) {
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
+        let offset = 0;
+        try {
+            do {
+                const read = await this.#connection.read(p.subarray(offset));
+                if (read === null) {
+                    this.#canRead = false;
+                    this.stateChangeHandler?.(false);
+                    throw new _0_errors_js_1.ConnectionError("The connection was closed.");
+                }
+                offset += read;
+            } while (offset < p.byteLength);
+        }
+        catch {
+            this.#canRead = false;
+            this.stateChangeHandler?.(false);
+            throw new _0_errors_js_1.ConnectionError("The connection was closed.");
+        }
+        finally {
+            unlock();
+        }
+    }
+    async write(p) {
+        this.#assertConnected();
+        const unlock = await this.#wMutex.lock();
+        try {
+            this.#assertConnected();
+            let written = 0;
+            while (written < p.byteLength) {
+                try {
+                    const wrote = await this.#connection.write(p.subarray(written));
+                    this.callback?.write(wrote);
+                    written += wrote;
+                }
+                catch {
+                    this.#canWrite = false;
+                    this.stateChangeHandler?.(false);
+                    throw new _0_errors_js_1.ConnectionError("The connection was closed.");
+                }
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+    close() {
+        this.#assertConnected();
+        this.#connection.close();
+        this.#canRead = this.#canWrite = false;
+        this.#connection = undefined;
+    }
+}
+exports.ConnectionSocks5 = ConnectionSocks5;

package/script/connection/1_connection_socks5.node.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 interface ConnectionSocks5Params {
+    username: string;
+    password: string;
+}
+export declare class ConnectionSocks5 implements Connection {
+    #private;
+    stateChangeHandler?: Connection["stateChangeHandler"];
+    constructor(hostname: string, port: number, socks5Hostname: string, socks5Port: number, params?: ConnectionSocks5Params);
+    open(): Promise<void> | undefined;
+    get isConnected(): boolean;
+    read(p: Uint8Array): Promise<void>;
+    write(p: Uint8Array): Promise<void>;
+    close(): void;
+}
+//# sourceMappingURL=1_connection_socks5.node.d.ts.map

package/script/connection/1_connection_socks5.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"1_connection_socks5.node.d.ts","sourceRoot":"","sources":["../../src/connection/1_connection_socks5.node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAkBpD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,gBAAiB,YAAW,UAAU;;IAejD,kBAAkB,CAAC,EAAE,UAAU,CAAC,oBAAoB,CAAC,CAAC;gBAE1C,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,sBAAsB;IAevH,IAAI;IAoHJ,IAAI,WAAW,YAEd;IAQK,IAAI,CAAC,CAAC,EAAE,UAAU;IAclB,KAAK,CAAC,CAAC,EAAE,UAAU;IA0BzB,KAAK;CAKN"}

package/script/connection/1_connection_socks5.node.js

@@ -0,0 +1,218 @@
+"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.ConnectionSocks5 = void 0;
+const node_net_1 = require("node:net");
+const _0_deps_js_1 = require("../0_deps.js");
+const _0_errors_js_1 = require("../0_errors.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const VERSION_SOCKS = 5;
+const VERSION_USERNAME_PASSWORD_AUTH = 1;
+const AUTH_MEHTOD_NONE = 0;
+const AUTH_METHOD_USERNAME_PASSWORD = 2;
+const RESULT_SUCCESS = 0;
+const COMMAND_CONNECT = 1;
+const ADDRESS_TYPE_4 = 1;
+const ADDRESS_TYPE_DOMAIN_NAME = 3;
+const ADDRESS_TYPE_6 = 4;
+const L = (0, _1_utilities_js_1.getLogger)("ConnectionTCP");
+const errConnectionNotOpen = new _0_errors_js_1.ConnectionError("The connection is not open.");
+class ConnectionSocks5 {
+    #hostname;
+    #port;
+    #socks5Hostname;
+    #socks5Port;
+    #credentials;
+    #socket;
+    #rMutex = new _1_utilities_js_1.Mutex();
+    #wMutex = new _1_utilities_js_1.Mutex();
+    #buffer = new Array();
+    #nextResolve = null;
+    stateChangeHandler;
+    constructor(hostname, port, socks5Hostname, socks5Port, params) {
+        this.#hostname = hostname.slice(0, 255);
+        this.#port = port;
+        this.#socks5Hostname = socks5Hostname;
+        this.#socks5Port = socks5Port;
+        this.#credentials = params?.username && params.password ? { username: params.username.slice(0, 255), password: params.password.slice(0, 255) } : undefined;
+    }
+    #rejectRead() {
+        if (this.#nextResolve !== null) {
+            this.#nextResolve[1].reject(errConnectionNotOpen);
+            this.#nextResolve = null;
+        }
+    }
+    open() {
+        if (this.isConnected) {
+            return;
+        }
+        this.#socket = new node_net_1.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();
+            }
+        });
+        return new Promise((resolve, reject) => {
+            this.#socket.connect(this.#socks5Port, this.#socks5Hostname);
+            this.#socket.once("error", reject);
+            this.#socket.once("connect", async () => {
+                this.#socket.off("error", reject);
+                try {
+                    const header = new Uint8Array([VERSION_SOCKS, 2, AUTH_MEHTOD_NONE, AUTH_METHOD_USERNAME_PASSWORD]);
+                    await this.write(header);
+                    const negotiation = new Uint8Array(2);
+                    await this.read(negotiation);
+                    if (negotiation[0] !== VERSION_SOCKS || (negotiation[1] !== AUTH_MEHTOD_NONE && negotiation[1] !== AUTH_METHOD_USERNAME_PASSWORD)) {
+                        throw new _0_errors_js_1.ConnectionError("Negotiation with SOCKS5 server failed.");
+                    }
+                    if (negotiation[1] === AUTH_METHOD_USERNAME_PASSWORD && !this.#credentials) {
+                        throw new _0_errors_js_1.ConnectionError("Username and password are required for connecting to SOCKS5 server.");
+                    }
+                    else if (this.#credentials) {
+                        await this.write((0, _0_deps_js_1.concat)([new Uint8Array([VERSION_USERNAME_PASSWORD_AUTH, this.#credentials.username.length]), (0, _1_utilities_js_1.encodeText)(this.#credentials.username), new Uint8Array([this.#credentials.password.length]), (0, _1_utilities_js_1.encodeText)(this.#credentials.password)]));
+                        const status = new Uint8Array(2);
+                        await this.read(status);
+                        if (status[0] !== VERSION_USERNAME_PASSWORD_AUTH || status[1] !== RESULT_SUCCESS) {
+                            throw new _0_errors_js_1.ConnectionError("SOCKS5 username and password authentication failed.");
+                        }
+                    }
+                    let hostnameType;
+                    let hostname;
+                    if ((0, _0_deps_js_1.isIPv4)(this.#hostname)) {
+                        hostnameType = ADDRESS_TYPE_4;
+                        hostname = new Uint8Array((0, _1_utilities_js_1.ipv4ToBytes)(this.#hostname));
+                    }
+                    else if ((0, _0_deps_js_1.isIPv6)(this.#hostname)) {
+                        hostnameType = ADDRESS_TYPE_6;
+                        hostname = new Uint8Array((0, _1_utilities_js_1.ipv6ToBytes)(this.#hostname));
+                    }
+                    else {
+                        hostnameType = ADDRESS_TYPE_DOMAIN_NAME;
+                        hostname = (0, _0_deps_js_1.concat)([new Uint8Array([this.#hostname.length]), (0, _1_utilities_js_1.encodeText)(this.#hostname)]);
+                    }
+                    const address = (0, _0_deps_js_1.concat)([new Uint8Array([hostnameType]), hostname, new Uint8Array(2)]);
+                    new DataView(address.buffer).setUint16(hostname.byteLength + 1, this.#port);
+                    await this.write((0, _0_deps_js_1.concat)([new Uint8Array([VERSION_SOCKS, COMMAND_CONNECT, 0]), address]));
+                    const status = new Uint8Array(3);
+                    await this.read(status);
+                    if (status[0] !== VERSION_SOCKS || status[1] !== RESULT_SUCCESS) {
+                        throw new _0_errors_js_1.ConnectionError("Connection with SOCKS5 server failed.");
+                    }
+                    const addressType = new Uint8Array(1);
+                    await this.read(addressType);
+                    switch (addressType[0]) {
+                        case ADDRESS_TYPE_4: {
+                            const ipv4 = new Uint8Array(4);
+                            await this.read(ipv4);
+                            break;
+                        }
+                        case ADDRESS_TYPE_6: {
+                            const ipv4 = new Uint8Array(16);
+                            await this.read(ipv4);
+                            break;
+                        }
+                        case ADDRESS_TYPE_DOMAIN_NAME: {
+                            const length = new Uint8Array(1);
+                            await this.read(length);
+                            const domainName = new Uint8Array(length[0]);
+                            await this.read(domainName);
+                            break;
+                        }
+                    }
+                    const port = new Uint8Array(2);
+                    await this.read(port);
+                }
+                catch (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+                this.stateChangeHandler?.(true);
+                L.debug("connected to", this.#hostname, "port", this.#port, "through socks5 server", this.#socks5Hostname, "port", this.#socks5Port);
+            });
+        });
+    }
+    get isConnected() {
+        return this.#socket?.readyState === "open";
+    }
+    #assertConnected() {
+        if (!this.isConnected) {
+            throw errConnectionNotOpen;
+        }
+    }
+    async read(p) {
+        this.#assertConnected();
+        const unlock = await this.#rMutex.lock();
+        try {
+            this.#assertConnected();
+            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));
+        }
+        finally {
+            unlock();
+        }
+    }
+    async write(p) {
+        this.#assertConnected();
+        const unlock = await this.#wMutex.lock();
+        try {
+            this.#assertConnected();
+            try {
+                await new Promise((resolve, reject) => {
+                    this.#socket.write(p, (err) => {
+                        (err === undefined || err === null) ? resolve() : reject(err);
+                    });
+                });
+            }
+            catch (err) {
+                if (!this.isConnected) {
+                    throw errConnectionNotOpen;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+    close() {
+        this.#assertConnected();
+        this.#socket.destroy();
+        this.#socket = undefined;
+    }
+}
+exports.ConnectionSocks5 = ConnectionSocks5;

package/script/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;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"}
+{"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,CAEzB;IAQK,IAAI;IAiBJ,IAAI,CAAC,CAAC,EAAE,UAAU;IAyBlB,KAAK,CAAC,CAAC,EAAE,UAAU;IAsBzB,KAAK;CAMN"}

package/script/connection/1_connection_tcp.js

@@ -39,7 +39,6 @@ class ConnectionTCP {
         this.#port = port;
     }
     get isConnected() {
-        Deno.errors.BrokenPipe;
         return !!this.#connection && this.#canRead && this.#canWrite;
     }
     #assertConnected() {

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"}