@mtkruto/node 0.63.3 → 0.63.6

package/esm/deps/jsr.io/@std/async/1.0.12/pool.js

@@ -0,0 +1,99 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/** Error message emitted from the thrown error while mapping. */
+const ERROR_WHILE_MAPPING_MESSAGE = "Cannot complete the mapping as an error was thrown from an item";
+/**
+ * pooledMap transforms values from an (async) iterable into another async
+ * iterable. The transforms are done concurrently, with a max concurrency
+ * defined by the poolLimit.
+ *
+ * If an error is thrown from `iterableFn`, no new transformations will begin.
+ * All currently executing transformations are allowed to finish and still
+ * yielded on success. After that, the rejections among them are gathered and
+ * thrown by the iterator in an `AggregateError`.
+ *
+ * @example Usage
+ * ```ts
+ * import { pooledMap } from "@std/async/pool";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const results = pooledMap(
+ *   2,
+ *   [1, 2, 3],
+ *   (i) => new Promise((r) => setTimeout(() => r(i), 1000)),
+ * );
+ *
+ * assertEquals(await Array.fromAsync(results), [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T the input type.
+ * @typeParam R the output type.
+ * @param poolLimit The maximum count of items being processed concurrently.
+ * @param array The input array for mapping.
+ * @param iteratorFn The function to call for every item of the array.
+ * @returns The async iterator with the transformed values.
+ */
+export function pooledMap(poolLimit, array, iteratorFn) {
+    // Create the async iterable that is returned from this function.
+    const res = new TransformStream({
+        async transform(p, controller) {
+            try {
+                const s = await p;
+                controller.enqueue(s);
+            }
+            catch (e) {
+                if (e instanceof AggregateError &&
+                    e.message === ERROR_WHILE_MAPPING_MESSAGE) {
+                    controller.error(e);
+                }
+            }
+        },
+    });
+    // Start processing items from the iterator
+    (async () => {
+        const writer = res.writable.getWriter();
+        const executing = [];
+        try {
+            for await (const item of array) {
+                const p = Promise.resolve().then(() => iteratorFn(item));
+                // Only write on success. If we `writer.write()` a rejected promise,
+                // that will end the iteration. We don't want that yet. Instead let it
+                // fail the race, taking us to the catch block where all currently
+                // executing jobs are allowed to finish and all rejections among them
+                // can be reported together.
+                writer.write(p);
+                const e = p.then(() => executing.splice(executing.indexOf(e), 1));
+                executing.push(e);
+                if (executing.length >= poolLimit) {
+                    await Promise.race(executing);
+                }
+            }
+            // Wait until all ongoing events have processed, then close the writer.
+            await Promise.all(executing);
+            writer.close();
+        }
+        catch {
+            const errors = [];
+            for (const result of await Promise.allSettled(executing)) {
+                if (result.status === "rejected") {
+                    errors.push(result.reason);
+                }
+            }
+            writer.write(Promise.reject(new AggregateError(errors, ERROR_WHILE_MAPPING_MESSAGE))).catch(() => { });
+        }
+    })();
+    // Feature test until browser coverage is adequate
+    return Symbol.asyncIterator in res.readable &&
+        typeof res.readable[Symbol.asyncIterator] === "function"
+        ? res.readable[Symbol.asyncIterator]()
+        : (async function* () {
+            const reader = res.readable.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                yield value;
+            }
+            reader.releaseLock();
+        })();
+}

