@depup/aws-sdk__checksums 3.1000.18-depup.0

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

@@ -0,0 +1,123 @@
+import { setFeature } from "@aws-sdk/core/client";
+import { HttpRequest } from "@smithy/core/protocols";
+import { createBufferedReadable } from "@smithy/core/serde";
+import { ChecksumAlgorithm, DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation } from "./constants";
+import { getChecksumAlgorithmForRequest } from "./getChecksumAlgorithmForRequest";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { hasHeader } from "./hasHeader";
+import { hasHeaderWithPrefix } from "./hasHeaderWithPrefix";
+import { isStreaming } from "./isStreaming";
+import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
+import { stringHasher } from "./stringHasher";
+export const flexibleChecksumsMiddlewareOptions = {
+    name: "flexibleChecksumsMiddleware",
+    step: "build",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    if (!HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    if (hasHeaderWithPrefix("x-amz-checksum-", args.request.headers)) {
+        return next(args);
+    }
+    const { request, input } = args;
+    const { body: requestBody, headers } = request;
+    const { base64Encoder, streamHasher } = config;
+    const { requestChecksumRequired, requestAlgorithmMember } = middlewareConfig;
+    const requestChecksumCalculation = await config.requestChecksumCalculation();
+    const requestAlgorithmMemberName = requestAlgorithmMember?.name;
+    const requestAlgorithmMemberHttpHeader = requestAlgorithmMember?.httpHeader;
+    if (requestAlgorithmMemberName && !input[requestAlgorithmMemberName]) {
+        if (requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired) {
+            input[requestAlgorithmMemberName] = DEFAULT_CHECKSUM_ALGORITHM;
+            if (requestAlgorithmMemberHttpHeader) {
+                headers[requestAlgorithmMemberHttpHeader] = DEFAULT_CHECKSUM_ALGORITHM;
+            }
+        }
+    }
+    const checksumAlgorithm = getChecksumAlgorithmForRequest(input, {
+        requestChecksumRequired,
+        requestAlgorithmMember: requestAlgorithmMember?.name,
+        requestChecksumCalculation,
+    });
+    let updatedBody = requestBody;
+    let updatedHeaders = headers;
+    if (checksumAlgorithm) {
+        switch (checksumAlgorithm) {
+            case ChecksumAlgorithm.CRC32:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC32", "U");
+                break;
+            case ChecksumAlgorithm.CRC32C:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC32C", "V");
+                break;
+            case ChecksumAlgorithm.CRC64NVME:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_CRC64", "W");
+                break;
+            case ChecksumAlgorithm.SHA1:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_SHA1", "X");
+                break;
+            case ChecksumAlgorithm.SHA256:
+                setFeature(context, "FLEXIBLE_CHECKSUMS_REQ_SHA256", "Y");
+                break;
+        }
+        const checksumLocationName = getChecksumLocationName(checksumAlgorithm);
+        const checksumAlgorithmFn = selectChecksumAlgorithmFunction(checksumAlgorithm, config);
+        if (isStreaming(requestBody)) {
+            const { getAwsChunkedEncodingStream, bodyLengthChecker } = config;
+            updatedBody = getAwsChunkedEncodingStream(typeof config.requestStreamBufferSize === "number" && config.requestStreamBufferSize >= 8 * 1024
+                ? createBufferedReadable(requestBody, config.requestStreamBufferSize, context.logger)
+                : requestBody, {
+                base64Encoder,
+                bodyLengthChecker,
+                checksumLocationName,
+                checksumAlgorithmFn,
+                streamHasher,
+            });
+            updatedHeaders = {
+                ...headers,
+                "content-encoding": headers["content-encoding"]
+                    ? `${headers["content-encoding"]},aws-chunked`
+                    : "aws-chunked",
+                "transfer-encoding": "chunked",
+                "x-amz-decoded-content-length": headers["content-length"],
+                "x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER",
+                "x-amz-trailer": checksumLocationName,
+            };
+            delete updatedHeaders["content-length"];
+        }
+        else if (!hasHeader(checksumLocationName, headers)) {
+            const rawChecksum = await stringHasher(checksumAlgorithmFn, requestBody);
+            updatedHeaders = {
+                ...headers,
+                [checksumLocationName]: base64Encoder(rawChecksum),
+            };
+        }
+    }
+    try {
+        const result = await next({
+            ...args,
+            request: {
+                ...request,
+                headers: updatedHeaders,
+                body: updatedBody,
+            },
+        });
+        return result;
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === "InvalidChunkSizeError") {
+            try {
+                if (!e.message.endsWith(".")) {
+                    e.message += ".";
+                }
+                e.message +=
+                    " Set [requestStreamBufferSize=number e.g. 65_536] in client constructor to instruct AWS SDK to buffer your input stream.";
+            }
+            catch (ignored) {
+            }
+        }
+        throw e;
+    }
+};

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

