@mtkruto/node 0.1.800 → 0.2.1

package/script/connection/1_connection_tcp.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 _ConnectionTCP_instances, _ConnectionTCP_hostname, _ConnectionTCP_port, _ConnectionTCP_connection, _ConnectionTCP_rMutex, _ConnectionTCP_wMutex, _ConnectionTCP_buffer, _ConnectionTCP_nextResolve, _ConnectionTCP_canRead, _ConnectionTCP_canWrite, _ConnectionTCP_assertConnected, _ConnectionTCP_rejectRead;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTCP = void 0;
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 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/>.
+ */
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const _0_deps_js_1 = require("../0_deps.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const L = (0, _1_utilities_js_1.getLogger)("ConnectionTCP");
+class ConnectionTCP {
+    constructor(hostname, port) {
+        _ConnectionTCP_instances.add(this);
+        _ConnectionTCP_hostname.set(this, void 0);
+        _ConnectionTCP_port.set(this, void 0);
+        _ConnectionTCP_connection.set(this, void 0);
+        _ConnectionTCP_rMutex.set(this, new _1_utilities_js_1.Mutex());
+        _ConnectionTCP_wMutex.set(this, new _1_utilities_js_1.Mutex());
+        _ConnectionTCP_buffer.set(this, new Uint8Array());
+        _ConnectionTCP_nextResolve.set(this, null);
+        _ConnectionTCP_canRead.set(this, false);
+        _ConnectionTCP_canWrite.set(this, false);
+        Object.defineProperty(this, "connect", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dntShim.Deno.connect
+        });
+        Object.defineProperty(this, "stateChangeHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _ConnectionTCP_hostname, hostname, "f");
+        __classPrivateFieldSet(this, _ConnectionTCP_port, port, "f");
+    }
+    get connected() {
+        return !!__classPrivateFieldGet(this, _ConnectionTCP_connection, "f") && __classPrivateFieldGet(this, _ConnectionTCP_canRead, "f") && __classPrivateFieldGet(this, _ConnectionTCP_canWrite, "f");
+    }
+    async open() {
+        if (this.connected) {
+            throw new Error("Connection already open");
+        }
+        const connection = await this.connect({
+            hostname: __classPrivateFieldGet(this, _ConnectionTCP_hostname, "f"),
+            port: __classPrivateFieldGet(this, _ConnectionTCP_port, "f"),
+        });
+        __classPrivateFieldSet(this, _ConnectionTCP_canRead, __classPrivateFieldSet(this, _ConnectionTCP_canWrite, true, "f"), "f");
+        this.stateChangeHandler?.(true);
+        Promise.resolve().then(async () => {
+            do {
+                try {
+                    for await (const chunk of (0, _0_deps_js_1.iterateReader)(connection)) {
+                        this.callback?.read(chunk.length);
+                        __classPrivateFieldSet(this, _ConnectionTCP_buffer, (0, _0_deps_js_1.concat)([__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f"), chunk]), "f");
+                        if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null && __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length >= __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[0]) {
+                            __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].resolve();
+                            __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+                        }
+                    }
+                    __classPrivateFieldSet(this, _ConnectionTCP_canRead, false, "f");
+                    break;
+                }
+                catch (err) {
+                    if (!this.connected) {
+                        this.stateChangeHandler?.(false);
+                        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+                    }
+                    else {
+                        L.error(err);
+                    }
+                }
+            } while (this.connected);
+        });
+        __classPrivateFieldSet(this, _ConnectionTCP_connection, connection, "f");
+    }
+    async read(p) {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_rMutex, "f").lock();
+        try {
+            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+            if (__classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").length < p.length) {
+                await new Promise((resolve, reject) => __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, [p.length, { resolve, reject }], "f"));
+            }
+            const slice = __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").slice(0, p.length);
+            p.set(slice);
+            __classPrivateFieldSet(this, _ConnectionTCP_buffer, __classPrivateFieldGet(this, _ConnectionTCP_buffer, "f").slice(slice.length), "f");
+        }
+        finally {
+            unlock();
+        }
+    }
+    async write(p) {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        const unlock = await __classPrivateFieldGet(this, _ConnectionTCP_wMutex, "f").lock();
+        try {
+            __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+            let written = 0;
+            while (written < p.length) {
+                try {
+                    const wrote = await __classPrivateFieldGet(this, _ConnectionTCP_connection, "f").write(p.subarray(written));
+                    this.callback?.write(wrote);
+                    written += wrote;
+                }
+                catch (err) {
+                    if (err instanceof dntShim.Deno.errors.BrokenPipe) {
+                        __classPrivateFieldSet(this, _ConnectionTCP_canWrite, false, "f");
+                    }
+                    if (!this.connected) {
+                        this.stateChangeHandler?.(false);
+                    }
+                    throw err;
+                }
+            }
+        }
+        finally {
+            unlock();
+        }
+    }
+    close() {
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_assertConnected).call(this);
+        __classPrivateFieldGet(this, _ConnectionTCP_connection, "f").close();
+        __classPrivateFieldSet(this, _ConnectionTCP_canRead, __classPrivateFieldSet(this, _ConnectionTCP_canWrite, false, "f"), "f");
+        __classPrivateFieldSet(this, _ConnectionTCP_connection, undefined, "f");
+        __classPrivateFieldGet(this, _ConnectionTCP_instances, "m", _ConnectionTCP_rejectRead).call(this);
+    }
+}
+exports.ConnectionTCP = ConnectionTCP;
+_ConnectionTCP_hostname = new WeakMap(), _ConnectionTCP_port = new WeakMap(), _ConnectionTCP_connection = new WeakMap(), _ConnectionTCP_rMutex = new WeakMap(), _ConnectionTCP_wMutex = new WeakMap(), _ConnectionTCP_buffer = new WeakMap(), _ConnectionTCP_nextResolve = new WeakMap(), _ConnectionTCP_canRead = new WeakMap(), _ConnectionTCP_canWrite = new WeakMap(), _ConnectionTCP_instances = new WeakSet(), _ConnectionTCP_assertConnected = function _ConnectionTCP_assertConnected() {
+    if (!this.connected) {
+        throw new Error("Connection not open");
+    }
+}, _ConnectionTCP_rejectRead = function _ConnectionTCP_rejectRead() {
+    if (__classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f") != null) {
+        __classPrivateFieldGet(this, _ConnectionTCP_nextResolve, "f")[1].reject(new Error("Connection was closed"));
+        __classPrivateFieldSet(this, _ConnectionTCP_nextResolve, null, "f");
+    }
+};

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