package/esm/deps/jsr.io/@std/async/1.0.12/retry.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Error thrown in {@linkcode retry} once the maximum number of failed attempts
+ * has been reached.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { RetryError } from "@std/async/retry";
+ *
+ * throw new RetryError({ foo: "bar" }, 3);
+ * ```
+ */
+export declare class RetryError extends Error {
+    /**
+     * Constructs a new {@linkcode RetryError} instance.
+     *
+     * @param cause the cause for this error.
+     * @param attempts the number of retry attempts made.
+     */
+    constructor(cause: unknown, attempts: number);
+}
+/** Options for {@linkcode retry}. */
+export interface RetryOptions {
+    /**
+     * How much to backoff after each retry.
+     *
+     * @default {2}
+     */
+    multiplier?: number;
+    /**
+     * The maximum milliseconds between attempts.
+     *
+     * @default {60000}
+     */
+    maxTimeout?: number;
+    /**
+     * The maximum amount of attempts until failure.
+     *
+     * @default {5}
+     */
+    maxAttempts?: number;
+    /**
+     * The initial and minimum amount of milliseconds between attempts.
+     *
+     * @default {1000}
+     */
+    minTimeout?: number;
+    /**
+     * Amount of jitter to introduce to the time between attempts. This is `1`
+     * for full jitter by default.
+     *
+     * @default {1}
+     */
+    jitter?: number;
+}
+/**
+ * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
+ * Retries as long as the given function throws. If the attempts are exhausted,
+ * throws a {@linkcode RetryError} with `cause` set to the inner exception.
+ *
+ * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
+ * How long the actual delay is, depends on `jitter`.
+ *
+ * When `jitter` is the default value of `1`, waits between two attempts for a
+ * randomized amount between 0 and the backoff time. With the default options
+ * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
+ * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
+ *
+ * When `jitter` is `0`, waits the full backoff time.
+ *
+ * @example Example configuration 1
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Below resolves to the first non-error result of `req`
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2,
+ *  maxTimeout: 60000,
+ *  maxAttempts: 5,
+ *  minTimeout: 100,
+ *  jitter: 1,
+ * });
+ * ```
+ *
+ * @example Example configuration 2
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Make sure we wait at least 1 minute, but at most 2 minutes
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2.34,
+ *  maxTimeout: 80000,
+ *  maxAttempts: 7,
+ *  minTimeout: 1000,
+ *  jitter: 0.5,
+ * });
+ * ```
+ *
+ * @typeParam T The return type of the function to retry and returned promise.
+ * @param fn The function to retry.
+ * @param options Additional options.
+ * @returns The promise that resolves with the value returned by the function to retry.
+ */
+export declare function retry<T>(fn: (() => Promise<T>) | (() => T), options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.12/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/retry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;;;;OAKG;gBACS,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM;CAK7C;AAED,qCAAqC;AACrC,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,CAAC,CAAC,CA6CZ"}

package/esm/deps/jsr.io/@std/async/1.0.12/retry.js

@@ -0,0 +1,107 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { exponentialBackoffWithJitter } from "./_util.js";
+/**
+ * Error thrown in {@linkcode retry} once the maximum number of failed attempts
+ * has been reached.
+ *
+ * @example Usage
+ * ```ts no-assert ignore
+ * import { RetryError } from "@std/async/retry";
+ *
+ * throw new RetryError({ foo: "bar" }, 3);
+ * ```
+ */
+export class RetryError extends Error {
+    /**
+     * Constructs a new {@linkcode RetryError} instance.
+     *
+     * @param cause the cause for this error.
+     * @param attempts the number of retry attempts made.
+     */
+    constructor(cause, attempts) {
+        super(`Retrying exceeded the maxAttempts (${attempts}).`);
+        this.name = "RetryError";
+        this.cause = cause;
+    }
+}
+/**
+ * Calls the given (possibly asynchronous) function up to `maxAttempts` times.
+ * Retries as long as the given function throws. If the attempts are exhausted,
+ * throws a {@linkcode RetryError} with `cause` set to the inner exception.
+ *
+ * The backoff is calculated by multiplying `minTimeout` with `multiplier` to the power of the current attempt counter (starting at 0 up to `maxAttempts - 1`). It is capped at `maxTimeout` however.
+ * How long the actual delay is, depends on `jitter`.
+ *
+ * When `jitter` is the default value of `1`, waits between two attempts for a
+ * randomized amount between 0 and the backoff time. With the default options
+ * the maximal delay will be `15s = 1s + 2s + 4s + 8s`. If all five attempts
+ * are exhausted the mean delay will be `9.5s = ½(4s + 15s)`.
+ *
+ * When `jitter` is `0`, waits the full backoff time.
+ *
+ * @example Example configuration 1
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Below resolves to the first non-error result of `req`
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2,
+ *  maxTimeout: 60000,
+ *  maxAttempts: 5,
+ *  minTimeout: 100,
+ *  jitter: 1,
+ * });
+ * ```
+ *
+ * @example Example configuration 2
+ * ```ts no-assert
+ * import { retry } from "@std/async/retry";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Make sure we wait at least 1 minute, but at most 2 minutes
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2.34,
+ *  maxTimeout: 80000,
+ *  maxAttempts: 7,
+ *  minTimeout: 1000,
+ *  jitter: 0.5,
+ * });
+ * ```
+ *
+ * @typeParam T The return type of the function to retry and returned promise.
+ * @param fn The function to retry.
+ * @param options Additional options.
+ * @returns The promise that resolves with the value returned by the function to retry.
+ */
+export async function retry(fn, options) {
+    const { multiplier = 2, maxTimeout = 60000, maxAttempts = 5, minTimeout = 1000, jitter = 1, } = options ?? {};
+    if (maxTimeout <= 0) {
+        throw new TypeError(`Cannot retry as 'maxTimeout' must be positive: current value is ${maxTimeout}`);
+    }
+    if (minTimeout > maxTimeout) {
+        throw new TypeError(`Cannot retry as 'minTimeout' must be <= 'maxTimeout': current values 'minTimeout=${minTimeout}', 'maxTimeout=${maxTimeout}'`);
+    }
+    if (jitter > 1) {
+        throw new TypeError(`Cannot retry as 'jitter' must be <= 1: current value is ${jitter}`);
+    }
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt + 1 >= maxAttempts) {
+                throw new RetryError(error, maxAttempts);
+            }
+            const timeout = exponentialBackoffWithJitter(maxTimeout, minTimeout, attempt, multiplier, jitter);
+            await new Promise((r) => setTimeout(r, timeout));
+        }
+        attempt++;
+    }
+}

