@mtkruto/node 0.1.800 → 0.2.1

package/esm/deps/deno.land/std@0.224.0/io/_constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_constants.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/io/_constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,QAAS,CAAC;AACzC,eAAO,MAAM,mBAAmB,QAAY,CAAC"}

package/esm/deps/deno.land/std@0.224.0/io/_constants.js

@@ -0,0 +1,4 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export const DEFAULT_CHUNK_SIZE = 16640;
+export const DEFAULT_BUFFER_SIZE = 32 * 1024;

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.d.ts

@@ -0,0 +1,70 @@
+import type { Reader, ReaderSync } from "./types.js";
+export type { Reader, ReaderSync };
+/**
+ * Turns a {@linkcode Reader} into an async iterator.
+ *
+ * @example
+ * ```ts
+ * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = await Deno.open("/etc/passwd");
+ * for await (const chunk of iterateReader(file)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Second argument can be used to tune size of a buffer.
+ * Default size of the buffer is 32kB.
+ *
+ * @example
+ * ```ts
+ * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = await Deno.open("/etc/passwd");
+ * const iter = iterateReader(file, {
+ *   bufSize: 1024 * 1024
+ * });
+ * for await (const chunk of iter) {
+ *   console.log(chunk);
+ * }
+ * ```
+ */
+export declare function iterateReader(reader: Reader, options?: {
+    bufSize?: number;
+}): AsyncIterableIterator<Uint8Array>;
+/**
+ * Turns a {@linkcode ReaderSync} into an iterator.
+ *
+ * ```ts
+ * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = Deno.openSync("/etc/passwd");
+ * for (const chunk of iterateReaderSync(file)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Second argument can be used to tune size of a buffer.
+ * Default size of the buffer is 32kB.
+ *
+ * ```ts
+ * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+
+ * using file = await Deno.open("/etc/passwd");
+ * const iter = iterateReaderSync(file, {
+ *   bufSize: 1024 * 1024
+ * });
+ * for (const chunk of iter) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Iterator uses an internal buffer of fixed size for efficiency; it returns
+ * a view on that buffer on each iteration. It is therefore caller's
+ * responsibility to copy contents of the buffer if needed; otherwise the
+ * next iteration will overwrite contents of previously returned chunk.
+ */
+export declare function iterateReaderSync(reader: ReaderSync, options?: {
+    bufSize?: number;
+}): IterableIterator<Uint8Array>;
+//# sourceMappingURL=iterate_reader.d.ts.map

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_reader.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/io/iterate_reader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAErD,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAuB,aAAa,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,qBAAqB,CAAC,UAAU,CAAC,CAWnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAiB,iBAAiB,CAChC,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,gBAAgB,CAAC,UAAU,CAAC,CAW9B"}

package/esm/deps/deno.land/std@0.224.0/io/iterate_reader.js

@@ -0,0 +1,86 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { DEFAULT_BUFFER_SIZE } from "./_constants.js";
+/**
+ * Turns a {@linkcode Reader} into an async iterator.
+ *
+ * @example
+ * ```ts
+ * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = await Deno.open("/etc/passwd");
+ * for await (const chunk of iterateReader(file)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Second argument can be used to tune size of a buffer.
+ * Default size of the buffer is 32kB.
+ *
+ * @example
+ * ```ts
+ * import { iterateReader } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = await Deno.open("/etc/passwd");
+ * const iter = iterateReader(file, {
+ *   bufSize: 1024 * 1024
+ * });
+ * for await (const chunk of iter) {
+ *   console.log(chunk);
+ * }
+ * ```
+ */
+export async function* iterateReader(reader, options) {
+    const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;
+    const b = new Uint8Array(bufSize);
+    while (true) {
+        const result = await reader.read(b);
+        if (result === null) {
+            break;
+        }
+        yield b.slice(0, result);
+    }
+}
+/**
+ * Turns a {@linkcode ReaderSync} into an iterator.
+ *
+ * ```ts
+ * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+ *
+ * using file = Deno.openSync("/etc/passwd");
+ * for (const chunk of iterateReaderSync(file)) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Second argument can be used to tune size of a buffer.
+ * Default size of the buffer is 32kB.
+ *
+ * ```ts
+ * import { iterateReaderSync } from "https://deno.land/std@$STD_VERSION/io/iterate_reader.ts";
+
+ * using file = await Deno.open("/etc/passwd");
+ * const iter = iterateReaderSync(file, {
+ *   bufSize: 1024 * 1024
+ * });
+ * for (const chunk of iter) {
+ *   console.log(chunk);
+ * }
+ * ```
+ *
+ * Iterator uses an internal buffer of fixed size for efficiency; it returns
+ * a view on that buffer on each iteration. It is therefore caller's
+ * responsibility to copy contents of the buffer if needed; otherwise the
+ * next iteration will overwrite contents of previously returned chunk.
+ */
+export function* iterateReaderSync(reader, options) {
+    const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;
+    const b = new Uint8Array(bufSize);
+    while (true) {
+        const result = reader.readSync(b);
+        if (result === null) {
+            break;
+        }
+        yield b.slice(0, result);
+    }
+}

