@syncfusion/ej2-office-common 35.1.37

package/src/encryption/encryption-info-xml.js

@@ -0,0 +1,282 @@
+/*
+ * Minimal attribute-oriented XML element parser for OFFCRYPTO EncryptionInfo.
+ *
+ * @remarks
+ * EncryptionInfo XML is a small attribute-heavy tree (encryption / keyData /
+ * dataIntegrity / keyEncryptors). This parser intentionally does **not** pull a
+ * full OOXML DOM. It supports nested elements, attributes, default namespaces,
+ * and rejects DOCTYPE / entity expansion.
+ *
+ * @private
+ */
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { EncryptedPackageError, PackageLimitError, } from './errors';
+var DEFAULT_XML_NESTING = 256;
+var DEFAULT_XML_ATTRS = 4096;
+var DEFAULT_TEXT_NODE = 32 * 1024 * 1024;
+/**
+ * Parses EncryptionInfo UTF-8 XML into a single root element tree.
+ *
+ * @throws {EncryptedPackageError} Malformed XML.
+ * @throws {PackageLimitError} Nesting / attribute / text limits.
+ */
+export function parseEncryptionInfoXml(xmlText, limits, partName) {
+    if (partName === void 0) { partName = 'EncryptionInfo'; }
+    if (/<!DOCTYPE/i.test(xmlText) || /<!ENTITY/i.test(xmlText)) {
+        throw new EncryptedPackageError('EncryptionInfo XML must not contain DTD or entities');
+    }
+    var maxDepth = (limits.xmlNestingDepth != null ? limits.xmlNestingDepth : DEFAULT_XML_NESTING);
+    var maxAttrs = (limits.xmlAttributesPerElement != null ? limits.xmlAttributesPerElement : DEFAULT_XML_ATTRS);
+    var maxText = (limits.textNodeLengthBytes != null ? limits.textNodeLengthBytes : DEFAULT_TEXT_NODE);
+    var i = 0;
+    var length = xmlText.length;
+    var skipWs = function () {
+        while (i < length) {
+            var c = xmlText.charCodeAt(i);
+            if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) {
+                i += 1;
+            }
+            else {
+                break;
+            }
+        }
+    };
+    var peek = function () { return (i < length ? xmlText[i] : ''); };
+    var startsWith = function (s) { return xmlText.startsWith(s, i); };
+    var readName = function () {
+        var start = i;
+        while (i < length) {
+            var c = xmlText[i];
+            if (/[A-Za-z0-9:_.-]/.test(c)) {
+                i += 1;
+            }
+            else {
+                break;
+            }
+        }
+        if (i === start) {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: expected name');
+        }
+        return xmlText.slice(start, i);
+    };
+    var decodeEntities = function (raw) {
+        return raw
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&apos;/g, "'")
+            .replace(/&amp;/g, '&');
+    };
+    var readAttrValue = function () {
+        var quote = peek();
+        if (quote !== '"' && quote !== "'") {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: attribute value');
+        }
+        i += 1;
+        var start = i;
+        while (i < length && xmlText[i] !== quote) {
+            i += 1;
+            if (i - start > maxText) {
+                throw new PackageLimitError('textNodeLengthBytes', { partName: partName, actual: i - start });
+            }
+        }
+        if (i >= length) {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed attribute');
+        }
+        var value = xmlText.slice(start, i);
+        i += 1; // closing quote
+        return decodeEntities(value);
+    };
+    var resolveQName = function (qName, nsStack, isAttr) {
+        var colon = qName.indexOf(':');
+        var prefix = colon === -1 ? '' : qName.slice(0, colon);
+        var localName = colon === -1 ? qName : qName.slice(colon + 1);
+        if (isAttr && prefix === '') {
+            return { localName: localName, namespaceUri: '' };
+        }
+        if (prefix === 'xmlns') {
+            return { localName: localName, namespaceUri: 'http://www.w3.org/2000/xmlns/' };
+        }
+        for (var s = nsStack.length - 1; s >= 0; s--) {
+            var uri = nsStack[s].get(prefix);
+            if (uri !== undefined) {
+                return { localName: localName, namespaceUri: uri };
+            }
+        }
+        return { localName: localName, namespaceUri: '' };
+    };
+    var parseElement = function (nsStack, depth) {
+        if (depth > maxDepth) {
+            throw new PackageLimitError('xmlNestingDepth', { partName: partName, actual: depth });
+        }
+        if (peek() !== '<') {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: expected element');
+        }
+        i += 1; // <
+        if (peek() === '/') {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: unexpected end tag');
+        }
+        // Skip processing instructions / comments / XML declaration at this level via caller.
+        var rawName = readName();
+        skipWs();
+        var pendingAttrs = [];
+        var selfClosing = false;
+        var localNs = new Map();
+        while (i < length && peek() !== '>' && peek() !== '/') {
+            var attrName = readName();
+            skipWs();
+            if (peek() !== '=') {
+                throw new EncryptedPackageError('EncryptionInfo XML is invalid: expected =');
+            }
+            i += 1;
+            skipWs();
+            var attrValue = readAttrValue();
+            skipWs();
+            if (attrName === 'xmlns') {
+                localNs.set('', attrValue);
+            }
+            else if (attrName.startsWith('xmlns:')) {
+                localNs.set(attrName.slice(6), attrValue);
+            }
+            else {
+                pendingAttrs.push({ qName: attrName, value: attrValue });
+            }
+            if (pendingAttrs.length > maxAttrs) {
+                throw new PackageLimitError('xmlAttributesPerElement', {
+                    partName: partName,
+                    actual: pendingAttrs.length,
+                });
+            }
+        }
+        if (startsWith('/>')) {
+            selfClosing = true;
+            i += 2;
+        }
+        else if (peek() === '>') {
+            i += 1;
+        }
+        else {
+            throw new EncryptedPackageError('EncryptionInfo XML is invalid: element tag');
+        }
+        var childNsStack = __spread(nsStack, [localNs]);
+        var nameResolved = resolveQName(rawName, childNsStack, false);
+        var attributes = pendingAttrs.map(function (a) {
+            var r = resolveQName(a.qName, childNsStack, true);
+            return { localName: r.localName, namespaceUri: r.namespaceUri, value: a.value };
+        });
+        if (selfClosing) {
+            return { kind: 'element',
+                localName: nameResolved.localName,
+                namespaceUri: nameResolved.namespaceUri,
+                attributes: attributes,
+                children: [],
+            };
+        }
+        var children = [];
+        for (;;) {
+            skipWs();
+            if (i >= length) {
+                throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed element');
+            }
+            if (startsWith('</')) {
+                i += 2;
+                var endName = readName();
+                skipWs();
+                if (peek() !== '>') {
+                    throw new EncryptedPackageError('EncryptionInfo XML is invalid: end tag');
+                }
+                i += 1;
+                if (endName !== rawName) {
+                    throw new EncryptedPackageError("EncryptionInfo XML is invalid: mismatched end tag " + endName);
+                }
+                break;
+            }
+            if (startsWith('<!--')) {
+                var end = xmlText.indexOf('-->', i + 4);
+                if (end < 0) {
+                    throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed comment');
+                }
+                i = end + 3;
+                continue;
+            }
+            if (startsWith('<?')) {
+                var end = xmlText.indexOf('?>', i + 2);
+                if (end < 0) {
+                    throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed PI');
+                }
+                i = end + 2;
+                continue;
+            }
+            if (peek() === '<') {
+                children.push(parseElement(childNsStack, depth + 1));
+                continue;
+            }
+            // Text node — EncryptionInfo does not need text content; skip with limit.
+            var textStart = i;
+            while (i < length && peek() !== '<') {
+                i += 1;
+                if (i - textStart > maxText) {
+                    throw new PackageLimitError('textNodeLengthBytes', {
+                        partName: partName,
+                        actual: i - textStart,
+                    });
+                }
+            }
+        }
+        return { kind: 'element',
+            localName: nameResolved.localName,
+            namespaceUri: nameResolved.namespaceUri,
+            attributes: attributes,
+            children: children,
+        };
+    };
+    // Skip BOM / XML declaration / leading comments.
+    skipWs();
+    if (startsWith('\uFEFF')) {
+        i += 1;
+        skipWs();
+    }
+    while (startsWith('<?') || startsWith('<!--')) {
+        if (startsWith('<?')) {
+            var end = xmlText.indexOf('?>', i + 2);
+            if (end < 0) {
+                throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed declaration');
+            }
+            i = end + 2;
+        }
+        else {
+            var end = xmlText.indexOf('-->', i + 4);
+            if (end < 0) {
+                throw new EncryptedPackageError('EncryptionInfo XML is invalid: unclosed comment');
+            }
+            i = end + 3;
+        }
+        skipWs();
+    }
+    var root = parseElement([new Map()], 1);
+    skipWs();
+    if (i < length) {
+        // Allow trailing whitespace only (already skipped); anything else is junk.
+        throw new EncryptedPackageError('EncryptionInfo XML is invalid: trailing content');
+    }
+    return root;
+}

