@tonysamperi/krypto 1.0.0

package/dist/cjs/kdf/kdf.model.d.cts

@@ -0,0 +1,7 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { CipherParams } from "../lib/cipher-params.class.cjs";
+export declare abstract class AbstractKDF {
+    static execute: (password: string, keySize: number, ivSize: number, salt?: WordArray | string) => CipherParams;
+    abstract compute?(password: WordArray | string, salt: WordArray | string): WordArray;
+}
+export type KDF = typeof AbstractKDF;

package/dist/cjs/kdf/open-ssl-kdf.class.d.cts

@@ -0,0 +1,21 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { CipherParams } from "../lib/cipher-params.class.cjs";
+import { AbstractKDF } from "./kdf.model.cjs";
+export declare class OpenSSLKdf implements AbstractKDF {
+    /**
+     * Derives a key and IV from a password.
+     *
+     * @param password The password to derive from.
+     * @param keySize The size in words of the key to generate.
+     * @param ivSize The size in words of the IV to generate.
+     * @param salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+     *
+     * @return A cipher params object with the key, IV, and salt.
+     *
+     * @example
+     *
+     *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32);
+     *     let derivedParams = OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
+     */
+    static execute(password: string, keySize: number, ivSize: number, salt?: WordArray | string): CipherParams;
+}

package/dist/cjs/kdf/pbkdf2.class.d.cts

@@ -0,0 +1,18 @@
+import { WordArray } from "../lib/word-array.class.cjs";
+import { HasherConstructor } from "../lib/hasher-constructor.type.cjs";
+import { AbstractKDF } from "./kdf.model.cjs";
+export interface PBKDF2Config {
+    keySize: number;
+    hasher: HasherConstructor;
+    iterations: number;
+}
+export declare class PBKDF2 implements AbstractKDF {
+    cfg: PBKDF2Config;
+    constructor(cfg: Partial<PBKDF2Config>);
+    static execute(password: WordArray | string, salt: WordArray | string, cfg?: {
+        keySize?: number;
+        hasher?: HasherConstructor;
+        iterations?: number;
+    }): WordArray;
+    compute(password: WordArray | string, salt: WordArray | string): WordArray;
+}

package/dist/cjs/lib/block-cipher.class.d.cts

@@ -0,0 +1,13 @@
+import { Cipher } from "./cipher.class.cjs";
+import { WordArray } from "./word-array.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { BlockCipherModeAlgorithm } from "../mode/block-cipher-mode-algorithm.class.cjs";
+export declare abstract class BlockCipher extends Cipher {
+    protected _mode: BlockCipherModeAlgorithm;
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    abstract decryptBlock(M: number[], offset: number): void;
+    abstract encryptBlock(M: number[], offset: number): void;
+    reset(): void;
+    protected _doFinalize(): WordArray;
+    protected _doProcessBlock(words: number[], offset: number): void;
+}

package/dist/cjs/lib/buffered-block-algorithm-config.interface.d.cts

@@ -0,0 +1,13 @@
+import { Formatter } from "../format/formatter.interface.cjs";
+import { WordArray } from "./word-array.class.cjs";
+import { KDF } from "../kdf/kdf.model.cjs";
+import { BlockCipherMode } from "../mode/block-cipher-mode.class.cjs";
+import { Padding } from "../pad/padding.model.cjs";
+export interface BufferedBlockAlgorithmConfig {
+    blockSize?: number;
+    iv?: WordArray;
+    format?: Formatter;
+    kdf?: KDF;
+    mode?: typeof BlockCipherMode;
+    padding?: Padding;
+}

package/dist/cjs/lib/buffered-block-algorithm.class.d.cts