package/esm/deps/deno.land/std@0.224.0/io/types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * An abstract interface which when implemented provides an interface to read bytes into an array buffer asynchronously.
+ */
+export interface Reader {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number of
+     * bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` resolves to `n` < `p.byteLength`, it may
+     * use all of `p` as scratch space during the call. If some data is
+     * available but not `p.byteLength` bytes, `read()` conventionally resolves
+     * to what is available instead of waiting for more.
+     *
+     * When `read()` encounters end-of-file condition, it resolves to EOF
+     * (`null`).
+     *
+     * When `read()` encounters an error, it rejects with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that
+     * happen after reading some bytes and also both of the allowed EOF
+     * behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use
+     * {@linkcode https://deno.land/std@$STD_VERSION/io/to_iterator.ts?s=toIterator}
+     * to turn a {@linkcode Reader} into an {@linkcode AsyncIterableIterator}.
+     */
+    read(p: Uint8Array): Promise<number | null>;
+}
+/**
+ * An abstract interface which when implemented provides an interface to read bytes into an array buffer synchronously.
+ */
+export interface ReaderSync {
+    /** Reads up to `p.byteLength` bytes into `p`. It resolves to the number
+     * of bytes read (`0` < `n` <= `p.byteLength`) and rejects if any error
+     * encountered. Even if `read()` returns `n` < `p.byteLength`, it may use
+     * all of `p` as scratch space during the call. If some data is available
+     * but not `p.byteLength` bytes, `read()` conventionally returns what is
+     * available instead of waiting for more.
+     *
+     * When `readSync()` encounters end-of-file condition, it returns EOF
+     * (`null`).
+     *
+     * When `readSync()` encounters an error, it throws with an error.
+     *
+     * Callers should always process the `n` > `0` bytes returned before
+     * considering the EOF (`null`). Doing so correctly handles I/O errors that happen
+     * after reading some bytes and also both of the allowed EOF behaviors.
+     *
+     * Implementations should not retain a reference to `p`.
+     *
+     * Use
+     * {@linkcode https://deno.land/std@$STD_VERSION/io/to_iterator.ts?s=toIteratorSync}
+     * to turn a {@linkcode ReaderSync} into an {@linkcode IterableIterator}.
+     */
+    readSync(p: Uint8Array): number | null;
+}
+/**
+ * An abstract interface which when implemented provides an interface to write bytes from an array buffer to a file/resource asynchronously.
+ */
+export interface Writer {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data stream. It
+     * resolves to the number of bytes written from `p` (`0` <= `n` <=
+     * `p.byteLength`) or reject with the error encountered that caused the
+     * write to stop early. `write()` must reject with a non-null error if
+     * would resolve to `n` < `p.byteLength`. `write()` must not modify the
+     * slice data, even temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    write(p: Uint8Array): Promise<number>;
+}
+/**
+ * An abstract interface which when implemented provides an interface to write bytes from an array buffer to a file/resource synchronously.
+ */
+export interface WriterSync {
+    /** Writes `p.byteLength` bytes from `p` to the underlying data
+     * stream. It returns the number of bytes written from `p` (`0` <= `n`
+     * <= `p.byteLength`) and any error encountered that caused the write to
+     * stop early. `writeSync()` must throw a non-null error if it returns `n` <
+     * `p.byteLength`. `writeSync()` must not modify the slice data, even
+     * temporarily.
+     *
+     * Implementations should not retain a reference to `p`.
+     */
+    writeSync(p: Uint8Array): number;
+}
+/**
+ * An abstract interface which when implemented provides an interface to close files/resources that were previously opened.
+ */
+export interface Closer {
+    /** Closes the resource, "freeing" the backing file/resource. */
+    close(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/deps/deno.land/std@0.224.0/io/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/deps/deno.land/std@0.224.0/io/types.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;OAQG;IACH,KAAK,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACvC;AACD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;;;;;;OAQG;IACH,SAAS,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,gEAAgE;IAChE,KAAK,IAAI,IAAI,CAAC;CACf"}

package/esm/deps/deno.land/std@0.224.0/io/types.js

@@ -0,0 +1,3 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export {};

package/esm/deps/deno.land/std@0.224.0/io/write_all.d.ts

@@ -0,0 +1,39 @@
+import type { Writer, WriterSync } from "./types.js";
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example
+ * ```ts
+ * import { writeAll } from "https://deno.land/std@$STD_VERSION/io/write_all.ts";
+
+ * // Example writing to stdout
+ * let contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ *
+ * // Example writing to file
+ * contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', {write: true});
+ * await writeAll(file, contentBytes);
+ * ```
+ */
+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
+ * ```ts
+ * import { writeAllSync } from "https://deno.land/std@$STD_VERSION/io/write_all.ts";
+ *
+ * // Example writing to stdout
+ * let contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ *
+ * // Example writing to file
+ * contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync('test.file', {write: true});
+ * writeAllSync(file, contentBytes);
+ * ```
+ */
+export declare function writeAllSync(writer: WriterSync, data: Uint8Array): void;
+//# sourceMappingURL=write_all.d.ts.map

package/esm/deps/deno.land/std@0.224.0/io/write_all.d.ts.map

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

package/esm/deps/deno.land/std@0.224.0/io/write_all.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Write all the content of the array buffer (`arr`) to the writer (`w`).
+ *
+ * @example
+ * ```ts
+ * import { writeAll } from "https://deno.land/std@$STD_VERSION/io/write_all.ts";
+
+ * // Example writing to stdout
+ * let contentBytes = new TextEncoder().encode("Hello World");
+ * await writeAll(Deno.stdout, contentBytes);
+ *
+ * // Example writing to file
+ * contentBytes = new TextEncoder().encode("Hello World");
+ * using file = await Deno.open('test.file', {write: true});
+ * await writeAll(file, contentBytes);
+ * ```
+ */
+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
+ * ```ts
+ * import { writeAllSync } from "https://deno.land/std@$STD_VERSION/io/write_all.ts";
+ *
+ * // Example writing to stdout
+ * let contentBytes = new TextEncoder().encode("Hello World");
+ * writeAllSync(Deno.stdout, contentBytes);
+ *
+ * // Example writing to file
+ * contentBytes = new TextEncoder().encode("Hello World");
+ * using file = Deno.openSync('test.file', {write: true});
+ * writeAllSync(file, contentBytes);
+ * ```
+ */
+export function writeAllSync(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += writer.writeSync(data.subarray(nwritten));
+    }
+}

package/esm/deps/raw.githubusercontent.com/MTKruto/socks5/main/client.d.ts

@@ -0,0 +1,45 @@
+import * as dntShim from "../../../../../_dnt.shims.js";
+export declare const SOCKS_VERSION = 5;
+export declare const USERNAME_PASSWORD_AUTH_VERSION = 1;
+export declare enum AddrType {
+    IPv4 = 1,
+    DomainName = 3,
+    IPv6 = 4
+}
+export declare enum AuthMethod {
+    NoAuth = 0,
+    UsernamePassword = 2,
+    NoneAcceptable = 255
+}
+export declare enum ReplyStatus {
+    Success = 0,
+    GeneralError = 1,
+    RulesetError = 2,
+    NetworkUnreachable = 3,
+    HostUnreachable = 4,
+    ConnectionRefused = 5,
+    TTLExpired = 6,
+    UnsupportedCommand = 7,
+    UnsupportedAddress = 8
+}
+export declare enum Command {
+    Connect = 1,
+    Bind = 2,
+    UdpAssociate = 3
+}
+interface AddrConfig {
+    hostname: string;
+    port?: number;
+}
+interface AuthConfig {
+    username: string;
+    password: string;
+}
+export type ClientConfig = AddrConfig | (AddrConfig & AuthConfig);
+export declare class Client {
+    #private;
+    constructor(config: ClientConfig);
+    connect(opts: dntShim.Deno.ConnectOptions): Promise<dntShim.Deno.TcpConn>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/esm/deps/raw.githubusercontent.com/MTKruto/socks5/main/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/raw.githubusercontent.com/MTKruto/socks5/main/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,8BAA8B,CAAC;AAIxD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,oBAAY,QAAQ;IAClB,IAAI,IAAI;IACR,UAAU,IAAI;IACd,IAAI,IAAI;CACT;AACD,oBAAY,UAAU;IACpB,MAAM,IAAI;IACV,gBAAgB,IAAI;IACpB,cAAc,MAAO;CACtB;AACD,oBAAY,WAAW;IACrB,OAAO,IAAI;IACX,YAAY,IAAA;IACZ,YAAY,IAAA;IACZ,kBAAkB,IAAA;IAClB,eAAe,IAAA;IACf,iBAAiB,IAAA;IACjB,UAAU,IAAA;IACV,kBAAkB,IAAA;IAClB,kBAAkB,IAAA;CACnB;AACD,oBAAY,OAAO;IACjB,OAAO,IAAI;IACX,IAAI,IAAA;IACJ,YAAY,IAAA;CACb;AAuFD,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC,CAAC;AAElE,qBAAa,MAAM;;gBAGL,MAAM,EAAE,YAAY;IAwG1B,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC;CA8ChF"}

package/esm/deps/raw.githubusercontent.com/MTKruto/socks5/main/client.js

@@ -0,0 +1,253 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Client_config, _Client_connectAndRequest;
+import * as dntShim from "../../../../../_dnt.shims.js";
+import { writeAll } from "./deps.js";
+import { readN } from "./utils.js";
+export const SOCKS_VERSION = 5;
+export const USERNAME_PASSWORD_AUTH_VERSION = 1;
+export var AddrType;
+(function (AddrType) {
+    AddrType[AddrType["IPv4"] = 1] = "IPv4";
+    AddrType[AddrType["DomainName"] = 3] = "DomainName";
+    AddrType[AddrType["IPv6"] = 4] = "IPv6";
+})(AddrType || (AddrType = {}));
+export var AuthMethod;
+(function (AuthMethod) {
+    AuthMethod[AuthMethod["NoAuth"] = 0] = "NoAuth";
+    AuthMethod[AuthMethod["UsernamePassword"] = 2] = "UsernamePassword";
+    AuthMethod[AuthMethod["NoneAcceptable"] = 255] = "NoneAcceptable";
+})(AuthMethod || (AuthMethod = {}));
+export var ReplyStatus;
+(function (ReplyStatus) {
+    ReplyStatus[ReplyStatus["Success"] = 0] = "Success";
+    ReplyStatus[ReplyStatus["GeneralError"] = 1] = "GeneralError";
+    ReplyStatus[ReplyStatus["RulesetError"] = 2] = "RulesetError";
+    ReplyStatus[ReplyStatus["NetworkUnreachable"] = 3] = "NetworkUnreachable";
+    ReplyStatus[ReplyStatus["HostUnreachable"] = 4] = "HostUnreachable";
+    ReplyStatus[ReplyStatus["ConnectionRefused"] = 5] = "ConnectionRefused";
+    ReplyStatus[ReplyStatus["TTLExpired"] = 6] = "TTLExpired";
+    ReplyStatus[ReplyStatus["UnsupportedCommand"] = 7] = "UnsupportedCommand";
+    ReplyStatus[ReplyStatus["UnsupportedAddress"] = 8] = "UnsupportedAddress";
+})(ReplyStatus || (ReplyStatus = {}));
+export var Command;
+(function (Command) {
+    Command[Command["Connect"] = 1] = "Connect";
+    Command[Command["Bind"] = 2] = "Bind";
+    Command[Command["UdpAssociate"] = 3] = "UdpAssociate";
+})(Command || (Command = {}));
+function decodeError(status) {
+    switch (status) {
+        case ReplyStatus.GeneralError:
+            return "general SOCKS server failure";
+        case ReplyStatus.RulesetError:
+            return "connection not allowed by ruleset";
+        case ReplyStatus.NetworkUnreachable:
+            return "Network unreachable";
+        case ReplyStatus.HostUnreachable:
+            return "Host unreachable";
+        case ReplyStatus.ConnectionRefused:
+            return "Connection refused";
+        case ReplyStatus.TTLExpired:
+            return "TTL expired";
+        case ReplyStatus.UnsupportedCommand:
+            return "Command not supported";
+        case ReplyStatus.UnsupportedAddress:
+            return "Address type not supported";
+        default:
+            return "unknown SOCKS error";
+    }
+}
+const v4Pattern = /^(?:\d{1,3}\.){3}\d{1,3}/;
+const v6Pattern = /^(?:[A-F0-9]{1,4}:){7}[A-F0-9]{1,4}$/i;
+function serializeAddress(hostname, port) {
+    const portBytes = [port >> 8, port % 256];
+    if (v4Pattern.test(hostname)) {
+        return Uint8Array.from([
+            AddrType.IPv4,
+            ...hostname.split(".").map(Number),
+            ...portBytes,
+        ]);
+    }
+    if (v6Pattern.test(hostname)) {
+        return Uint8Array.from([
+            AddrType.IPv6,
+            ...hostname.split(":").flatMap((x) => {
+                const num = parseInt(x, 16);
+                return [num >> 8, num % 256];
+            }),
+            ...portBytes,
+        ]);
+    }
+    const bytes = new TextEncoder().encode(hostname);
+    return Uint8Array.from([
+        AddrType.DomainName,
+        bytes.length,
+        ...bytes,
+        ...portBytes,
+    ]);
+}
+async function deserializeAddress(r) {
+    const [type] = await readN(r, 1);
+    const hostname = await (async () => {
+        if (type === AddrType.IPv4) {
+            const parts = [...(await readN(r, 4))];
+            return { value: parts.map(String).join("."), length: 4 };
+        }
+        if (type === AddrType.IPv6) {
+            const parts = [];
+            const buff = await readN(r, 16);
+            for (let i = 0; i < buff.length; i += 2) {
+                parts.push((buff[i] << 8) + buff[i + 1]);
+            }
+            return { value: parts.map(String).join(":"), length: 16 };
+        }
+        if (type === AddrType.DomainName) {
+            const [length] = await readN(r, 1);
+            return {
+                value: new TextDecoder().decode(await readN(r, length)),
+                length: length + 1,
+            };
+        }
+        throw new Error(`unexpected address type: ${type}`);
+    })();
+    const [portUpper, portLower] = await readN(r, 2);
+    const port = (portUpper << 8) + portLower;
+    return { hostname: hostname.value, port, bytesRead: hostname.length + 3 };
+}
+export class Client {
+    constructor(config) {
+        _Client_config.set(this, void 0);
+        _Client_connectAndRequest.set(this, async (cmd, hostname, port) => {
+            // @ts-ignore: lib
+            const conn = await dntShim.Deno.connect({
+                hostname: __classPrivateFieldGet(this, _Client_config, "f").hostname,
+                port: __classPrivateFieldGet(this, _Client_config, "f").port,
+            });
+            // handle auth negotiation
+            const methods = [AuthMethod.NoAuth];
+            if ("username" in __classPrivateFieldGet(this, _Client_config, "f")) {
+                methods.push(AuthMethod.UsernamePassword);
+            }
+            await writeAll(conn, Uint8Array.from([SOCKS_VERSION, methods.length, ...methods]));
+            const [negotiationVersion, method] = await readN(conn, 2);
+            if (negotiationVersion !== SOCKS_VERSION ||
+                method === AuthMethod.NoneAcceptable) {
+                try {
+                    conn.close();
+                }
+                catch {
+                    // ignore
+                }
+                throw new Error(negotiationVersion !== SOCKS_VERSION
+                    ? `unsupported SOCKS version number: ${negotiationVersion}`
+                    : "no acceptable authentication methods");
+            }
+            if (method === AuthMethod.UsernamePassword) {
+                const cfg = __classPrivateFieldGet(this, _Client_config, "f");
+                const te = new TextEncoder();
+                const username = te.encode(cfg.username);
+                const password = te.encode(cfg.password);
+                await writeAll(conn, Uint8Array.from([
+                    USERNAME_PASSWORD_AUTH_VERSION,
+                    username.length,
+                    ...username,
+                    password.length,
+                    ...password,
+                ]));
+                const [authVersion, status] = await readN(conn, 2);
+                if (authVersion !== USERNAME_PASSWORD_AUTH_VERSION ||
+                    status !== ReplyStatus.Success) {
+                    try {
+                        conn.close();
+                    }
+                    catch {
+                        // ignore
+                    }
+                    throw new Error(authVersion !== USERNAME_PASSWORD_AUTH_VERSION
+                        ? `unsupported authentication version number: ${authVersion}`
+                        : "authentication failed");
+                }
+            }
+            // handle actual message
+            await writeAll(conn, Uint8Array.from([
+                SOCKS_VERSION,
+                cmd,
+                0,
+                ...serializeAddress(hostname, port),
+            ]));
+            const [replyVersion, status, _] = await readN(conn, 3);
+            if (replyVersion !== SOCKS_VERSION || status !== ReplyStatus.Success) {
+                try {
+                    conn.close();
+                }
+                catch {
+                    // ignore
+                }
+                throw new Error(replyVersion !== SOCKS_VERSION
+                    ? `unsupported SOCKS version number: ${replyVersion}`
+                    : decodeError(status));
+            }
+            return {
+                conn,
+                ...(await deserializeAddress(conn)),
+            };
+        });
+        __classPrivateFieldSet(this, _Client_config, {
+            ...config,
+            port: config.port ?? 1080,
+        }, "f");
+    }
+    // @ts-ignore: lib
+    async connect(opts) {
+        const remoteAddr = {
+            hostname: opts.hostname ?? "127.0.0.1",
+            port: opts.port,
+            transport: "tcp",
+        };
+        const { conn, hostname, port } = await __classPrivateFieldGet(this, _Client_connectAndRequest, "f").call(this, Command.Connect, remoteAddr.hostname, remoteAddr.port);
+        const localAddr = {
+            hostname,
+            port,
+            transport: "tcp",
+        };
+        return {
+            setKeepAlive(keepalive) {
+                conn.setKeepAlive(keepalive);
+            },
+            setNoDelay(nodelay) {
+                conn.setNoDelay(nodelay);
+            },
+            get localAddr() {
+                return localAddr;
+            },
+            get remoteAddr() {
+                return remoteAddr;
+            },
+            get rid() {
+                return conn.rid;
+            },
+            get readable() {
+                return conn.readable;
+            },
+            get writable() {
+                return conn.writable;
+            },
+            read: conn.read.bind(conn),
+            write: conn.write.bind(conn),
+            close: conn.close.bind(conn),
+            closeWrite: conn.closeWrite.bind(conn),
+            // @ts-ignore: lib
+        };
+    }
+}
+_Client_config = new WeakMap(), _Client_connectAndRequest = new WeakMap();

package/esm/deps/raw.githubusercontent.com/MTKruto/socks5/main/deps.d.ts

@@ -0,0 +1,3 @@
+export { writeAll } from "../../../../deno.land/std@0.224.0/io/write_all.js";
+export { type Reader } from "../../../../deno.land/std@0.224.0/io/types.js";
+//# sourceMappingURL=deps.d.ts.map