package/src/encryption/errors.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Encryption-related error types shared across Office libraries.
+ *
+ * @remarks
+ * Messages must never include the consumer password or key material.
+ * Citation: [MS-OFFCRYPTO] §1.3.3.4, §2.3.4.4–§2.3.4.15.
+ */
+/**
+ * Shared fields for limit-breach errors.
+ */
+export interface SecurityErrorOptions {
+    /** Package part that triggered the failure, when known. */
+    readonly partName?: string;
+    /** Observed value that exceeded the configured limit, when known. */
+    readonly actual?: number;
+}
+/**
+ * Decrypt-relevant numeric guards (subset of broader package security limits).
+ */
+export interface DecryptSecurityLimits {
+    /** Maximum sum of uncompressed part bytes across the package. */
+    readonly totalUncompressedBytes: number;
+    /** Maximum uncompressed size of any single part / decrypted stream. */
+    readonly singlePartUncompressedBytes: number;
+    /** Maximum element nesting depth during EncryptionInfo XML parse. */
+    readonly xmlNestingDepth?: number;
+    /** Maximum attribute count on a single EncryptionInfo XML element. */
+    readonly xmlAttributesPerElement?: number;
+    /** Maximum length in bytes of a single EncryptionInfo XML text node. */
+    readonly textNodeLengthBytes?: number;
+}
+/**
+ * Default decrypt limits aligned with typical Office package security defaults.
+ */
+export declare const DEFAULT_DECRYPT_SECURITY_LIMITS: DecryptSecurityLimits;
+/**
+ * Builds effective decrypt limits from optional caller overrides.
+ */
+export declare function resolveDecryptLimits(overrides?: Partial<DecryptSecurityLimits>): DecryptSecurityLimits;
+export declare class PackageLimitError extends Error {
+    /** Name of the limit field that was exceeded. */
+    readonly limit: keyof DecryptSecurityLimits | string;
+    /** Offending part name when applicable. */
+    readonly partName: string | undefined;
+    /** Observed value when known. */
+    readonly actual: number | undefined;
+    constructor(limit: keyof DecryptSecurityLimits | string, options?: SecurityErrorOptions);
+}
+/**
+ * Raised when the package is encrypted and cannot be opened as supplied.
+ */
+export declare class EncryptedPackageError extends Error {
+    constructor(message: string);
+}
+/**
+ * Raised when a consumer-supplied password fails OFFCRYPTO verification.
+ */
+export declare class InvalidPasswordError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Raised when the package uses a recognized encryption method this build does not decrypt.
+ */
+export declare class UnsupportedEncryptionError extends Error {
+    constructor(message?: string);
+}

