@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/core/zip/read.js

@@ -0,0 +1,262 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { PackageError, SecurityError } from '../errors/docx-error';
+import { resolveResourceLimits } from '../security/limits';
+import { crc32 } from './crc32';
+import { inflateRaw } from './deflate';
+import { assertSafeZipItemName } from './names';
+var SIG_EOCD = 0x06054b50;
+var SIG_CFH = 0x02014b50;
+var SIG_LFH = 0x04034b50;
+var METHOD_STORE = 0;
+var METHOD_DEFLATE = 8;
+var FLAG_ENCRYPTED = 0x0001;
+var FLAG_UTF8 = 0x0800;
+var OLE_MAGIC = Uint8Array.of(0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1);
+/** Word binary FIB identifier (`wIdent`) per [MS-DOC] §2.5.1. */
+var WORD_FIB_WIDENT = 0xa5ec;
+function isOleCompound(bytes) {
+    if (bytes.length < OLE_MAGIC.length) {
+        return false;
+    }
+    for (var i = 0; i < OLE_MAGIC.length; i += 1) {
+        if (bytes[i] !== OLE_MAGIC[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * UTF-16LE directory/stream name scan (null-terminated CFB names).
+ * Used only to classify unsupported OLE containers — not a full CFB parser.
+ */
+function containsUtf16LeAsciiName(bytes, asciiName) {
+    if (bytes.length < asciiName.length * 2) {
+        return false;
+    }
+    outer: for (var i = 0; i <= bytes.length - asciiName.length * 2; i += 1) {
+        for (var j = 0; j < asciiName.length; j += 1) {
+            var lo = bytes[i + j * 2];
+            var hi = bytes[i + j * 2 + 1];
+            if (lo !== asciiName.charCodeAt(j) || hi !== 0) {
+                continue outer;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * True when a Word binary File Information Block (`wIdent` = 0xA5EC) appears
+ * at a typical CFB sector start (offset 512) or immediately after the header.
+ * [MS-DOC] §2.5.1 FibBase; [MS-CFB] sector 0 layout.
+ */
+function hasWordBinaryFib(bytes) {
+    var e_1, _a;
+    var candidates = [512, OLE_MAGIC.length];
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var offset = candidates_1_1.value;
+            if (bytes.length < offset + 2) {
+                continue;
+            }
+            var view = new DataView(bytes.buffer, bytes.byteOffset + offset, 2);
+            if (view.getUint16(0, true) === WORD_FIB_WIDENT) {
+                return true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return false;
+}
+/**
+ * OLE compound files are never OPC ZIP. Distinguish common Office containers:
+ * - legacy binary Word ([MS-DOC] `WordDocument` stream / FIB) → invalid-zip
+ * - OFFCRYPTO encrypted package streams → encrypted
+ * - other OLE → invalid-zip (unsupported container)
+ *
+ * Product scope excludes DOC binary load and OFFCRYPTO decrypt
+ * (`docs/requirements/000-product-scope.md`, `opc-package.md`).
+ */
+function rejectOleCompound(bytes) {
+    var hasWordDocumentStream = containsUtf16LeAsciiName(bytes, 'WordDocument');
+    var hasWordFib = hasWordBinaryFib(bytes);
+    var hasEncryptedPackage = containsUtf16LeAsciiName(bytes, 'EncryptedPackage');
+    var hasEncryptionInfo = containsUtf16LeAsciiName(bytes, 'EncryptionInfo');
+    if ((hasWordDocumentStream || hasWordFib) && !hasEncryptedPackage && !hasEncryptionInfo) {
+        throw new PackageError('package/invalid-zip', 'Input is a legacy binary Word document (OLE compound / .doc), not an OPC ZIP (.docx). Binary DOC is out of scope.');
+    }
+    if (hasEncryptedPackage || hasEncryptionInfo) {
+        throw new PackageError('package/encrypted', 'Input is an encrypted Office package (OLE compound / [MS-OFFCRYPTO]), not an OPC ZIP');
+    }
+    throw new PackageError('package/invalid-zip', 'Input is an OLE compound file, not an OPC ZIP (.docx)');
+}
+function findEocdOffset(view) {
+    var length = view.byteLength;
+    if (length < 22) {
+        throw new PackageError('package/invalid-zip', 'Buffer is too small to be a ZIP archive');
+    }
+    var minStart = Math.max(0, length - 22 - 65535);
+    for (var i = length - 22; i >= minStart; i -= 1) {
+        if (view.getUint32(i, true) !== SIG_EOCD) {
+            continue;
+        }
+        var commentLength = view.getUint16(i + 20, true);
+        if (i + 22 + commentLength === length) {
+            return i;
+        }
+    }
+    throw new PackageError('package/invalid-zip', 'ZIP end-of-central-directory signature not found');
+}
+function decodeItemName(bytes, utf8) {
+    return new TextDecoder(utf8 ? 'utf-8' : 'latin1').decode(bytes);
+}
+function readSlice(bytes, start, size, what) {
+    var end = start + size;
+    if (start < 0 || end > bytes.length) {
+        throw new PackageError('package/invalid-zip', "Truncated ZIP " + what);
+    }
+    return bytes.subarray(start, end);
+}
+function inflateEntry(compressed, method, limits, remainingTotal, name) {
+    var maxOutput = Math.min(limits.singlePartUncompressedSize, remainingTotal, compressed.length === 0
+        ? limits.singlePartUncompressedSize
+        : compressed.length * limits.compressionRatio);
+    if (maxOutput <= 0) {
+        throw new SecurityError('security/total-uncompressed', "Total uncompressed size limit hit at " + name);
+    }
+    if (method === METHOD_STORE) {
+        if (compressed.length > limits.singlePartUncompressedSize) {
+            throw new SecurityError('security/part-size', "Uncompressed entry " + name + " exceeds the single-part limit");
+        }
+        if (compressed.length > remainingTotal) {
+            throw new SecurityError('security/total-uncompressed', "Total uncompressed size limit hit at " + name);
+        }
+        return compressed.slice();
+    }
+    if (method !== METHOD_DEFLATE) {
+        throw new PackageError('package/invalid-zip', "ZIP item " + name + " uses compression method " + String(method) + "; OPC allows only STORE and DEFLATE (ECMA-376-2 \u00A77.3.6)");
+    }
+    try {
+        var inflated = inflateRaw(compressed, maxOutput);
+        if (inflated.length > limits.singlePartUncompressedSize) {
+            throw new SecurityError('security/part-size', "Uncompressed entry " + name + " exceeds the single-part limit");
+        }
+        if (compressed.length > 0 && inflated.length / compressed.length > limits.compressionRatio) {
+            throw new SecurityError('security/zip-bomb', "Inflate ratio exceeded for " + name);
+        }
+        return inflated;
+    }
+    catch (cause) {
+        if (cause instanceof SecurityError || cause instanceof PackageError) {
+            throw cause;
+        }
+        if (cause instanceof RangeError) {
+            // zlib hit the maxOutputLength cap we passed. Name the limit that bound
+            // it, so a legitimately huge document is not misreported as a bomb.
+            if (maxOutput === remainingTotal && remainingTotal < limits.singlePartUncompressedSize) {
+                throw new SecurityError('security/total-uncompressed', "Total uncompressed size limit hit at " + name, { cause: cause });
+            }
+            if (maxOutput === compressed.length * limits.compressionRatio) {
+                throw new SecurityError('security/zip-bomb', "Inflate ratio exceeded for " + name, { cause: cause });
+            }
+            throw new SecurityError('security/part-size', "Uncompressed entry " + name + " exceeds the single-part limit " +
+                "(raise ResourceLimits.singlePartUncompressedSize to load large documents)", { cause: cause });
+        }
+        throw new PackageError('package/invalid-zip', "DEFLATE stream is invalid for " + name, { cause: cause });
+    }
+}
+/**
+ * Reads a ZIP archive entirely in memory. Does not write to the filesystem.
+ * ZIP item names are those stored in the archive (ECMA-376-2 §7.3.3), not OPC
+ * logical part names (no leading slash in the ZIP item).
+ */
+export function readZip(bytes, limitOverrides) {
+    var limits = resolveResourceLimits(limitOverrides);
+    if (isOleCompound(bytes)) {
+        rejectOleCompound(bytes);
+    }
+    var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    var eocd = findEocdOffset(view);
+    var diskNumber = view.getUint16(eocd + 4, true);
+    var cdDisk = view.getUint16(eocd + 6, true);
+    var entriesOnDisk = view.getUint16(eocd + 8, true);
+    var totalEntries = view.getUint16(eocd + 10, true);
+    var cdSize = view.getUint32(eocd + 12, true);
+    var cdOffset = view.getUint32(eocd + 16, true);
+    if (diskNumber !== 0 || cdDisk !== 0 || entriesOnDisk !== totalEntries) {
+        throw new PackageError('package/invalid-zip', 'Multi-disk ZIP archives are not supported');
+    }
+    if (totalEntries === 0xffff || cdOffset === 0xffffffff || cdSize === 0xffffffff) {
+        throw new PackageError('package/invalid-zip', 'ZIP64 archives are not supported in this ZIP reader');
+    }
+    if (totalEntries > limits.entryCount) {
+        throw new SecurityError('security/entry-count', "ZIP entry count " + String(totalEntries) + " exceeds the limit");
+    }
+    if (cdOffset + cdSize > bytes.length) {
+        throw new PackageError('package/invalid-zip', 'Central directory is truncated');
+    }
+    var namesSeen = new Map();
+    var entries = [];
+    var cursor = cdOffset;
+    var totalUncompressed = 0;
+    for (var n = 0; n < totalEntries; n += 1) {
+        if (view.getUint32(cursor, true) !== SIG_CFH) {
+            throw new PackageError('package/invalid-zip', 'Central directory file header signature missing');
+        }
+        var flags = view.getUint16(cursor + 8, true);
+        var method = view.getUint16(cursor + 10, true);
+        var crcExpected = view.getUint32(cursor + 16, true);
+        var compressedSize = view.getUint32(cursor + 20, true);
+        view.getUint32(cursor + 24, true);
+        var nameLength = view.getUint16(cursor + 28, true);
+        var extraLength = view.getUint16(cursor + 30, true);
+        var commentLength = view.getUint16(cursor + 32, true);
+        var localHeaderOffset = view.getUint32(cursor + 42, true);
+        var nameBytes = readSlice(bytes, cursor + 46, nameLength, 'item name');
+        var name_1 = decodeItemName(nameBytes, (flags & FLAG_UTF8) !== 0);
+        cursor += 46 + nameLength + extraLength + commentLength;
+        if ((flags & FLAG_ENCRYPTED) !== 0) {
+            throw new PackageError('package/encrypted', "ZIP item " + name_1 + " is encrypted; OPC ZIP encryption is forbidden (ECMA-376-2 \u00A77.3.6)");
+        }
+        assertSafeZipItemName(name_1);
+        var lower = name_1.toLowerCase();
+        var previous = namesSeen.get(lower);
+        if (previous !== undefined) {
+            throw new PackageError('package/duplicate-zip-entry', "Duplicate ZIP item name " + name_1 + " (conflicts with " + previous + ")");
+        }
+        namesSeen.set(lower, name_1);
+        if (view.getUint32(localHeaderOffset, true) !== SIG_LFH) {
+            throw new PackageError('package/invalid-zip', "Local file header missing for " + name_1);
+        }
+        var localNameLength = view.getUint16(localHeaderOffset + 26, true);
+        var localExtraLength = view.getUint16(localHeaderOffset + 28, true);
+        var dataStart = localHeaderOffset + 30 + localNameLength + localExtraLength;
+        var compressed = readSlice(bytes, dataStart, compressedSize, "payload for " + name_1);
+        var remaining = limits.totalUncompressedSize - totalUncompressed;
+        var data = inflateEntry(compressed, method, limits, remaining, name_1);
+        if (crc32(data) !== crcExpected) {
+            throw new PackageError('package/invalid-zip', "CRC-32 mismatch for " + name_1);
+        }
+        totalUncompressed += data.byteLength;
+        if (totalUncompressed > limits.totalUncompressedSize) {
+            throw new SecurityError('security/total-uncompressed', "Total uncompressed size limit hit at " + name_1);
+        }
+        entries.push({ name: name_1, data: data });
+    }
+    return entries;
+}

package/src/core/zip/write.d.ts

@@ -0,0 +1,7 @@
+import { ZipEntry } from './zip-entry';
+/**
+ * Writes a ZIP archive with STORE (method 0) so payload bytes are bit-stable.
+ * Compression method may later change on save as long as inflated bytes match
+ * (docs/specs/opc-package.md). OPC ZIP item names are ASCII (ECMA-376-2 §7.3.3).
+ */
+export declare function writeZip(entries: ReadonlyArray<ZipEntry>): Uint8Array;

package/src/core/zip/write.js

@@ -0,0 +1,189 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+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 { PackageError } from '../errors/docx-error';
+import { crc32 } from './crc32';
+import { assertSafeZipItemName } from './names';
+var SIG_LFH = 0x04034b50;
+var SIG_CFH = 0x02014b50;
+var SIG_EOCD = 0x06054b50;
+var METHOD_STORE = 0;
+var VERSION = 20;
+function concat(parts) {
+    var e_1, _a, e_2, _b;
+    var total = 0;
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            total += part.byteLength;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var out = new Uint8Array(total);
+    var offset = 0;
+    try {
+        for (var parts_2 = __values(parts), parts_2_1 = parts_2.next(); !parts_2_1.done; parts_2_1 = parts_2.next()) {
+            var part = parts_2_1.value;
+            out.set(part, offset);
+            offset += part.byteLength;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (parts_2_1 && !parts_2_1.done && (_b = parts_2.return)) _b.call(parts_2);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return out;
+}
+function u16(value) {
+    var bytes = new Uint8Array(2);
+    new DataView(bytes.buffer).setUint16(0, value, true);
+    return bytes;
+}
+function u32(value) {
+    var bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, true);
+    return bytes;
+}
+/**
+ * Writes a ZIP archive with STORE (method 0) so payload bytes are bit-stable.
+ * Compression method may later change on save as long as inflated bytes match
+ * (docs/specs/opc-package.md). OPC ZIP item names are ASCII (ECMA-376-2 §7.3.3).
+ */
+export function writeZip(entries) {
+    var e_3, _a, e_4, _b;
+    var encoder = new TextEncoder();
+    var seen = new Map();
+    var prepared = [];
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            assertSafeZipItemName(entry.name);
+            if (!/^[\u0020-\u007e]+$/.test(entry.name)) {
+                throw new PackageError('package/invalid-part-name', "ZIP item name is not ASCII as required by ECMA-376-2 \u00A77.3.3: " + entry.name);
+            }
+            var lower = entry.name.toLowerCase();
+            var previous = seen.get(lower);
+            if (previous !== undefined) {
+                throw new PackageError('package/duplicate-zip-entry', "Duplicate ZIP item name " + entry.name + " (conflicts with " + previous + ")");
+            }
+            seen.set(lower, entry.name);
+            prepared.push({
+                nameBytes: encoder.encode(entry.name),
+                name: entry.name,
+                data: entry.data,
+                crc: crc32(entry.data),
+            });
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (prepared.length > 0xffff) {
+        throw new PackageError('package/invalid-zip', 'Too many ZIP entries to encode in a non-ZIP64 archive');
+    }
+    var localParts = [];
+    var centralParts = [];
+    var offset = 0;
+    try {
+        for (var prepared_1 = __values(prepared), prepared_1_1 = prepared_1.next(); !prepared_1_1.done; prepared_1_1 = prepared_1.next()) {
+            var item = prepared_1_1.value;
+            var local = concat([
+                u32(SIG_LFH),
+                u16(VERSION),
+                u16(0),
+                u16(METHOD_STORE),
+                u16(0),
+                u16(0),
+                u32(item.crc),
+                u32(item.data.byteLength),
+                u32(item.data.byteLength),
+                u16(item.nameBytes.byteLength),
+                u16(0),
+                item.nameBytes,
+                item.data,
+            ]);
+            localParts.push(local);
+            var central = concat([
+                u32(SIG_CFH),
+                u16(VERSION),
+                u16(VERSION),
+                u16(0),
+                u16(METHOD_STORE),
+                u16(0),
+                u16(0),
+                u32(item.crc),
+                u32(item.data.byteLength),
+                u32(item.data.byteLength),
+                u16(item.nameBytes.byteLength),
+                u16(0),
+                u16(0),
+                u16(0),
+                u16(0),
+                u32(0),
+                u32(offset),
+                item.nameBytes,
+            ]);
+            centralParts.push(central);
+            offset += local.byteLength;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (prepared_1_1 && !prepared_1_1.done && (_b = prepared_1.return)) _b.call(prepared_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var centralDirectory = concat(centralParts);
+    var eocd = concat([
+        u32(SIG_EOCD),
+        u16(0),
+        u16(0),
+        u16(prepared.length),
+        u16(prepared.length),
+        u32(centralDirectory.byteLength),
+        u32(offset),
+        u16(0),
+    ]);
+    return concat(__spread(localParts, [centralDirectory, eocd]));
+}

package/src/core/zip/zip-entry.d.ts

@@ -0,0 +1,4 @@
+export interface ZipEntry {
+    readonly name: string;
+    readonly data: Uint8Array;
+}

package/src/features/bibliography/index.d.ts

@@ -0,0 +1,100 @@
+import { WordDocument } from '../document/document';
+import { FeatureMultiPackagePart } from '../document/feature-multi-package-part';
+import { OpcPackage } from '../../core/opc/package';
+import { PartName } from '../../core/opc/part-name';
+/**
+ * @private
+ * Transitional bibliography namespace (ECMA-376-4 §13.2.3). */
+export declare const BIBLIOGRAPHY_NAMESPACE = "http://schemas.openxmlformats.org/officeDocument/2006/bibliography";
+/**
+ * @private
+ * Strict bibliography namespace (ECMA-376-1 §15.2.3). */
+export declare const BIBLIOGRAPHY_STRICT_NAMESPACE = "http://purl.oclc.org/ooxml/officeDocument/bibliography";
+/**
+ * @private
+ * Transitional customXml relationship used by Bibliography parts (ECMA-376-1 §15.2.3). */
+export declare const BIBLIOGRAPHY_CUSTOM_XML_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml";
+/**
+ * @private
+ * Strict customXml relationship used by Bibliography parts. */
+export declare const STRICT_BIBLIOGRAPHY_CUSTOM_XML_RELATIONSHIP_TYPE = "http://purl.oclc.org/ooxml/officeDocument/relationships/customXml";
+/**
+ * @private
+ * Bibliography part content type (ECMA-376-1 §15.2.3). */
+export declare const BIBLIOGRAPHY_CONTENT_TYPE = "application/xml";
+interface BibliographyMetadata {
+    readonly present: boolean;
+    readonly sourceCount: number;
+    readonly styleName: string | undefined;
+    readonly selectedStyle: string | undefined;
+    readonly sourceTags: ReadonlyArray<string>;
+}
+/**
+ * Preserve-only bibliography sources catalog linked from the Main Document via a
+ * `customXml` relationship. Source field content is opaque; style name and tags
+ * are read-only metadata. No source editor or mutation API is provided.
+ *
+ * @private
+ */
+export declare class BibliographyCatalog implements FeatureMultiPackagePart {
+    private readonly metadata;
+    /**
+     * @private
+     */
+    constructor(metadata: BibliographyMetadata);
+    /**
+     * Whether a Bibliography part (`b:Sources` root) was found.
+     *
+     * @public
+     */
+    present(): boolean;
+    /**
+     * Count of `b:Source` children under `b:Sources`.
+     *
+     * @public
+     */
+    sourceCount(): number;
+    /**
+     * `b:Sources/@StyleName`, or `undefined` when absent.
+     *
+     * @public
+     */
+    styleName(): string | undefined;
+    /**
+     * `b:Sources/@SelectedStyle`, or `undefined` when absent.
+     *
+     * @public
+     */
+    selectedStyle(): string | undefined;
+    /**
+     * `b:Source/b:Tag` text values in document order.
+     *
+     * @public
+     */
+    sourceTags(): ReadonlyArray<string>;
+    /**
+     * @private
+     */
+    isDirty(): boolean;
+    /**
+     * @private
+     */
+    applyToPackage(pkg: OpcPackage, mainPartName: PartName): OpcPackage;
+}
+/**
+ * @private
+ * Test hook */
+export declare function resetBibliographyFeatureForTests(): void;
+/**
+ * @private
+ * Register the bibliography detection handler. Idempotent. */
+export declare function registerBibliographyFeature(): void;
+/**
+ * Bibliography catalog for a document. Requires {@link registerBibliographyFeature}.
+ *
+ * @throws DocxError `UNKNOWN_FEATURE` when the module was not registered before load.
+ *
+ * @private
+ */
+export declare function bibliographyFor(document: WordDocument): BibliographyCatalog;
+export {};