@cj-tech-master/excelts 9.1.0 → 9.2.0

package/dist/cjs/modules/pdf/core/encryption.js

@@ -17,7 +17,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initEncryption = initEncryption;
 exports.encryptData = encryptData;
-const crypto_1 = require("./crypto");
+const crypto_1 = require("../../../utils/crypto.js");
+const binary_1 = require("../../../utils/binary.js");
 // =============================================================================
 // Public API
 // =============================================================================
@@ -37,22 +38,22 @@ function initEncryption(options) {
     const oKeySalt = (0, crypto_1.randomBytes)(8);
     // Step 3: Compute U value
     // U hash = SHA-256(userPassword + uValidationSalt)
-    const uHash = (0, crypto_1.sha256)((0, crypto_1.concatArrays)(userPwd, uValidationSalt));
-    const uValue = (0, crypto_1.concatArrays)(uHash, uValidationSalt, uKeySalt);
+    const uHash = (0, crypto_1.sha256)((0, binary_1.concatUint8Arrays)([userPwd, uValidationSalt]));
+    const uValue = (0, binary_1.concatUint8Arrays)([uHash, uValidationSalt, uKeySalt]);
     // Step 4: Compute UE value
     // UE = AES-256-CBC-encrypt(encryptionKey, SHA-256(userPassword + uKeySalt), zeroIV)
     // Actually: the key for encrypting UE is SHA-256(password + key_salt),
     // and we encrypt the file encryption key with it.
-    const ueKey = (0, crypto_1.sha256)((0, crypto_1.concatArrays)(userPwd, uKeySalt));
+    const ueKey = (0, crypto_1.sha256)((0, binary_1.concatUint8Arrays)([userPwd, uKeySalt]));
     const zeroIv = new Uint8Array(16);
     const ueValue = (0, crypto_1.aesCbcEncryptRaw)(encryptionKey, ueKey, zeroIv);
     // Step 5: Compute O value
     // O hash = SHA-256(ownerPassword + oValidationSalt + U(0..47))
-    const oHash = (0, crypto_1.sha256)((0, crypto_1.concatArrays)(ownerPwd, oValidationSalt, uValue));
-    const oValue = (0, crypto_1.concatArrays)(oHash, oValidationSalt, oKeySalt);
+    const oHash = (0, crypto_1.sha256)((0, binary_1.concatUint8Arrays)([ownerPwd, oValidationSalt, uValue]));
+    const oValue = (0, binary_1.concatUint8Arrays)([oHash, oValidationSalt, oKeySalt]);
     // Step 6: Compute OE value
     // OE = AES-256-CBC-encrypt(encryptionKey, SHA-256(ownerPassword + oKeySalt + U(0..47)), zeroIV)
-    const oeKey = (0, crypto_1.sha256)((0, crypto_1.concatArrays)(ownerPwd, oKeySalt, uValue));
+    const oeKey = (0, crypto_1.sha256)((0, binary_1.concatUint8Arrays)([ownerPwd, oKeySalt, uValue]));
     const oeValue = (0, crypto_1.aesCbcEncryptRaw)(encryptionKey, oeKey, zeroIv);
     // Step 7: Compute Perms value
     // 16-byte block: P(4 LE bytes) + 0xFF(4 bytes) + 'T' or 'F' (encryptMetadata) + 'a' 'd' 'b' + 0(3 bytes)

package/dist/cjs/modules/pdf/core/pdf-object.js

@@ -153,12 +153,37 @@ function encodePdfUtf16String(value) {
 class PdfDict {
     constructor() {
         this.entries = [];
+        /** When set, toString() returns this raw string. set() appends/replaces entries within it. */
+        this._raw = null;
+    }
+    /**
+     * Create a PdfDict that wraps a pre-serialized dictionary string.
+     * toString() returns the raw string (with any set() overrides applied).
+     */
+    static fromRawString(raw) {
+        const d = new PdfDict();
+        d._raw = raw;
+        return d;
     }
     /**
      * Set a dictionary entry. The key should NOT include the leading /.
      * The value should be a pre-serialized PDF value string.
      */
     set(key, value) {
+        if (this._raw !== null) {
+            // Update or append the entry in the raw string.
+            // Use a regex that matches /Key followed by a simple token value (number, name, ref).
+            // This is safe for keys like /Length, /Filter which have simple values.
+            const keyPattern = new RegExp(`(/${key})\\s+\\S+(?:\\s+\\d+\\s+R)?`);
+            if (keyPattern.test(this._raw)) {
+                this._raw = this._raw.replace(keyPattern, `/${key} ${value}`);
+            }
+            else {
+                // Append before the closing >>
+                this._raw = this._raw.replace(/>>$/, `\n${pdfName(key)} ${value}\n>>`);
+            }
+            return this;
+        }
         const idx = this.entries.findIndex(([k]) => k === key);
         if (idx >= 0) {
             this.entries[idx] = [key, value];
@@ -177,10 +202,23 @@ class PdfDict {
         }
         return this;
     }
+    /**
+     * Remove a dictionary entry by key.
+     */
+    delete(key) {
+        const idx = this.entries.findIndex(([k]) => k === key);
+        if (idx >= 0) {
+            this.entries.splice(idx, 1);
+        }
+        return this;
+    }
     /**
      * Serialize to a PDF dictionary string.
      */
     toString() {
+        if (this._raw !== null) {
+            return this._raw;
+        }
         const parts = ["<<"];
         for (const [key, value] of this.entries) {
             parts.push(`${pdfName(key)} ${value}`);

package/dist/cjs/modules/pdf/core/pdf-stream.js

@@ -132,6 +132,30 @@ class PdfContentStream {
         this.parts.push(`${(0, pdf_object_1.pdfNumber)(x)} ${(0, pdf_object_1.pdfNumber)(y)} ${(0, pdf_object_1.pdfNumber)(width)} ${(0, pdf_object_1.pdfNumber)(height)} re`);
         return this;
     }
+    /**
+     * Append a cubic Bezier curve to the current path.
+     * From current point to (x3, y3), with control points (x1, y1) and (x2, y2).
+     */
+    curveTo(x1, y1, x2, y2, x3, y3) {
+        this.parts.push(`${(0, pdf_object_1.pdfNumber)(x1)} ${(0, pdf_object_1.pdfNumber)(y1)} ${(0, pdf_object_1.pdfNumber)(x2)} ${(0, pdf_object_1.pdfNumber)(y2)} ${(0, pdf_object_1.pdfNumber)(x3)} ${(0, pdf_object_1.pdfNumber)(y3)} c`);
+        return this;
+    }
+    /**
+     * Append a cubic Bezier curve where the first control point is the current point.
+     * From current point to (x3, y3), with control points (current, y1) and (x2, y2).
+     */
+    curveToV(x2, y2, x3, y3) {
+        this.parts.push(`${(0, pdf_object_1.pdfNumber)(x2)} ${(0, pdf_object_1.pdfNumber)(y2)} ${(0, pdf_object_1.pdfNumber)(x3)} ${(0, pdf_object_1.pdfNumber)(y3)} v`);
+        return this;
+    }
+    /**
+     * Append a cubic Bezier curve where the second control point equals (x3, y3).
+     * From current point to (x3, y3), with control point (x1, y1).
+     */
+    curveToY(x1, y1, x3, y3) {
+        this.parts.push(`${(0, pdf_object_1.pdfNumber)(x1)} ${(0, pdf_object_1.pdfNumber)(y1)} ${(0, pdf_object_1.pdfNumber)(x3)} ${(0, pdf_object_1.pdfNumber)(y3)} y`);
+        return this;
+    }
     // ===========================================================================
     // Path Painting
     // ===========================================================================
@@ -357,6 +381,48 @@ class PdfContentStream {
         }
         return this.moveTo(x1, y1).lineTo(x2, y2).stroke().restore();
     }
+    /**
+     * Append an ellipse to the current path using 4 cubic Bezier curves.
+     * (cx, cy) is the center; rx, ry are the radii.
+     *
+     * Uses the standard kappa = 4 * (sqrt(2) - 1) / 3 ≈ 0.5522847 approximation.
+     */
+    ellipse(cx, cy, rx, ry) {
+        const k = 0.5522847;
+        const kx = k * rx;
+        const ky = k * ry;
+        this.moveTo(cx + rx, cy);
+        this.curveTo(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);
+        this.curveTo(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);
+        this.curveTo(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);
+        this.curveTo(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);
+        return this;
+    }
+    /**
+     * Append a circle to the current path.
+     * (cx, cy) is the center; r is the radius.
+     */
+    circle(cx, cy, r) {
+        return this.ellipse(cx, cy, r, r);
+    }
+    /**
+     * Append a rounded rectangle to the current path.
+     * (x, y) is the lower-left corner; r is the corner radius.
+     */
+    roundedRect(x, y, width, height, r) {
+        const k = 0.5522847;
+        const kr = k * r;
+        this.moveTo(x + r, y);
+        this.lineTo(x + width - r, y);
+        this.curveTo(x + width - r + kr, y, x + width, y + r - kr, x + width, y + r);
+        this.lineTo(x + width, y + height - r);
+        this.curveTo(x + width, y + height - r + kr, x + width - r + kr, y + height, x + width - r, y + height);
+        this.lineTo(x + r, y + height);
+        this.curveTo(x + r - kr, y + height, x, y + height - r + kr, x, y + height - r);
+        this.lineTo(x, y + r);
+        this.curveTo(x, y + r - kr, x + r - kr, y, x + r, y);
+        return this;
+    }
     // ===========================================================================
     // Serialization
     // ===========================================================================

package/dist/cjs/modules/pdf/core/pdf-writer.js

@@ -9,12 +9,16 @@
  * 3. Cross-reference table
  * 4. Trailer (with document catalog reference)
  *
+ * Also provides {@link buildIncremental} for appending incremental updates
+ * to an existing PDF without rewriting the original bytes.
+ *
  * Encryption uses AES-256 (V=5, R=5) per ISO 32000-2:2020.
  *
  * @see ISO 32000-2:2020, Chapter 7.5 — File Structure
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PdfWriter = void 0;
+exports.buildIncremental = buildIncremental;
 const pdf_object_1 = require("./pdf-object");
 const errors_1 = require("../errors");
 const binary_1 = require("../../../utils/binary.js");
@@ -38,6 +42,14 @@ class PdfWriter {
         this.catalogRef = 0;
         this.infoRef = 0;
         this.encryption = null;
+        this.pdfVersion = "2.0";
+    }
+    /**
+     * Set the PDF version string (e.g. "1.4", "1.7", "2.0").
+     * Default is "2.0".
+     */
+    setVersion(version) {
+        this.pdfVersion = version;
     }
     /**
      * Enable encryption for this document.
@@ -67,10 +79,11 @@ class PdfWriter {
             content: typeof dict === "string" ? dict : dict.toString()
         });
     }
-    addStreamObject(objectNumber, dict, data) {
+    addStreamObject(objectNumber, dict, data, options) {
         let streamData = data instanceof Uint8Array ? data : data.toUint8Array();
+        const compress = options?.compress ?? true;
         // Compress with zlib (RFC 1950) for PDF /FlateDecode
-        if (streamData.length > 256 && !dict.toString().includes("/Filter")) {
+        if (compress && streamData.length > 256 && !dict.toString().includes("/Filter")) {
             const compressed = (0, compress_1.zlibSync)(streamData, { level: 6 });
             if (compressed.length < streamData.length) {
                 dict.set("Filter", "/FlateDecode");
@@ -89,6 +102,22 @@ class PdfWriter {
             streamData
         });
     }
+    /**
+     * Return all stored objects for inspection (e.g., incremental update remapping).
+     * Stream objects include their binary data.
+     */
+    getObjects() {
+        return this.objects.map(o => {
+            const result = {
+                objectNumber: o.objectNumber,
+                content: o.content
+            };
+            if ("streamData" in o) {
+                result.streamData = o.streamData;
+            }
+            return result;
+        });
+    }
     /**
      * Set the document catalog object number.
      * This is required and references the root of the document structure.
@@ -147,14 +176,25 @@ class PdfWriter {
     }
     /**
      * Create and add the Catalog dictionary.
+     *
+     * @param pagesRef - Object number of the Pages tree root
+     * @param optionsOrOutlinesRef - Either an outlinesRef number (legacy) or an options object
      */
-    addCatalog(pagesRef, outlinesRef) {
+    addCatalog(pagesRef, optionsOrOutlinesRef) {
+        const resolvedOptions = typeof optionsOrOutlinesRef === "number"
+            ? { outlinesRef: optionsOrOutlinesRef }
+            : (optionsOrOutlinesRef ?? {});
         const objNum = this.allocObject();
         const dict = new pdf_object_1.PdfDict().set("Type", "/Catalog").set("Pages", (0, pdf_object_1.pdfRef)(pagesRef));
-        if (outlinesRef) {
-            dict.set("Outlines", (0, pdf_object_1.pdfRef)(outlinesRef));
+        if (resolvedOptions.outlinesRef) {
+            dict.set("Outlines", (0, pdf_object_1.pdfRef)(resolvedOptions.outlinesRef));
             dict.set("PageMode", "/UseOutlines");
         }
+        if (resolvedOptions.extraEntries) {
+            for (const [key, value] of resolvedOptions.extraEntries) {
+                dict.set(key, value);
+            }
+        }
         this.addObject(objNum, dict);
         this.setCatalog(objNum);
         return objNum;
@@ -174,7 +214,7 @@ class PdfWriter {
         let byteOffset = 0;
         // --- Header ---
         // Include a comment with high bytes to signal binary content per PDF spec §3.4.1
-        const headerStr = "%PDF-2.0\n";
+        const headerStr = `%PDF-${this.pdfVersion}\n`;
         const headerStrBytes = encoder.encode(headerStr);
         chunks.push(headerStrBytes);
         byteOffset += headerStrBytes.length;
@@ -464,3 +504,229 @@ function unescapePdfString(value) {
     }
     return result;
 }
+// =============================================================================
+// Incremental Update
+// =============================================================================
+/**
+ * Build an incremental update that appends new/modified objects to an
+ * existing PDF without rewriting the original bytes.
+ *
+ * The result is `originalData + "\n" + new objects + xref + trailer + %%EOF`.
+ * The new trailer's `/Prev` points to the original xref offset so that PDF
+ * readers can follow the chain of incremental updates.
+ *
+ * @param originalData - The original, unmodified PDF bytes (preserved byte-for-byte)
+ * @param modifiedObjects - Map of object number → serialized content.
+ *   Values are either a plain string (for non-stream objects) or
+ *   `{ dict, data }` for stream objects.
+ * @param newTrailerEntries - Additional/override entries for the new trailer.
+ *   Keys like `/Root`, `/Info`, `/Encrypt`, `/ID` are preserved from the
+ *   original trailer by default but can be overridden here.
+ *
+ * @see ISO 32000-2:2020, §7.5.6 — Incremental Updates
+ */
+function buildIncremental(originalData, modifiedObjects, newTrailerEntries) {
+    if (modifiedObjects.size === 0) {
+        return originalData;
+    }
+    const encoder = new TextEncoder();
+    // --- Locate the original startxref offset ---
+    const oldXrefOffset = findOriginalXrefOffset(originalData);
+    // --- Extract original trailer entries we want to preserve ---
+    const originalTrailerEntries = extractOriginalTrailerEntries(originalData);
+    // --- Determine /Size for the new trailer ---
+    // /Size must be one more than the highest object number across original + new
+    const originalSize = originalTrailerEntries.get("Size") ?? "0";
+    let maxObjNum = parseInt(originalSize, 10) - 1;
+    for (const objNum of modifiedObjects.keys()) {
+        if (objNum > maxObjNum) {
+            maxObjNum = objNum;
+        }
+    }
+    const newSize = maxObjNum + 1;
+    // --- Build the appended body ---
+    const chunks = [];
+    let byteOffset = originalData.length;
+    // Start with a newline separator after the original %%EOF
+    const separator = encoder.encode("\n");
+    chunks.push(separator);
+    byteOffset += separator.length;
+    // Sort modified objects by object number for deterministic output
+    const sortedObjects = [...modifiedObjects.entries()].sort((a, b) => a[0] - b[0]);
+    // Track offsets for the xref entries
+    const objectOffsets = new Map();
+    for (const [objNum, content] of sortedObjects) {
+        objectOffsets.set(objNum, byteOffset);
+        const objHeader = encoder.encode(`${objNum} 0 obj\n`);
+        chunks.push(objHeader);
+        byteOffset += objHeader.length;
+        if (typeof content === "string") {
+            // Non-stream object
+            const contentBytes = encoder.encode(content + "\n");
+            chunks.push(contentBytes);
+            byteOffset += contentBytes.length;
+        }
+        else {
+            // Stream object: dict + stream data
+            let streamData = content.data;
+            const dict = content.dict;
+            // Compress if beneficial and not already filtered
+            if (streamData.length > 256 && !dict.toString().includes("/Filter")) {
+                const compressed = (0, compress_1.zlibSync)(streamData, { level: 6 });
+                if (compressed.length < streamData.length) {
+                    dict.set("Filter", "/FlateDecode");
+                    streamData = compressed;
+                }
+            }
+            dict.set("Length", (0, pdf_object_1.pdfNumber)(streamData.length));
+            const dictBytes = encoder.encode(dict.toString() + "\n");
+            chunks.push(dictBytes);
+            byteOffset += dictBytes.length;
+            const streamStart = encoder.encode("stream\n");
+            chunks.push(streamStart);
+            byteOffset += streamStart.length;
+            chunks.push(streamData);
+            byteOffset += streamData.length;
+            const streamEnd = encoder.encode("\nendstream\n");
+            chunks.push(streamEnd);
+            byteOffset += streamEnd.length;
+        }
+        const objFooter = encoder.encode("endobj\n");
+        chunks.push(objFooter);
+        byteOffset += objFooter.length;
+    }
+    // --- Build the new xref section ---
+    const xrefOffset = byteOffset;
+    // Group consecutive object numbers into subsections
+    const objNums = [...objectOffsets.keys()].sort((a, b) => a - b);
+    const subsections = [];
+    for (const objNum of objNums) {
+        const last = subsections[subsections.length - 1];
+        if (last && objNum === last.start + last.entries.length) {
+            // Consecutive — extend current subsection
+            last.entries.push({ objNum, offset: objectOffsets.get(objNum) });
+        }
+        else {
+            // New subsection
+            subsections.push({
+                start: objNum,
+                entries: [{ objNum, offset: objectOffsets.get(objNum) }]
+            });
+        }
+    }
+    let xrefStr = "xref\n";
+    for (const sub of subsections) {
+        xrefStr += `${sub.start} ${sub.entries.length}\n`;
+        for (const entry of sub.entries) {
+            const offsetStr = entry.offset.toString().padStart(10, "0");
+            xrefStr += `${offsetStr} 00000 n \n`;
+        }
+    }
+    const xrefBytes = encoder.encode(xrefStr);
+    chunks.push(xrefBytes);
+    // --- Build the new trailer ---
+    let trailerStr = "trailer\n<<\n";
+    trailerStr += `/Size ${newSize}\n`;
+    // Preserve original trailer keys: Root, Info, Encrypt, ID
+    for (const key of ["Root", "Info", "Encrypt", "ID"]) {
+        if (newTrailerEntries.has(key)) {
+            trailerStr += `/${key} ${newTrailerEntries.get(key)}\n`;
+        }
+        else if (originalTrailerEntries.has(key)) {
+            trailerStr += `/${key} ${originalTrailerEntries.get(key)}\n`;
+        }
+    }
+    // Add any extra new trailer entries not already handled
+    for (const [key, value] of newTrailerEntries) {
+        if (key === "Root" || key === "Info" || key === "Encrypt" || key === "ID" || key === "Size") {
+            continue; // Already handled above
+        }
+        trailerStr += `/${key} ${value}\n`;
+    }
+    // /Prev points to the original xref offset
+    trailerStr += `/Prev ${oldXrefOffset}\n`;
+    trailerStr += ">>\n";
+    trailerStr += "startxref\n";
+    trailerStr += `${xrefOffset}\n`;
+    trailerStr += "%%EOF\n";
+    const trailerBytes = encoder.encode(trailerStr);
+    chunks.push(trailerBytes);
+    // --- Concatenate: originalData + appended chunks ---
+    return (0, binary_1.concatUint8Arrays)([originalData, ...chunks]);
+}
+/**
+ * Find the xref offset stored after the last `startxref` keyword in the PDF.
+ */
+function findOriginalXrefOffset(data) {
+    // Scan backward from the end to find "startxref"
+    const keyword = "startxref";
+    const decoder = new TextDecoder("latin1");
+    // Search in the last 1024 bytes (%%EOF + startxref are typically near the end)
+    const searchStart = Math.max(0, data.length - 1024);
+    const tail = decoder.decode(data.subarray(searchStart));
+    const idx = tail.lastIndexOf(keyword);
+    if (idx < 0) {
+        throw new errors_1.PdfStructureError("Could not find startxref in original PDF");
+    }
+    // Extract the number after "startxref"
+    const afterKeyword = tail.substring(idx + keyword.length).trim();
+    const match = afterKeyword.match(/^(\d+)/);
+    if (!match) {
+        throw new errors_1.PdfStructureError("Invalid startxref offset in original PDF");
+    }
+    return parseInt(match[1], 10);
+}
+/**
+ * Extract key trailer entries from the original PDF as serialized strings.
+ * This is a lightweight scan — it doesn't fully parse the trailer, just
+ * extracts the values we need for preservation.
+ */
+function extractOriginalTrailerEntries(data) {
+    const entries = new Map();
+    const decoder = new TextDecoder("latin1");
+    // Find the last "trailer" keyword — scan backward
+    const text = decoder.decode(data);
+    // Find the last trailer dict. For PDFs with incremental updates,
+    // we want the most recent (last) trailer.
+    const trailerIdx = text.lastIndexOf("trailer");
+    if (trailerIdx < 0) {
+        // Could be an xref stream PDF — no traditional trailer
+        return entries;
+    }
+    // Find the << >> dict after "trailer"
+    const afterTrailer = text.substring(trailerIdx + 7);
+    const dictStart = afterTrailer.indexOf("<<");
+    if (dictStart < 0) {
+        return entries;
+    }
+    // Find the matching >>
+    let depth = 0;
+    let dictEnd = -1;
+    for (let i = dictStart; i < afterTrailer.length - 1; i++) {
+        if (afterTrailer[i] === "<" && afterTrailer[i + 1] === "<") {
+            depth++;
+            i++;
+        }
+        else if (afterTrailer[i] === ">" && afterTrailer[i + 1] === ">") {
+            depth--;
+            i++;
+            if (depth === 0) {
+                dictEnd = i + 1;
+                break;
+            }
+        }
+    }
+    if (dictEnd < 0) {
+        return entries;
+    }
+    const dictStr = afterTrailer.substring(dictStart, dictEnd);
+    // Extract known keys with a simple regex-based approach
+    for (const key of ["Root", "Info", "Encrypt", "ID", "Size"]) {
+        const keyPattern = new RegExp(`/${key}\\s+(.+?)(?=\\s*/[A-Z]|\\s*>>)`, "s");
+        const match = dictStr.match(keyPattern);
+        if (match) {
+            entries.set(key, match[1].trim());
+        }
+    }
+    return entries;
+}