@@ -0,0 +1,48 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { isChecksumWithPartNumber } from "./isChecksumWithPartNumber";
+import { validateChecksumFromResponse } from "./validateChecksumFromResponse";
+export const flexibleChecksumsResponseMiddlewareOptions = {
+    name: "flexibleChecksumsResponseMiddleware",
+    toMiddleware: "deserializerMiddleware",
+    relation: "after",
+    tags: ["BODY_CHECKSUM"],
+    override: true,
+};
+export const flexibleChecksumsResponseMiddleware = (config, middlewareConfig) => (next, context) => async (args) => {
+    if (!HttpRequest.isInstance(args.request)) {
+        return next(args);
+    }
+    const input = args.input;
+    const result = await next(args);
+    const response = result.response;
+    const { requestValidationModeMember, responseAlgorithms } = middlewareConfig;
+    if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") {
+        const { clientName, commandName } = context;
+        const customChecksumAlgorithms = Object.keys(config.checksumAlgorithms ?? {}).filter((algorithm) => {
+            const responseHeader = getChecksumLocationName(algorithm);
+            return response.headers[responseHeader] !== undefined;
+        });
+        const algoList = getChecksumAlgorithmListForResponse([
+            ...(responseAlgorithms ?? []),
+            ...customChecksumAlgorithms,
+        ]);
+        const isS3WholeObjectMultipartGetResponseChecksum = clientName === "S3Client" &&
+            commandName === "GetObjectCommand" &&
+            algoList.every((algorithm) => {
+                const responseHeader = getChecksumLocationName(algorithm);
+                const checksumFromResponse = response.headers[responseHeader];
+                return !checksumFromResponse || isChecksumWithPartNumber(checksumFromResponse);
+            });
+        if (isS3WholeObjectMultipartGetResponseChecksum) {
+            return result;
+        }
+        await validateChecksumFromResponse(response, {
+            config,
+            responseAlgorithms: algoList,
+            logger: context.logger,
+        });
+    }
+    return result;
+};

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

@@ -0,0 +1,2 @@
+import { stringHasher } from "./stringHasher";
+export const getChecksum = async (body, { checksumAlgorithmFn, base64Encoder }) => base64Encoder(await stringHasher(checksumAlgorithmFn, body));

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

@@ -0,0 +1,13 @@
+import { DEFAULT_CHECKSUM_ALGORITHM, RequestChecksumCalculation } from "./constants";
+export const getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember, requestChecksumCalculation }) => {
+    if (!requestAlgorithmMember) {
+        return requestChecksumCalculation === RequestChecksumCalculation.WHEN_SUPPORTED || requestChecksumRequired
+            ? DEFAULT_CHECKSUM_ALGORITHM
+            : undefined;
+    }
+    if (!input[requestAlgorithmMember]) {
+        return undefined;
+    }
+    const checksumAlgorithm = input[requestAlgorithmMember];
+    return checksumAlgorithm;
+};

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

@@ -0,0 +1,15 @@
+import { PRIORITY_ORDER_ALGORITHMS } from "./types";
+export const getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => {
+    const validChecksumAlgorithms = [];
+    let i = PRIORITY_ORDER_ALGORITHMS.length;
+    for (const algorithm of responseAlgorithms) {
+        const priority = PRIORITY_ORDER_ALGORITHMS.indexOf(algorithm);
+        if (priority !== -1) {
+            validChecksumAlgorithms[priority] = algorithm;
+        }
+        else {
+            validChecksumAlgorithms[i++] = algorithm;
+        }
+    }
+    return validChecksumAlgorithms.filter(Boolean);
+};

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

@@ -0,0 +1,2 @@
+import { ChecksumAlgorithm } from "./constants";
+export const getChecksumLocationName = (algorithm) => algorithm === ChecksumAlgorithm.MD5 ? "content-md5" : `x-amz-checksum-${algorithm.toLowerCase()}`;

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