@@ -0,0 +1,3 @@
+export declare const DEFAULT_CHUNK_SIZE = 16640;
+export declare const DEFAULT_BUFFER_SIZE: number;
+//# sourceMappingURL=_constants.d.ts.map

package/script/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/script/deps/deno.land/std@0.224.0/io/_constants.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BUFFER_SIZE = exports.DEFAULT_CHUNK_SIZE = void 0;
+exports.DEFAULT_CHUNK_SIZE = 16640;
+exports.DEFAULT_BUFFER_SIZE = 32 * 1024;

package/script/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/script/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/script/deps/deno.land/std@0.224.0/io/iterate_reader.js

@@ -0,0 +1,91 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateReaderSync = exports.iterateReader = void 0;
+const _constants_js_1 = require("./_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);
+ * }
+ * ```
+ */
+async function* iterateReader(reader, options) {
+    const bufSize = options?.bufSize ?? _constants_js_1.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);
+    }
+}
+exports.iterateReader = iterateReader;
+/**
+ * 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.
+ */
+function* iterateReaderSync(reader, options) {
+    const bufSize = options?.bufSize ?? _constants_js_1.DEFAULT_BUFFER_SIZE;
+    const b = new Uint8Array(bufSize);
+    while (true) {
+        const result = reader.readSync(b);
+        if (result === null) {
+            break;
+        }
+        yield b.slice(0, result);
+    }
+}
+exports.iterateReaderSync = iterateReaderSync;

package/script/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/script/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/script/deps/deno.land/std@0.224.0/io/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/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/script/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/script/deps/deno.land/std@0.224.0/io/write_all.js

@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAllSync = exports.writeAll = void 0;
+/**
+ * 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);
+ * ```
+ */
+async function writeAll(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += await writer.write(data.subarray(nwritten));
+    }
+}
+exports.writeAll = writeAll;
+/**
+ * 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);
+ * ```
+ */
+function writeAllSync(writer, data) {
+    let nwritten = 0;
+    while (nwritten < data.length) {
+        nwritten += writer.writeSync(data.subarray(nwritten));
+    }
+}
+exports.writeAllSync = writeAllSync;

package/script/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/script/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"}