@@ -0,0 +1,54 @@
+import { WordArray } from "./word-array.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+export declare abstract class BufferedBlockAlgorithm {
+    cfg: BufferedBlockAlgorithmConfig;
+    protected _data: WordArray;
+    protected _minBufferSize: number;
+    protected _nDataBytes: number;
+    protected abstract _doProcessBlock(wordArray: number[], offset: number): void;
+    constructor(cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates a copy of this object.
+     *
+     * @return The clone.
+     *
+     * @example
+     *
+     *     let clone = bufferedBlockAlgorithm.clone();
+     */
+    clone(): BufferedBlockAlgorithm;
+    /**
+     * Resets this block algorithm's data buffer to its initial state.
+     *
+     * @example
+     *
+     *     bufferedBlockAlgorithm.reset();
+     */
+    reset(): void;
+    /**
+     * Adds new data to this block algorithm's buffer.
+     *
+     * @param data The data to append. Strings are converted to a WordArray using UTF-8.
+     *
+     * @example
+     *
+     *     bufferedBlockAlgorithm._append('data');
+     *     bufferedBlockAlgorithm._append(wordArray);
+     */
+    protected _append(data: string | WordArray): void;
+    /**
+     * Processes available data blocks.
+     *
+     * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+     *
+     * @param doFlush Whether all blocks and partial blocks should be processed.
+     *
+     * @return The processed data.
+     *
+     * @example
+     *
+     *     let processedData = bufferedBlockAlgorithm._process();
+     *     let processedData = bufferedBlockAlgorithm._process(!!'flush');
+     */
+    protected _process(doFlush?: boolean): WordArray;
+}

package/dist/cjs/lib/cipher-helper.class.d.cts