@@ -0,0 +1,10 @@
+import { flexibleChecksumsInputMiddleware, flexibleChecksumsInputMiddlewareOptions, } from "./flexibleChecksumsInputMiddleware";
+import { flexibleChecksumsMiddleware, flexibleChecksumsMiddlewareOptions } from "./flexibleChecksumsMiddleware";
+import { flexibleChecksumsResponseMiddleware, flexibleChecksumsResponseMiddlewareOptions, } from "./flexibleChecksumsResponseMiddleware";
+export const getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({
+    applyToStack: (clientStack) => {
+        clientStack.add(flexibleChecksumsMiddleware(config, middlewareConfig), flexibleChecksumsMiddlewareOptions);
+        clientStack.addRelativeTo(flexibleChecksumsInputMiddleware(config, middlewareConfig), flexibleChecksumsInputMiddlewareOptions);
+        clientStack.addRelativeTo(flexibleChecksumsResponseMiddleware(config, middlewareConfig), flexibleChecksumsResponseMiddlewareOptions);
+    },
+});

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

@@ -0,0 +1,9 @@
+export const hasHeader = (header, headers) => {
+    const soughtHeader = header.toLowerCase();
+    for (const headerName of Object.keys(headers)) {
+        if (soughtHeader === headerName.toLowerCase()) {
+            return true;
+        }
+    }
+    return false;
+};

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

@@ -0,0 +1,9 @@
+export const hasHeaderWithPrefix = (headerPrefix, headers) => {
+    const soughtHeaderPrefix = headerPrefix.toLowerCase();
+    for (const headerName of Object.keys(headers)) {
+        if (headerName.toLowerCase().startsWith(soughtHeaderPrefix)) {
+            return true;
+        }
+    }
+    return false;
+};

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/submodules/flexible-checksums/isChecksumWithPartNumber.js

@@ -0,0 +1,13 @@
+export const isChecksumWithPartNumber = (checksum) => {
+    const lastHyphenIndex = checksum.lastIndexOf("-");
+    if (lastHyphenIndex !== -1) {
+        const numberPart = checksum.slice(lastHyphenIndex + 1);
+        if (!numberPart.startsWith("0")) {
+            const number = parseInt(numberPart, 10);
+            if (!isNaN(number) && number >= 1 && number <= 10000) {
+                return true;
+            }
+        }
+    }
+    return false;
+};

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

@@ -0,0 +1,2 @@
+import { isArrayBuffer } from "@smithy/core/serde";
+export const isStreaming = (body) => body !== undefined && typeof body !== "string" && !ArrayBuffer.isView(body) && !isArrayBuffer(body);

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

@@ -0,0 +1,11 @@
+import { normalizeProvider } from "@smithy/core/client";
+import { DEFAULT_REQUEST_CHECKSUM_CALCULATION, DEFAULT_RESPONSE_CHECKSUM_VALIDATION } from "./constants";
+export const resolveFlexibleChecksumsConfig = (input) => {
+    const { requestChecksumCalculation, responseChecksumValidation, requestStreamBufferSize } = input;
+    return Object.assign(input, {
+        requestChecksumCalculation: normalizeProvider(requestChecksumCalculation ?? DEFAULT_REQUEST_CHECKSUM_CALCULATION),
+        responseChecksumValidation: normalizeProvider(responseChecksumValidation ?? DEFAULT_RESPONSE_CHECKSUM_VALIDATION),
+        requestStreamBufferSize: Number(requestStreamBufferSize ?? 0),
+        checksumAlgorithms: input.checksumAlgorithms ?? {},
+    });
+};

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

@@ -0,0 +1,27 @@
+import { Crc32, Crc32c, Crc64Nvme } from "@aws-sdk/checksums/crc";
+import { ChecksumAlgorithm } from "./constants";
+import { CLIENT_SUPPORTED_ALGORITHMS } from "./types";
+export const selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => {
+    const { checksumAlgorithms = {} } = config;
+    switch (checksumAlgorithm) {
+        case ChecksumAlgorithm.MD5:
+            return checksumAlgorithms?.MD5 ?? config.md5;
+        case ChecksumAlgorithm.CRC32:
+            return checksumAlgorithms?.CRC32 ?? Crc32;
+        case ChecksumAlgorithm.CRC32C:
+            return checksumAlgorithms?.CRC32C ?? Crc32c;
+        case ChecksumAlgorithm.CRC64NVME:
+            return checksumAlgorithms?.CRC64NVME ?? Crc64Nvme;
+        case ChecksumAlgorithm.SHA1:
+            return checksumAlgorithms?.SHA1 ?? config.sha1;
+        case ChecksumAlgorithm.SHA256:
+            return checksumAlgorithms?.SHA256 ?? config.sha256;
+        default:
+            if (checksumAlgorithms?.[checksumAlgorithm]) {
+                return checksumAlgorithms[checksumAlgorithm];
+            }
+            throw new Error(`The checksum algorithm "${checksumAlgorithm}" is not supported by the client.` +
+                ` Select one of ${CLIENT_SUPPORTED_ALGORITHMS}, or provide an implementation to ` +
+                ` the client constructor checksums field.`);
+    }
+};

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