package/esm/deps/jsr.io/@std/async/1.0.12/tee.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility for representing n-tuple. Used in {@linkcode tee}.
+ *
+ * @internal
+ */
+export type Tuple<T, N extends number> = N extends N ? number extends N ? T[] : TupleOf<T, N, []> : never;
+/**
+ * Utility for representing n-tuple of. Used in {@linkcode Tuple}.
+ *
+ * @internal
+ */
+export type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : TupleOf<T, N, [T, ...R]>;
+/**
+ * Branches the given async iterable into the `n` branches.
+ *
+ * @example Usage
+ * ```ts
+ * import { tee } from "@std/async/tee";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const gen = async function* gen() {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * };
+ *
+ * const [branch1, branch2] = tee(gen());
+ *
+ * const result1 = await Array.fromAsync(branch1);
+ * assertEquals(result1, [1, 2, 3]);
+ *
+ * const result2 = await Array.fromAsync(branch2);
+ * assertEquals(result2, [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T The type of the provided async iterable and the returned async iterables.
+ * @typeParam N The amount of branches to tee into.
+ * @param iterable The iterable to tee.
+ * @param n The amount of branches to tee into.
+ * @returns The tuple where each element is an async iterable.
+ */
+export declare function tee<T, N extends number = 2>(iterable: AsyncIterable<T>, n?: N): Tuple<AsyncIterable<T>, N>;
+//# sourceMappingURL=tee.d.ts.map

package/esm/deps/jsr.io/@std/async/1.0.12/tee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/async/1.0.12/tee.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAChD,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAC1C,KAAK,CAAC;AAEV;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAC1D,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GACrB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAuC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EACzC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,CAAC,GAAE,CAAU,GACZ,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAuB5B"}

package/esm/deps/jsr.io/@std/async/1.0.12/tee.js

