@mtkruto/node 0.1.0 → 0.1.101

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

@@ -0,0 +1,21 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { fnv32, fnv32a } from "./fnv32.js";
+import { fnv64, fnv64a } from "./fnv64.js";
+export function fnv(name, buf) {
+    if (!buf) {
+        throw new TypeError("no data provided for hashing");
+    }
+    switch (name) {
+        case "FNV32":
+            return fnv32(buf);
+        case "FNV64":
+            return fnv64(buf);
+        case "FNV32A":
+            return fnv32a(buf);
+        case "FNV64A":
+            return fnv64a(buf);
+        default:
+            throw new TypeError(`unsupported fnv digest: ${name}`);
+    }
+}

package/esm/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/esm/deps/deno.land/std@0.203.0/crypto/_fnv/util.js

@@ -0,0 +1,48 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+export function swap32(val) {
+    return (((val & 0xff) << 24) |
+        ((val & 0xff00) << 8) |
+        ((val >> 8) & 0xff00) |
+        ((val >> 24) & 0xff));
+}
+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
+ */
+export function mul32(a, b) {
+    // https://stackoverflow.com/a/28151933
+    const al = n16(a);
+    const ah = a - al;
+    return n32(n32(ah * b) + al * b);
+}
+/**
+ * mul64 performs 64-bit multiplication with two 32-bit words
+ * @param [ah, al]
+ * @param [bh, bl]
+ */
+export function mul64([ah, al], [bh, bl]) {
+    const [n, c] = mul32WithCarry(al, bl);
+    return [n32(mul32(al, bh) + mul32(ah, bl) + c), n];
+}

package/esm/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;
+}