ranuts 0.1.0-alpha → 0.1.0-alpha-22

package/dist/src/utils/totp/sha/common.d.ts

@@ -0,0 +1,151 @@
+import type { EncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, FormatType, GenericInputType, packedValue } from './custom_types';
+export declare const TWO_PWR_32 = 4294967296;
+export declare const K_sha2: number[];
+export declare const H_trunc: number[];
+export declare const H_full: number[];
+export declare const sha_variant_error = "Chosen SHA variant is not supported";
+export declare const mac_rounds_error = "Cannot set numRounds with MAC";
+/**
+ * Concatenates 2 packed arrays. Clobbers array `a`.
+ *
+ * @param a First array to concatenate.
+ * @param b Second array to concatenate.
+ * @returns The concatentation of `a` + `b`.
+ */
+export declare function packedLEConcat(a: packedValue, b: packedValue): packedValue;
+/**
+ * Validate hash list containing output formatting options, ensuring presence of every option or adding the default
+ * value.
+ *
+ * @param options Hashmap of output formatting options from user.
+ * @returns Validated hashmap containing output formatting options.
+ */
+export declare function getOutputOpts(options?: {
+    outputUpper?: boolean;
+    b64Pad?: string;
+    shakeLen?: number;
+    outputLen?: number;
+}): {
+    outputUpper: boolean;
+    b64Pad: string;
+    outputLen: number;
+};
+/**
+ * Parses an external constructor object and returns a packed number, if possible.
+ *
+ * @param key The human-friendly key name to prefix any errors with
+ * @param value The input value object to parse
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @param fallback Fallback value if `value` is undefined.  If not present and `value` is undefined, an Error is thrown
+ */
+export declare function parseInputOption(key: string, value: GenericInputType | undefined, bigEndianMod: -1 | 1, fallback?: packedValue): packedValue;
+export 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[];
+}

package/dist/src/utils/totp/sha/converters.d.ts

@@ -0,0 +1,88 @@
+import type { EncodingType, FormatType, packedValue } from './custom_types';
+/**
+ * Function that takes an input format and UTF encoding and returns the appropriate function used to convert the input.
+ *
+ * @param format The format of the input to be converted
+ * @param utfType The string encoding to use for TEXT inputs.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian
+ * @returns Function that will convert an input to a packed int array.
+ */
+export declare function getStrConverter(format: FormatType, utfType: EncodingType, bigEndianMod: -1 | 1): (input: any, existingBin?: number[], existingBinLen?: number) => packedValue;
+/**
+ * Convert an array of words to a hexadecimal string.
+ *
+ * toString() won't work here because it removes preceding zeros (e.g. 0x00000001.toString === "1" rather than
+ * "00000001" and 0.toString(16) === "0" rather than "00").
+ *
+ * @param packed Array of integers to be converted.
+ * @param outputLength Length of output in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @param formatOpts Hashmap containing validated output formatting options.
+ * @returns Hexadecimal representation of `packed`.
+ */
+export declare function packed2hex(packed: number[], outputLength: number, bigEndianMod: -1 | 1, formatOpts: {
+    outputUpper: boolean;
+    b64Pad: string;
+}): string;
+/**
+ * Convert an array of words to a base-64 string.
+ *
+ * @param packed Array of integers to be converted.
+ * @param outputLength Length of output in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @param formatOpts Hashmap containing validated output formatting options.
+ * @returns Base64-encoded representation of `packed`.
+ */
+export declare function packed2b64(packed: number[], outputLength: number, bigEndianMod: -1 | 1, formatOpts: {
+    outputUpper: boolean;
+    b64Pad: string;
+}): string;
+/**
+ * Convert an array of words to raw bytes string.
+ *
+ * @param packed Array of integers to be converted.
+ * @param outputLength Length of output in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @returns Raw bytes representation of `packed`.
+ */
+export declare function packed2bytes(packed: number[], outputLength: number, bigEndianMod: -1 | 1): string;
+/**
+ * Convert an array of words to an ArrayBuffer.
+ *
+ * @param packed Array of integers to be converted.
+ * @param outputLength Length of output in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @returns An ArrayBuffer containing bytes from `packed.
+ */
+export declare function packed2arraybuffer(packed: number[], outputLength: number, bigEndianMod: -1 | 1): ArrayBuffer;
+/**
+ * Convert an array of words to an Uint8Array.
+ *
+ * @param packed Array of integers to be converted.
+ * @param outputLength Length of output in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @returns An Uint8Array containing bytes from `packed.
+ */
+export declare function packed2uint8array(packed: number[], outputLength: number, bigEndianMod: -1 | 1): Uint8Array;
+/**
+ * Function that takes an output format and associated parameters and returns a function that converts packed integers
+ * to that format.
+ *
+ * @param format The desired output formatting.
+ * @param outputBinLen Output length in bits.
+ * @param bigEndianMod Modifier for whether hash function is big or small endian.
+ * @param outputOptions Hashmap of output formatting options
+ * @returns Function that will convert a packed integer array to desired format.
+ */
+export declare function getOutputConverter(format: 'HEX' | 'B64' | 'BYTES', outputBinLen: number, bigEndianMod: -1 | 1, outputOptions: {
+    outputUpper: boolean;
+    b64Pad: string;
+}): (binarray: number[]) => string;
+export declare function getOutputConverter(format: 'ARRAYBUFFER', outputBinLen: number, bigEndianMod: -1 | 1, outputOptions: {
+    outputUpper: boolean;
+    b64Pad: string;
+}): (binarray: number[]) => ArrayBuffer;
+export declare function getOutputConverter(format: 'UINT8ARRAY', outputBinLen: number, bigEndianMod: -1 | 1, outputOptions: {
+    outputUpper: boolean;
+    b64Pad: string;
+}): (binarray: number[]) => Uint8Array;

