ranuts 0.1.0-alpha.11 → 0.1.0-alpha.13

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

@@ -33,7 +33,7 @@ export declare class Mathjs {
     getDecimalLength: (n: number) => number;
     amend: (n: number, precision?: number) => number;
     power: (a: number, b: number) => number;
-    static handleMethod: (l: number, r: number) => (type: string) => number | undefined;
+    static handleMethod: (l: number, r: number) => ((type: string) => number | undefined);
     static add: (a: number, b: number) => number | undefined;
     static divide: (a: number, b: number) => number | undefined;
     static multiply: (a: number, b: number) => number | undefined;

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

@@ -1,5 +1,5 @@
 /**
- * @description: 对象转url字符串
+ * @description: 对象转 url 字符串
  * @param {*} data
  * @return {*}
  */
@@ -25,16 +25,23 @@ export declare const merge: (a: Obj, b?: Obj) => Obj;
  *
  * @export
  * @param {IAnyObject} source 需要被重写的对象
- * @param {string} name 需要被重写对象的key
+ * @param {string} name 需要被重写对象的 key
  * @param {(...args: any[]) => any} replacement 以原有的函数作为参数，执行并重写原有函数
  * @param {boolean} isForced 是否强制重写（可能原先没有该属性）
  */
 export declare function replaceOld(source: any, name: string, replacement: (...args: unknown[]) => unknown, isForced?: boolean): void;
 /**
- * @description: 将exports对象拼接到obj上，并冻结obj
+ * @description: 将 exports 对象拼接到 obj 上，并冻结 obj
  * @param {Object} obj
  * @param {Object} exports
  * @return {Object}
  */
 export declare const mergeExports: (obj: Object, exports: Object) => Object;
+/**
+ * @description: 给全局对象上增加属性
+ * @param {string} name
+ * @param {string} value
+ * @return {*}
+ */
+export declare const setAttributeByGlobal: (name: string, value: unknown) => void;
 export {};

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

@@ -0,0 +1,2 @@
+export declare const localStorageSetItem: (name: string, value: string) => void;
+export declare const localStorageGetItem: (name: string) => string;

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

@@ -1,4 +1,4 @@
-type Callback = (...args: unknown[]) => unknown;
+type Callback = Function;
 type EventName = string | symbol;
 type EventItem = {
     name?: string | symbol;
@@ -8,10 +8,40 @@ type EventItem = {
 export declare class SyncHook {
     private _events;
     constructor();
-    tap: (eventName: EventName, eventItem: EventItem | Callback) => void;
+    /**
+     * @description: 订阅事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    tap: (eventName: EventName, eventItem: EventItem | Callback) => SyncHook;
+    /**
+     * @description: 触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {void}
+     */
     call: (eventName: EventName, ...args: Array<unknown>) => void;
+    /**
+     * @description: 同步触发事件
+     * @param {EventName} eventName
+     * @param {array} args
+     * @return {Promise<void>}
+     */
     callSync: (eventName: EventName, ...args: Array<unknown>) => Promise<void>;
-    once: (eventName: EventName, eventItem: EventItem | Callback) => void;
-    off: (eventName: EventName, eventItem: EventItem | Callback) => void;
+    /**
+     * @description: 只订阅一次事件，触发后就移除事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    once: (eventName: EventName, eventItem: EventItem | Callback) => SyncHook;
+    /**
+     * @description: 移除订阅的事件
+     * @param {EventName} eventName
+     * @param {EventItem} eventItem
+     * @return {void}
+     */
+    off: (eventName: EventName, eventItem: EventItem | Callback) => SyncHook;
 }
 export {};

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;