@mtkruto/node 0.1.0 → 0.1.101

package/script/connection/1_connection_web_socket.js

@@ -107,7 +107,7 @@ class ConnectionWebSocket extends _0_connection_js_1.ConnectionUnframed {
                 this.buffer.push(byte);
             }
             if (this.nextResolve != null && this.buffer.length >= this.nextResolve[0]) {
-                this.nextResolve[1]();
+                this.nextResolve[1].resolve();
                 this.nextResolve = null;
             }
             release();
@@ -162,7 +162,7 @@ class ConnectionWebSocket extends _0_connection_js_1.ConnectionUnframed {
         const release = await this.rMutex.acquire();
         try {
             if (this.buffer.length < p.length) {
-                await new Promise((r) => this.nextResolve = [p.length, r]);
+                await new Promise((resolve, reject) => this.nextResolve = [p.length, { resolve, reject }]);
             }
             p.set(this.buffer.splice(0, p.length));
         }
@@ -187,6 +187,9 @@ class ConnectionWebSocket extends _0_connection_js_1.ConnectionUnframed {
             throw new Error("Connection not open");
         }
         this.webSocket.close(1000, "method");
+        if (this.nextResolve != null) {
+            this.nextResolve[1].reject(new Error("Connection not open"));
+        }
     }
 }
 exports.ConnectionWebSocket = ConnectionWebSocket;

