@aws-sdk/checksums 3.1000.9 → 3.1000.11

package/dist-cjs/submodules/sha/index.js

@@ -0,0 +1,312 @@
+const { toUint8Array, concatBytes } = require("@smithy/core/serde");
+const { createHmac, createHash } = require("node:crypto");
+const { Sha256, Sha256Js, Sha256Node } = require("@smithy/core/checksum");
+exports.Sha256 = Sha256;
+exports.Sha256Js = Sha256Js;
+exports.Sha256Node = Sha256Node;
+
+const BLOCK = 64;
+const DIGEST_LENGTH = 20;
+const INIT = new Int32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+const K = new Int32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]);
+class Sha1Js {
+    digestLength = DIGEST_LENGTH;
+    state = Int32Array.from(INIT);
+    w;
+    buffer = new Uint8Array(BLOCK);
+    bufferLength = 0;
+    bytesHashed = 0;
+    finished = false;
+    inner;
+    outer;
+    constructor(secret) {
+        if (secret) {
+            const key = Sha1Js.normalizeKey(secret);
+            this.inner = new Sha1Js();
+            this.outer = new Sha1Js();
+            const pad = new Uint8Array(BLOCK * 2);
+            for (let i = 0; i < BLOCK; ++i) {
+                pad[i] = 0x36 ^ key[i];
+                pad[i + BLOCK] = 0x5c ^ key[i];
+            }
+            this.inner.update(pad.subarray(0, BLOCK));
+            this.outer.update(pad.subarray(BLOCK));
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.inner) {
+            this.inner.update(data);
+            return;
+        }
+        let pos = 0;
+        let { length } = data;
+        this.bytesHashed += length;
+        if (this.bufferLength > 0) {
+            while (length > 0 && this.bufferLength < BLOCK) {
+                this.buffer[this.bufferLength++] = data[pos++];
+                --length;
+            }
+            if (this.bufferLength === BLOCK) {
+                this.hashBuffer(this.buffer, 0);
+                this.bufferLength = 0;
+            }
+        }
+        while (length >= BLOCK) {
+            this.hashBuffer(data, pos);
+            pos += BLOCK;
+            length -= BLOCK;
+        }
+        while (length > 0) {
+            this.buffer[this.bufferLength++] = data[pos++];
+            --length;
+        }
+    }
+    async digest() {
+        if (this.inner && this.outer) {
+            if (this.finished) {
+                throw new Error("Attempted to digest an already finished HMAC.");
+            }
+            this.finished = true;
+            const innerDigest = this.inner.digestSync();
+            this.outer.update(innerDigest);
+            return this.outer.digestSync();
+        }
+        return this.digestSync();
+    }
+    reset() {
+        this.state = Int32Array.from(INIT);
+        this.buffer = new Uint8Array(BLOCK);
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+    }
+    digestSync() {
+        const state = this.state.slice();
+        const buffer = this.buffer.slice();
+        let bufferLength = this.bufferLength;
+        const bitsHi = (this.bytesHashed / 0x20000000) | 0;
+        const bitsLo = this.bytesHashed << 3;
+        buffer[bufferLength++] = 0x80;
+        if (bufferLength > BLOCK - 8) {
+            for (let i = bufferLength; i < BLOCK; ++i) {
+                buffer[i] = 0;
+            }
+            this.hashBufferWith(state, buffer, 0);
+            bufferLength = 0;
+        }
+        for (let i = bufferLength; i < BLOCK - 8; ++i) {
+            buffer[i] = 0;
+        }
+        const v = new DataView(buffer.buffer, buffer.byteOffset, BLOCK);
+        v.setUint32(BLOCK - 8, bitsHi, false);
+        v.setUint32(BLOCK - 4, bitsLo, false);
+        this.hashBufferWith(state, buffer, 0);
+        const out = new Uint8Array(DIGEST_LENGTH);
+        out[0] = (state[0] >>> 24) & 0xff;
+        out[1] = (state[0] >>> 16) & 0xff;
+        out[2] = (state[0] >>> 8) & 0xff;
+        out[3] = state[0] & 0xff;
+        out[4] = (state[1] >>> 24) & 0xff;
+        out[5] = (state[1] >>> 16) & 0xff;
+        out[6] = (state[1] >>> 8) & 0xff;
+        out[7] = state[1] & 0xff;
+        out[8] = (state[2] >>> 24) & 0xff;
+        out[9] = (state[2] >>> 16) & 0xff;
+        out[10] = (state[2] >>> 8) & 0xff;
+        out[11] = state[2] & 0xff;
+        out[12] = (state[3] >>> 24) & 0xff;
+        out[13] = (state[3] >>> 16) & 0xff;
+        out[14] = (state[3] >>> 8) & 0xff;
+        out[15] = state[3] & 0xff;
+        out[16] = (state[4] >>> 24) & 0xff;
+        out[17] = (state[4] >>> 16) & 0xff;
+        out[18] = (state[4] >>> 8) & 0xff;
+        out[19] = state[4] & 0xff;
+        return out;
+    }
+    static normalizeKey(secret) {
+        const key = toUint8Array(secret);
+        if (key.byteLength > BLOCK) {
+            const h = new Sha1Js();
+            h.update(key);
+            const digest = h.digestSync();
+            const padded = new Uint8Array(BLOCK);
+            padded.set(digest);
+            return padded;
+        }
+        const padded = new Uint8Array(BLOCK);
+        padded.set(key);
+        return padded;
+    }
+    hashBuffer(data, offset) {
+        this.hashBufferWith(this.state, data, offset);
+    }
+    hashBufferWith(state, data, offset) {
+        const w = (this.w ??= new Int32Array(80));
+        let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4];
+        for (let t = 0; t < 16; ++t) {
+            w[t] =
+                ((data[offset + t * 4] & 0xff) << 24) |
+                    ((data[offset + t * 4 + 1] & 0xff) << 16) |
+                    ((data[offset + t * 4 + 2] & 0xff) << 8) |
+                    (data[offset + t * 4 + 3] & 0xff);
+        }
+        for (let t = 16; t < 80; ++t) {
+            const x = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
+            w[t] = (x << 1) | (x >>> 31);
+        }
+        for (let t = 0; t < 80; ++t) {
+            const r = t < 20 ? 0 : t < 40 ? 1 : t < 60 ? 2 : 3;
+            const temp = (((((s0 << 5) | (s0 >>> 27)) +
+                (r === 0 ? (s1 & s2) ^ (~s1 & s3) : r === 2 ? (s1 & s2) ^ (s1 & s3) ^ (s2 & s3) : s1 ^ s2 ^ s3)) |
+                0) +
+                ((s4 + ((K[r] + w[t]) | 0)) | 0)) |
+                0;
+            s4 = s3;
+            s3 = s2;
+            s2 = (s1 << 30) | (s1 >>> 2);
+            s1 = s0;
+            s0 = temp;
+        }
+        state[0] = (state[0] + s0) | 0;
+        state[1] = (state[1] + s1) | 0;
+        state[2] = (state[2] + s2) | 0;
+        state[3] = (state[3] + s3) | 0;
+        state[4] = (state[4] + s4) | 0;
+    }
+}
+
+const hasNativeCrypto = (() => {
+    try {
+        createHash("sha1");
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+const Sha1Node = hasNativeCrypto ? buildNativeClass() : Sha1Js;
+function buildNativeClass() {
+    return class Sha1Node {
+        digestLength = 20;
+        secret;
+        hash;
+        isHmac;
+        finished = false;
+        constructor(secret) {
+            this.secret = secret;
+            this.isHmac = !!secret;
+            this.hash = this.createHash();
+        }
+        update(data) {
+            if (this.finished) {
+                throw new Error("Attempted to update an already finished hash.");
+            }
+            this.hash.update(data);
+        }
+        async digest() {
+            let buf;
+            if (this.isHmac) {
+                this.finished = true;
+                buf = this.hash.digest();
+            }
+            else {
+                buf = this.hash.copy().digest();
+            }
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        reset() {
+            this.hash = this.createHash();
+            this.finished = false;
+        }
+        createHash() {
+            return this.secret ? createHmac("sha1", toBuffer(this.secret)) : createHash("sha1");
+        }
+    };
+}
+function toBuffer(data) {
+    if (typeof data === "string") {
+        return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+        return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return Buffer.from(data);
+}
+
+const { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
+const subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function"
+    ? globalThis.crypto.subtle
+    : undefined;
+const MAX_PENDING_BYTES = 8 * 1024 * 1024;
+class Sha1WebCrypto {
+    digestLength = 20;
+    secret;
+    pending = [];
+    pendingBytes = 0;
+    fallback;
+    finished = false;
+    constructor(secret) {
+        if (secret) {
+            this.secret = toUint8Array(secret);
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.fallback) {
+            this.fallback.update(data);
+            return;
+        }
+        this.pending.push(data.slice());
+        this.pendingBytes += data.byteLength;
+        if (this.pendingBytes >= MAX_PENDING_BYTES) {
+            this.switchToFallback();
+        }
+    }
+    async digest() {
+        if (this.fallback) {
+            return this.fallback.digest();
+        }
+        if (this.secret && this.finished) {
+            throw new Error("Attempted to digest an already finished HMAC.");
+        }
+        const data = concatBytes(this.pending);
+        if (subtle) {
+            if (this.secret) {
+                this.finished = true;
+                const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-1" }, false, ["sign"]);
+                const sig = await subtle.sign("HMAC", key, data);
+                return new Uint8Array(sig);
+            }
+            const hash = await subtle.digest("SHA-1", data);
+            return new Uint8Array(hash);
+        }
+        const sha1 = new Sha1Js(this.secret);
+        sha1.update(data);
+        return sha1.digest();
+    }
+    reset() {
+        this.pending = [];
+        this.pendingBytes = 0;
+        this.fallback = undefined;
+        this.finished = false;
+    }
+    switchToFallback() {
+        const sha1Js = new Sha1Js(this.secret);
+        for (const chunk of this.pending) {
+            sha1Js.update(chunk);
+        }
+        this.fallback = sha1Js;
+        this.pending = [];
+        this.pendingBytes = 0;
+    }
+}
+
+exports.Sha1 = Sha1Node;
+exports.Sha1Js = Sha1Js;
+exports.Sha1Node = Sha1Node;
+exports.Sha1WebCrypto = Sha1WebCrypto;

package/dist-es/index.js

@@ -1,8 +1,2 @@
-export { Crc64Nvme } from "./crc64-nvme/Crc64Nvme";
-export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
-export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, } from "./flexible-checksums/NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS";
-export { ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, } from "./flexible-checksums/NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS";
-export { RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, } from "./flexible-checksums/constants";
-export { flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware, } from "./flexible-checksums/flexibleChecksumsMiddleware";
-export { getFlexibleChecksumsPlugin } from "./flexible-checksums/getFlexibleChecksumsPlugin";
-export { resolveFlexibleChecksumsConfig } from "./flexible-checksums/resolveFlexibleChecksumsConfig";
+export { Crc64Nvme, Crc64NvmeJs, crc64NvmeCrtContainer } from "@aws-sdk/checksums/crc";
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware, getFlexibleChecksumsPlugin, resolveFlexibleChecksumsConfig, } from "@aws-sdk/checksums/flexible-checksums";

package/dist-es/submodules/crc/crc32c/Crc32cJs.js

@@ -0,0 +1,31 @@
+const T = new Uint32Array(256);
+for (let i = 0; i < 256; ++i) {
+    let c = i;
+    for (let j = 0; j < 8; ++j) {
+        c = c & 1 ? 0x82f63b78 ^ (c >>> 1) : c >>> 1;
+    }
+    T[i] = c >>> 0;
+}
+export class Crc32cJs {
+    digestLength = 4;
+    crc = 0xffff_ffff;
+    update(data) {
+        let crc = this.crc;
+        for (let i = 0; i < data.length; ++i) {
+            crc = (crc >>> 8) ^ T[(crc ^ data[i]) & 0xff];
+        }
+        this.crc = crc;
+    }
+    async digest() {
+        const value = (this.crc ^ 0xffff_ffff) >>> 0;
+        const out = new Uint8Array(4);
+        out[0] = value >>> 24;
+        out[1] = (value >>> 16) & 0xff;
+        out[2] = (value >>> 8) & 0xff;
+        out[3] = value & 0xff;
+        return out;
+    }
+    reset() {
+        this.crc = 0xffff_ffff;
+    }
+}

package/dist-es/submodules/crc/crc32c/Crc32cNode.js

@@ -0,0 +1,2 @@
+import { Crc32cJs } from "./Crc32cJs";
+export const Crc32cNode = Crc32cJs;

package/dist-es/submodules/crc/crc64-nvme/Crc64Nvme.js

@@ -0,0 +1,18 @@
+import { crc64NvmeCrtContainer } from "./crc64-nvme-crt-container";
+import { Crc64NvmeJs } from "./Crc64NvmeJs";
+export class Crc64Nvme {
+    impl;
+    constructor() {
+        const Crt = crc64NvmeCrtContainer.CrtCrc64Nvme;
+        this.impl = Crt ? new Crt() : new Crc64NvmeJs();
+    }
+    update(data) {
+        this.impl.update(data);
+    }
+    async digest() {
+        return this.impl.digest();
+    }
+    reset() {
+        this.impl.reset();
+    }
+}

package/dist-es/{crc64-nvme/Crc64Nvme.js → submodules/crc/crc64-nvme/Crc64NvmeJs.js}

@@ -29,7 +29,7 @@ const ensureTablesInitialized = () => {
         [t0, t1, t2, t3, t4, t5, t6, t7] = CRC64_NVME_REVERSED_TABLE;
     }
 };
-export class Crc64Nvme {
+export class Crc64NvmeJs {
     c1 = 0;
     c2 = 0;
     constructor() {
@@ -66,7 +66,7 @@ export class Crc64Nvme {
             crc2 = ((crc2 >>> 8) | ((crc1 & 255) << 24)) >>> 0;
             crc1 = (crc1 >>> 8) ^ t0[idx];
             crc2 ^= t0[idx + 1];
-            i++;
+            ++i;
         }
         this.c1 = crc1;
         this.c2 = crc2;

package/dist-es/submodules/crc/index.browser.js

@@ -0,0 +1,6 @@
+const no = Symbol.for("node-only");
+export { Crc32cJs, Crc32cJs as Crc32c } from "./crc32c/Crc32cJs";
+export const Crc32cNode = no;
+export { Crc64NvmeJs, Crc64NvmeJs as Crc64Nvme } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-es/submodules/crc/index.js

@@ -0,0 +1,6 @@
+export { Crc32cJs } from "./crc32c/Crc32cJs";
+export { Crc32cNode, Crc32cNode as Crc32c } from "./crc32c/Crc32cNode";
+export { Crc64Nvme } from "./crc64-nvme/Crc64Nvme";
+export { Crc64NvmeJs } from "./crc64-nvme/Crc64NvmeJs";
+export { crc64NvmeCrtContainer } from "./crc64-nvme/crc64-nvme-crt-container";
+export { Crc32, Crc32Js, Crc32Node } from "@smithy/core/checksum";

package/dist-es/submodules/flexible-checksums/index.js

@@ -0,0 +1,6 @@
+export { ENV_REQUEST_CHECKSUM_CALCULATION, CONFIG_REQUEST_CHECKSUM_CALCULATION, NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS, } from "./NODE_REQUEST_CHECKSUM_CALCULATION_CONFIG_OPTIONS";
+export { ENV_RESPONSE_CHECKSUM_VALIDATION, CONFIG_RESPONSE_CHECKSUM_VALIDATION, NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS, } from "./NODE_RESPONSE_CHECKSUM_VALIDATION_CONFIG_OPTIONS";
+export { RequestChecksumCalculation, DEFAULT_REQUEST_CHECKSUM_CALCULATION, ResponseChecksumValidation, DEFAULT_RESPONSE_CHECKSUM_VALIDATION, ChecksumAlgorithm, ChecksumLocation, DEFAULT_CHECKSUM_ALGORITHM, } from "./constants";
+export { flexibleChecksumsMiddlewareOptions, flexibleChecksumsMiddleware } from "./flexibleChecksumsMiddleware";
+export { getFlexibleChecksumsPlugin } from "./getFlexibleChecksumsPlugin";
+export { resolveFlexibleChecksumsConfig } from "./resolveFlexibleChecksumsConfig";

package/dist-es/{flexible-checksums → submodules/flexible-checksums}/selectChecksumAlgorithmFunction.js

@@ -1,8 +1,5 @@
-import { AwsCrc32c } from "@aws-crypto/crc32c";
-import { crc64NvmeCrtContainer } from "../crc64-nvme/crc64-nvme-crt-container";
-import { Crc64Nvme } from "../crc64-nvme/Crc64Nvme";
+import { Crc32, Crc32c, Crc64Nvme } from "@aws-sdk/checksums/crc";
 import { ChecksumAlgorithm } from "./constants";
-import { getCrc32ChecksumAlgorithmFunction } from "./getCrc32ChecksumAlgorithmFunction";
 import { CLIENT_SUPPORTED_ALGORITHMS } from "./types";
 export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => {
     const { checksumAlgorithms = {} } = config;
@@ -10,14 +7,11 @@ export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => {
         case ChecksumAlgorithm.MD5:
             return checksumAlgorithms?.MD5 ?? config.md5;
         case ChecksumAlgorithm.CRC32:
-            return checksumAlgorithms?.CRC32 ?? getCrc32ChecksumAlgorithmFunction();
+            return checksumAlgorithms?.CRC32 ?? Crc32;
         case ChecksumAlgorithm.CRC32C:
-            return checksumAlgorithms?.CRC32C ?? AwsCrc32c;
+            return checksumAlgorithms?.CRC32C ?? Crc32c;
         case ChecksumAlgorithm.CRC64NVME:
-            if (typeof crc64NvmeCrtContainer.CrtCrc64Nvme !== "function") {
-                return checksumAlgorithms?.CRC64NVME ?? Crc64Nvme;
-            }
-            return checksumAlgorithms?.CRC64NVME ?? crc64NvmeCrtContainer.CrtCrc64Nvme;
+            return checksumAlgorithms?.CRC64NVME ?? Crc64Nvme;
         case ChecksumAlgorithm.SHA1:
             return checksumAlgorithms?.SHA1 ?? config.sha1;
         case ChecksumAlgorithm.SHA256:

package/dist-es/submodules/md5/index.js

@@ -0,0 +1 @@
+export { Md5, Md5Js, Md5Node } from "@smithy/core/checksum";

package/dist-es/submodules/sha/index.browser.js

@@ -0,0 +1,4 @@
+const no = Symbol.for("node-only");
+export { Sha1Js, Sha1Js as Sha1 } from "./sha1/Sha1Js";
+export const Sha1Node = no;
+export { Sha256, Sha256Js, Sha256Node, Sha256WebCrypto } from "@smithy/core/checksum";

package/dist-es/submodules/sha/index.js

@@ -0,0 +1,4 @@
+export { Sha1Js } from "./sha1/Sha1Js";
+export { Sha1Node, Sha1Node as Sha1 } from "./sha1/Sha1Node";
+export { Sha1WebCrypto } from "./sha1/Sha1WebCrypto";
+export { Sha256, Sha256Js, Sha256Node } from "@smithy/core/checksum";

package/dist-es/submodules/sha/sha1/Sha1Js.js

@@ -0,0 +1,173 @@
+import { toUint8Array } from "@smithy/core/serde";
+const BLOCK = 64;
+const DIGEST_LENGTH = 20;
+const INIT = new Int32Array([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+const K = new Int32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]);
+export class Sha1Js {
+    digestLength = DIGEST_LENGTH;
+    state = Int32Array.from(INIT);
+    w;
+    buffer = new Uint8Array(BLOCK);
+    bufferLength = 0;
+    bytesHashed = 0;
+    finished = false;
+    inner;
+    outer;
+    constructor(secret) {
+        if (secret) {
+            const key = Sha1Js.normalizeKey(secret);
+            this.inner = new Sha1Js();
+            this.outer = new Sha1Js();
+            const pad = new Uint8Array(BLOCK * 2);
+            for (let i = 0; i < BLOCK; ++i) {
+                pad[i] = 0x36 ^ key[i];
+                pad[i + BLOCK] = 0x5c ^ key[i];
+            }
+            this.inner.update(pad.subarray(0, BLOCK));
+            this.outer.update(pad.subarray(BLOCK));
+        }
+    }
+    update(data) {
+        if (this.finished) {
+            throw new Error("Attempted to update an already finished HMAC.");
+        }
+        if (this.inner) {
+            this.inner.update(data);
+            return;
+        }
+        let pos = 0;
+        let { length } = data;
+        this.bytesHashed += length;
+        if (this.bufferLength > 0) {
+            while (length > 0 && this.bufferLength < BLOCK) {
+                this.buffer[this.bufferLength++] = data[pos++];
+                --length;
+            }
+            if (this.bufferLength === BLOCK) {
+                this.hashBuffer(this.buffer, 0);
+                this.bufferLength = 0;
+            }
+        }
+        while (length >= BLOCK) {
+            this.hashBuffer(data, pos);
+            pos += BLOCK;
+            length -= BLOCK;
+        }
+        while (length > 0) {
+            this.buffer[this.bufferLength++] = data[pos++];
+            --length;
+        }
+    }
+    async digest() {
+        if (this.inner && this.outer) {
+            if (this.finished) {
+                throw new Error("Attempted to digest an already finished HMAC.");
+            }
+            this.finished = true;
+            const innerDigest = this.inner.digestSync();
+            this.outer.update(innerDigest);
+            return this.outer.digestSync();
+        }
+        return this.digestSync();
+    }
+    reset() {
+        this.state = Int32Array.from(INIT);
+        this.buffer = new Uint8Array(BLOCK);
+        this.bufferLength = 0;
+        this.bytesHashed = 0;
+    }
+    digestSync() {
+        const state = this.state.slice();
+        const buffer = this.buffer.slice();
+        let bufferLength = this.bufferLength;
+        const bitsHi = (this.bytesHashed / 0x20000000) | 0;
+        const bitsLo = this.bytesHashed << 3;
+        buffer[bufferLength++] = 0x80;
+        if (bufferLength > BLOCK - 8) {
+            for (let i = bufferLength; i < BLOCK; ++i) {
+                buffer[i] = 0;
+            }
+            this.hashBufferWith(state, buffer, 0);
+            bufferLength = 0;
+        }
+        for (let i = bufferLength; i < BLOCK - 8; ++i) {
+            buffer[i] = 0;
+        }
+        const v = new DataView(buffer.buffer, buffer.byteOffset, BLOCK);
+        v.setUint32(BLOCK - 8, bitsHi, false);
+        v.setUint32(BLOCK - 4, bitsLo, false);
+        this.hashBufferWith(state, buffer, 0);
+        const out = new Uint8Array(DIGEST_LENGTH);
+        out[0] = (state[0] >>> 24) & 0xff;
+        out[1] = (state[0] >>> 16) & 0xff;
+        out[2] = (state[0] >>> 8) & 0xff;
+        out[3] = state[0] & 0xff;
+        out[4] = (state[1] >>> 24) & 0xff;
+        out[5] = (state[1] >>> 16) & 0xff;
+        out[6] = (state[1] >>> 8) & 0xff;
+        out[7] = state[1] & 0xff;
+        out[8] = (state[2] >>> 24) & 0xff;
+        out[9] = (state[2] >>> 16) & 0xff;
+        out[10] = (state[2] >>> 8) & 0xff;
+        out[11] = state[2] & 0xff;
+        out[12] = (state[3] >>> 24) & 0xff;
+        out[13] = (state[3] >>> 16) & 0xff;
+        out[14] = (state[3] >>> 8) & 0xff;
+        out[15] = state[3] & 0xff;
+        out[16] = (state[4] >>> 24) & 0xff;
+        out[17] = (state[4] >>> 16) & 0xff;
+        out[18] = (state[4] >>> 8) & 0xff;
+        out[19] = state[4] & 0xff;
+        return out;
+    }
+    static normalizeKey(secret) {
+        const key = toUint8Array(secret);
+        if (key.byteLength > BLOCK) {
+            const h = new Sha1Js();
+            h.update(key);
+            const digest = h.digestSync();
+            const padded = new Uint8Array(BLOCK);
+            padded.set(digest);
+            return padded;
+        }
+        const padded = new Uint8Array(BLOCK);
+        padded.set(key);
+        return padded;
+    }
+    hashBuffer(data, offset) {
+        this.hashBufferWith(this.state, data, offset);
+    }
+    hashBufferWith(state, data, offset) {
+        const w = (this.w ??= new Int32Array(80));
+        let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4];
+        for (let t = 0; t < 16; ++t) {
+            w[t] =
+                ((data[offset + t * 4] & 0xff) << 24) |
+                    ((data[offset + t * 4 + 1] & 0xff) << 16) |
+                    ((data[offset + t * 4 + 2] & 0xff) << 8) |
+                    (data[offset + t * 4 + 3] & 0xff);
+        }
+        for (let t = 16; t < 80; ++t) {
+            const x = w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16];
+            w[t] = (x << 1) | (x >>> 31);
+        }
+        for (let t = 0; t < 80; ++t) {
+            const r = t < 20 ? 0 : t < 40 ? 1 : t < 60 ? 2 : 3;
+            const temp = (((((s0 << 5) | (s0 >>> 27)) +
+                (r === 0 ? (s1 & s2) ^ (~s1 & s3) : r === 2 ? (s1 & s2) ^ (s1 & s3) ^ (s2 & s3) : s1 ^ s2 ^ s3)) |
+                0) +
+                ((s4 + ((K[r] + w[t]) | 0)) | 0)) |
+                0;
+            s4 = s3;
+            s3 = s2;
+            s2 = (s1 << 30) | (s1 >>> 2);
+            s1 = s0;
+            s0 = temp;
+        }
+        state[0] = (state[0] + s0) | 0;
+        state[1] = (state[1] + s1) | 0;
+        state[2] = (state[2] + s2) | 0;
+        state[3] = (state[3] + s3) | 0;
+        state[4] = (state[4] + s4) | 0;
+    }
+}