package/dist/src/utils/totp/sha/custom_types.d.ts

@@ -0,0 +1,60 @@
+export type EncodingType = 'UTF8' | 'UTF16BE' | 'UTF16LE';
+export type FormatNoTextType = 'HEX' | 'B64' | 'BYTES' | 'ARRAYBUFFER' | 'UINT8ARRAY';
+export type FormatType = 'TEXT' | FormatNoTextType;
+export type GenericInputType = {
+    value: string;
+    format: 'TEXT';
+    encoding?: EncodingType;
+} | {
+    value: string;
+    format: 'B64' | 'HEX' | 'BYTES';
+} | {
+    value: ArrayBuffer;
+    format: 'ARRAYBUFFER';
+} | {
+    value: Uint8Array;
+    format: 'UINT8ARRAY';
+};
+export type FixedLengthOptionsNoEncodingType = {
+    hmacKey?: GenericInputType;
+} | {
+    numRounds?: number;
+};
+export type FixedLengthOptionsEncodingType = {
+    hmacKey?: GenericInputType;
+    encoding?: EncodingType;
+} | {
+    numRounds?: number;
+    encoding?: EncodingType;
+};
+export interface packedValue {
+    value: number[];
+    binLen: number;
+}
+export interface SHAKEOptionsNoEncodingType {
+    numRounds?: number;
+}
+export interface SHAKEOptionsEncodingType extends SHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+export interface CSHAKEOptionsNoEncodingType {
+    customization?: GenericInputType;
+    funcName?: GenericInputType;
+}
+export interface CSHAKEOptionsEncodingType extends CSHAKEOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+export interface KMACOptionsNoEncodingType {
+    kmacKey: GenericInputType;
+    customization?: GenericInputType;
+}
+export interface KMACOptionsEncodingType extends KMACOptionsNoEncodingType {
+    encoding?: EncodingType;
+}
+export interface ResolvedCSHAKEOptionsNoEncodingType {
+    funcName: packedValue;
+    customization: packedValue;
+}
+export interface ResolvedKMACOptionsNoEncodingType extends ResolvedCSHAKEOptionsNoEncodingType {
+    kmacKey: packedValue;
+}

