@mtkruto/browser 0.132.0 → 0.133.0

package/script/transport/0_obfuscation.d.ts

@@ -19,7 +19,11 @@
  */
 import { CTR } from "../1_utilities.js";
 import type { Connection } from "../2_connection.js";
-export declare function getObfuscationParameters(protocol: number, connection: Connection): Promise<{
+export interface GetObfuscationParametersParams {
+    dcId?: number;
+    secret?: Uint8Array;
+}
+export declare function getObfuscationParameters(protocol: number, connection: Connection, params?: GetObfuscationParametersParams): Promise<{
     encryptionCTR: CTR;
     decryptionCTR: CTR;
 }>;

package/script/transport/0_obfuscation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"0_obfuscation.d.ts","sourceRoot":"","sources":["../../src/transport/0_obfuscation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,GAAG,EAAc,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU;;;GA0CtF"}
+{"version":3,"file":"0_obfuscation.d.ts","sourceRoot":"","sources":["../../src/transport/0_obfuscation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,GAAG,EAAsB,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,WAAW,8BAA8B;IAC7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,wBAAsB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,8BAA8B;;;GAyD/H"}

package/script/transport/0_obfuscation.js

@@ -22,7 +22,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getObfuscationParameters = getObfuscationParameters;
 const _0_deps_js_1 = require("../0_deps.js");
 const _1_utilities_js_1 = require("../1_utilities.js");
-async function getObfuscationParameters(protocol, connection) {
+async function getObfuscationParameters(protocol, connection, params) {
     let init;
     while (true) {
         init = (0, _0_deps_js_1.concat)([crypto.getRandomValues(new Uint8Array(56)), (0, _1_utilities_js_1.intToBytes)(protocol, 4, { byteOrder: "big", isSigned: false }), crypto.getRandomValues(new Uint8Array(4))]);
@@ -40,14 +40,27 @@ async function getObfuscationParameters(protocol, connection) {
         }
         break;
     }
-    const encryptKey = init.slice(8, 8 + 32);
+    if (params?.dcId !== undefined) {
+        init.set((0, _1_utilities_js_1.intToBytes)(params.dcId, 2, { byteOrder: "little" }), 60);
+    }
+    let secret = params?.secret;
+    if (secret !== undefined && secret.byteLength >= 17) {
+        secret = secret.subarray(1, 17);
+    }
+    let encryptKey = init.slice(8, 8 + 32);
     const encryptIv = init.slice(40, 40 + 16);
+    if (secret) {
+        encryptKey = await (0, _1_utilities_js_1.sha256)((0, _0_deps_js_1.concat)([encryptKey, secret]));
+    }
     const importedEncryptedKey = await _1_utilities_js_1.CTR.importKey(encryptKey);
     const encryptionCTR = new _1_utilities_js_1.CTR(importedEncryptedKey, encryptIv);
     const encryptedInit = await encryptionCTR.call(init);
     const initRev = new Uint8Array(init).reverse();
-    const decryptKey = initRev.slice(8, 8 + 32);
+    let decryptKey = initRev.slice(8, 8 + 32);
     const decryptIv = initRev.slice(40, 40 + 16);
+    if (secret) {
+        decryptKey = await (0, _1_utilities_js_1.sha256)((0, _0_deps_js_1.concat)([decryptKey, secret]));
+    }
     const importedDecryptKey = await _1_utilities_js_1.CTR.importKey(decryptKey);
     const decryptionCTR = new _1_utilities_js_1.CTR(importedDecryptKey, decryptIv);
     await connection.write((0, _0_deps_js_1.concat)([init.subarray(0, 56), encryptedInit.subarray(56, 56 + 8)]));

package/script/transport/1_transport_intermediate.d.ts

@@ -19,9 +19,15 @@
  */
 import type { Connection } from "../2_connection.js";
 import { Transport } from "./0_transport.js";
+export interface TransportIntermediateParams {
+    isObfuscated?: boolean;
+    isPadded?: boolean;
+    dcId?: number;
+    secret?: Uint8Array;
+}
 export declare class TransportIntermediate extends Transport implements Transport {
     #private;
-    constructor(connection: Connection, obfuscated?: boolean);
+    constructor(connection: Connection, params?: TransportIntermediateParams);
     initialize(): Promise<void>;
     receive(): Promise<Uint8Array>;
     send(buffer: Uint8Array): Promise<void>;

package/script/transport/1_transport_intermediate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_transport_intermediate.d.ts","sourceRoot":"","sources":["../../src/transport/1_transport_intermediate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,qBAAa,qBAAsB,SAAQ,SAAU,YAAW,SAAS;;gBAI3D,UAAU,EAAE,UAAU,EAAE,UAAU,UAAQ;IAMhD,UAAU;IAQV,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IAiB9B,IAAI,CAAC,MAAM,EAAE,UAAU;CAM9B"}
+{"version":3,"file":"1_transport_intermediate.d.ts","sourceRoot":"","sources":["../../src/transport/1_transport_intermediate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,MAAM,WAAW,2BAA2B;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED,qBAAa,qBAAsB,SAAQ,SAAU,YAAW,SAAS;;gBAO3D,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,2BAA2B;IASlE,UAAU;IAYV,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IAiB9B,IAAI,CAAC,MAAM,EAAE,UAAU;CAW9B"}

package/script/transport/1_transport_intermediate.js

@@ -26,18 +26,24 @@ const _0_obfuscation_js_1 = require("./0_obfuscation.js");
 const _0_transport_js_1 = require("./0_transport.js");
 class TransportIntermediate extends _0_transport_js_1.Transport {
     #connection;
-    #obfuscated;
-    constructor(connection, obfuscated = false) {
+    #isObfuscated;
+    #isPadded;
+    #dcId;
+    #secret;
+    constructor(connection, params) {
         super();
         this.#connection = connection;
-        this.#obfuscated = obfuscated;
+        this.#isObfuscated = params?.isObfuscated ?? false;
+        this.#isPadded = params?.isPadded ?? false;
+        this.#dcId = params?.dcId;
+        this.#secret = params?.secret;
     }
     async initialize() {
-        if (this.#obfuscated) {
-            this.obfuscationParameters = await (0, _0_obfuscation_js_1.getObfuscationParameters)(0xEEEEEEEE, this.#connection);
+        if (this.#isObfuscated) {
+            this.obfuscationParameters = await (0, _0_obfuscation_js_1.getObfuscationParameters)(this.#isPadded ? 0xDDDDDDDD : 0xEEEEEEEE, this.#connection, { dcId: this.#dcId, secret: this.#secret });
         }
         else {
-            await this.#connection.write(new Uint8Array([0xEE, 0xEE, 0xEE, 0xEE]));
+            await this.#connection.write(new Uint8Array(this.#isPadded ? [0xDD, 0xDD, 0xDD, 0xDD] : [0xEE, 0xEE, 0xEE, 0xEE]));
         }
     }
     async receive() {
@@ -54,6 +60,10 @@ class TransportIntermediate extends _0_transport_js_1.Transport {
         return await this.decrypt(buffer);
     }
     async send(buffer) {
+        if (this.#isPadded) {
+            const padding = crypto.getRandomValues(new Uint8Array(Math.abs((0, _1_utilities_js_1.getRandomId)(true) % 16)));
+            buffer = (0, _0_deps_js_1.concat)([buffer, padding]);
+        }
         const length = (0, _1_utilities_js_1.intToBytes)(buffer.length, 4);
         const data = (0, _0_deps_js_1.concat)([length, buffer]);
         await this.#connection.write(await this.encrypt(data));

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

@@ -0,0 +1,23 @@
+/**
+ * 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 declare function transportProviderMtproxy(link: 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

@@ -0,0 +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"}

package/script/transport/2_transport_provider_mtproxy.js

@@ -0,0 +1,54 @@
+"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.transportProviderMtproxy = transportProviderMtproxy;
+const _0_deps_js_1 = require("../0_deps.js");
+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;
+    if (port === undefined && secret === undefined) {
+        const url = new URL(hostnameOrLink);
+        const hostname_ = url.searchParams.get("server");
+        const port_ = url.searchParams.get("port");
+        const secret_ = url.searchParams.get("secret");
+        if (!hostname_ || !port_ || !secret_) {
+            throw new TypeError("Invalid MTProxy link.");
+        }
+        hostname = hostname_;
+        port = parseInt(port_);
+        secret = (0, _0_deps_js_1.decodeHex)(secret_);
+        if (isNaN(port) || port < 0 || port > 0xFFFF) {
+            throw new TypeError("Server port is invalid.");
+        }
+        if (secret.byteLength < 16) {
+            throw new TypeError("Proxy secret must be at least 16 bytes.");
+        }
+    }
+    return ({ dc, isCdn }) => {
+        const dcId = (0, _1_transport_provider_js_1.getDcId)(dc, isCdn);
+        const connection = secret.byteLength <= 17 ? new _1_connection_tcp_js_1.ConnectionTCP(hostname, port) : new _1_connection_tls_js_1.ConnectionTLS(hostname, port, secret);
+        const transport = new _1_transport_intermediate_js_1.TransportIntermediate(connection, { isPadded: true, isObfuscated: true, secret, dcId });
+        return { connection, transport, dcId };
+    };
+}

package/script/transport/2_transport_provider_web_socket.js

@@ -39,8 +39,8 @@ const transportProviderWebSocket = (params) => {
         params.wss ??= typeof location !== "undefined" && location.protocol === "http:" && location.hostname !== "localhost" ? false : true;
         const url = `${params.wss ? "wss" : "ws"}://${dcToNameMap[dc]}${isCdn ? "-1" : ""}.web.telegram.org/${dc.endsWith("-test") ? "apiws_test" : "apiws"}`;
         const connection = new _2_connection_js_1.ConnectionWebSocket(url);
-        const transport = new _1_transport_intermediate_js_1.TransportIntermediate(connection, true);
         const dcId = (0, _1_transport_provider_js_1.getDcId)(dc, isCdn);
+        const transport = new _1_transport_intermediate_js_1.TransportIntermediate(connection, { isObfuscated: true, dcId });
         return { connection, transport, dcId };
     };
 };

package/script/utilities/1_crypto.d.ts

@@ -27,4 +27,5 @@ export declare class CTR {
     static importKey(key: Uint8Array<ArrayBuffer>): Promise<CryptoKey>;
     call(data: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
 }
+export declare function hmacSha256(data: Uint8Array<ArrayBuffer>, secret: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
 //# sourceMappingURL=1_crypto.d.ts.map

package/script/utilities/1_crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_crypto.d.ts","sourceRoot":"","sources":["../../src/utilities/1_crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,qBAAa,GAAG;;IAMd,IAAI,MAAM,IAAI;QAAE,EAAE,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAE9C;gBAEW,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,UAAU;WAK7B,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;IAIlE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;CAkD5E"}
+{"version":3,"file":"1_crypto.d.ts","sourceRoot":"","sources":["../../src/utilities/1_crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,qBAAa,GAAG;;IAMd,IAAI,MAAM,IAAI;QAAE,EAAE,EAAE,UAAU,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAE9C;gBAEW,GAAG,EAAE,SAAS,EAAE,EAAE,EAAE,UAAU;WAK7B,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC;IAIlE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;CAkD5E;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,oCAe9F"}

package/script/utilities/1_crypto.js

@@ -20,6 +20,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CTR = void 0;
+exports.hmacSha256 = hmacSha256;
 const _0_deps_js_1 = require("../0_deps.js");
 const _0_int_js_1 = require("./0_int.js");
 class CTR {
@@ -81,3 +82,7 @@ class CTR {
     }
 }
 exports.CTR = CTR;
+async function hmacSha256(data, secret) {
+    const key = await crypto.subtle.importKey("raw", secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    return new Uint8Array(await crypto.subtle.sign("HMAC", key, data.buffer));
+}

package/esm/deps/jsr.io/@std/io/0.225.3/_constants.d.ts

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

package/esm/deps/jsr.io/@std/io/0.225.3/_constants.d.ts.map

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

package/esm/deps/jsr.io/@std/io/0.225.3/_constants.js

@@ -1,4 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-export const DEFAULT_CHUNK_SIZE = 16_640;
-export const DEFAULT_BUFFER_SIZE = 32 * 1024;

package/esm/deps/jsr.io/@std/io/0.225.3/iterate_reader.d.ts

@@ -1,80 +0,0 @@
-import type { Reader, ReaderSync } from "./types.js";
-export type { Reader, ReaderSync };
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example Usage
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @example Usage with buffer size
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @param reader The reader to read from
- * @param options The options
- * @param options.bufSize The size of the buffer to use
- * @returns The async iterator of Uint8Array chunks
- */
-export declare function iterateReader(reader: Reader, options?: {
-    bufSize?: number;
-}): AsyncIterableIterator<Uint8Array>;
-/**
- * Turns a {@linkcode ReaderSync} into an iterator.
- *
- * @example Usage
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = Deno.openSync("README.md");
- * for (const chunk of iterateReaderSync(file)) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example Usage with buffer size
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * 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.
- *
- * @param reader The reader to read from
- * @param options The options
- * @returns The iterator of Uint8Array chunks
- */
-export declare function iterateReaderSync(reader: ReaderSync, options?: {
-    bufSize?: number;
-}): IterableIterator<Uint8Array>;
-//# sourceMappingURL=iterate_reader.d.ts.map

package/esm/deps/jsr.io/@std/io/0.225.3/iterate_reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterate_reader.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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/jsr.io/@std/io/0.225.3/iterate_reader.js

@@ -1,96 +0,0 @@
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-import { DEFAULT_BUFFER_SIZE } from "./_constants.js";
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example Usage
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @example Usage with buffer size
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @param reader The reader to read from
- * @param options The options
- * @param options.bufSize The size of the buffer to use
- * @returns The async iterator of Uint8Array chunks
- */
-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.
- *
- * @example Usage
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = Deno.openSync("README.md");
- * for (const chunk of iterateReaderSync(file)) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example Usage with buffer size
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * 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.
- *
- * @param reader The reader to read from
- * @param options The options
- * @returns The iterator of Uint8Array chunks
- */
-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/script/deps/jsr.io/@std/io/0.225.3/_constants.d.ts

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

package/script/deps/jsr.io/@std/io/0.225.3/_constants.d.ts.map

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

package/script/deps/jsr.io/@std/io/0.225.3/_constants.js

@@ -1,7 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. 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 = 16_640;
-exports.DEFAULT_BUFFER_SIZE = 32 * 1024;

package/script/deps/jsr.io/@std/io/0.225.3/iterate_reader.d.ts

@@ -1,80 +0,0 @@
-import type { Reader, ReaderSync } from "./types.js";
-export type { Reader, ReaderSync };
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example Usage
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @example Usage with buffer size
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @param reader The reader to read from
- * @param options The options
- * @param options.bufSize The size of the buffer to use
- * @returns The async iterator of Uint8Array chunks
- */
-export declare function iterateReader(reader: Reader, options?: {
-    bufSize?: number;
-}): AsyncIterableIterator<Uint8Array>;
-/**
- * Turns a {@linkcode ReaderSync} into an iterator.
- *
- * @example Usage
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = Deno.openSync("README.md");
- * for (const chunk of iterateReaderSync(file)) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example Usage with buffer size
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * 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.
- *
- * @param reader The reader to read from
- * @param options The options
- * @returns The iterator of Uint8Array chunks
- */
-export declare function iterateReaderSync(reader: ReaderSync, options?: {
-    bufSize?: number;
-}): IterableIterator<Uint8Array>;
-//# sourceMappingURL=iterate_reader.d.ts.map

package/script/deps/jsr.io/@std/io/0.225.3/iterate_reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterate_reader.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/io/0.225.3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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/jsr.io/@std/io/0.225.3/iterate_reader.js

@@ -1,100 +0,0 @@
-"use strict";
-// Copyright 2018-2026 the Deno authors. MIT license.
-// This module is browser compatible.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.iterateReader = iterateReader;
-exports.iterateReaderSync = iterateReaderSync;
-const _constants_js_1 = require("./_constants.js");
-/**
- * Turns a {@linkcode Reader} into an async iterator.
- *
- * @example Usage
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * for await (const chunk of iterateReader(file)) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @example Usage with buffer size
- * ```ts no-assert
- * import { iterateReader } from "@std/io/iterate-reader";
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReader(file, {
- *   bufSize: 1024 * 1024
- * });
- * for await (const chunk of iter) {
- *   console.log(chunk);
- * }
- * ```
- *
- * @param reader The reader to read from
- * @param options The options
- * @param options.bufSize The size of the buffer to use
- * @returns The async iterator of Uint8Array chunks
- */
-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);
-    }
-}
-/**
- * Turns a {@linkcode ReaderSync} into an iterator.
- *
- * @example Usage
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = Deno.openSync("README.md");
- * for (const chunk of iterateReaderSync(file)) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * Second argument can be used to tune size of a buffer.
- * Default size of the buffer is 32kB.
- *
- * @example Usage with buffer size
- * ```ts
- * import { iterateReaderSync } from "@std/io/iterate-reader";
- * import { assert } from "@std/assert/assert"
- *
- * using file = await Deno.open("README.md");
- * const iter = iterateReaderSync(file, {
- *   bufSize: 1024 * 1024
- * });
- * for (const chunk of iter) {
- *   assert(chunk instanceof Uint8Array);
- * }
- * ```
- *
- * 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.
- *
- * @param reader The reader to read from
- * @param options The options
- * @returns The iterator of Uint8Array chunks
- */
-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);
-    }
-}