@rowsncolumns/toolkit 24.4.1

package/dist/esm/excel-parser/cfb-decryptor.js

@@ -0,0 +1,493 @@
+/// <reference path="../xlsx.d.ts" />
+import { CFB } from "xlsx/xlsx.mjs";
+import { sha1 } from "@noble/hashes/sha1";
+import { sha256 } from "@noble/hashes/sha256";
+import { sha384, sha512 } from "@noble/hashes/sha512";
+import { cbc, ecb } from "@noble/ciphers/aes";
+const BLOCK_KEY_VERIFIER_INPUT = new Uint8Array([
+    0xfe, 0xa7, 0xd2, 0x76, 0x3b, 0x4b, 0x9e, 0x79,
+]);
+const BLOCK_KEY_VERIFIER_HASH = new Uint8Array([
+    0xd7, 0xaa, 0x0f, 0x6d, 0x30, 0x61, 0x34, 0x4e,
+]);
+const BLOCK_KEY_ENCRYPTION_KEY = new Uint8Array([
+    0x14, 0x6e, 0x0b, 0xe7, 0xab, 0xac, 0xd0, 0xd6,
+]);
+export const LEGACY_XLS_UNSUPPORTED_MESSAGE = "This file is a legacy Excel 97-2003 (.xls) workbook, which is not supported. Please open it in Excel and save it as .xlsx, then try again.";
+/**
+ * Inspects a CFB container's directory to decide whether it is an
+ * Office-encrypted OOXML package (`EncryptionInfo` stream present) or an
+ * unencrypted legacy BIFF `.xls` workbook (`Workbook`/`Book` stream present
+ * without `EncryptionInfo`). Returns "unknown" for anything else, including
+ * containers that fail to parse — callers should fall back to their existing
+ * behavior in that case.
+ */
+export const detectCfbContainerKind = async (source) => {
+    try {
+        const buffer = source instanceof File ? await source.arrayBuffer() : source;
+        const cfb = CFB.read(new Uint8Array(buffer), { type: "array" });
+        const streamNames = new Set(cfb.FileIndex.map((entry) => entry.name));
+        if (streamNames.has("EncryptionInfo")) {
+            return "encrypted-ooxml";
+        }
+        if (streamNames.has("Workbook") || streamNames.has("Book")) {
+            return "legacy-xls";
+        }
+        return "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+};
+export class CFBDecryptor {
+    /**
+     * Decrypts a CFB-encrypted XLSX file
+     * @param source The encrypted file or array buffer
+     * @param password The password to decrypt with
+     * @returns The decrypted XLSX data as ArrayBuffer
+     */
+    static async decrypt(source, password) {
+        // Read CFB structure
+        const buffer = source instanceof File ? await source.arrayBuffer() : source;
+        const uint8Array = new Uint8Array(buffer);
+        const cfb = CFB.read(uint8Array, { type: "array" });
+        // Dispatch on the EncryptionInfo version (MS-OFFCRYPTO): agile (4.4), standard AES (x.2 + fAES),
+        // or RC4 CryptoAPI (x.2 + fCryptoAPI). Extensible (x.3) and legacy schemes are unsupported.
+        const infoContent = this.getEncryptionInfoContent(cfb);
+        if (!infoContent) {
+            throw new Error("Could not parse encryption information");
+        }
+        const view = new DataView(infoContent.buffer, infoContent.byteOffset, infoContent.byteLength);
+        const versionMajor = view.getUint16(0, true);
+        const versionMinor = view.getUint16(2, true);
+        if (versionMajor === 4 && versionMinor === 4) {
+            return this.decryptAgile(cfb, password);
+        }
+        if (versionMinor === 2 && versionMajor >= 2 && versionMajor <= 4) {
+            return this.decryptStandardFamily(cfb, infoContent, password);
+        }
+        const detail = versionMinor === 3 ? " (extensible encryption)" : "";
+        throw new Error(`Unsupported workbook encryption version ${versionMajor}.${versionMinor}${detail}. ` +
+            `Supported: agile (4.4), standard AES (x.2), RC4 CryptoAPI.`);
+    }
+    static decryptAgile(cfb, password) {
+        const encryptionInfo = this.parseEncryptionInfo(cfb);
+        if (!encryptionInfo) {
+            throw new Error("Could not parse encryption information");
+        }
+        // Derive key from password
+        const passwordDerivedKey = this.deriveKey(password, encryptionInfo);
+        // Verify password by decrypting verifier
+        const isValid = this.verifyPassword(passwordDerivedKey, encryptionInfo);
+        if (!isValid) {
+            throw new Error("Incorrect password");
+        }
+        // Decrypt the encrypted key value to get the actual encryption key
+        const encryptionKey = this.decryptEncryptedKey(passwordDerivedKey, encryptionInfo);
+        // Decrypt the package using the decrypted encryption key
+        const encryptedPackage = this.getEncryptedPackage(cfb);
+        return this.decryptPackage(encryptedPackage, encryptionKey, encryptionInfo);
+    }
+    static getEncryptionInfoContent(cfb) {
+        const entry = cfb.FileIndex.find((e) => e.name === "EncryptionInfo");
+        if (!entry || !entry.content) {
+            return null;
+        }
+        const contentArray = entry.content;
+        return contentArray instanceof Uint8Array
+            ? contentArray
+            : new Uint8Array(contentArray);
+    }
+    // ── Standard (MS-OFFCRYPTO §2.3.4.5-9) & RC4 CryptoAPI (§2.3.5) ──────────────────
+    static decryptStandardFamily(cfb, infoContent, password) {
+        // `body` begins at the EncryptionHeaderFlags dword (after the 4-byte version).
+        const body = infoContent.subarray(4);
+        const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+        const headerSize = dv.getUint32(4, true);
+        const header = body.subarray(8, 8 + headerSize);
+        const hdv = new DataView(header.buffer, header.byteOffset, header.byteLength);
+        const algId = hdv.getUint32(8, true);
+        const keySizeBits = hdv.getUint32(16, true);
+        const verifier = body.subarray(8 + headerSize);
+        const salt = verifier.subarray(4, 20);
+        const encryptedVerifier = verifier.subarray(20, 36);
+        // AES uses a 32-byte encrypted verifier hash (SHA1 padded to two blocks); RC4 uses 20.
+        const isAes = (algId & 0xff00) === 0x6600;
+        const isRc4 = algId === 0x6801 || algId === 0;
+        if (!isAes && !isRc4) {
+            throw new Error(`Unsupported workbook encryption cipher (algId 0x${algId.toString(16)}).`);
+        }
+        const vhashLen = isAes ? 32 : 20;
+        const encryptedVerifierHash = verifier.subarray(40, 40 + vhashLen);
+        const encryptedPackage = this.getEncryptedPackage(cfb);
+        if (isAes) {
+            const keyBytes = keySizeBits !== 0
+                ? keySizeBits / 8
+                : algId === 0x660e
+                    ? 16
+                    : algId === 0x660f
+                        ? 24
+                        : 32;
+            const key = this.standardKey(password, salt, keyBytes);
+            const verifierPlain = this.aesEcbDecrypt(encryptedVerifier, key);
+            const expected = this.hash(verifierPlain, "SHA1");
+            const stored = this.aesEcbDecrypt(encryptedVerifierHash, key);
+            if (!this.bytesEqual(expected, stored.subarray(0, expected.length))) {
+                throw new Error("Incorrect password");
+            }
+            return this.decryptStandardPackage(encryptedPackage, key);
+        }
+        // RC4 CryptoAPI: 40-bit keys are 5 significant bytes zero-padded to 16.
+        const keyBytes = keySizeBits === 40 || keySizeBits === 0 ? 5 : keySizeBits / 8;
+        const key0 = this.rc4CryptoApiKey(password, salt, keyBytes, 0);
+        const combined = this.rc4(key0, this.concatArrays(encryptedVerifier, encryptedVerifierHash));
+        const verifierPlain = combined.subarray(0, encryptedVerifier.length);
+        const storedHash = combined.subarray(encryptedVerifier.length);
+        if (!this.bytesEqual(this.hash(verifierPlain, "SHA1"), storedHash)) {
+            throw new Error("Incorrect password");
+        }
+        return this.decryptRc4Package(encryptedPackage, password, salt, keyBytes);
+    }
+    /** Standard key derivation (MS-OFFCRYPTO §2.3.4.7): iterated SHA1 then the X1‖X2 final block. */
+    static standardKey(password, salt, keyBytes) {
+        const SPIN_COUNT = 50000;
+        let h = this.hash(this.concatArrays(salt, this.stringToUtf16LE(password)), "SHA1");
+        for (let i = 0; i < SPIN_COUNT; i++) {
+            h = this.hash(this.concatArrays(this.le32(i), h), "SHA1");
+        }
+        const hfinal = this.hash(this.concatArrays(h, this.le32(0)), "SHA1");
+        const buf1 = new Uint8Array(64).fill(0x36);
+        const buf2 = new Uint8Array(64).fill(0x5c);
+        for (let i = 0; i < 20; i++) {
+            buf1[i] ^= hfinal[i];
+            buf2[i] ^= hfinal[i];
+        }
+        const x1 = this.hash(buf1, "SHA1");
+        const x2 = this.hash(buf2, "SHA1");
+        return this.concatArrays(x1, x2).slice(0, keyBytes);
+    }
+    static decryptStandardPackage(encryptedPackage, key) {
+        const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+        const packageSize = Number(sizeView.getBigUint64(0, true));
+        const decrypted = this.aesEcbDecrypt(encryptedPackage.subarray(8), key);
+        const trimmed = decrypted.subarray(0, packageSize);
+        const result = new ArrayBuffer(trimmed.byteLength);
+        new Uint8Array(result).set(trimmed);
+        return result;
+    }
+    /** RC4 CryptoAPI key derivation (MS-OFFCRYPTO §2.3.5.2). */
+    static rc4CryptoApiKey(password, salt, keyBytes, block) {
+        const h0 = this.hash(this.concatArrays(salt, this.stringToUtf16LE(password)), "SHA1");
+        const hfinal = this.hash(this.concatArrays(h0, this.le32(block)), "SHA1");
+        if (keyBytes === 5) {
+            const key = new Uint8Array(16);
+            key.set(hfinal.subarray(0, 5));
+            return key;
+        }
+        return hfinal.subarray(0, keyBytes);
+    }
+    static decryptRc4Package(encryptedPackage, password, salt, keyBytes) {
+        const RC4_BLOCK_LENGTH = 512;
+        const sizeView = new DataView(encryptedPackage.buffer, encryptedPackage.byteOffset, 8);
+        const packageSize = Number(sizeView.getBigUint64(0, true));
+        const data = encryptedPackage.subarray(8);
+        const out = new Uint8Array(data.length);
+        // RC4 re-keys every 512 bytes of the encrypted package, using the block index.
+        for (let block = 0; block * RC4_BLOCK_LENGTH < data.length; block++) {
+            const start = block * RC4_BLOCK_LENGTH;
+            const end = Math.min(start + RC4_BLOCK_LENGTH, data.length);
+            const key = this.rc4CryptoApiKey(password, salt, keyBytes, block);
+            out.set(this.rc4(key, data.subarray(start, end)), start);
+        }
+        const trimmed = out.subarray(0, packageSize);
+        const result = new ArrayBuffer(trimmed.byteLength);
+        new Uint8Array(result).set(trimmed);
+        return result;
+    }
+    /** AES-ECB block decrypt (no padding). Trailing sub-block bytes are ignored. */
+    static aesEcbDecrypt(data, key) {
+        const aligned = data.length - (data.length % 16);
+        const cipher = ecb(key, { disablePadding: true });
+        return cipher.decrypt(data.subarray(0, aligned));
+    }
+    /** RC4 stream cipher (KSA + PRGA). Symmetric — the same op encrypts and decrypts. */
+    static rc4(key, data) {
+        const s = new Uint8Array(256);
+        for (let i = 0; i < 256; i++)
+            s[i] = i;
+        let j = 0;
+        for (let i = 0; i < 256; i++) {
+            j = (j + s[i] + key[i % key.length]) & 0xff;
+            const t = s[i];
+            s[i] = s[j];
+            s[j] = t;
+        }
+        const out = new Uint8Array(data.length);
+        let a = 0;
+        let b = 0;
+        for (let k = 0; k < data.length; k++) {
+            a = (a + 1) & 0xff;
+            b = (b + s[a]) & 0xff;
+            const t = s[a];
+            s[a] = s[b];
+            s[b] = t;
+            out[k] = data[k] ^ s[(s[a] + s[b]) & 0xff];
+        }
+        return out;
+    }
+    static le32(n) {
+        const b = new Uint8Array(4);
+        new DataView(b.buffer).setUint32(0, n >>> 0, true);
+        return b;
+    }
+    static bytesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    static parseEncryptionInfo(cfb) {
+        // Find EncryptionInfo stream
+        const encInfoEntry = cfb.FileIndex.find((entry) => entry.name === "EncryptionInfo");
+        if (!encInfoEntry || !encInfoEntry.content) {
+            return null;
+        }
+        // CFB library returns content as array, convert to Uint8Array with proper buffer
+        const contentArray = encInfoEntry.content;
+        const content = contentArray instanceof Uint8Array
+            ? contentArray
+            : new Uint8Array(contentArray);
+        // Create a new buffer to ensure we have a proper ArrayBuffer
+        const buffer = new ArrayBuffer(content.length);
+        const bufferView = new Uint8Array(buffer);
+        bufferView.set(content);
+        const view = new DataView(buffer);
+        // Read version info
+        const versionMajor = view.getUint16(0, true);
+        const versionMinor = view.getUint16(2, true);
+        // Only support Agile encryption (version 4.4)
+        if (versionMajor !== 4 || versionMinor !== 4) {
+            throw new Error(`Unsupported encryption version: ${versionMajor}.${versionMinor}. Only Agile encryption (4.4) is supported.`);
+        }
+        // Parse XML encryption descriptor (starts at byte 8)
+        const xmlBytes = content.slice(8);
+        const xmlString = new TextDecoder().decode(xmlBytes);
+        const encInfo = this.parseAgileEncryptionXml(xmlString);
+        return encInfo;
+    }
+    static parseAgileEncryptionXml(xml) {
+        // Simple XML parsing for encryption parameters
+        const getAttr = (tag, attr) => {
+            // Match tag with optional namespace prefix (p:, x:, etc.)
+            // Use non-greedy match to avoid consuming the target attribute
+            const regex = new RegExp(`<(?:\\w+:)?${tag}[^>]*?\\s+${attr}="([^"]*)"`, "i");
+            const match = xml.match(regex);
+            if (!match) {
+                console.warn(`Failed to find attribute ${attr} on tag ${tag}`);
+                // Try alternative: attribute might be first after tag name
+                const altRegex = new RegExp(`<(?:\\w+:)?${tag}\\s+${attr}="([^"]*)"`, "i");
+                const altMatch = xml.match(altRegex);
+                return altMatch ? altMatch[1] : "";
+            }
+            return match ? match[1] : "";
+        };
+        const getBase64 = (tag, attr) => {
+            const base64 = getAttr(tag, attr);
+            if (!base64) {
+                console.warn(`No base64 value found for ${tag}.${attr}`);
+                return new Uint8Array(0);
+            }
+            try {
+                const binary = atob(base64);
+                const bytes = new Uint8Array(binary.length);
+                for (let i = 0; i < binary.length; i++) {
+                    bytes[i] = binary.charCodeAt(i);
+                }
+                return bytes;
+            }
+            catch (error) {
+                console.error(`Failed to decode base64 for ${tag}.${attr}:`, error);
+                return new Uint8Array(0);
+            }
+        };
+        const algorithm = getAttr("keyData", "cipherAlgorithm") || "AES";
+        const keySize = parseInt(getAttr("keyData", "keyBits") || "256") / 8;
+        const blockSize = parseInt(getAttr("keyData", "blockSize") || "16");
+        const hashAlgorithm = getAttr("keyData", "hashAlgorithm") || "SHA512";
+        const hashSize = parseInt(getAttr("keyData", "hashSize") || "64");
+        const saltSize = parseInt(getAttr("keyData", "saltSize") || "16");
+        // TWO different salts are used:
+        // 1. passwordSalt from encryptedKey - for password derivation and verification
+        // 2. packageSalt from keyData - for package decryption IVs
+        const passwordSalt = getBase64("encryptedKey", "saltValue");
+        const packageSalt = getBase64("keyData", "saltValue");
+        // Get values from p:encryptedKey element
+        const spinCount = parseInt(getAttr("encryptedKey", "spinCount") || "100000");
+        const encryptedVerifierHashInput = getBase64("encryptedKey", "encryptedVerifierHashInput");
+        const encryptedVerifierHashValue = getBase64("encryptedKey", "encryptedVerifierHashValue");
+        const encryptedKeyValue = getBase64("encryptedKey", "encryptedKeyValue");
+        // Validate that all required values were parsed
+        if (!passwordSalt.length || !packageSalt.length) {
+            throw new Error("Failed to parse salt values from encryption info");
+        }
+        if (!encryptedVerifierHashInput.length ||
+            !encryptedVerifierHashValue.length ||
+            !encryptedKeyValue.length) {
+            throw new Error("Failed to parse encrypted verifier values from encryption info");
+        }
+        return {
+            algorithm,
+            keySize,
+            blockSize,
+            hashAlgorithm,
+            hashSize,
+            saltSize,
+            passwordSalt,
+            packageSalt,
+            encryptedVerifierHashInput,
+            encryptedVerifierHashValue,
+            encryptedKeyValue,
+            spinCount,
+        };
+    }
+    static deriveKey(password, info) {
+        // Convert password to UTF-16LE
+        const passwordBytes = this.stringToUtf16LE(password);
+        // Initial hash H0 = H(passwordSalt + password)
+        // Use passwordSalt from encryptedKey, NOT packageSalt from keyData
+        let hash = this.hash(this.concatArrays(info.passwordSalt, passwordBytes), info.hashAlgorithm);
+        // Spin iteration: H(iterator + H(n-1))
+        for (let i = 0; i < info.spinCount; i++) {
+            const iterator = new Uint8Array(4);
+            new DataView(iterator.buffer).setUint32(0, i, true);
+            hash = this.hash(this.concatArrays(iterator, hash), info.hashAlgorithm);
+        }
+        // Return H_final (the result after spin iterations)
+        // Individual keys are derived from this using block keys
+        return hash;
+    }
+    static decryptEncryptedKey(passwordDerivedKey, info) {
+        const keyForKeyValue = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_ENCRYPTION_KEY, info);
+        // Agile encryption uses raw CBC block decryption (no PKCS padding).
+        const decryptedKey = this.decryptAESNoPadding(info.encryptedKeyValue, keyForKeyValue, info.passwordSalt.slice(0, 16));
+        return decryptedKey.slice(0, info.keySize);
+    }
+    static verifyPassword(passwordDerivedKey, info) {
+        try {
+            const keyForVerifierInput = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_INPUT, info);
+            // Decrypt verifier hash input
+            const verifierHashInput = this.decryptAESNoPadding(info.encryptedVerifierHashInput, keyForVerifierInput, info.passwordSalt.slice(0, 16));
+            // Hash the decrypted verifier
+            const verifierHash = this.hash(verifierHashInput.slice(0, 16), info.hashAlgorithm);
+            const keyForVerifierValue = this.deriveAgileBlockKey(passwordDerivedKey, BLOCK_KEY_VERIFIER_HASH, info);
+            // Decrypt verifier hash value
+            const decryptedVerifierHash = this.decryptAESNoPadding(info.encryptedVerifierHashValue, keyForVerifierValue, info.passwordSalt.slice(0, 16));
+            // Compare hashes
+            const expectedHashLength = Math.min(info.hashSize, verifierHash.length, decryptedVerifierHash.length);
+            for (let i = 0; i < expectedHashLength; i++) {
+                if (verifierHash[i] !== decryptedVerifierHash[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.error("Password verification error:", error);
+            return false;
+        }
+    }
+    static getEncryptedPackage(cfb) {
+        const entry = cfb.FileIndex.find((e) => e.name === "EncryptedPackage" || e.name === "0EncryptedPackage");
+        if (!entry || !entry.content) {
+            throw new Error("EncryptedPackage stream not found");
+        }
+        // CFB library returns content as array, convert to proper Uint8Array
+        const contentArray = entry.content;
+        return contentArray instanceof Uint8Array
+            ? contentArray
+            : new Uint8Array(contentArray);
+    }
+    static decryptPackage(encrypted, key, info) {
+        // Read the package size from the first 8 bytes
+        const sizeView = new DataView(encrypted.buffer, encrypted.byteOffset, 8);
+        const packageSize = Number(sizeView.getBigUint64(0, true));
+        // Skip the first 8 bytes (package size) to get encrypted data
+        const encryptedData = encrypted.slice(8);
+        // MS-OFFCRYPTO uses segmented decryption with 4096-byte blocks
+        const SEGMENT_LENGTH = 4096;
+        const totalSegments = Math.ceil(encryptedData.length / SEGMENT_LENGTH);
+        const decryptedSegments = [];
+        for (let i = 0; i < totalSegments; i++) {
+            const start = i * SEGMENT_LENGTH;
+            const end = Math.min(start + SEGMENT_LENGTH, encryptedData.length);
+            const segment = encryptedData.slice(start, end);
+            // Generate IV for this segment: hash(packageSalt + block number)
+            // Use packageSalt from keyData, NOT passwordSalt from encryptedKey
+            const blockNumber = new Uint8Array(4);
+            new DataView(blockNumber.buffer).setUint32(0, i, true);
+            const ivInput = this.concatArrays(info.packageSalt, blockNumber);
+            const ivHash = this.hash(ivInput, info.hashAlgorithm);
+            const iv = ivHash.slice(0, 16); // Use first 16 bytes as IV
+            // Decrypt this segment
+            const decryptedSegment = this.decryptAESNoPadding(segment, key, iv);
+            decryptedSegments.push(decryptedSegment);
+        }
+        // Concatenate all decrypted segments
+        const totalLength = decryptedSegments.reduce((sum, seg) => sum + seg.length, 0);
+        const allDecrypted = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const seg of decryptedSegments) {
+            allDecrypted.set(seg, offset);
+            offset += seg.length;
+        }
+        // Trim to actual package size (remove padding)
+        const trimmed = allDecrypted.slice(0, packageSize);
+        // Create a proper ArrayBuffer from the decrypted data
+        const result = new ArrayBuffer(trimmed.byteLength);
+        new Uint8Array(result).set(trimmed);
+        return result;
+    }
+    static decryptAESNoPadding(data, key, iv) {
+        const cipher = cbc(key, iv, { disablePadding: true });
+        return cipher.decrypt(data);
+    }
+    static deriveAgileBlockKey(passwordDerivedKey, blockKey, info) {
+        return this.hash(this.concatArrays(passwordDerivedKey, blockKey), info.hashAlgorithm).slice(0, info.keySize);
+    }
+    static hash(data, algorithm) {
+        switch (algorithm.toUpperCase()) {
+            case "SHA1":
+                return sha1(data);
+            case "SHA256":
+                return sha256(data);
+            case "SHA384":
+                return sha384(data);
+            case "SHA512":
+                return sha512(data);
+            default:
+                throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+        }
+    }
+    static stringToUtf16LE(str) {
+        const bytes = new Uint8Array(str.length * 2);
+        for (let i = 0; i < str.length; i++) {
+            const code = str.charCodeAt(i);
+            bytes[i * 2] = code & 0xff;
+            bytes[i * 2 + 1] = (code >> 8) & 0xff;
+        }
+        return bytes;
+    }
+    static concatArrays(...arrays) {
+        const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const arr of arrays) {
+            result.set(arr, offset);
+            offset += arr.length;
+        }
+        return result;
+    }
+}

package/dist/esm/excel-parser/cfb-encryptor.d.ts

@@ -0,0 +1,23 @@
+type EncryptOptions = {
+    spinCount?: number;
+};
+export declare class CFBEncryptor {
+    static encrypt(source: ArrayBuffer | Uint8Array, password: string, options?: EncryptOptions): Promise<Uint8Array>;
+    private static buildEncryptionInfoStream;
+    private static buildEncryptedPackageStream;
+    private static encryptPackage;
+    private static buildEncryptionXml;
+    private static derivePasswordKey;
+    private static deriveAgileBlockKey;
+    private static encryptDataIntegrityValue;
+    private static encryptAESNoPadding;
+    private static sha512Hash;
+    private static hmacSha512;
+    private static toBase64;
+    private static padToBlockSize;
+    private static stringToUtf16LE;
+    private static concatArrays;
+    private static randomBytes;
+}
+export {};
+//# sourceMappingURL=cfb-encryptor.d.ts.map

package/dist/esm/excel-parser/cfb-encryptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cfb-encryptor.d.ts","sourceRoot":"","sources":["../../../excel-parser/cfb-encryptor.ts"],"names":[],"mappings":"AAMA,KAAK,cAAc,GAAG;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAwBF,qBAAa,YAAY;WACV,OAAO,CAClB,MAAM,EAAE,WAAW,GAAG,UAAU,EAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,UAAU,CAAC;IA4FtB,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAWxC,OAAO,CAAC,MAAM,CAAC,2BAA2B;IAW1C,OAAO,CAAC,MAAM,CAAC,cAAc;IA0B7B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IA6CjC,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAehC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAUlC,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAiBxC,OAAO,CAAC,MAAM,CAAC,mBAAmB;IASlC,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB,OAAO,CAAC,MAAM,CAAC,QAAQ;IAQvB,OAAO,CAAC,MAAM,CAAC,cAAc;IAW7B,OAAO,CAAC,MAAM,CAAC,eAAe;IAU9B,OAAO,CAAC,MAAM,CAAC,YAAY;IAW3B,OAAO,CAAC,MAAM,CAAC,WAAW;CAc3B"}