package/script/deps/deno.land/{std@0.201.0 → std@0.203.0}/assert/assert_false.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertFalse = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
+/** Make an assertion, error will be thrown if `expr` have truthy value. */
 function assertFalse(expr, msg = "") {
     if (expr) {
         throw new assertion_error_js_1.AssertionError(msg);

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/fnv32.d.ts

@@ -0,0 +1,2 @@
+export declare const fnv32: (data: Uint8Array) => ArrayBuffer;
+export declare const fnv32a: (data: Uint8Array) => ArrayBuffer;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/fnv32.js

@@ -0,0 +1,29 @@
+"use strict";
+// Ported from Go:
+// https://github.com/golang/go/tree/go1.13.10/src/hash/fnv/fnv.go
+// Copyright 2011 The Go Authors. All rights reserved. BSD license.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv32a = exports.fnv32 = void 0;
+const util_js_1 = require("./util.js");
+const prime32 = 16777619;
+const fnv32 = (data) => {
+    let hash = 2166136261;
+    data.forEach((c) => {
+        hash = (0, util_js_1.mul32)(hash, prime32);
+        hash ^= c;
+    });
+    return Uint32Array.from([(0, util_js_1.swap32)(hash)]).buffer;
+};
+exports.fnv32 = fnv32;
+const fnv32a = (data) => {
+    let hash = 2166136261;
+    data.forEach((c) => {
+        hash ^= c;
+        hash = (0, util_js_1.mul32)(hash, prime32);
+    });
+    return Uint32Array.from([(0, util_js_1.swap32)(hash)]).buffer;
+};
+exports.fnv32a = fnv32a;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/fnv64.d.ts

@@ -0,0 +1,2 @@
+export declare const fnv64: (data: Uint8Array) => ArrayBuffer;
+export declare const fnv64a: (data: Uint8Array) => ArrayBuffer;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/fnv64.js

@@ -0,0 +1,32 @@
+"use strict";
+// Ported from Go:
+// https://github.com/golang/go/tree/go1.13.10/src/hash/fnv/fnv.go
+// Copyright 2011 The Go Authors. All rights reserved. BSD license.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv64a = exports.fnv64 = void 0;
+const util_js_1 = require("./util.js");
+const prime64Lo = 435;
+const prime64Hi = 256;
+const fnv64 = (data) => {
+    let hashLo = 2216829733;
+    let hashHi = 3421674724;
+    data.forEach((c) => {
+        [hashHi, hashLo] = (0, util_js_1.mul64)([hashHi, hashLo], [prime64Hi, prime64Lo]);
+        hashLo ^= c;
+    });
+    return new Uint32Array([(0, util_js_1.swap32)(hashHi >>> 0), (0, util_js_1.swap32)(hashLo >>> 0)]).buffer;
+};
+exports.fnv64 = fnv64;
+const fnv64a = (data) => {
+    let hashLo = 2216829733;
+    let hashHi = 3421674724;
+    data.forEach((c) => {
+        hashLo ^= c;
+        [hashHi, hashLo] = (0, util_js_1.mul64)([hashHi, hashLo], [prime64Hi, prime64Lo]);
+    });
+    return new Uint32Array([(0, util_js_1.swap32)(hashHi >>> 0), (0, util_js_1.swap32)(hashLo >>> 0)]).buffer;
+};
+exports.fnv64a = fnv64a;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/mod.d.ts

@@ -0,0 +1 @@
+export declare function fnv(name: string, buf?: Uint8Array): ArrayBuffer;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/mod.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnv = void 0;
+const fnv32_js_1 = require("./fnv32.js");
+const fnv64_js_1 = require("./fnv64.js");
+function fnv(name, buf) {
+    if (!buf) {
+        throw new TypeError("no data provided for hashing");
+    }
+    switch (name) {
+        case "FNV32":
+            return (0, fnv32_js_1.fnv32)(buf);
+        case "FNV64":
+            return (0, fnv64_js_1.fnv64)(buf);
+        case "FNV32A":
+            return (0, fnv32_js_1.fnv32a)(buf);
+        case "FNV64A":
+            return (0, fnv64_js_1.fnv64a)(buf);
+        default:
+            throw new TypeError(`unsupported fnv digest: ${name}`);
+    }
+}
+exports.fnv = fnv;

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/util.d.ts

@@ -0,0 +1,13 @@
+export declare function swap32(val: number): number;
+/**
+ * mul32 performs 32-bit multiplication, a * b
+ * @param a
+ * @param b
+ */
+export declare function mul32(a: number, b: number): number;
+/**
+ * mul64 performs 64-bit multiplication with two 32-bit words
+ * @param [ah, al]
+ * @param [bh, bl]
+ */
+export declare function mul64([ah, al]: [number, number], [bh, bl]: [number, number]): [number, number];

package/script/deps/deno.land/std@0.203.0/crypto/_fnv/util.js

@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mul64 = exports.mul32 = exports.swap32 = void 0;
+function swap32(val) {
+    return (((val & 0xff) << 24) |
+        ((val & 0xff00) << 8) |
+        ((val >> 8) & 0xff00) |
+        ((val >> 24) & 0xff));
+}
+exports.swap32 = swap32;
+function n16(n) {
+    return n & 0xffff;
+}
+function n32(n) {
+    return n >>> 0;
+}
+function add32WithCarry(a, b) {
+    const added = n32(a) + n32(b);
+    return [n32(added), added > 0xffffffff ? 1 : 0];
+}
+function mul32WithCarry(a, b) {
+    const al = n16(a);
+    const ah = n16(a >>> 16);
+    const bl = n16(b);
+    const bh = n16(b >>> 16);
+    const [t, tc] = add32WithCarry(al * bh, ah * bl);
+    const [n, nc] = add32WithCarry(al * bl, n32(t << 16));
+    const carry = nc + (tc << 16) + n16(t >>> 16) + ah * bh;
+    return [n, carry];
+}
+/**
+ * mul32 performs 32-bit multiplication, a * b
+ * @param a
+ * @param b
+ */
+function mul32(a, b) {
+    // https://stackoverflow.com/a/28151933
+    const al = n16(a);
+    const ah = a - al;
+    return n32(n32(ah * b) + al * b);
+}
+exports.mul32 = mul32;
+/**
+ * mul64 performs 64-bit multiplication with two 32-bit words
+ * @param [ah, al]
+ * @param [bh, bl]
+ */
+function mul64([ah, al], [bh, bl]) {
+    const [n, c] = mul32WithCarry(al, bl);
+    return [n32(mul32(al, bh) + mul32(ah, bl) + c), n];
+}
+exports.mul64 = mul64;

package/script/deps/deno.land/std@0.203.0/crypto/_wasm/lib/deno_std_wasm_crypto.generated.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Returns the digest of the given `data` using the given hash `algorithm`.
+ *
+ * `length` will usually be left `undefined` to use the default length for
+ * the algorithm. For algorithms with variable-length output, it can be used
+ * to specify a non-negative integer number of bytes.
+ *
+ * An error will be thrown if `algorithm` is not a supported hash algorithm or
+ * `length` is not a supported length for the algorithm.
+ * @param {string} algorithm
+ * @param {Uint8Array} data
+ * @param {number | undefined} length
+ * @returns {Uint8Array}
+ */
+export function digest(algorithm: string, data: Uint8Array, length: number | undefined): Uint8Array;
+/** Instantiates an instance of the Wasm module returning its functions.
+ * @remarks It is safe to call this multiple times and once successfully
+ * loaded it will always return a reference to the same object.
+ */
+export function instantiate(): {
+    digest: typeof digest;
+    DigestContext: typeof DigestContext;
+};
+/** Instantiates an instance of the Wasm module along with its exports.
+ * @remarks It is safe to call this multiple times and once successfully
+ * loaded it will always return a reference to the same object.
+ * @returns {{
+ *   instance: WebAssembly.Instance;
+ *   exports: { digest: typeof digest; DigestContext : typeof DigestContext  }
+ * }}
+ */
+export function instantiateWithInstance(): {
+    instance: WebAssembly.Instance;
+    exports: {
+        digest: typeof digest;
+        DigestContext: typeof DigestContext;
+    };
+};
+/** Gets if the Wasm module has been instantiated. */
+export function isInstantiated(): boolean;
+/**
+ * A context for incrementally computing a digest using a given hash algorithm.
+ */
+export class DigestContext {
+    static __wrap(ptr: any): any;
+    /**
+     * Creates a new context incrementally computing a digest using the given
+     * hash algorithm.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm.
+     * @param {string} algorithm
+     */
+    constructor(algorithm: string);
+    __destroy_into_raw(): number | undefined;
+    ptr: number | undefined;
+    free(): void;
+    /**
+     * Update the digest's internal state with the additional input `data`.
+     *
+     * If the `data` array view is large, it will be split into subarrays (via
+     * JavaScript bindings) which will be processed sequentially in order to
+     * limit the amount of memory that needs to be allocated in the Wasm heap.
+     * @param {Uint8Array} data
+     */
+    update(data: Uint8Array): void;
+    /**
+     * Returns the digest of the input data so far. This may be called repeatedly
+     * without side effects.
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digest(length: number | undefined): Uint8Array;
+    /**
+     * Returns the digest of the input data so far, and resets this context to
+     * its initial state, as though it has not yet been provided with any input
+     * data. (It will still use the same algorithm.)
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digestAndReset(length: number | undefined): Uint8Array;
+    /**
+     * Returns the digest of the input data so far, and then drops the context
+     * from memory on the Wasm side. This context must no longer be used, and any
+     * further method calls will result in null pointer errors being thrown.
+     * https://github.com/rustwasm/wasm-bindgen/blob/bf39cfd8/crates/backend/src/codegen.rs#L186
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digestAndDrop(length: number | undefined): Uint8Array;
+    /**
+     * Resets this context to its initial state, as though it has not yet been
+     * provided with any input data. (It will still use the same algorithm.)
+     */
+    reset(): void;
+    /**
+     * Returns a new `DigestContext` that is a copy of this one, i.e., using the
+     * same algorithm and with a copy of the same internal state.
+     *
+     * This may be a more efficient option for computing multiple digests that
+     * start with a common prefix.
+     * @returns {DigestContext}
+     */
+    clone(): DigestContext;
+}