package/src/encryption/errors.js

@@ -0,0 +1,124 @@
+/**
+ * Encryption-related error types shared across Office libraries.
+ *
+ * @remarks
+ * Messages must never include the consumer password or key material.
+ * Citation: [MS-OFFCRYPTO] §1.3.3.4, §2.3.4.4–§2.3.4.15.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var ONE_KIB = 1024;
+var ONE_MIB = ONE_KIB * 1024;
+var ONE_GIB = ONE_MIB * 1024;
+/**
+ * Default decrypt limits aligned with typical Office package security defaults.
+ */
+export var DEFAULT_DECRYPT_SECURITY_LIMITS = Object.freeze({
+    totalUncompressedBytes: 1 * ONE_GIB,
+    singlePartUncompressedBytes: 256 * ONE_MIB,
+    xmlNestingDepth: 256,
+    xmlAttributesPerElement: 4096,
+    textNodeLengthBytes: 32 * ONE_MIB,
+});
+/**
+ * Builds effective decrypt limits from optional caller overrides.
+ */
+export function resolveDecryptLimits(overrides) {
+    if (overrides === undefined) {
+        return DEFAULT_DECRYPT_SECURITY_LIMITS;
+    }
+    var xmlNestingDepth = (overrides.xmlNestingDepth != null ? overrides.xmlNestingDepth : DEFAULT_DECRYPT_SECURITY_LIMITS.xmlNestingDepth);
+    var xmlAttributesPerElement = (overrides.xmlAttributesPerElement != null ? overrides.xmlAttributesPerElement : DEFAULT_DECRYPT_SECURITY_LIMITS.xmlAttributesPerElement);
+    var textNodeLengthBytes = (overrides.textNodeLengthBytes != null ? overrides.textNodeLengthBytes : DEFAULT_DECRYPT_SECURITY_LIMITS.textNodeLengthBytes);
+    var resolved = __assign({ totalUncompressedBytes: (overrides.totalUncompressedBytes != null ? overrides.totalUncompressedBytes : DEFAULT_DECRYPT_SECURITY_LIMITS.totalUncompressedBytes), singlePartUncompressedBytes: (overrides.singlePartUncompressedBytes != null ? overrides.singlePartUncompressedBytes : DEFAULT_DECRYPT_SECURITY_LIMITS.singlePartUncompressedBytes) }, (xmlNestingDepth === undefined ? {} : { xmlNestingDepth: xmlNestingDepth }), (xmlAttributesPerElement === undefined ? {} : { xmlAttributesPerElement: xmlAttributesPerElement }), (textNodeLengthBytes === undefined ? {} : { textNodeLengthBytes: textNodeLengthBytes }));
+    return Object.freeze(resolved);
+}
+var PackageLimitError = /** @class */ (function (_super) {
+    __extends(PackageLimitError, _super);
+    function PackageLimitError(limit, options) {
+        var _newTarget = this.constructor;
+        if (options === void 0) { options = {}; }
+        var _this = this;
+        var partSuffix = options.partName === undefined ? '' : " (part: " + options.partName + ")";
+        var actualSuffix = options.actual === undefined ? '' : "; actual value: " + String(options.actual);
+        _this = _super.call(this, "Package security limit exceeded: " + limit + partSuffix + actualSuffix) || this;
+        _this.name = 'PackageLimitError';
+        _this.limit = limit;
+        _this.partName = options.partName;
+        _this.actual = options.actual;
+        // ES5 / AMD emit: restore prototype so `instanceof` works in browsers.
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return PackageLimitError;
+}(Error));
+export { PackageLimitError };
+/**
+ * Raised when the package is encrypted and cannot be opened as supplied.
+ */
+var EncryptedPackageError = /** @class */ (function (_super) {
+    __extends(EncryptedPackageError, _super);
+    function EncryptedPackageError(message) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, message) || this;
+        _this.name = 'EncryptedPackageError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return EncryptedPackageError;
+}(Error));
+export { EncryptedPackageError };
+/**
+ * Raised when a consumer-supplied password fails OFFCRYPTO verification.
+ */
+var InvalidPasswordError = /** @class */ (function (_super) {
+    __extends(InvalidPasswordError, _super);
+    function InvalidPasswordError(message) {
+        var _newTarget = this.constructor;
+        if (message === void 0) { message = 'Invalid password'; }
+        var _this = _super.call(this, message) || this;
+        _this.name = 'InvalidPasswordError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return InvalidPasswordError;
+}(Error));
+export { InvalidPasswordError };
+/**
+ * Raised when the package uses a recognized encryption method this build does not decrypt.
+ */
+var UnsupportedEncryptionError = /** @class */ (function (_super) {
+    __extends(UnsupportedEncryptionError, _super);
+    function UnsupportedEncryptionError(message) {
+        var _newTarget = this.constructor;
+        if (message === void 0) { message = 'Unsupported encryption method'; }
+        var _this = _super.call(this, message) || this;
+        _this.name = 'UnsupportedEncryptionError';
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return UnsupportedEncryptionError;
+}(Error));
+export { UnsupportedEncryptionError };

package/src/encryption/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared OFFCRYPTO Agile password decrypt for Office Open XML packages.
+ *
+ * @remarks
+ * Implements [MS-OFFCRYPTO] Agile EncryptionInfo (4.4) + password keyEncryptor
+ * + AES-CBC EncryptedPackage segment decrypt. Consumed by PowerPoint and other
+ * Office libraries via `@syncfusion/ej2-office-common`.
+ *
+ * @packageDocumentation
+ */
+import { DecryptSecurityLimits } from './errors';
+/**
+ * Returns whether `input` begins with the OLE compound-file signature used by
+ * ECMA-376 OFFCRYPTO packages.
+ *
+ * @param input - Entire package bytes.
+ * @returns `true` when the CFB signature matches.
+ *
+ * @public
+ */
+export declare function isOffCryptoPackage(input: Uint8Array | ArrayBuffer): boolean;
+/**
+ * Decrypts an OFFCRYPTO OLE CFB package to OPC ZIP bytes.
+ *
+ * @param input - Entire encrypted package bytes (CFB).
+ * @param password - Consumer password (never logged; not retained).
+ * @param limits - Decrypt size / XML guards (duck-types broader SecurityLimits).
+ * @returns Decrypted OPC package bytes.
+ *
+ * @public
+ */
+export declare function decryptOffCryptoPackage(input: Uint8Array, password: string, limits?: DecryptSecurityLimits): Promise<Uint8Array>;
+export { DEFAULT_DECRYPT_SECURITY_LIMITS, EncryptedPackageError, InvalidPasswordError, PackageLimitError, resolveDecryptLimits, UnsupportedEncryptionError, DecryptSecurityLimits, SecurityErrorOptions, } from './errors';
+export { AGILE_ENCRYPTION_NS, AGILE_RESERVED, AGILE_VERSION_MAJOR, AGILE_VERSION_MINOR, BLOCK_KEY_ENCRYPTOR_KEY, BLOCK_KEY_HMAC_KEY, BLOCK_KEY_HMAC_VALUE, BLOCK_KEY_VERIFIER_HASH, BLOCK_KEY_VERIFIER_INPUT, ENCRYPTED_PACKAGE_SEGMENT_SIZE, PASSWORD_KEY_ENCRYPTOR_NS, PASSWORD_KEY_ENCRYPTOR_URI, STREAM_ENCRYPTED_PACKAGE, STREAM_ENCRYPTION_INFO, } from './agile-constants';
+export { aesCbcDecrypt, aesCbcEncrypt, concatBytes, deriveAgileIv, deriveAgileKey, encodePasswordUtf16Le, hashBytes, hashDigestLength, hmacBytes, timingSafeEqual, AgileHashName, } from './crypto-primitives';

package/src/encryption/index.js

@@ -0,0 +1,100 @@
+/**
+ * Shared OFFCRYPTO Agile password decrypt for Office Open XML packages.
+ *
+ * @remarks
+ * Implements [MS-OFFCRYPTO] Agile EncryptionInfo (4.4) + password keyEncryptor
+ * + AES-CBC EncryptedPackage segment decrypt. Consumed by PowerPoint and other
+ * Office libraries via `@syncfusion/ej2-office-common`.
+ *
+ * @packageDocumentation
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { parseAgileEncryptionInfo } from './agile-encryption-info';
+import { unlockIntermediateKey } from './agile-password';
+import { readOffCryptoStreams } from './cfb-reader';
+import { decryptEncryptedPackageStream } from './decrypt-encrypted-package';
+import { DEFAULT_DECRYPT_SECURITY_LIMITS, resolveDecryptLimits, } from './errors';
+/** OLE CFB header signature used by ECMA-376 OFFCRYPTO packages ([MS-CFB]). */
+var OLE_CFB_SIGNATURE = Object.freeze([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]);
+/**
+ * Returns whether `input` begins with the OLE compound-file signature used by
+ * ECMA-376 OFFCRYPTO packages.
+ *
+ * @param input - Entire package bytes.
+ * @returns `true` when the CFB signature matches.
+ *
+ * @public
+ */
+export function isOffCryptoPackage(input) {
+    var bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+    if (bytes.byteLength < OLE_CFB_SIGNATURE.length) {
+        return false;
+    }
+    for (var i = 0; i < OLE_CFB_SIGNATURE.length; i++) {
+        if (bytes[i] !== OLE_CFB_SIGNATURE[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Decrypts an OFFCRYPTO OLE CFB package to OPC ZIP bytes.
+ *
+ * @param input - Entire encrypted package bytes (CFB).
+ * @param password - Consumer password (never logged; not retained).
+ * @param limits - Decrypt size / XML guards (duck-types broader SecurityLimits).
+ * @returns Decrypted OPC package bytes.
+ *
+ * @public
+ */
+export function decryptOffCryptoPackage(input, password, limits) {
+    if (limits === void 0) { limits = DEFAULT_DECRYPT_SECURITY_LIMITS; }
+    return __awaiter(this, void 0, void 0, function () {
+        var resolved, streams, info, secretKey;
+        return __generator(this, function (_a) {
+            resolved = resolveDecryptLimits(limits);
+            streams = readOffCryptoStreams(input);
+            info = parseAgileEncryptionInfo(streams.encryptionInfo, resolved);
+            secretKey = unlockIntermediateKey(password, info.passwordKeyEncryptor);
+            return [2 /*return*/, decryptEncryptedPackageStream(streams.encryptedPackage, secretKey, info.keyData, info.dataIntegrity, resolved)];
+        });
+    });
+}
+export { DEFAULT_DECRYPT_SECURITY_LIMITS, EncryptedPackageError, InvalidPasswordError, PackageLimitError, resolveDecryptLimits, UnsupportedEncryptionError, } from './errors';
+// Re-export internals needed by test fixtures / host encrypt harnesses.
+export { AGILE_ENCRYPTION_NS, AGILE_RESERVED, AGILE_VERSION_MAJOR, AGILE_VERSION_MINOR, BLOCK_KEY_ENCRYPTOR_KEY, BLOCK_KEY_HMAC_KEY, BLOCK_KEY_HMAC_VALUE, BLOCK_KEY_VERIFIER_HASH, BLOCK_KEY_VERIFIER_INPUT, ENCRYPTED_PACKAGE_SEGMENT_SIZE, PASSWORD_KEY_ENCRYPTOR_NS, PASSWORD_KEY_ENCRYPTOR_URI, STREAM_ENCRYPTED_PACKAGE, STREAM_ENCRYPTION_INFO, } from './agile-constants';
+export { aesCbcDecrypt, aesCbcEncrypt, concatBytes, deriveAgileIv, deriveAgileKey, encodePasswordUtf16Le, hashBytes, hashDigestLength, hmacBytes, timingSafeEqual, } from './crypto-primitives';