ranuts 0.1.0-alpha.8 → 0.2.0-alpha.0

package/dist/src/utils/str.d.ts

@@ -0,0 +1,212 @@
+/**
+ * @description: 将字符串转对象，比如
+ * @param {string} url 'a=1&b=2&c=3'
+ * @param {string} sep &
+ * @param {string} eq =
+ * @return {object} {a:1,b:2,c:3}
+ */
+export declare const strParse: (str?: string, sep?: string | RegExp, eq?: string | RegExp) => Record<string, string>;
+/**
+ * @description: 清除字符串中的空格、换行和 HTML 标签
+ * @param {string} str 要清理的字符串
+ * @return {string} 清理后的纯文本
+ */
+export declare const clearBr: (str?: string) => string;
+/**
+ * @description: 传入字符串和指定的格式，将字符串转成 xml
+ * @param {string} xmlStr
+ * @param {DOMParserSupportedType} format
+ * @return {Document}
+ */
+export declare const str2Xml: (xmlStr: string, format?: DOMParserSupportedType) => HTMLElement | undefined;
+export declare const isString: (obj: unknown) => boolean;
+export declare function randomString(len?: number): string;
+export declare function changeHumpToLowerCase(str: string): string;
+interface ClearStrOption {
+    urlencoded?: boolean;
+}
+/**
+ * @description: 去除字符串首尾的空格，encode 编码，首尾的引号
+ * @param {string} str
+ * @return {string}
+ */
+export declare const clearStr: (str: string, options?: ClearStrOption) => string;
+/**
+ * 获取文本中包含搜索关键词的完整句子，对于重复的句子只保留最长的一个
+ * @param text 原文本
+ * @param searchValue 搜索关键词
+ * @returns 包含关键词的完整句子数组（已去重）
+ */
+export declare function getMatchingSentences(text: string, searchValue: string): string[];
+export declare const toString: (value: string | number) => string;
+export declare const checkEncoding: (uint8Array: Uint8Array) => string;
+export interface TransformText {
+    encoding: string;
+    content: string;
+}
+export declare const transformText: (content: string | ArrayBuffer) => TransformText | undefined;
+/**
+ * MD5 hash function implementation
+ * @param str The string to hash
+ * @returns The MD5 hash as a hexadecimal string
+ */
+export declare const md5: (str: string) => string;
+export declare const getRandomString: (len?: number) => string;
+type FileChunk = {
+    name: string;
+    type: string;
+    size: number;
+    lastModified: number;
+    totalChunks: number;
+    chunkIndex: number;
+    data: string;
+};
+/**
+ * 消息编解码工具
+ * 正确处理所有 Unicode 字符，包括中文、emoji 等
+ * 编码后的字符串只包含 A-Z, a-z, 0-9, +, /, = 这些安全字符
+ * 适合在 URL、Cookie 等场景使用
+ * 编码解码过程是双向的，不会丢失数据，不会出现编码解码不一致的问题
+ */
+export declare const MessageCodec: {
+    /**
+     * 编码消息
+     * @param data 要编码的数据
+     * @returns 编码后的字符串
+     */
+    encode(data: any): string;
+    /**
+     * 解码消息
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的数据
+     */
+    decode<T = any>(encodedStr: string): T | null;
+    /**
+     * 编码文件对象
+     * @param file File对象
+     * @returns 编码后的字符串
+     * @throws {MessageCodecError} 当文件编码失败时抛出
+     */
+    encodeFile(file: File): Promise<string>;
+    /**
+     * 解码文件对象
+     * @param encoded 编码后的字符串
+     * @returns 解码后的 File 对象
+     * @throws {MessageCodecError} 当解码失败或类型不匹配时抛出
+     */
+    decodeFile(encoded: string): File;
+    /**
+     * 编码 Blob 对象
+     * @param blob Blob 对象
+     * @returns 编码后的字符串
+     * @throws {MessageCodecError} 当编码失败时抛出
+     */
+    encodeBlob(blob: Blob): Promise<string>;
+    /**
+     * 解码 Blob 对象
+     * @param encoded 编码后的字符串
+     * @returns 解码后的 Blob 对象
+     * @throws {MessageCodecError} 当解码失败或类型不匹配时抛出
+     */
+    decodeBlob(encoded: string): Blob;
+    /**
+     * 编码 Date 对象
+     * @param date Date 对象
+     * @returns 编码后的字符串
+     */
+    encodeDate(date: Date): string;
+    /**
+     * 解码 Date 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 Date 对象
+     */
+    decodeDate(encodedStr: string): Date;
+    /**
+     * 编码 RegExp 对象
+     * @param regexp RegExp 对象
+     * @returns 编码后的字符串
+     */
+    encodeRegExp(regexp: RegExp): string;
+    /**
+     * 解码 RegExp 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 RegExp 对象
+     */
+    decodeRegExp(encodedStr: string): RegExp;
+    /**
+     * 编码 Map 对象
+     * @param map Map 对象
+     * @returns 编码后的字符串
+     */
+    encodeMap<K, V>(map: Map<K, V>): string;
+    /**
+     * 解码 Map 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 Map 对象
+     */
+    decodeMap<K, V>(encodedStr: string): Map<K, V>;
+    /**
+     * 编码 Set 对象
+     * @param set Set 对象
+     * @returns 编码后的字符串
+     */
+    encodeSet<T>(set: Set<T>): string;
+    /**
+     * 解码 Set 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 Set 对象
+     */
+    decodeSet<T>(encodedStr: string): Set<T>;
+    /**
+     * 编码 Error 对象
+     * @param error Error 对象
+     * @returns 编码后的字符串
+     */
+    encodeError(error: Error): string;
+    /**
+     * 解码 Error 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 Error 对象
+     */
+    decodeError(encodedStr: string): Error;
+    /**
+     * 编码 ArrayBuffer 对象
+     * @param buffer ArrayBuffer 对象
+     * @returns 编码后的字符串
+     */
+    encodeArrayBuffer(buffer: ArrayBuffer): string;
+    /**
+     * 解码 ArrayBuffer 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 ArrayBuffer 对象
+     */
+    decodeArrayBuffer(encodedStr: string): ArrayBuffer;
+    /**
+     * 编码 TypedArray 对象
+     * @param typedArray TypedArray 对象
+     * @returns 编码后的字符串
+     */
+    encodeTypedArray(typedArray: ArrayBufferView): string;
+    /**
+     * 解码 TypedArray 对象
+     * @param encodedStr 编码后的字符串
+     * @returns 解码后的 TypedArray 对象
+     */
+    decodeTypedArray(encodedStr: string): ArrayBufferView;
+    /**
+     * 分片编码文件对象
+     * @param file File 对象
+     * @param chunkSize 分片大小，默认 1MB
+     * @returns 包含文件信息和分片数据的可传输对象数组
+     * @throws {MessageCodecError} 当分片编码失败时抛出
+     */
+    encodeFileChunked(file: File, chunkSize?: number): Promise<FileChunk[]>;
+    /**
+     * 解码分片文件对象
+     * @param chunks 编码后的文件分片数组
+     * @returns 重建的File对象
+     * @throws {MessageCodecError} 当分片解码失败或分片不完整时抛出
+     */
+    decodeFileChunked(chunks: FileChunk[]): Promise<File>;
+};
+export {};