@@ -0,0 +1,10 @@
+import { WordArray } from "./word-array.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { CipherParams } from "./cipher-params.class.cjs";
+import { Cipher } from "./cipher.class.cjs";
+export declare class CipherHelper {
+    private readonly _cipher;
+    constructor(_cipher: typeof Cipher);
+    decrypt(ciphertext: CipherParams | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): WordArray;
+    encrypt(message: WordArray | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+}

package/dist/cjs/lib/cipher-params.class.d.cts

@@ -0,0 +1,53 @@
+import { WordArray } from "./word-array.class.cjs";
+import { Cipher } from "./cipher.class.cjs";
+import { BlockCipherMode } from "../mode/block-cipher-mode.class.cjs";
+import { Padding } from "../pad/padding.model.cjs";
+import { Formatter } from "../format/formatter.interface.cjs";
+export declare class CipherParams {
+    algorithm?: typeof Cipher;
+    blockSize?: number;
+    ciphertext?: WordArray;
+    formatter?: Formatter;
+    iv?: WordArray;
+    key?: WordArray | string;
+    mode?: typeof BlockCipherMode;
+    padding?: Padding;
+    salt?: WordArray | string;
+    /**
+     * Initializes a newly created cipher params object.
+     *
+     * @param cipherParams An object with any of the possible cipher parameters.
+     *
+     * @example
+     *
+     *     let cipherParams = CipherParams.create({
+     *         ciphertext: ciphertextWordArray,
+     *         key: keyWordArray,
+     *         iv: ivWordArray,
+     *         salt: saltWordArray,
+     *         algorithm: AES,
+     *         mode: CBC,
+     *         padding: PKCS7,
+     *         blockSize: 4,
+     *         formatter: OpenSSLFormatter
+     *     });
+     */
+    constructor(cipherParams: Omit<CipherParams, "extend" | "toString">);
+    extend(additionalParams: CipherParams): CipherParams;
+    /**
+     * Converts this cipher params object to a string.
+     *
+     * @param formatter (Optional) The formatting strategy to use.
+     *
+     * @return The stringified cipher params.
+     *
+     * @throws Error If neither the formatter nor the default formatter is set.
+     *
+     * @example
+     *
+     *     let string = cipherParams + '';
+     *     let string = cipherParams.toString();
+     *     let string = cipherParams.toString(CryptoJS.format.OpenSSL);
+     */
+    toString(formatter?: Formatter): string;
+}

package/dist/cjs/lib/cipher.class.d.cts

@@ -0,0 +1,112 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.cjs";
+import { WordArray } from "./word-array.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { CipherHelper } from "./cipher-helper.class.cjs";
+export declare abstract class Cipher extends BufferedBlockAlgorithm {
+    /**
+     * This cipher's IV size. Default: 4 (128 bits / 32 Bits)
+     */
+    static ivSize: number;
+    /**
+     * This cipher's key size. Default: 4 (128 bits / 32 Bits)
+     */
+    static keySize: number;
+    /**
+     * A constant representing decryption mode.
+     */
+    protected static readonly _DEC_XFORM_MODE = 2;
+    /**
+     * A constant representing encryption mode.
+     */
+    protected static readonly _ENC_XFORM_MODE = 1;
+    /**
+     * The key.
+     */
+    protected _key: WordArray;
+    /**
+     * Either the encryption or decryption transformation mode constant.
+     */
+    protected _xformMode: number;
+    /**
+     * Initializes a newly created cipher.
+     *
+     * @param xformMode Either the encryption or decryption transormation mode constant.
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @example
+     *
+     *     let cipher = AES.create(AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
+     */
+    constructor(xformMode: number, key: WordArray, cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates shortcut functions to a cipher's object interface.
+     *
+     * @param cipher The cipher to create a helper for.
+     *
+     * @return An object with encrypt and decrypt shortcut functions.
+     *
+     * @example
+     *
+     *     const AES = Cipher._createHelper(AESAlgorithm);
+     */
+    static _createHelper(cipher: typeof Cipher): CipherHelper;
+    /**
+     * Creates this cipher in decryption mode.
+     *
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher instance.
+     *
+     * @example
+     *
+     *     let cipher = AES.createDecryptor(keyWordArray, { iv: ivWordArray });
+     */
+    static createDecryptor(key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): Cipher;
+    /**
+     * Creates this cipher in encryption mode.
+     *
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher instance.
+     *
+     * @example
+     *
+     *     let cipher = AES.createEncryptor(keyWordArray, { iv: ivWordArray });
+     */
+    static createEncryptor(key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): Cipher;
+    /**
+     * Finalizes the encryption or decryption process.
+     * Note that the finalize operation is effectively a destructive, read-once operation.
+     *
+     * @param dataUpdate The final data to encrypt or decrypt.
+     *
+     * @return The data after final processing.
+     *
+     * @example
+     *
+     *     var encrypted = cipher.finalize();
+     *     var encrypted = cipher.finalize('data');
+     *     var encrypted = cipher.finalize(wordArray);
+     */
+    finalize(dataUpdate?: WordArray | string): WordArray;
+    /**
+     * Adds data to be encrypted or decrypted.
+     *
+     * @param dataUpdate The data to encrypt or decrypt.
+     *
+     * @return The data after processing.
+     *
+     * @example
+     *
+     *     let encrypted = cipher.process('data');
+     *     let encrypted = cipher.process(wordArray);
+     */
+    process(dataUpdate: WordArray | string): WordArray;
+    /**
+     * Cipher specific finalize function explicitly implemented in the derived class.
+     */
+    protected abstract _doFinalize(): WordArray;
+}

package/dist/cjs/lib/hasher-constructor.type.d.cts

@@ -0,0 +1,3 @@
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { Hasher } from "./hasher.class.cjs";
+export type HasherConstructor<T extends Hasher = Hasher> = new (cfg?: BufferedBlockAlgorithmConfig) => T;

package/dist/cjs/lib/hasher-helper.type.d.cts

@@ -0,0 +1,3 @@
+import { WordArray } from "./word-array.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+export type HasherHelper = (message: WordArray | string, cfg?: BufferedBlockAlgorithmConfig) => WordArray;

package/dist/cjs/lib/hasher.class.d.cts

@@ -0,0 +1,58 @@
+import { BufferedBlockAlgorithm } from "./buffered-block-algorithm.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { WordArray } from "./word-array.class.cjs";
+import { HasherConstructor } from "./hasher-constructor.type.cjs";
+import { HasherHelper } from "./hasher-helper.type.cjs";
+export declare abstract class Hasher extends BufferedBlockAlgorithm {
+    /**
+     * Initializes a newly created hasher.
+     *
+     * @param cfg (Optional) The configuration options to use for this hash computation.
+     *
+     * @example
+     *
+     *     let hasher = CryptoJS.algo.SHA256.create();
+     */
+    constructor(cfg?: BufferedBlockAlgorithmConfig);
+    /**
+     * Creates a shortcut function to the object interface of a hasher.
+     *
+     * @param hasher The hasher to create a helper for.
+     *
+     * @return The shortcut function.
+     *
+     * @example
+     *
+     *     const SHA256 = Hasher._createHelper(SHA256);
+     */
+    static _createHelper<T extends Hasher = Hasher>(hasher: HasherConstructor<T>): HasherHelper;
+    protected abstract _doFinalize(): WordArray;
+    /**
+     * Finalizes the hash computation.
+     * Note that the finalize operation is effectively a destructive, read-once operation.
+     *
+     * @param messageUpdate (Optional) A final message update.
+     *
+     * @return The hash.
+     *
+     * @example
+     *
+     *     let hash = hasher.finalize();
+     *     let hash = hasher.finalize('message');
+     *     let hash = hasher.finalize(wordArray);
+     */
+    finalize(messageUpdate?: WordArray | string): WordArray;
+    /**
+     * Updates this hasher with a message.
+     *
+     * @param messageUpdate The message to append.
+     *
+     * @return This hasher.
+     *
+     * @example
+     *
+     *     hasher.update('message');
+     *     hasher.update(wordArray);
+     */
+    update(messageUpdate: WordArray | string): Hasher;
+}

package/dist/cjs/lib/hmac.class.d.cts

@@ -0,0 +1,11 @@
+import { HasherConstructor } from "./hasher-constructor.type.cjs";
+import { WordArray } from "./word-array.class.cjs";
+export declare class HMAC {
+    private _hasher;
+    private _iKey;
+    private _oKey;
+    constructor(hasher: HasherConstructor, rawKey: WordArray | string);
+    finalize(messageUpdate?: WordArray | string): WordArray;
+    reset(): void;
+    update(messageUpdate: WordArray | string): this;
+}

package/dist/cjs/lib/index.d.cts

@@ -0,0 +1,8 @@
+export { BlockCipher } from "./block-cipher.class.cjs";
+export { CipherParams } from "./cipher-params.class.cjs";
+export { Hasher } from "./hasher.class.cjs";
+export { PasswordBasedCipher } from "./password-based-cipher.class.cjs";
+export { SerializableCipher } from "./serializable-cipher.class.cjs";
+export { WordArray } from "./word-array.class.cjs";
+export { X64Word } from "./x64-word.class.cjs";
+export { X64WordArray } from "./x64-word-array.class.cjs";

package/dist/cjs/lib/password-based-cipher.class.d.cts

@@ -0,0 +1,54 @@
+import { WordArray } from "./word-array.class.cjs";
+import { Cipher } from "./cipher.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { CipherParams } from "./cipher-params.class.cjs";
+import { Formatter } from "../format/formatter.interface.cjs";
+export declare class PasswordBasedCipher {
+    static cfg: BufferedBlockAlgorithmConfig;
+    /**
+     * Decrypts serialized ciphertext using a password.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param ciphertext The ciphertext to decrypt.
+     * @param password The password.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return The plaintext.
+     *
+     * @example
+     *
+     *     var plaintext = PasswordBasedCipher.decrypt(AES, formattedCiphertext, 'password', { format: OpenSSL });
+     *     var plaintext = PasswordBasedCipher.decrypt(AES, ciphertextParams, 'password', { format: OpenSSL });
+     */
+    static decrypt(cipher: typeof Cipher, ciphertext: CipherParams | string, password: string, cfg?: BufferedBlockAlgorithmConfig): WordArray;
+    /**
+     * Encrypts a message using a password.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param message The message to encrypt.
+     * @param password The password.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher params object.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password');
+     *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(AES, message, 'password', { format: OpenSSL });
+     */
+    static encrypt(cipher: typeof Cipher, message: WordArray | string, password: string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+    /**
+     * Converts serialized ciphertext to CipherParams,
+     * else assumed CipherParams already and returns ciphertext unchanged.
+     *
+     * @param ciphertext The ciphertext.
+     * @param format The formatting strategy to use to parse serialized ciphertext.
+     *
+     * @return The unserialized ciphertext.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+     */
+    protected static _parse(ciphertext: CipherParams | string, format: Formatter): CipherParams;
+}

package/dist/cjs/lib/serializable-cipher.class.d.cts

@@ -0,0 +1,73 @@
+import { WordArray } from "./word-array.class.cjs";
+import { Cipher } from "./cipher.class.cjs";
+import { BufferedBlockAlgorithmConfig } from "./buffered-block-algorithm-config.interface.cjs";
+import { CipherParams } from "./cipher-params.class.cjs";
+import { Formatter } from "../format/formatter.interface.cjs";
+export declare class SerializableCipher {
+    static cfg: BufferedBlockAlgorithmConfig;
+    /**
+     * Decrypts serialized ciphertext.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param ciphertext The ciphertext to decrypt.
+     * @param key The key.
+     * @param optionalCfg The configuration options to use for this operation.
+     *
+     * @return The plaintext.
+     *
+     * @example
+     *
+     *     let plaintext = SerializableCipher.decrypt(
+     *         AESAlgorithm,
+     *         formattedCiphertext,
+     *         key, {
+     *             iv: iv,
+     *             format: CryptoJS.format.OpenSSL
+     *         }
+     *     );
+     *
+     *     let plaintext = SerializableCipher.decrypt(
+     *         AESAlgorithm,
+     *         ciphertextParams,
+     *         key, {
+     *             iv: iv,
+     *             format: CryptoJS.format.OpenSSL
+     *         }
+     *     );
+     */
+    static decrypt(cipher: typeof Cipher, ciphertext: CipherParams | string, key: WordArray | string, optionalCfg?: BufferedBlockAlgorithmConfig): WordArray;
+    /**
+     * Encrypts a message.
+     *
+     * @param cipher The cipher algorithm to use.
+     * @param message The message to encrypt.
+     * @param key The key.
+     * @param cfg (Optional) The configuration options to use for this operation.
+     *
+     * @return A cipher params object.
+     *
+     * @example
+     *
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
+     *     let ciphertextParams = SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, {
+     *       iv: iv,
+     *       format: CryptoJS.format.OpenSSL
+     *     });
+     */
+    static encrypt(cipher: typeof Cipher, message: WordArray | string, key: WordArray | string, cfg?: BufferedBlockAlgorithmConfig): CipherParams;
+    /**
+     * Converts serialized ciphertext to CipherParams,
+     * else assumed CipherParams already and returns ciphertext unchanged.
+     *
+     * @param ciphertext The ciphertext.
+     * @param format The formatting strategy to use to parse serialized ciphertext.
+     *
+     * @return The deserialized ciphertext.
+     *
+     * @example
+     *
+     *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+     */
+    protected static _parse(ciphertext: CipherParams | string, format: Formatter): CipherParams;
+}

package/dist/cjs/lib/word-array.class.d.cts

@@ -0,0 +1,75 @@
+export declare class WordArray {
+    sigBytes: number;
+    words: number[];
+    /**
+     * Initializes a newly created word array.
+     *
+     * @param words (Optional) An array of 32-bit words.
+     * @param sigBytes (Optional) The number of significant bytes in the words.
+     *
+     * @example
+     *
+     *     let wordArray = new WordArray();
+     *     let wordArray = new WordArray([0x00010203, 0x04050607]);
+     *     let wordArray = new WordArray([0x00010203, 0x04050607], 6);
+     */
+    constructor(words?: number[], sigBytes?: number);
+    /**
+     * Creates a word array filled with random bytes.
+     *
+     * @param nBytes The number of random bytes to generate.
+     *
+     * @return The random word array.
+     *
+     * @example
+     *
+     *     let wordArray = WordArray.random(16);
+     */
+    static random(nBytes: number): WordArray;
+    /**
+     * Removes insignificant bits.
+     *
+     * @example
+     *
+     *     wordArray.clamp();
+     */
+    clamp(): void;
+    /**
+     * Creates a copy of this word array.
+     *
+     * @return The clone.
+     *
+     * @example
+     *
+     *     let clone = wordArray.clone();
+     */
+    clone(): WordArray;
+    /**
+     * Concatenates a word array to this word array.
+     *
+     * @param wordArray The word array to append.
+     *
+     * @return This word array.
+     *
+     * @example
+     *
+     *     wordArray1.concat(wordArray2);
+     */
+    concat(wordArray: WordArray): WordArray;
+    /**
+     * Converts this word array to a string.
+     *
+     * @param encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+     *
+     * @return The stringified word array.
+     *
+     * @example
+     *
+     *     let string = wordArray + '';
+     *     let string = wordArray.toString();
+     *     let string = wordArray.toString(CryptoJS.enc.Utf8);
+     */
+    toString<T extends {
+        stringify: (arg: WordArray) => string;
+    }>(encoder?: T): string;
+}

package/dist/cjs/lib/x64-word-array.class.d.cts

@@ -0,0 +1,10 @@
+import { X64Word } from "./x64-word.class.cjs";
+import { WordArray } from "./word-array.class.cjs";
+export declare class X64WordArray {
+    sigBytes: number;
+    words: X64Word[];
+    constructor(words?: X64Word[], sigBytes?: number);
+    static create(words?: X64Word[], sigBytes?: number): X64WordArray;
+    clone(): X64WordArray;
+    toX32(): WordArray;
+}

package/dist/cjs/lib/x64-word.class.d.cts

@@ -0,0 +1,14 @@
+export declare class X64Word {
+    high: number;
+    low: number;
+    constructor(high: number, low: number);
+    add(word: X64Word): X64Word;
+    and(word: X64Word): X64Word;
+    not(): X64Word;
+    or(word: X64Word): X64Word;
+    rotL(n: number): X64Word;
+    rotR(n: number): X64Word;
+    shiftL(n: number): X64Word;
+    shiftR(n: number): X64Word;
+    xor(word: X64Word): X64Word;
+}

package/dist/cjs/mode/block-cipher-mode-algorithm.class.d.cts

@@ -0,0 +1,20 @@
+import { BlockCipher } from "../lib/block-cipher.class.cjs";
+import { BlockCipherMode } from "./block-cipher-mode.class.cjs";
+export declare abstract class BlockCipherModeAlgorithm {
+    __creator: ((cipher: BlockCipher, iv: number[]) => BlockCipherMode) | undefined;
+    protected _cipher: BlockCipher;
+    protected _iv: number[] | undefined;
+    constructor(cipher: BlockCipher, iv: number[]);
+    abstract processBlock(words: number[], offset: number): void;
+    /**
+     * Initializes a newly created mode.
+     *
+     * @param cipher A block cipher instance.
+     * @param iv The IV words.
+     *
+     * @example
+     *
+     *     var mode = CBC.Encryptor.create(cipher, iv.words);
+     */
+    init(cipher: BlockCipher, iv?: number[]): void;
+}