@@ -0,0 +1,102 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+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 _Queue_source, _Queue_queue;
+class Queue {
+    constructor(iterable) {
+        _Queue_source.set(this, void 0);
+        _Queue_queue.set(this, void 0);
+        Object.defineProperty(this, "head", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        __classPrivateFieldSet(this, _Queue_source, iterable[Symbol.asyncIterator](), "f");
+        __classPrivateFieldSet(this, _Queue_queue, {
+            value: undefined,
+            next: undefined,
+        }, "f");
+        this.head = __classPrivateFieldGet(this, _Queue_queue, "f");
+        this.done = false;
+    }
+    async next() {
+        const result = await __classPrivateFieldGet(this, _Queue_source, "f").next();
+        if (!result.done) {
+            const nextNode = {
+                value: result.value,
+                next: undefined,
+            };
+            __classPrivateFieldGet(this, _Queue_queue, "f").next = nextNode;
+            __classPrivateFieldSet(this, _Queue_queue, nextNode, "f");
+        }
+        else {
+            this.done = true;
+        }
+    }
+}
+_Queue_source = new WeakMap(), _Queue_queue = new WeakMap();
+/**
+ * Branches the given async iterable into the `n` branches.
+ *
+ * @example Usage
+ * ```ts
+ * import { tee } from "@std/async/tee";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const gen = async function* gen() {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * };
+ *
+ * const [branch1, branch2] = tee(gen());
+ *
+ * const result1 = await Array.fromAsync(branch1);
+ * assertEquals(result1, [1, 2, 3]);
+ *
+ * const result2 = await Array.fromAsync(branch2);
+ * assertEquals(result2, [1, 2, 3]);
+ * ```
+ *
+ * @typeParam T The type of the provided async iterable and the returned async iterables.
+ * @typeParam N The amount of branches to tee into.
+ * @param iterable The iterable to tee.
+ * @param n The amount of branches to tee into.
+ * @returns The tuple where each element is an async iterable.
+ */
+export function tee(iterable, n = 2) {
+    const queue = new Queue(iterable);
+    async function* generator() {
+        let buffer = queue.head;
+        while (true) {
+            if (buffer.next) {
+                buffer = buffer.next;
+                yield buffer.value;
+            }
+            else if (queue.done) {
+                return;
+            }
+            else {
+                await queue.next();
+            }
+        }
+    }
+    return Array.from({ length: n }).map(() => generator());
+}

package/esm/session/1_session.js

@@ -30,7 +30,7 @@ var _Session_instances, _Session_dc, _Session_cdn, _Session_lastConnect, _Sessio
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import * as dntShim from "../_dnt.shims.js";
-import { SECOND } from "../0_deps.js";
+import { delay, SECOND } from "../0_deps.js";
 import { drop, getLogger, Mutex } from "../1_utilities.js";
 import { transportProviderTcp, transportProviderWebSocket } from "../3_transport.js";
 import { SessionState } from "./0_session_state.js";
@@ -91,7 +91,7 @@ export class Session {
         return this.transport.connection.connected;
     }
     async connect() {
-        const release = await __classPrivateFieldGet(this, _Session_connectMutex, "f").lock();
+        const unlock = await __classPrivateFieldGet(this, _Session_connectMutex, "f").lock();
         try {
             if (this.connected) {
                 return;
@@ -102,7 +102,7 @@ export class Session {
             __classPrivateFieldSet(this, _Session_disconnected, false, "f");
         }
         finally {
-            release();
+            unlock();
         }
     }
     async waitUntilConnected() {
@@ -140,7 +140,7 @@ _Session_dc = new WeakMap(), _Session_cdn = new WeakMap(), _Session_lastConnect
     }
     if (__classPrivateFieldGet(this, _Session_lastConnect, "f") && Date.now() - __classPrivateFieldGet(this, _Session_lastConnect, "f").getTime() <= 10 * SECOND) {
         __classPrivateFieldGet(this, _Session_L, "f").debug("reconnecting after a delay");
-        await new Promise((r) => setTimeout(r, 3 * SECOND));
+        await delay(3 * SECOND);
     }
     else {
         __classPrivateFieldGet(this, _Session_L, "f").debug("reconnecting");

package/esm/session/2_session_encrypted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAA8C,OAAO,EAAuC,MAAM,YAAY,CAAC;AACtH,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAGvC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASxD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAQD,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAQZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAMpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAExB;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,UAAU,IAAI,IAAI;IAuDrB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CA4U9C"}
+{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAA8C,OAAO,EAAuC,MAAM,YAAY,CAAC;AACtH,OAAO,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAGvC,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AASxD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAQD,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAQZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAMpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAExB;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,UAAU,IAAI,IAAI;IAuDrB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CAsU9C"}

package/esm/session/2_session_encrypted.js

@@ -29,7 +29,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SessionEncrypted_instances, _a, _SessionEncrypted_id, _SessionEncrypted_authKey, _SessionEncrypted_authKeyId, _SessionEncrypted_toAcknowledge, _SessionEncrypted_pendingMessages, _SessionEncrypted_pendingPings, _SessionEncrypted_L, _SessionEncrypted_TGCRYPTO_INITED, _SessionEncrypted_assertNotDisconnected, _SessionEncrypted_invalidateSession, _SessionEncrypted_rejectAllPending, _SessionEncrypted_onMessageFailed, _SessionEncrypted_setServerSalt, _SessionEncrypted_receive, _SessionEncrypted_encryptMessage, _SessionEncrypted_decryptMessage, _SessionEncrypted_startReceiveLoop, _SessionEncrypted_receiveLoopActive, _SessionEncrypted_receiveLoop, _SessionEncrypted_onMessage, _SessionEncrypted_onRpcResult, _SessionEncrypted_onMsgDetailedInfo, _SessionEncrypted_onMsgNewDetailedInfo, _SessionEncrypted_onBadMsgNotification, _SessionEncrypted_onBadServerSalt, _SessionEncrypted_onPong, _SessionEncrypted_onNewSessionCreated, _SessionEncrypted_onMessageContainer, _SessionEncrypted_pingInterval, _SessionEncrypted_startPingLoop, _SessionEncrypted_pingLoopAbortController, _SessionEncrypted_LpingLoop, _SessionEncrypted_pingLoop, _SessionEncrypted_sendPingDelayDisconnect, _SessionEncrypted_resendPendingPing;
-import { assertEquals, concat, ige256Decrypt, ige256Encrypt, initTgCrypto, SECOND } from "../0_deps.js";
+import { assertEquals, concat, delay, ige256Decrypt, ige256Encrypt, initTgCrypto, SECOND } from "../0_deps.js";
 import { ConnectionError, TransportError } from "../0_errors.js";
 import { bigIntFromBuffer, bufferFromBigInt, drop, getLogger, getRandomId, gunzip, mod, sha1, sha256, toUnixTimestamp } from "../1_utilities.js";
 import { deserializeMessage, Mtproto, repr, serializeMessage, TLReader, X } from "../2_tl.js";
@@ -386,13 +386,7 @@ async function _SessionEncrypted_onMessage(msgId, body) {
     while (this.connected) {
         const then = Date.now();
         try {
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(resolve, __classPrivateFieldGet(this, _SessionEncrypted_pingInterval, "f") - timeElapsed);
-                __classPrivateFieldGet(this, _SessionEncrypted_pingLoopAbortController, "f").signal.onabort = () => {
-                    reject(__classPrivateFieldGet(this, _SessionEncrypted_pingLoopAbortController, "f")?.signal.reason);
-                    clearTimeout(timeout);
-                };
-            });
+            await delay(__classPrivateFieldGet(this, _SessionEncrypted_pingInterval, "f") - timeElapsed, { signal: __classPrivateFieldGet(this, _SessionEncrypted_pingLoopAbortController, "f").signal });
             if (!this.connected) {
                 continue;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mtkruto/node",
-  "version": "0.63.3",
+  "version": "0.63.6",
   "description": "MTKruto for Node.js",
   "author": "Roj <rojvv@icloud.com>",
   "repository": {

package/script/0_deps.d.ts

@@ -17,16 +17,21 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-export * from "./deps/jsr.io/@std/assert/1.0.11/mod.js";
-export { basename } from "./deps/jsr.io/@std/path/1.0.8/basename.js";
-export { extname } from "./deps/jsr.io/@std/path/1.0.8/extname.js";
-export { isAbsolute } from "./deps/jsr.io/@std/path/1.0.8/is_absolute.js";
+export { assert } from "./deps/jsr.io/@std/assert/1.0.12/assert.js";
+export { assertFalse } from "./deps/jsr.io/@std/assert/1.0.12/false.js";
+export { assertEquals } from "./deps/jsr.io/@std/assert/1.0.12/equals.js";
+export { unreachable } from "./deps/jsr.io/@std/assert/1.0.12/unreachable.js";
+export { AssertionError } from "./deps/jsr.io/@std/assert/1.0.12/assertion_error.js";
 export { join } from "./deps/jsr.io/@std/path/1.0.8/join.js";
+export { extname } from "./deps/jsr.io/@std/path/1.0.8/extname.js";
+export { basename } from "./deps/jsr.io/@std/path/1.0.8/basename.js";
 export { toFileUrl } from "./deps/jsr.io/@std/path/1.0.8/to_file_url.js";
+export { isAbsolute } from "./deps/jsr.io/@std/path/1.0.8/is_absolute.js";
+export { delay } from "./deps/jsr.io/@std/async/1.0.12/mod.js";
 export { concat } from "./deps/jsr.io/@std/bytes/1.0.5/concat.js";
+export { iterateReader } from "./deps/jsr.io/@std/io/0.225.2/iterate_reader.js";
 export { MINUTE, SECOND } from "./deps/jsr.io/@std/datetime/0.225.3/constants.js";
 export { toArrayBuffer } from "./deps/jsr.io/@std/streams/1.0.9/to_array_buffer.js";
-export { iterateReader } from "./deps/jsr.io/@std/io/0.225.2/iterate_reader.js";
 export { decodeBase64, encodeBase64 } from "./deps/jsr.io/@std/encoding/1.0.7/base64.js";
 import { contentType as contentType_ } from "./deps/jsr.io/@std/media-types/1.1.0/content_type.js";
 export declare const contentType: typeof contentType_;

package/script/0_deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"0_deps.d.ts","sourceRoot":"","sources":["../src/0_deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,cAAc,yCAAyC,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,MAAM,0CAA0C,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,uCAAuC,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AAEzE,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAElE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kDAAkD,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,qDAAqD,CAAC;AAEpF,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAEhF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAEzF,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,sDAAsD,CAAC;AACnG,eAAO,MAAM,WAAW,EAAE,OAAO,YAMhC,CAAC;AAEF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,UAMzC;AAED,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,+CAA+C,CAAC;AAEnH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"0_deps.d.ts","sourceRoot":"","sources":["../src/0_deps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,4CAA4C,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,iDAAiD,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,qDAAqD,CAAC;AAErF,OAAO,EAAE,IAAI,EAAE,MAAM,uCAAuC,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,0CAA0C,CAAC;AACnE,OAAO,EAAE,QAAQ,EAAE,MAAM,2CAA2C,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE1E,OAAO,EAAE,KAAK,EAAE,MAAM,wCAAwC,CAAC;AAE/D,OAAO,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AAElE,OAAO,EAAE,aAAa,EAAE,MAAM,iDAAiD,CAAC;AAEhF,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kDAAkD,CAAC;AAElF,OAAO,EAAE,aAAa,EAAE,MAAM,qDAAqD,CAAC;AAEpF,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAEzF,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,sDAAsD,CAAC;AACnG,eAAO,MAAM,WAAW,EAAE,OAAO,YAMhC,CAAC;AAEF,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,UAMzC;AAED,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,+CAA+C,CAAC;AAEnH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}