lambda-live-debugger 1.12.8 → 1.12.9

package/node_modules/@aws-sdk/checksums/dist-es/submodules/xxh/xxhash64/Xxh64.js

@@ -0,0 +1,150 @@
+import { m32, U64 } from "../U64";
+const P = U64.create(6)
+    .write(0, 0b10011110001101110111100110110001, 0b10000101111010111100101010000111)
+    .write(1, 0b11000010101100101010111000111101, 0b00100111110101001110101101001111)
+    .write(3, 0b00010110010101100110011110110001, 0b10011110001101110111100111111001)
+    .write(4, 0b10000101111010111100101001110111, 0b11000010101100101010111001100011)
+    .write(5, 0b00100111110101001110101100101111, 0b00010110010101100110011111000101);
+P.copy(0, 2).add(2, P.hi(1), P.lo(1));
+const P1 = 0;
+const P2 = 1;
+const P1_2 = 2;
+const P3 = 3;
+const P4 = 4;
+const P5 = 5;
+const SEED = 0;
+const ACC0 = 1;
+const ACC1 = 2;
+const ACC2 = 3;
+const ACC3 = 4;
+const T0 = 5;
+const T1 = 6;
+const T2 = 7;
+export class Xxh64 {
+    digestLength = 8;
+    byteCount = 0;
+    mem = U64.create(8);
+    stripeBuffer = new Uint8Array(32);
+    bufferIndex = 0;
+    constructor() {
+        this.mem.write(SEED, 0, 0);
+        this.reset();
+    }
+    update(chunk) {
+        this.byteCount += chunk.byteLength;
+        this._update(chunk);
+    }
+    _update(chunk) {
+        if (this.bufferIndex !== 0 && this.bufferIndex + chunk.byteLength >= 32) {
+            const bytesFilled = 32 - this.bufferIndex;
+            for (let i = 0; i < bytesFilled; ++i) {
+                this.stripeBuffer[this.bufferIndex++] = chunk[i];
+            }
+            this.processStripe(this.stripeBuffer);
+            this.bufferIndex = 0;
+            return this._update(chunk.subarray(bytesFilled));
+        }
+        if (chunk.byteLength < 32) {
+            for (let i = 0; i < chunk.byteLength; ++i) {
+                this.stripeBuffer[this.bufferIndex++] = chunk[i];
+                if (this.bufferIndex === this.stripeBuffer.byteLength) {
+                    this.bufferIndex = 0;
+                    this.processStripe(this.stripeBuffer);
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < chunk.byteLength; i += 32) {
+                const chunkLen = Math.min(i + 32, chunk.byteLength) - i;
+                const subchunk = chunk.subarray(i, i + chunkLen);
+                if (chunkLen < 32) {
+                    return this._update(subchunk);
+                }
+                this.processStripe(subchunk);
+            }
+        }
+    }
+    async digest() {
+        const { mem, byteCount } = this;
+        const m = T0;
+        if (byteCount < 32) {
+            mem.copy(SEED, m).add(m, P.hi(P5), P.lo(P5));
+        }
+        else {
+            mem.copy(ACC0, T1).rotateLeft(T1, 1);
+            mem.write(m, mem.hi(T1), mem.lo(T1));
+            mem.copy(ACC1, T1).rotateLeft(T1, 7);
+            mem.add(m, mem.hi(T1), mem.lo(T1));
+            mem.copy(ACC2, T1).rotateLeft(T1, 12);
+            mem.add(m, mem.hi(T1), mem.lo(T1));
+            mem.copy(ACC3, T1).rotateLeft(T1, 18);
+            mem.add(m, mem.hi(T1), mem.lo(T1));
+            this.mergeAcc(m, ACC0);
+            this.mergeAcc(m, ACC1);
+            this.mergeAcc(m, ACC2);
+            this.mergeAcc(m, ACC3);
+        }
+        mem.add(m, Math.floor(byteCount / m32), byteCount & m32);
+        let rem = this.bufferIndex;
+        let ptr = 0;
+        const b = this.stripeBuffer;
+        while (rem >= 8) {
+            const v1 = b[ptr++] | (b[ptr++] << 8) | (b[ptr++] << 16) | ((b[ptr++] << 24) >>> 0);
+            const v0 = b[ptr++] | (b[ptr++] << 8) | (b[ptr++] << 16) | ((b[ptr++] << 24) >>> 0);
+            mem.write(T1, 0, 0);
+            this.roundAt(T1, v0, v1);
+            mem.xor(m, mem.hi(T1), mem.lo(T1)).rotateLeft(m, 27).multiply(m, P.hi(P1), P.lo(P1)).add(m, P.hi(P4), P.lo(P4));
+            rem -= 8;
+        }
+        while (rem >= 4) {
+            const lo = b[ptr++] | (b[ptr++] << 8) | (b[ptr++] << 16) | ((b[ptr++] << 24) >>> 0);
+            mem.write(T1, 0, lo).multiply(T1, P.hi(P1), P.lo(P1));
+            mem.xor(m, mem.hi(T1), mem.lo(T1)).rotateLeft(m, 23).multiply(m, P.hi(P2), P.lo(P2)).add(m, P.hi(P3), P.lo(P3));
+            rem -= 4;
+        }
+        while (rem >= 1) {
+            mem.write(T1, 0, b[ptr++]).multiply(T1, P.hi(P5), P.lo(P5));
+            mem.xor(m, mem.hi(T1), mem.lo(T1)).rotateLeft(m, 11).multiply(m, P.hi(P1), P.lo(P1));
+            rem -= 1;
+        }
+        this.avalanche(m);
+        return mem.toBytes(m);
+    }
+    reset() {
+        const { mem } = this;
+        this.byteCount = 0;
+        this.bufferIndex = 0;
+        mem.copy(SEED, ACC0).add(ACC0, P.hi(P1_2), P.lo(P1_2));
+        mem.copy(SEED, ACC1).add(ACC1, P.hi(P2), P.lo(P2));
+        mem.copy(SEED, ACC2);
+        mem.copy(SEED, ACC3).subtract(ACC3, P.hi(P1), P.lo(P1));
+    }
+    processStripe(stripe) {
+        for (let i = 0; i < 4; ++i) {
+            const ix = i * 8;
+            const v1 = stripe[ix] | (stripe[ix + 1] << 8) | (stripe[ix + 2] << 16) | ((stripe[ix + 3] << 24) >>> 0);
+            const v0 = stripe[ix + 4] | (stripe[ix + 5] << 8) | (stripe[ix + 6] << 16) | ((stripe[ix + 7] << 24) >>> 0);
+            this.roundAt(ACC0 + i, v0, v1);
+        }
+    }
+    mergeAcc(m, acc) {
+        const { mem } = this;
+        mem.write(T1, 0, 0);
+        this.roundAt(T1, mem.hi(acc), mem.lo(acc));
+        mem.xor(m, mem.hi(T1), mem.lo(T1)).multiply(m, P.hi(P1), P.lo(P1)).add(m, P.hi(P4), P.lo(P4));
+    }
+    roundAt(i, v0, v1) {
+        const { mem } = this;
+        mem.write(T2, v0, v1).multiply(T2, P.hi(P2), P.lo(P2));
+        mem.add(i, mem.hi(T2), mem.lo(T2)).rotateLeft(i, 31).multiply(i, P.hi(P1), P.lo(P1));
+    }
+    avalanche(i) {
+        const { mem } = this;
+        mem.copy(i, T1).right(T1, 33);
+        mem.xor(i, mem.hi(T1), mem.lo(T1)).multiply(i, P.hi(P2), P.lo(P2));
+        mem.copy(i, T1).right(T1, 29);
+        mem.xor(i, mem.hi(T1), mem.lo(T1)).multiply(i, P.hi(P3), P.lo(P3));
+        mem.copy(i, T1).right(T1, 32);
+        mem.xor(i, mem.hi(T1), mem.lo(T1));
+    }
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/sha/index.browser.d.ts

@@ -1,3 +1,5 @@
 export { Sha1Js, Sha1Js as Sha1 } from "./sha1/Sha1Js";
 export declare const Sha1Node: symbol;
+export { Sha512WebCrypto, Sha512WebCrypto as Sha512 } from "./sha512/Sha512WebCrypto";
+export { Sha512Js } from "./sha512/Sha512Js";
 export { Sha256, Sha256Js, Sha256Node, Sha256WebCrypto } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-types/submodules/sha/index.d.ts

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

package/node_modules/@aws-sdk/checksums/dist-types/submodules/sha/sha512/Sha512.d.ts

@@ -0,0 +1,17 @@
+import type { SourceData } from "@smithy/types";
+import { Sha512Js } from "./Sha512Js";
+/**
+ * SHA-512, using Node.js native crypto when available and falling back to the
+ * inherited pure-JS implementation otherwise.
+ * @public
+ */
+export declare class Sha512 extends Sha512Js {
+    private native?;
+    private readonly nativeSecret?;
+    private nativeFinished;
+    constructor(secret?: SourceData);
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private createNative;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/sha/sha512/Sha512Js.d.ts

@@ -0,0 +1,29 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * Pure JS SHA-512 implementation with HMAC support.
+ * 64-bit words are held as [hi, lo] u32 pairs; all arithmetic is split accordingly.
+ * Non-destructive digest for plain hash — safe to call digest() multiple times.
+ * @see https://csrc.nist.gov/pubs/fips/180-4/upd1/final
+ * @public
+ */
+export declare class Sha512Js implements Checksum {
+    readonly digestLength = 64;
+    private state;
+    private w?;
+    private buffer;
+    private bufferLength;
+    private bytesHashed;
+    private finished;
+    private readonly key?;
+    private inner?;
+    private outer?;
+    constructor(secret?: SourceData);
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private initHmac;
+    private digestSync;
+    private static normalizeKey;
+    private hashBuffer;
+    private hashBufferWith;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/sha/sha512/Sha512WebCrypto.d.ts

@@ -0,0 +1,22 @@
+import type { Checksum, SourceData } from "@smithy/types";
+/**
+ * SHA-512 using the Web Crypto API (crypto.subtle) when available,
+ * falling back to the pure JS implementation.
+ *
+ * Caution: WebCrypto digest() needs the whole message at once, so data is
+ * buffered until MAX_PENDING_BYTES, then streamed through Sha512Js instead.
+ * @public
+ */
+export declare class Sha512WebCrypto implements Checksum {
+    readonly digestLength: 64;
+    private readonly secret?;
+    private pending;
+    private pendingBytes;
+    private fallback?;
+    private finished;
+    constructor(secret?: SourceData);
+    update(data: Uint8Array): void;
+    digest(): Promise<Uint8Array>;
+    reset(): void;
+    private switchToFallback;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/U64.d.ts

@@ -0,0 +1,110 @@
+/**
+ * @internal
+ */
+export type u32 = number;
+/**
+ * Larger (left) 32 bits of a u64.
+ * @internal
+ */
+export type u64_l = u32;
+/**
+ * Low (right) 32 bits of a u64.
+ * @internal
+ */
+export type u64_r = u32;
+/**
+ * @internal
+ */
+export type index = number;
+/**
+ * @internal
+ */
+export type distance = number;
+/**
+ * @internal
+ */
+export type size = number;
+/**
+ * 8-bit mask.
+ * @internal
+ */
+export declare const m8 = 255;
+/**
+ * 16-bit mask.
+ * @internal
+ */
+export declare const m16 = 65535;
+/**
+ * 32-bit mask.
+ * @internal
+ */
+export declare const m32 = 4294967295;
+/**
+ * Fixed-length allocation of u64 values stored as pairs of u32 in a Uint32Array.
+ * Slot i occupies indices [i*2, i*2+1] where [0]=high bits, [1]=low bits.
+ *
+ * @internal
+ */
+export declare class U64 extends Uint32Array {
+    private constructor();
+    /**
+     * Creates a U64
+     *
+     * @param size - number of U32 pairs.
+     */
+    static create(size: index): U64;
+    /**
+     * Set pair at slot i.
+     */
+    write(i: index, v0: u64_l, v1: u64_r): U64;
+    /**
+     * Copy pair from slot source to target.
+     */
+    copy(source: index, target: index): U64;
+    /**
+     * Add in-place at [i].
+     */
+    add(i: index, v0: u64_l, v1: u64_r): U64;
+    /**
+     * Multiply in-place at [i].
+     */
+    multiply(i: index, v0: u64_l, v1: u64_r): U64;
+    /**
+     * [i] += a * b.
+     */
+    addProduct(i: index, a: u32, b: u32): U64;
+    /**
+     * 64×64→128-bit multiplication.
+     * Multiplies slot `i` by slot `j`, stores high 64 bits in `t` and low 64 bits in `u`.
+     */
+    multiply128(i: index, j: index, t: index, u: index): U64;
+    /**
+     * Subtract in-place at [i].
+     */
+    subtract(i: index, v0: u64_l, v1: u64_r): U64;
+    /**
+     * Left shift in-place at [i].
+     */
+    left(i: index, places: distance): U64;
+    /**
+     * Rotate left (circular shift) at [i].
+     */
+    rotateLeft(i: index, places: distance): U64;
+    /**
+     * Right shift in-place at [i].
+     */
+    right(i: index, places: distance): U64;
+    /**
+     * XOR in-place at [i].
+     */
+    xor(i: index, v0: u64_l, v1: u64_r): U64;
+    toBytes(i: index): Uint8Array;
+    /**
+     * Read the high 32 bits of slot i.
+     */
+    hi(i: index): u64_l;
+    /**
+     * Read the low 32 bits of slot i.
+     */
+    lo(i: index): u64_r;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/Xxh3.d.ts

@@ -0,0 +1,139 @@
+import type { index, size, u32, u64_l, u64_r } from "./U64";
+import { U64 } from "./U64";
+export declare const PRIME32_1 = 2654435761;
+export declare const PRIME32_2 = 2246822519;
+export declare const PRIME32_3 = 3266489917;
+export declare const PRIME64_1_0 = 2654435761;
+export declare const PRIME64_1_1 = 2246822535;
+export declare const PRIME64_2_0 = 3266489917;
+export declare const PRIME64_2_1 = 668265295;
+export declare const PRIME64_3_0 = 374761393;
+export declare const PRIME64_3_1 = 2654435833;
+export declare const PRIME64_4_0 = 2246822519;
+export declare const PRIME64_4_1 = 3266489955;
+export declare const PRIME64_5_0 = 668265263;
+export declare const PRIME64_5_1 = 374761413;
+export declare const PRIME_MX1_0 = 374761361;
+export declare const PRIME_MX1_1 = 2654435833;
+export declare const PRIME_MX2_0 = 2679250021;
+export declare const PRIME_MX2_1 = 513335077;
+export declare const DEFAULT_SECRET: Uint8Array;
+/** Slot layout: 0=seed, 1..8=acc[0..7], 9..16=scratch temps */
+export declare const SEED = 0;
+export declare const ACC = 1;
+export declare const T0 = 9;
+export declare const T1 = 10;
+export declare const T2 = 11;
+export declare const T3 = 12;
+export declare const T4 = 13;
+export declare const T5 = 14;
+export declare const T6 = 15;
+export declare const SECRET_LENGTH = 192;
+export declare const STRIPES_PER_BLOCK: number;
+export declare const BLOCK_SIZE: number;
+/**
+ * Reads a 32-bit unsigned integer from a byte array in little-endian order.
+ * @internal
+ */
+export declare function readU32LE(b: Uint8Array, offset: index): u32;
+/**
+ * Reads a 64-bit unsigned integer from a byte array in little-endian order.
+ * @internal
+ */
+export declare function readU64LE(b: Uint8Array, offset: index): [u64_l, u64_r];
+/**
+ * Reverses the bytes in [x].
+ * @internal
+ */
+export declare function bswap32(x: u32): u32;
+/**
+ * @internal
+ */
+export declare abstract class Xxh3 {
+    protected mem: U64;
+    protected seed0: u64_l;
+    protected seed1: u64_r;
+    protected secret: Uint8Array;
+    private dvBuffer;
+    private dataView;
+    /**
+     * Fixed-size buffer (BLOCK_SIZE = 1024 bytes).
+     * For inputs lte 240 bytes, holds the entire input for small/medium paths.
+     * In streaming mode, buffers the latest block. Complete blocks
+     * are processed immediately. The partial tail is kept for finalization
+     * during digest.
+     */
+    protected blockBuffer: Uint8Array;
+    protected bufferIndex: number;
+    protected byteCount: number;
+    private prevTail;
+    private hasPrevTail;
+    /**
+     * This mode can be entered but not exited.
+     */
+    protected streaming: boolean;
+    protected constructor(slots: size, seed0?: number, seed1?: number);
+    update(chunk: Uint8Array): void;
+    reset(): void;
+    /**
+     * Returns the buffered input for small/medium paths (byteCount lte 240).
+     * Only valid when not entered into streaming mode.
+     */
+    protected getBufferedInput(): Uint8Array;
+    /**
+     * Finalizes the large (over 240 bytes) streaming path.
+     * Processes the remaining buffered data as the last (partial) block.
+     */
+    protected finalizeLargeAccumulators(): void;
+    /**
+     * Used in step 1: initialize.
+     */
+    protected initAccumulators(): void;
+    /**
+     * Used in step 2: accumulate.
+     */
+    protected accumulateStripe(input: Uint8Array, stripeOffset: index, secretOffset: index): void;
+    /**
+     * Used in step 3: scramble.
+     */
+    protected roundScramble(): void;
+    /**
+     * Used in step 4: merge.
+     */
+    protected finalMerge(init0: u64_l, init1: u64_r, secretOffset: index): Uint8Array;
+    /**
+     * Mixes two 64-bit input lanes with secret-derived keys.
+     * Used in step 2: accumulate (medium-length path, 17–240 bytes).
+     */
+    protected mix(data: Uint8Array, dataOffset: index, secretOffset: index): index;
+    /**
+     * avalanche(x): x ^= x >> 37; x *= PRIME_MX1; x ^= x >> 32; Result in `i`.
+     * Used in step 5: avalanche.
+     */
+    protected avalanche(i: index, v0: u64_l, v1: u64_r): void;
+    /**
+     * avalanche_XXH64(x): x ^= x>>33; x *= P2; x ^= x>>29; x *= P3; x ^= x>>32; Result in `i`.
+     * Used in step 5: avalanche.
+     */
+    protected avalanche64(i: index, v0: u64_l, v1: u64_r): void;
+    /**
+     * Derives a custom secret from the default secret and the seed.
+     * Used in step 1: initialize.
+     */
+    protected deriveSecret(): Uint8Array;
+    /**
+     * Returns a cached DataView for the given Uint8Array's buffer.
+     * Used in step 2: accumulate.
+     */
+    protected view(b: Uint8Array): DataView;
+    /**
+     * Processes a complete block of BLOCK_SIZE bytes through accumulation and scrambling.
+     * Used in step 2: accumulate, and step 3: scramble.
+     */
+    private processFullBlock;
+    /**
+     * Processes the last (possibly partial) block.
+     * Used in step 2: accumulate.
+     */
+    private processLastBlock;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/index.d.ts

@@ -0,0 +1,3 @@
+export { Xxh64, Xxh64 as Xxh64Js } from "./xxhash64/Xxh64";
+export { Xxh3_64, Xxh3_64 as Xxh3_64Js } from "./xxhash3_64/Xxh3_64";
+export { Xxh3_128, Xxh3_128 as Xxh3_128Js } from "./xxhash3_128/Xxh3_128";

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/xxhash3_128/Xxh3_128.d.ts

@@ -0,0 +1,37 @@
+import type { Checksum } from "@smithy/types";
+import { Xxh3 } from "../Xxh3";
+/**
+ * XXHASH3 128-bit.
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/doc/xxhash_spec.md#xxh3-algorithm-overview
+ * @internal
+ */
+export declare class Xxh3_128 extends Xxh3 implements Checksum {
+    readonly digestLength = 16;
+    constructor();
+    digest(): Promise<Uint8Array>;
+    /**
+     * Concatenates two 64-bit slots into a 128-bit result.
+     * Used in step 4: merge.
+     */
+    private concat;
+    /**
+     * Handles inputs of 0–16 bytes.
+     * Used in steps 2–5: accumulate through avalanche (single-shot path).
+     */
+    private digestSmall;
+    /**
+     * Handles inputs of 17–240 bytes.
+     * Used in steps 2–5: accumulate through avalanche (single-shot path).
+     */
+    private digestMedium;
+    /**
+     * Mixes two 16-byte chunks from the input and accumulates into T0 and T1.
+     * Used in step 2: accumulate (medium-length path, 17–240 bytes).
+     */
+    private mixTwoChunks;
+    /**
+     * Handles inputs over 240 bytes via streaming accumulators.
+     * Used in steps 2–5: accumulate through avalanche (streaming path).
+     */
+    private digestLarge;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/xxhash3_64/Xxh3_64.d.ts

@@ -0,0 +1,27 @@
+import type { Checksum } from "@smithy/types";
+import { Xxh3 } from "../Xxh3";
+/**
+ * XXHASH3 64-bit.
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/doc/xxhash_spec.md#xxh3-algorithm-overview
+ * @internal
+ */
+export declare class Xxh3_64 extends Xxh3 implements Checksum {
+    readonly digestLength = 8;
+    constructor();
+    digest(): Promise<Uint8Array>;
+    /**
+     * Handles inputs of 0–16 bytes.
+     * Used in steps 2–5: accumulate through avalanche (single-shot path).
+     */
+    private digestSmall;
+    /**
+     * Handles inputs of 17–240 bytes.
+     * Used in steps 2–5: accumulate through avalanche (single-shot path).
+     */
+    private digestMedium;
+    /**
+     * Handles inputs over 240 bytes via streaming accumulators.
+     * Used in steps 2–5: accumulate through avalanche (streaming path).
+     */
+    private digestLarge;
+}

package/node_modules/@aws-sdk/checksums/dist-types/submodules/xxh/xxhash64/Xxh64.d.ts

@@ -0,0 +1,41 @@
+import type { Checksum } from "@smithy/types";
+/**
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/doc/xxhash_spec.md#xxh64-algorithm-description
+ * @internal
+ */
+export declare class Xxh64 implements Checksum {
+    readonly digestLength = 8;
+    private byteCount;
+    private mem;
+    private stripeBuffer;
+    private bufferIndex;
+    constructor();
+    update(chunk: Uint8Array): void;
+    private _update;
+    digest(): Promise<Uint8Array>;
+    /**
+     * Resets accumulators to their initial seeded state.
+     * Used in step 1: initialize.
+     */
+    reset(): void;
+    /**
+     * Processes a 32-byte stripe through the four accumulators.
+     * Used in step 2: accumulate.
+     */
+    private processStripe;
+    /**
+     * Merges an accumulator into the final hash value.
+     * Used in step 3: merge.
+     */
+    private mergeAcc;
+    /**
+     * round: acc += (lane * P2); acc <<<= 31; acc *= P1;
+     * Used in step 2: accumulate.
+     */
+    private roundAt;
+    /**
+     * Final bit mixing to ensure good distribution.
+     * Used in step 4: avalanche.
+     */
+    private avalanche;
+}

package/node_modules/@aws-sdk/checksums/dist-types/ts3.4/submodules/sha/index.browser.d.ts

@@ -1,3 +1,5 @@
 export { Sha1Js, Sha1Js as Sha1 } from "./sha1/Sha1Js";
 export declare const Sha1Node: symbol;
+export { Sha512WebCrypto, Sha512WebCrypto as Sha512 } from "./sha512/Sha512WebCrypto";
+export { Sha512Js } from "./sha512/Sha512Js";
 export { Sha256, Sha256Js, Sha256Node, Sha256WebCrypto } from "@smithy/core/checksum";

package/node_modules/@aws-sdk/checksums/dist-types/ts3.4/submodules/sha/index.d.ts

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

package/node_modules/@aws-sdk/checksums/dist-types/ts3.4/submodules/sha/sha512/Sha512.d.ts

@@ -0,0 +1,12 @@
+import { SourceData } from "@smithy/types";
+import { Sha512Js } from "./Sha512Js";
+export declare class Sha512 extends Sha512Js {
+  private native?;
+  private readonly nativeSecret?;
+  private nativeFinished;
+  constructor(secret?: SourceData);
+  update(data: Uint8Array): void;
+  digest(): Promise<Uint8Array>;
+  reset(): void;
+  private createNative;
+}

package/node_modules/@aws-sdk/checksums/dist-types/ts3.4/submodules/sha/sha512/Sha512Js.d.ts

@@ -0,0 +1,22 @@
+import { Checksum, SourceData } from "@smithy/types";
+export declare class Sha512Js implements Checksum {
+  readonly digestLength = 64;
+  private state;
+  private w?;
+  private buffer;
+  private bufferLength;
+  private bytesHashed;
+  private finished;
+  private readonly key?;
+  private inner?;
+  private outer?;
+  constructor(secret?: SourceData);
+  update(data: Uint8Array): void;
+  digest(): Promise<Uint8Array>;
+  reset(): void;
+  private initHmac;
+  private digestSync;
+  private static normalizeKey;
+  private hashBuffer;
+  private hashBufferWith;
+}

package/node_modules/@aws-sdk/checksums/dist-types/ts3.4/submodules/sha/sha512/Sha512WebCrypto.d.ts

@@ -0,0 +1,14 @@
+import { Checksum, SourceData } from "@smithy/types";
+export declare class Sha512WebCrypto implements Checksum {
+  readonly digestLength: 64;
+  private readonly secret?;
+  private pending;
+  private pendingBytes;
+  private fallback?;
+  private finished;
+  constructor(secret?: SourceData);
+  update(data: Uint8Array): void;
+  digest(): Promise<Uint8Array>;
+  reset(): void;
+  private switchToFallback;
+}