@@ -0,0 +1,6 @@
+import { toUint8Array } from "@smithy/core/serde";
+export const stringHasher = (checksumAlgorithmFn, body) => {
+    const hash = new checksumAlgorithmFn();
+    hash.update(toUint8Array(body || ""));
+    return hash.digest();
+};

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

@@ -0,0 +1,14 @@
+export var SelectorType;
+(function (SelectorType) {
+    SelectorType["ENV"] = "env";
+    SelectorType["CONFIG"] = "shared config entry";
+})(SelectorType || (SelectorType = {}));
+export const stringUnionSelector = (obj, key, union, type) => {
+    if (!(key in obj))
+        return undefined;
+    const value = obj[key].toUpperCase();
+    if (!Object.values(union).includes(value)) {
+        throw new TypeError(`Cannot load ${type} '${key}'. Expected one of ${Object.values(union)}, got '${obj[key]}'.`);
+    }
+    return value;
+};

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

@@ -0,0 +1,15 @@
+import { ChecksumAlgorithm } from "./constants";
+export const CLIENT_SUPPORTED_ALGORITHMS = [
+    ChecksumAlgorithm.CRC32,
+    ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.CRC64NVME,
+    ChecksumAlgorithm.SHA1,
+    ChecksumAlgorithm.SHA256,
+];
+export const PRIORITY_ORDER_ALGORITHMS = [
+    ChecksumAlgorithm.SHA256,
+    ChecksumAlgorithm.SHA1,
+    ChecksumAlgorithm.CRC32,
+    ChecksumAlgorithm.CRC32C,
+    ChecksumAlgorithm.CRC64NVME,
+];

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

@@ -0,0 +1,45 @@
+import { createChecksumStream } from "@smithy/core/serde";
+import { ChecksumAlgorithm } from "./constants";
+import { getChecksum } from "./getChecksum";
+import { getChecksumAlgorithmListForResponse } from "./getChecksumAlgorithmListForResponse";
+import { getChecksumLocationName } from "./getChecksumLocationName";
+import { isStreaming } from "./isStreaming";
+import { selectChecksumAlgorithmFunction } from "./selectChecksumAlgorithmFunction";
+export const validateChecksumFromResponse = async (response, { config, responseAlgorithms, logger }) => {
+    const checksumAlgorithms = getChecksumAlgorithmListForResponse(responseAlgorithms);
+    const { body: responseBody, headers: responseHeaders } = response;
+    for (const algorithm of checksumAlgorithms) {
+        const responseHeader = getChecksumLocationName(algorithm);
+        const checksumFromResponse = responseHeaders[responseHeader];
+        if (checksumFromResponse) {
+            let checksumAlgorithmFn;
+            try {
+                checksumAlgorithmFn = selectChecksumAlgorithmFunction(algorithm, config);
+            }
+            catch (error) {
+                if (algorithm === ChecksumAlgorithm.CRC64NVME) {
+                    logger?.warn(`Skipping ${ChecksumAlgorithm.CRC64NVME} checksum validation: ${error.message}`);
+                    continue;
+                }
+                throw error;
+            }
+            const { base64Encoder } = config;
+            if (isStreaming(responseBody)) {
+                response.body = createChecksumStream({
+                    expectedChecksum: checksumFromResponse,
+                    checksumSourceLocation: responseHeader,
+                    checksum: new checksumAlgorithmFn(),
+                    source: responseBody,
+                    base64Encoder,
+                });
+                return;
+            }
+            const checksum = await getChecksum(responseBody, { checksumAlgorithmFn, base64Encoder });
+            if (checksum === checksumFromResponse) {
+                break;
+            }
+            throw new Error(`Checksum mismatch: expected "${checksum}" but received "${checksumFromResponse}"` +
+                ` in response header "${responseHeader}".`);
+        }
+    }
+};

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;
+    }
+}

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

@@ -0,0 +1,59 @@
+import { createHash, createHmac } from "node:crypto";
+import { Sha1Js } from "./Sha1Js";
+const hasNativeCrypto = (() => {
+    try {
+        createHash("sha1");
+        return true;
+    }
+    catch {
+        return false;
+    }
+})();
+export 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);
+}