first commit

node_modules/jssha/dist/sha.d.ts

@@ -0,0 +1,152 @@
+type EncodingType = "UTF8" | "UTF16BE" | "UTF16LE";
+type FormatNoTextType = "HEX" | "B64" | "BYTES" | "ARRAYBUFFER" | "UINT8ARRAY";
+type GenericInputType = {
+    value: string;
+    format: "TEXT";
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: "B64" | "HEX" | "BYTES";
+} | {
+    value: ArrayBuffer;
+    format: "ARRAYBUFFER";
+} | {
+    value: Uint8Array;
+    format: "UINT8ARRAY";
+};
+type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+interface SHAKEOptionsNoEncodingType {
+    numRounds?: number;
+}
+interface SHAKEOptionsEncodingType extends SHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+interface CSHAKEOptionsNoEncodingType {
+    customization?: GenericInputType;
+    funcName?: GenericInputType;
+}
+interface CSHAKEOptionsEncodingType extends CSHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+interface KMACOptionsNoEncodingType {
+    kmacKey: GenericInputType;
+    customization?: GenericInputType;
+}
+interface KMACOptionsEncodingType extends KMACOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+
+type FixedLengthVariantType = "SHA-1" | "SHA-224" | "SHA-256" | "SHA-384" | "SHA-512" | "SHA3-224" | "SHA3-256" | "SHA3-384" | "SHA3-512";
+declare class jsSHA {
+    private readonly shaObj;
+    /**
+     * @param variant The desired SHA variant (SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA3-224, SHA3-256, SHA3-256,
+     *   SHA3-384, SHA3-512, SHAKE128, SHAKE256, CSHAKE128, CSHAKE256, KMAC128, or KMAC256) as a string.
+     * @param inputFormat The input format to be used in future `update` calls (TEXT, HEX, B64, BYTES, ARRAYBUFFER,
+     *   or UINT8ARRAY) as a string.
+     * @param options Options in the form of { encoding?: "UTF8" | "UTF16BE" | "UTF16LE"; numRounds?: number }.
+     *   `encoding` is for only TEXT input (defaults to UTF8) and `numRounds` defaults to 1.
+     *   `numRounds` is not valid for any of the MAC or CSHAKE variants.
+     *   * If the variant supports HMAC, `options` may have an additional `hmacKey` key which must be in the form of
+     *     {value: <INPUT>, format: <FORMAT>, encoding?: "UTF8" | "UTF16BE" | "UTF16LE"} where <FORMAT> takes the same
+     *     values as `inputFormat` and <INPUT> can be a `string | ArrayBuffer | Uint8Array` depending on <FORMAT>.
+     *     Supplying this key switches to HMAC calculation and replaces the now deprecated call to `setHMACKey`.
+     *   * If the variant is CSHAKE128 or CSHAKE256, `options` may have two additional keys, `customization` and `funcName`,
+     *     which are the NIST customization and function-name strings.  Both must be in the same form as `hmacKey`.
+     *   * If the variant is KMAC128 or KMAC256, `options` can include the `customization` key from CSHAKE variants and
+     *     *must* have a `kmacKey` key that takes the same form as the `customization` key.
+     */
+    constructor(variant: FixedLengthVariantType, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    constructor(variant: FixedLengthVariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    constructor(variant: "SHAKE128" | "SHAKE256", inputFormat: "TEXT", options?: SHAKEOptionsEncodingType);
+    constructor(variant: "SHAKE128" | "SHAKE256", inputFormat: FormatNoTextType, options?: SHAKEOptionsNoEncodingType);
+    constructor(variant: "CSHAKE128" | "CSHAKE256", inputFormat: "TEXT", options?: CSHAKEOptionsEncodingType);
+    constructor(variant: "CSHAKE128" | "CSHAKE256", inputFormat: FormatNoTextType, options?: CSHAKEOptionsNoEncodingType);
+    constructor(variant: "KMAC128" | "KMAC256", inputFormat: "TEXT", options: KMACOptionsEncodingType);
+    constructor(variant: "KMAC128" | "KMAC256", inputFormat: FormatNoTextType, options: KMACOptionsNoEncodingType);
+    /**
+     * Takes `input` and hashes as many blocks as possible. Stores the rest for either a future `update` or `getHash` call.
+     *
+     * @param input The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(input: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA or MAC (if a HMAC/KMAC key was specified) hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting (B64, HEX, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { outputUpper?: boolean; b64Pad?: string; outputLen?: number;  }.
+     *   `outputLen` is required for variable length output variants (this option was previously called `shakeLen` which
+     *    is now deprecated).
+     *   `outputUpper` is only for HEX output (defaults to false) and b64pad is only for B64 output (defaults to "=").
+     * @returns The hash in the format specified.
+     */
+    getHash(format: "HEX", options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "B64", options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "BYTES", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "UINT8ARRAY", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: "ARRAYBUFFER", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     * Now deprecated in favor of setting the `hmacKey` at object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key (HEX, TEXT, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { encoding?: "UTF8" | "UTF16BE" | "UTF16LE }.  `encoding` is only for TEXT
+     *   and defaults to UTF8.
+     */
+    setHMACKey(key: string, inputFormat: "TEXT", options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: "B64" | "HEX" | "BYTES"): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: "ARRAYBUFFER"): void;
+    setHMACKey(key: Uint8Array, inputFormat: "UINT8ARRAY"): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call. Now deprecated
+     * in favor of just calling `getHash`.
+     *
+     * @param format The desired output formatting (B64, HEX, BYTES, ARRAYBUFFER, or UINT8ARRAY) as a string.
+     * @param options Options in the form of { outputUpper?: boolean; b64Pad?: string }. `outputUpper` is only for HEX
+     *   output (defaults to false) and `b64pad` is only for B64 output (defaults to "=").
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: "HEX", options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: "B64", options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: "BYTES"): string;
+    getHMAC(format: "UINT8ARRAY"): Uint8Array;
+    getHMAC(format: "ARRAYBUFFER"): ArrayBuffer;
+}
+
+export { jsSHA as default };

node_modules/jssha/dist/sha1.d.ts

@@ -0,0 +1,163 @@
+type EncodingType = "UTF8" | "UTF16BE" | "UTF16LE";
+type FormatNoTextType = "HEX" | "B64" | "BYTES" | "ARRAYBUFFER" | "UINT8ARRAY";
+type FormatType = "TEXT" | FormatNoTextType;
+type GenericInputType = {
+    value: string;
+    format: "TEXT";
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: "B64" | "HEX" | "BYTES";
+} | {
+    value: ArrayBuffer;
+    format: "ARRAYBUFFER";
+} | {
+    value: Uint8Array;
+    format: "UINT8ARRAY";
+};
+type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+interface packedValue {
+    value: number[];
+    binLen: number;
+}
+
+declare abstract class jsSHABase<StateT, VariantT> {
+    /**
+     * @param variant The desired SHA variant.
+     * @param inputFormat The input format to be used in future `update` calls.
+     * @param options Hashmap of extra input options.
+     */
+    protected readonly shaVariant: VariantT;
+    protected readonly inputFormat: FormatType;
+    protected readonly utfType: EncodingType;
+    protected readonly numRounds: number;
+    protected abstract intermediateState: StateT;
+    protected keyWithIPad: number[];
+    protected keyWithOPad: number[];
+    protected remainder: number[];
+    protected remainderLen: number;
+    protected updateCalled: boolean;
+    protected processedLen: number;
+    protected macKeySet: boolean;
+    protected abstract readonly variantBlockSize: number;
+    protected abstract readonly bigEndianMod: -1 | 1;
+    protected abstract readonly outputBinLen: number;
+    protected abstract readonly isVariableLen: boolean;
+    protected abstract readonly HMACSupported: boolean;
+    protected abstract readonly converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    protected abstract readonly roundFunc: (block: number[], H: StateT) => StateT;
+    protected abstract readonly finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: StateT, outputLen: number) => number[];
+    protected abstract readonly stateCloneFunc: (state: StateT) => StateT;
+    protected abstract readonly newStateFunc: (variant: VariantT) => StateT;
+    protected abstract readonly getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    protected constructor(variant: VariantT, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    protected constructor(variant: VariantT, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    /**
+     * Hashes as many blocks as possible.  Stores the rest for either a future update or getHash call.
+     *
+     * @param srcString The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(srcString: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting
+     * @param options Hashmap of output formatting options. `outputLen` must be specified for variable length hashes.
+     *   `outputLen` replaces the now deprecated `shakeLen` key.
+     * @returns The hash in the format specified.
+     */
+    getHash(format: "HEX", options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "B64", options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "BYTES", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "UINT8ARRAY", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: "ARRAYBUFFER", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key.
+     * @param options Hashmap of extra input options.
+     */
+    setHMACKey(key: string, inputFormat: "TEXT", options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: "B64" | "HEX" | "BYTES"): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: "ARRAYBUFFER"): void;
+    setHMACKey(key: Uint8Array, inputFormat: "UINT8ARRAY"): void;
+    /**
+     * Internal function that sets the MAC key.
+     *
+     * @param key The packed MAC key to use
+     */
+    protected _setHMACKey(key: packedValue): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call.
+     *
+     * @param format The desired output formatting.
+     * @param options Hashmap of extra outputs options.
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: "HEX", options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: "B64", options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: "BYTES"): string;
+    getHMAC(format: "UINT8ARRAY"): Uint8Array;
+    getHMAC(format: "ARRAYBUFFER"): ArrayBuffer;
+    /**
+     * Internal function that returns the "raw" HMAC
+     */
+    protected _getHMAC(): number[];
+}
+
+declare class jsSHA extends jsSHABase<number[], "SHA-1"> {
+    intermediateState: number[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: number[]) => number[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: number[]) => number[];
+    stateCloneFunc: (state: number[]) => number[];
+    newStateFunc: (variant: "SHA-1") => number[];
+    getMAC: () => number[];
+    constructor(variant: "SHA-1", inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    constructor(variant: "SHA-1", inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}
+
+export { jsSHA as default };

node_modules/jssha/dist/sha256.d.ts

@@ -0,0 +1,164 @@
+type EncodingType = "UTF8" | "UTF16BE" | "UTF16LE";
+type FormatNoTextType = "HEX" | "B64" | "BYTES" | "ARRAYBUFFER" | "UINT8ARRAY";
+type FormatType = "TEXT" | FormatNoTextType;
+type GenericInputType = {
+    value: string;
+    format: "TEXT";
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: "B64" | "HEX" | "BYTES";
+} | {
+    value: ArrayBuffer;
+    format: "ARRAYBUFFER";
+} | {
+    value: Uint8Array;
+    format: "UINT8ARRAY";
+};
+type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+interface packedValue {
+    value: number[];
+    binLen: number;
+}
+
+declare abstract class jsSHABase<StateT, VariantT> {
+    /**
+     * @param variant The desired SHA variant.
+     * @param inputFormat The input format to be used in future `update` calls.
+     * @param options Hashmap of extra input options.
+     */
+    protected readonly shaVariant: VariantT;
+    protected readonly inputFormat: FormatType;
+    protected readonly utfType: EncodingType;
+    protected readonly numRounds: number;
+    protected abstract intermediateState: StateT;
+    protected keyWithIPad: number[];
+    protected keyWithOPad: number[];
+    protected remainder: number[];
+    protected remainderLen: number;
+    protected updateCalled: boolean;
+    protected processedLen: number;
+    protected macKeySet: boolean;
+    protected abstract readonly variantBlockSize: number;
+    protected abstract readonly bigEndianMod: -1 | 1;
+    protected abstract readonly outputBinLen: number;
+    protected abstract readonly isVariableLen: boolean;
+    protected abstract readonly HMACSupported: boolean;
+    protected abstract readonly converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    protected abstract readonly roundFunc: (block: number[], H: StateT) => StateT;
+    protected abstract readonly finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: StateT, outputLen: number) => number[];
+    protected abstract readonly stateCloneFunc: (state: StateT) => StateT;
+    protected abstract readonly newStateFunc: (variant: VariantT) => StateT;
+    protected abstract readonly getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    protected constructor(variant: VariantT, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    protected constructor(variant: VariantT, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    /**
+     * Hashes as many blocks as possible.  Stores the rest for either a future update or getHash call.
+     *
+     * @param srcString The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(srcString: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting
+     * @param options Hashmap of output formatting options. `outputLen` must be specified for variable length hashes.
+     *   `outputLen` replaces the now deprecated `shakeLen` key.
+     * @returns The hash in the format specified.
+     */
+    getHash(format: "HEX", options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "B64", options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "BYTES", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "UINT8ARRAY", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: "ARRAYBUFFER", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key.
+     * @param options Hashmap of extra input options.
+     */
+    setHMACKey(key: string, inputFormat: "TEXT", options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: "B64" | "HEX" | "BYTES"): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: "ARRAYBUFFER"): void;
+    setHMACKey(key: Uint8Array, inputFormat: "UINT8ARRAY"): void;
+    /**
+     * Internal function that sets the MAC key.
+     *
+     * @param key The packed MAC key to use
+     */
+    protected _setHMACKey(key: packedValue): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call.
+     *
+     * @param format The desired output formatting.
+     * @param options Hashmap of extra outputs options.
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: "HEX", options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: "B64", options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: "BYTES"): string;
+    getHMAC(format: "UINT8ARRAY"): Uint8Array;
+    getHMAC(format: "ARRAYBUFFER"): ArrayBuffer;
+    /**
+     * Internal function that returns the "raw" HMAC
+     */
+    protected _getHMAC(): number[];
+}
+
+type VariantType = "SHA-224" | "SHA-256";
+declare class jsSHA extends jsSHABase<number[], VariantType> {
+    intermediateState: number[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: number[]) => number[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: number[]) => number[];
+    stateCloneFunc: (state: number[]) => number[];
+    newStateFunc: (variant: VariantType) => number[];
+    getMAC: () => number[];
+    constructor(variant: VariantType, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    constructor(variant: VariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}
+
+export { jsSHA as default };

node_modules/jssha/dist/sha3.d.ts

@@ -0,0 +1,229 @@
+type EncodingType = "UTF8" | "UTF16BE" | "UTF16LE";
+type FormatNoTextType = "HEX" | "B64" | "BYTES" | "ARRAYBUFFER" | "UINT8ARRAY";
+type FormatType = "TEXT" | FormatNoTextType;
+type GenericInputType = {
+    value: string;
+    format: "TEXT";
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: "B64" | "HEX" | "BYTES";
+} | {
+    value: ArrayBuffer;
+    format: "ARRAYBUFFER";
+} | {
+    value: Uint8Array;
+    format: "UINT8ARRAY";
+};
+type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+interface packedValue {
+    value: number[];
+    binLen: number;
+}
+interface SHAKEOptionsNoEncodingType {
+    numRounds?: number;
+}
+interface SHAKEOptionsEncodingType extends SHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+interface CSHAKEOptionsNoEncodingType {
+    customization?: GenericInputType;
+    funcName?: GenericInputType;
+}
+interface CSHAKEOptionsEncodingType extends CSHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+interface KMACOptionsNoEncodingType {
+    kmacKey: GenericInputType;
+    customization?: GenericInputType;
+}
+interface KMACOptionsEncodingType extends KMACOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+
+declare abstract class jsSHABase<StateT, VariantT> {
+    /**
+     * @param variant The desired SHA variant.
+     * @param inputFormat The input format to be used in future `update` calls.
+     * @param options Hashmap of extra input options.
+     */
+    protected readonly shaVariant: VariantT;
+    protected readonly inputFormat: FormatType;
+    protected readonly utfType: EncodingType;
+    protected readonly numRounds: number;
+    protected abstract intermediateState: StateT;
+    protected keyWithIPad: number[];
+    protected keyWithOPad: number[];
+    protected remainder: number[];
+    protected remainderLen: number;
+    protected updateCalled: boolean;
+    protected processedLen: number;
+    protected macKeySet: boolean;
+    protected abstract readonly variantBlockSize: number;
+    protected abstract readonly bigEndianMod: -1 | 1;
+    protected abstract readonly outputBinLen: number;
+    protected abstract readonly isVariableLen: boolean;
+    protected abstract readonly HMACSupported: boolean;
+    protected abstract readonly converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    protected abstract readonly roundFunc: (block: number[], H: StateT) => StateT;
+    protected abstract readonly finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: StateT, outputLen: number) => number[];
+    protected abstract readonly stateCloneFunc: (state: StateT) => StateT;
+    protected abstract readonly newStateFunc: (variant: VariantT) => StateT;
+    protected abstract readonly getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    protected constructor(variant: VariantT, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    protected constructor(variant: VariantT, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    /**
+     * Hashes as many blocks as possible.  Stores the rest for either a future update or getHash call.
+     *
+     * @param srcString The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(srcString: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting
+     * @param options Hashmap of output formatting options. `outputLen` must be specified for variable length hashes.
+     *   `outputLen` replaces the now deprecated `shakeLen` key.
+     * @returns The hash in the format specified.
+     */
+    getHash(format: "HEX", options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "B64", options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "BYTES", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "UINT8ARRAY", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: "ARRAYBUFFER", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key.
+     * @param options Hashmap of extra input options.
+     */
+    setHMACKey(key: string, inputFormat: "TEXT", options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: "B64" | "HEX" | "BYTES"): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: "ARRAYBUFFER"): void;
+    setHMACKey(key: Uint8Array, inputFormat: "UINT8ARRAY"): void;
+    /**
+     * Internal function that sets the MAC key.
+     *
+     * @param key The packed MAC key to use
+     */
+    protected _setHMACKey(key: packedValue): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call.
+     *
+     * @param format The desired output formatting.
+     * @param options Hashmap of extra outputs options.
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: "HEX", options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: "B64", options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: "BYTES"): string;
+    getHMAC(format: "UINT8ARRAY"): Uint8Array;
+    getHMAC(format: "ARRAYBUFFER"): ArrayBuffer;
+    /**
+     * Internal function that returns the "raw" HMAC
+     */
+    protected _getHMAC(): number[];
+}
+
+/**
+ * Int_64 is a object for 2 32-bit numbers emulating a 64-bit number.
+ */
+declare class Int_64 {
+    /**
+     * @param msint_32 The most significant 32-bits of a 64-bit number.
+     * @param lsint_32 The least significant 32-bits of a 64-bit number.
+     */
+    readonly highOrder: number;
+    readonly lowOrder: number;
+    constructor(msint_32: number, lsint_32: number);
+}
+
+type FixedLengthVariantType = "SHA3-224" | "SHA3-256" | "SHA3-384" | "SHA3-512" | "SHAKE128" | "SHAKE256";
+type VariantType = FixedLengthVariantType | "SHAKE128" | "SHAKE256" | "CSHAKE128" | "CSHAKE256" | "KMAC128" | "KMAC256";
+declare class jsSHA extends jsSHABase<Int_64[][], VariantType> {
+    intermediateState: Int_64[][];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: Int_64[][]) => Int_64[][];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: Int_64[][], outputLen: number) => number[];
+    stateCloneFunc: (state: Int_64[][]) => Int_64[][];
+    newStateFunc: (variant: VariantType) => Int_64[][];
+    getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    constructor(variant: FixedLengthVariantType, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    constructor(variant: FixedLengthVariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    constructor(variant: "SHAKE128" | "SHAKE256", inputFormat: "TEXT", options?: SHAKEOptionsEncodingType);
+    constructor(variant: "SHAKE128" | "SHAKE256", inputFormat: FormatNoTextType, options?: SHAKEOptionsNoEncodingType);
+    constructor(variant: "CSHAKE128" | "CSHAKE256", inputFormat: "TEXT", options?: CSHAKEOptionsEncodingType);
+    constructor(variant: "CSHAKE128" | "CSHAKE256", inputFormat: FormatNoTextType, options?: CSHAKEOptionsNoEncodingType);
+    constructor(variant: "KMAC128" | "KMAC256", inputFormat: "TEXT", options: KMACOptionsEncodingType);
+    constructor(variant: "KMAC128" | "KMAC256", inputFormat: FormatNoTextType, options: KMACOptionsNoEncodingType);
+    /**
+     * Initialize CSHAKE variants.
+     *
+     * @param options Options containing CSHAKE params.
+     * @param funcNameOverride Overrides any "funcName" present in `options` (used with KMAC)
+     * @returns The delimiter to be used
+     */
+    protected _initializeCSHAKE(options?: CSHAKEOptionsNoEncodingType, funcNameOverride?: packedValue): number;
+    /**
+     * Initialize KMAC variants.
+     *
+     * @param options Options containing KMAC params.
+     */
+    protected _initializeKMAC(options: KMACOptionsNoEncodingType): void;
+    /**
+     * Returns the the KMAC in the specified format.
+     *
+     * @param options Hashmap of extra outputs options. `outputLen` must be specified.
+     * @returns The KMAC in the format specified.
+     */
+    protected _getKMAC(options: {
+        outputLen: number;
+    }): number[];
+}
+
+export { jsSHA as default };

node_modules/jssha/dist/sha512.d.ts

@@ -0,0 +1,177 @@
+type EncodingType = "UTF8" | "UTF16BE" | "UTF16LE";
+type FormatNoTextType = "HEX" | "B64" | "BYTES" | "ARRAYBUFFER" | "UINT8ARRAY";
+type FormatType = "TEXT" | FormatNoTextType;
+type GenericInputType = {
+    value: string;
+    format: "TEXT";
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: "B64" | "HEX" | "BYTES";
+} | {
+    value: ArrayBuffer;
+    format: "ARRAYBUFFER";
+} | {
+    value: Uint8Array;
+    format: "UINT8ARRAY";
+};
+type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+interface packedValue {
+    value: number[];
+    binLen: number;
+}
+
+declare abstract class jsSHABase<StateT, VariantT> {
+    /**
+     * @param variant The desired SHA variant.
+     * @param inputFormat The input format to be used in future `update` calls.
+     * @param options Hashmap of extra input options.
+     */
+    protected readonly shaVariant: VariantT;
+    protected readonly inputFormat: FormatType;
+    protected readonly utfType: EncodingType;
+    protected readonly numRounds: number;
+    protected abstract intermediateState: StateT;
+    protected keyWithIPad: number[];
+    protected keyWithOPad: number[];
+    protected remainder: number[];
+    protected remainderLen: number;
+    protected updateCalled: boolean;
+    protected processedLen: number;
+    protected macKeySet: boolean;
+    protected abstract readonly variantBlockSize: number;
+    protected abstract readonly bigEndianMod: -1 | 1;
+    protected abstract readonly outputBinLen: number;
+    protected abstract readonly isVariableLen: boolean;
+    protected abstract readonly HMACSupported: boolean;
+    protected abstract readonly converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    protected abstract readonly roundFunc: (block: number[], H: StateT) => StateT;
+    protected abstract readonly finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: StateT, outputLen: number) => number[];
+    protected abstract readonly stateCloneFunc: (state: StateT) => StateT;
+    protected abstract readonly newStateFunc: (variant: VariantT) => StateT;
+    protected abstract readonly getMAC: ((options: {
+        outputLen: number;
+    }) => number[]) | null;
+    protected constructor(variant: VariantT, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    protected constructor(variant: VariantT, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+    /**
+     * Hashes as many blocks as possible.  Stores the rest for either a future update or getHash call.
+     *
+     * @param srcString The input to be hashed.
+     * @returns A reference to the object.
+     */
+    update(srcString: string | ArrayBuffer | Uint8Array): this;
+    /**
+     * Returns the desired SHA hash of the input fed in via `update` calls.
+     *
+     * @param format The desired output formatting
+     * @param options Hashmap of output formatting options. `outputLen` must be specified for variable length hashes.
+     *   `outputLen` replaces the now deprecated `shakeLen` key.
+     * @returns The hash in the format specified.
+     */
+    getHash(format: "HEX", options?: {
+        outputUpper?: boolean;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "B64", options?: {
+        b64Pad?: string;
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "BYTES", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): string;
+    getHash(format: "UINT8ARRAY", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): Uint8Array;
+    getHash(format: "ARRAYBUFFER", options?: {
+        outputLen?: number;
+        shakeLen?: number;
+    }): ArrayBuffer;
+    /**
+     * Sets the HMAC key for an eventual `getHMAC` call.  Must be called immediately after jsSHA object instantiation.
+     *
+     * @param key The key used to calculate the HMAC
+     * @param inputFormat The format of key.
+     * @param options Hashmap of extra input options.
+     */
+    setHMACKey(key: string, inputFormat: "TEXT", options?: {
+        encoding?: EncodingType;
+    }): void;
+    setHMACKey(key: string, inputFormat: "B64" | "HEX" | "BYTES"): void;
+    setHMACKey(key: ArrayBuffer, inputFormat: "ARRAYBUFFER"): void;
+    setHMACKey(key: Uint8Array, inputFormat: "UINT8ARRAY"): void;
+    /**
+     * Internal function that sets the MAC key.
+     *
+     * @param key The packed MAC key to use
+     */
+    protected _setHMACKey(key: packedValue): void;
+    /**
+     * Returns the the HMAC in the specified format using the key given by a previous `setHMACKey` call.
+     *
+     * @param format The desired output formatting.
+     * @param options Hashmap of extra outputs options.
+     * @returns The HMAC in the format specified.
+     */
+    getHMAC(format: "HEX", options?: {
+        outputUpper?: boolean;
+    }): string;
+    getHMAC(format: "B64", options?: {
+        b64Pad?: string;
+    }): string;
+    getHMAC(format: "BYTES"): string;
+    getHMAC(format: "UINT8ARRAY"): Uint8Array;
+    getHMAC(format: "ARRAYBUFFER"): ArrayBuffer;
+    /**
+     * Internal function that returns the "raw" HMAC
+     */
+    protected _getHMAC(): number[];
+}
+
+/**
+ * Int_64 is a object for 2 32-bit numbers emulating a 64-bit number.
+ */
+declare class Int_64 {
+    /**
+     * @param msint_32 The most significant 32-bits of a 64-bit number.
+     * @param lsint_32 The least significant 32-bits of a 64-bit number.
+     */
+    readonly highOrder: number;
+    readonly lowOrder: number;
+    constructor(msint_32: number, lsint_32: number);
+}
+
+type VariantType = "SHA-384" | "SHA-512";
+declare class jsSHA extends jsSHABase<Int_64[], VariantType> {
+    intermediateState: Int_64[];
+    variantBlockSize: number;
+    bigEndianMod: -1 | 1;
+    outputBinLen: number;
+    isVariableLen: boolean;
+    HMACSupported: boolean;
+    converterFunc: (input: any, existingBin: number[], existingBinLen: number) => packedValue;
+    roundFunc: (block: number[], H: Int_64[]) => Int_64[];
+    finalizeFunc: (remainder: number[], remainderBinLen: number, processedBinLen: number, H: Int_64[]) => number[];
+    stateCloneFunc: (state: Int_64[]) => Int_64[];
+    newStateFunc: (variant: VariantType) => Int_64[];
+    getMAC: () => number[];
+    constructor(variant: VariantType, inputFormat: "TEXT", options?: FixedLengthOptionsEncodingType);
+    constructor(variant: VariantType, inputFormat: FormatNoTextType, options?: FixedLengthOptionsNoEncodingType);
+}
+
+export { jsSHA as default };