package/dist/src/utils/totp/sha/primitives_32.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The 32-bit implementation of circular rotate left.
+ *
+ * @param x The 32-bit integer argument.
+ * @param n The number of bits to shift.
+ * @returns `x` shifted left circularly by `n` bits
+ */
+export declare function rotl_32(x: number, n: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Parity function.
+ *
+ * @param x The first 32-bit integer argument.
+ * @param y The second 32-bit integer argument.
+ * @param z The third 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function parity_32(x: number, y: number, z: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Ch function.
+ *
+ * @param x The first 32-bit integer argument.
+ * @param y The second 32-bit integer argument.
+ * @param z The third 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function ch_32(x: number, y: number, z: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Maj function.
+ *
+ * @param x The first 32-bit integer argument.
+ * @param y The second 32-bit integer argument.
+ * @param z The third 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function maj_32(x: number, y: number, z: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Sigma0 function.
+ *
+ * @param x The 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma0_32(x: number): number;
+/**
+ * Add two 32-bit integers.
+ *
+ * This uses 16-bit operations internally to work around sign problems due to JavaScript's lack of uint32 support.
+ *
+ * @param a The first 32-bit integer argument to be added.
+ * @param b The second 32-bit integer argument to be added.
+ * @returns The sum of `a` + `b`.
+ */
+export declare function safeAdd_32_2(a: number, b: number): number;
+/**
+ * Add four 32-bit integers.
+ *
+ * This uses 16-bit operations internally to work around sign problems due to JavaScript's lack of uint32 support.
+ *
+ * @param a The first 32-bit integer argument to be added.
+ * @param b The second 32-bit integer argument to be added.
+ * @param c The third 32-bit integer argument to be added.
+ * @param d The fourth 32-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d`.
+ */
+export declare function safeAdd_32_4(a: number, b: number, c: number, d: number): number;
+/**
+ * Add five 32-bit integers.
+ *
+ * This uses 16-bit operations internally to work around sign problems due to JavaScript's lack of uint32 support.
+ *
+ * @param a The first 32-bit integer argument to be added.
+ * @param b The second 32-bit integer argument to be added.
+ * @param c The third 32-bit integer argument to be added.
+ * @param d The fourth 32-bit integer argument to be added.
+ * @param e The fifth 32-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d` + `e`.
+ */
+export declare function safeAdd_32_5(a: number, b: number, c: number, d: number, e: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Gamma1 function.
+ *
+ * @param x The 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma1_32(x: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Gamma0 function.
+ *
+ * @param x The 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma0_32(x: number): number;
+/**
+ * The 32-bit implementation of the NIST specified Sigma1 function.
+ *
+ * @param x The 32-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma1_32(x: number): number;

package/dist/src/utils/totp/sha/primitives_64.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Int_64 is a object for 2 32-bit numbers emulating a 64-bit number.
+ */
+export 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);
+}
+/**
+ * The 64-bit implementation of circular rotate left.
+ *
+ * This does not work for n >= 64 or n == 32 but those are never done.
+ *
+ * @param x The 64-bit integer argument.
+ * @param n The number of bits to shift.
+ * @returns `x` shifted left circularly by `n` bits.
+ */
+export declare function rotl_64(x: Int_64, n: number): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Ch function.
+ *
+ * @param x The first 64-bit integer argument.
+ * @param y The second 64-bit integer argument.
+ * @param z The third 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function ch_64(x: Int_64, y: Int_64, z: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Maj function.
+ *
+ * @param x The first 64-bit integer argument.
+ * @param y The second 64-bit integer argument.
+ * @param z The third 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function maj_64(x: Int_64, y: Int_64, z: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Sigma0 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma0_64(x: Int_64): Int_64;
+/**
+ * Add two 64-bit integers.
+ *
+ * @param x The first 64-bit integer argument to be added.
+ * @param y The second 64-bit integer argument to be added.
+ * @returns The sum of `x` + `y`.
+ */
+export declare function safeAdd_64_2(x: Int_64, y: Int_64): Int_64;
+/**
+ * Add four 64-bit integers.
+ *
+ * @param a The first 64-bit integer argument to be added.
+ * @param b The second 64-bit integer argument to be added.
+ * @param c The third 64-bit integer argument to be added.
+ * @param d The fouth 64-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d`.
+ */
+export declare function safeAdd_64_4(a: Int_64, b: Int_64, c: Int_64, d: Int_64): Int_64;
+/**
+ * Add five 64-bit integers.
+ *
+ * @param a The first 64-bit integer argument to be added.
+ * @param b The second 64-bit integer argument to be added.
+ * @param c The third 64-bit integer argument to be added.
+ * @param d The fouth 64-bit integer argument to be added.
+ * @param e The fifth 64-bit integer argument to be added.
+ * @returns The sum of `a` + `b` + `c` + `d` + `e`.
+ */
+export declare function safeAdd_64_5(a: Int_64, b: Int_64, c: Int_64, d: Int_64, e: Int_64): Int_64;
+/**
+ * XORs two given arguments.
+ *
+ * @param a The first argument to be XORed.
+ * @param b The second argument to be XORed.
+ * @returns The The XOR `a` and `b`
+ */
+export declare function xor_64_2(a: Int_64, b: Int_64): Int_64;
+/**
+ * XORs five given arguments.
+ *
+ * @param a The first argument to be XORed.
+ * @param b The second argument to be XORed.
+ * @param c The third argument to be XORed.
+ * @param d The fourth argument to be XORed.
+ * @param e The fifth argument to be XORed.
+ * @returns The XOR of `a`, `b`, `c`, `d`, and `e`.
+ */
+export declare function xor_64_5(a: Int_64, b: Int_64, c: Int_64, d: Int_64, e: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Gamma1 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma1_64(x: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Gamma0 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function gamma0_64(x: Int_64): Int_64;
+/**
+ * The 64-bit implementation of the NIST specified Sigma1 function.
+ *
+ * @param x The 64-bit integer argument.
+ * @returns The NIST specified output of the function.
+ */
+export declare function sigma1_64(x: Int_64): Int_64;

package/dist/src/utils/totp/sha/sha.d.ts

@@ -0,0 +1,103 @@
+import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, EncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType } from './custom_types';
+type FixedLengthVariantType = 'SHA-1' | 'SHA-224' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
+export default 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 {};

package/dist/src/utils/totp/sha/sha1.d.ts

@@ -0,0 +1,18 @@
+import { jsSHABase } from './common';
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+export default 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);
+}

package/dist/src/utils/totp/sha/sha256.d.ts

@@ -0,0 +1,20 @@
+import { jsSHABase } from './common';
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+type VariantType = 'SHA-224' | 'SHA-256';
+export default 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 {};