package/dist/src/utils/subscribe.d.ts

@@ -0,0 +1,46 @@
+export type Callback = Function;
+export type EventName = string | symbol;
+export type EventItem = {
+    name?: string | symbol;
+    callback: Callback;
+    initialCallback?: Callback;
+};
+export declare const NEW_LISTENER = "NEW_LISTENER";
+export declare class SyncHook {
+    readonly _events: Map<EventName, Set<EventItem>>;
+    /**
+     * @description: 订阅事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    tap: (eventName: EventName, eventItem: EventItem | Callback) => this;
+    /**
+     * @description: 触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {void}
+     */
+    call: (eventName: EventName, ...args: Array<unknown>) => this;
+    /**
+     * @description: 同步触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {Promise<void>}
+     */
+    callSync: (eventName: EventName, ...args: Array<unknown>) => Promise<this>;
+    /**
+     * @description: 只订阅一次事件，触发后就移除事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    once: (eventName: EventName, eventItem: EventItem | Callback) => this;
+    /**
+     * @description: 移除订阅的事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    off: (eventName: EventName, eventItem: EventItem | Callback) => this;
+}

package/dist/src/utils/throttle.d.ts

@@ -0,0 +1,15 @@
+type ThrottleFunc<T extends (...args: any[]) => void> = (...args: Parameters<T>) => any;
+/**
+ * @description: 节流
+ * @param {any} fn
+ * @param {*} wait
+ * @return {*}
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, delay?: number): ThrottleFunc<T>;
+/**
+ * @description: 生成节流函数
+ * @param {*} Function
+ * @return {*}
+ */
+export declare const generateThrottle: () => Function;
+export {};

package/dist/src/utils/time.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @description: 时间戳转日期
+ * @param {*} timestamp
+ * @param {*} returnType
+ * @return {*}
+ */
+export declare function timestampToTime(timestamp?: number | string): Date & {
+    format?: Function;
+};
+/**
+ * @description: 时间秒，转化成:分割的时间
+ * @param {number} time
+ * @return {*}
+ */
+export declare const timeFormat: (time: number) => string;
+/**
+ * @description: 获取当前时间戳
+ * @return {*}
+ */
+export declare const performanceTime: () => number;

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;