@cj-tech-master/excelts 9.5.0 → 9.5.1

package/dist/cjs/modules/pdf/render/style-converter.js

@@ -62,7 +62,7 @@ function argbToPdfColor(argb) {
 }
 /**
  * Convert a color data object to PDF color.
- * Handles both ARGB and theme-based colors.
+ * Handles ARGB, theme-based, and indexed colors.
  */
 function excelColorToPdf(color) {
     if (!color) {
@@ -84,6 +84,10 @@ function excelColorToPdf(color) {
         }
         return base;
     }
+    // Indexed colors (legacy Excel color palette)
+    if (color.indexed !== undefined) {
+        return indexedColorToPdf(color.indexed);
+    }
     return null;
 }
 /**
@@ -109,6 +113,99 @@ function themeColorToPdf(themeIndex) {
     }
     return null;
 }
+/**
+ * Standard Excel indexed color palette (56 colors + system colors).
+ * Index 0–7: legacy base colors
+ * Index 8–63: standard palette (indices 8–63)
+ * Index 64: system foreground (black)
+ * Index 65: system background (white)
+ *
+ * @see ECMA-376 §18.8.27 — indexedColors
+ */
+const INDEXED_COLORS = [
+    // 0–7: legacy base colors (same as 8–15 but less commonly used directly)
+    "000000", // 0: Black
+    "FFFFFF", // 1: White
+    "FF0000", // 2: Red
+    "00FF00", // 3: Green
+    "0000FF", // 4: Blue
+    "FFFF00", // 5: Yellow
+    "FF00FF", // 6: Magenta
+    "00FFFF", // 7: Cyan
+    // 8–63: standard palette
+    "000000", // 8: Black
+    "FFFFFF", // 9: White
+    "FF0000", // 10: Red
+    "00FF00", // 11: Green
+    "0000FF", // 12: Blue
+    "FFFF00", // 13: Yellow
+    "FF00FF", // 14: Magenta
+    "00FFFF", // 15: Cyan
+    "800000", // 16: Dark Red
+    "008000", // 17: Dark Green
+    "000080", // 18: Dark Blue (Navy)
+    "808000", // 19: Dark Yellow (Olive)
+    "800080", // 20: Purple
+    "008080", // 21: Teal
+    "C0C0C0", // 22: Silver
+    "808080", // 23: Gray
+    "9999FF", // 24: Periwinkle
+    "993366", // 25: Plum
+    "FFFFCC", // 26: Ivory
+    "CCFFFF", // 27: Light Cyan
+    "660066", // 28: Dark Purple
+    "FF8080", // 29: Coral
+    "0066CC", // 30: Ocean Blue
+    "CCCCFF", // 31: Ice Blue
+    "000080", // 32: Dark Blue
+    "FF00FF", // 33: Pink
+    "FFFF00", // 34: Yellow
+    "00FFFF", // 35: Cyan
+    "800080", // 36: Purple
+    "800000", // 37: Dark Red
+    "008080", // 38: Teal
+    "0000FF", // 39: Blue
+    "00CCFF", // 40: Sky Blue
+    "CCFFFF", // 41: Light Turquoise
+    "CCFFCC", // 42: Light Green
+    "FFFF99", // 43: Light Yellow
+    "99CCFF", // 44: Pale Blue
+    "FF99CC", // 45: Rose
+    "CC99FF", // 46: Lavender
+    "FFCC99", // 47: Tan
+    "3366FF", // 48: Light Blue
+    "33CCCC", // 49: Aqua
+    "99CC00", // 50: Lime
+    "FFCC00", // 51: Gold
+    "FF9900", // 52: Light Orange
+    "FF6600", // 53: Orange
+    "666699", // 54: Blue Gray
+    "969696", // 55: Gray 40%
+    "003366", // 56: Dark Teal
+    "339966", // 57: Sea Green
+    "003300", // 58: Very Dark Green
+    "333300", // 59: Dark Olive
+    "993300", // 60: Brown
+    "993366", // 61: Plum
+    "333399", // 62: Indigo
+    "333333" // 63: Gray 80%
+];
+/**
+ * Convert an indexed color to PDF color.
+ * Index 64 = system foreground (black), 65 = system background (white).
+ */
+function indexedColorToPdf(index) {
+    if (index === 64) {
+        return { r: 0, g: 0, b: 0 }; // System foreground (black)
+    }
+    if (index === 65) {
+        return { r: 1, g: 1, b: 1 }; // System background (white)
+    }
+    if (index >= 0 && index < INDEXED_COLORS.length) {
+        return argbToPdfColor(INDEXED_COLORS[index]) ?? null;
+    }
+    return null;
+}
 /**
  * Apply a tint value to a color.
  * Tint range: -1.0 (fully dark) to +1.0 (fully light).

package/dist/cjs/modules/word/color-utils.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * DOCX Module - Theme Color Utilities
+ *
+ * Resolves OOXML theme colors with tint/shade transformations.
+ * Extracted to a standalone file so that html-renderer and document.ts
+ * can both import it without creating circular heavy dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveThemeColor = resolveThemeColor;
+/**
+ * Map OOXML theme color attribute names to theme color scheme keys.
+ * Word uses different names in run/paragraph properties vs the theme XML.
+ */
+const THEME_COLOR_MAP = {
+    dark1: "dk1",
+    light1: "lt1",
+    dark2: "dk2",
+    light2: "lt2",
+    accent1: "accent1",
+    accent2: "accent2",
+    accent3: "accent3",
+    accent4: "accent4",
+    accent5: "accent5",
+    accent6: "accent6",
+    hyperlink: "hlink",
+    followedHyperlink: "folHlink",
+    // Direct names also work
+    dk1: "dk1",
+    lt1: "lt1",
+    dk2: "dk2",
+    lt2: "lt2",
+    hlink: "hlink",
+    folHlink: "folHlink"
+};
+/**
+ * Resolve a ColorSpec to an actual hex RGB color using the document theme.
+ *
+ * Applies theme color lookup + tint/shade transformations per OOXML spec.
+ *
+ * @param color - The color value (HexColor string or ColorSpec).
+ * @param theme - The document theme (from `doc.theme`).
+ * @returns Resolved hex color string (6 chars, no #), or undefined if unresolvable.
+ */
+function resolveThemeColor(color, theme) {
+    if (color === undefined) {
+        return undefined;
+    }
+    if (typeof color === "string") {
+        return color;
+    }
+    // ColorSpec with val — use directly
+    if (color.val && color.val !== "auto") {
+        return color.val;
+    }
+    // Resolve via theme
+    if (!color.themeColor || !theme) {
+        return color.val;
+    }
+    const key = THEME_COLOR_MAP[color.themeColor] ?? color.themeColor;
+    const base = theme.colorScheme.colors[key];
+    if (!base) {
+        return color.val;
+    }
+    // Apply tint or shade
+    if (color.themeTint) {
+        return applyTint(base, parseInt(color.themeTint, 16) / 255);
+    }
+    if (color.themeShade) {
+        return applyShade(base, parseInt(color.themeShade, 16) / 255);
+    }
+    return base;
+}
+/** Apply tint to a hex color. tint=1 → white, tint=0 → original. */
+function applyTint(hex, tint) {
+    const r = parseInt(hex.slice(0, 2), 16);
+    const g = parseInt(hex.slice(2, 4), 16);
+    const b = parseInt(hex.slice(4, 6), 16);
+    const nr = Math.round(r + (255 - r) * tint);
+    const ng = Math.round(g + (255 - g) * tint);
+    const nb = Math.round(b + (255 - b) * tint);
+    return toHex2(nr) + toHex2(ng) + toHex2(nb);
+}
+/** Apply shade to a hex color. shade=1 → original, shade=0 → black. */
+function applyShade(hex, shade) {
+    const r = parseInt(hex.slice(0, 2), 16);
+    const g = parseInt(hex.slice(2, 4), 16);
+    const b = parseInt(hex.slice(4, 6), 16);
+    const nr = Math.round(r * shade);
+    const ng = Math.round(g * shade);
+    const nb = Math.round(b * shade);
+    return toHex2(nr) + toHex2(ng) + toHex2(nb);
+}
+function toHex2(n) {
+    const h = Math.max(0, Math.min(255, n)).toString(16);
+    return h.length < 2 ? "0" + h : h;
+}

package/dist/cjs/modules/word/content-types.js

@@ -3,55 +3,54 @@
  * DOCX Module - Content Types Generator
  *
  * Generates [Content_Types].xml for the DOCX package.
+ * Uses a plain data record + free functions for tree-shakeability.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContentTypesManager = void 0;
+exports.createContentTypes = createContentTypes;
+exports.addContentTypeDefault = addContentTypeDefault;
+exports.addContentTypeOverride = addContentTypeOverride;
+exports.addImageContentTypeDefaults = addImageContentTypeDefaults;
+exports.renderContentTypes = renderContentTypes;
 const constants_1 = require("./constants");
-/**
- * Generates the [Content_Types].xml part.
- */
-class ContentTypesManager {
-    constructor() {
-        this._defaults = new Map();
-        this._overrides = [];
-        // Always include rels and xml defaults
-        this._defaults.set("rels", constants_1.ContentType.Relationships);
-        this._defaults.set("xml", constants_1.ContentType.Xml);
-    }
-    /** Add a default content type for a file extension. */
-    addDefault(extension, contentType) {
-        this._defaults.set(extension, contentType);
-    }
-    /** Add an override content type for a specific part. */
-    addOverride(partName, contentType) {
-        this._overrides.push({
-            partName: partName.startsWith("/") ? partName : `/${partName}`,
-            contentType
-        });
-    }
-    /** Add image extension defaults from a set of used extensions. */
-    addImageDefaults(extensions) {
-        for (const ext of extensions) {
-            const ct = constants_1.IMAGE_CONTENT_TYPES[ext.toLowerCase()];
-            if (ct) {
-                this._defaults.set(ext.toLowerCase(), ct);
-            }
+/** Create a new ContentTypesState with standard defaults (rels, xml). */
+function createContentTypes() {
+    const defaults = new Map();
+    defaults.set("rels", constants_1.ContentType.Relationships);
+    defaults.set("xml", constants_1.ContentType.Xml);
+    return { defaults, overrides: [] };
+}
+/** Add a default content type for a file extension. */
+function addContentTypeDefault(state, extension, contentType) {
+    state.defaults.set(extension, contentType);
+}
+/** Add an override content type for a specific part. */
+function addContentTypeOverride(state, partName, contentType) {
+    state.overrides.push({
+        partName: partName.startsWith("/") ? partName : `/${partName}`,
+        contentType
+    });
+}
+/** Add image extension defaults from a set of used extensions. */
+function addImageContentTypeDefaults(state, extensions) {
+    for (const ext of extensions) {
+        const ct = constants_1.IMAGE_CONTENT_TYPES[ext.toLowerCase()];
+        if (ct) {
+            state.defaults.set(ext.toLowerCase(), ct);
         }
     }
-    /** Render the [Content_Types].xml to a sink. */
-    render(xml) {
-        xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
-        xml.openNode("Types", { xmlns: constants_1.NS_CONTENT_TYPES });
-        // Defaults sorted by extension
-        const sortedDefaults = [...this._defaults.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-        for (const [ext, ct] of sortedDefaults) {
-            xml.leafNode("Default", { Extension: ext, ContentType: ct });
-        }
-        // Overrides in order
-        for (const override of this._overrides) {
-            xml.leafNode("Override", { PartName: override.partName, ContentType: override.contentType });
-        }
-        xml.closeNode();
+}
+/** Render the [Content_Types].xml to a sink. */
+function renderContentTypes(state, xml) {
+    xml.openXml(constants_1.STD_DOC_ATTRIBUTES);
+    xml.openNode("Types", { xmlns: constants_1.NS_CONTENT_TYPES });
+    // Defaults sorted by extension
+    const sortedDefaults = [...state.defaults.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [ext, ct] of sortedDefaults) {
+        xml.leafNode("Default", { Extension: ext, ContentType: ct });
+    }
+    // Overrides in order
+    for (const override of state.overrides) {
+        xml.leafNode("Override", { PartName: override.partName, ContentType: override.contentType });
     }
+    xml.closeNode();
 }
-exports.ContentTypesManager = ContentTypesManager;

package/dist/cjs/modules/word/crypto.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * DOCX Module - Encryption & Digital Signatures (Subpath Export)
+ *
+ * Import separately to avoid pulling crypto code into the bundle
+ * when only core document building is needed.
+ *
+ * @example
+ * ```ts
+ * import { isEncryptedDocx, decryptPackage } from "excelts/word/crypto";
+ * import { extractSignatures } from "excelts/word/crypto";
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFontKey = exports.obfuscateFont = exports.deobfuscateFont = exports.isWellFormedSignature = exports.extractSignatures = exports.parseSignatureXml = exports.hasDigitalSignatures = exports.AGILE_BLOCK_KEYS = exports.deriveEncryptionKey = exports.parseEncryptionInfoXml = exports.decryptPackage = exports.verifyPassword = exports.isEncryptedDocx = void 0;
+// Encryption utilities
+var encryption_1 = require("./encryption");
+Object.defineProperty(exports, "isEncryptedDocx", { enumerable: true, get: function () { return encryption_1.isEncryptedDocx; } });
+Object.defineProperty(exports, "verifyPassword", { enumerable: true, get: function () { return encryption_1.verifyPassword; } });
+Object.defineProperty(exports, "decryptPackage", { enumerable: true, get: function () { return encryption_1.decryptPackage; } });
+Object.defineProperty(exports, "parseEncryptionInfoXml", { enumerable: true, get: function () { return encryption_1.parseEncryptionInfoXml; } });
+Object.defineProperty(exports, "deriveEncryptionKey", { enumerable: true, get: function () { return encryption_1.deriveEncryptionKey; } });
+Object.defineProperty(exports, "AGILE_BLOCK_KEYS", { enumerable: true, get: function () { return encryption_1.AGILE_BLOCK_KEYS; } });
+// Digital signature utilities
+var digital_signatures_1 = require("./digital-signatures");
+Object.defineProperty(exports, "hasDigitalSignatures", { enumerable: true, get: function () { return digital_signatures_1.hasDigitalSignatures; } });
+Object.defineProperty(exports, "parseSignatureXml", { enumerable: true, get: function () { return digital_signatures_1.parseSignatureXml; } });
+Object.defineProperty(exports, "extractSignatures", { enumerable: true, get: function () { return digital_signatures_1.extractSignatures; } });
+Object.defineProperty(exports, "isWellFormedSignature", { enumerable: true, get: function () { return digital_signatures_1.isWellFormedSignature; } });
+// Font obfuscation utilities
+var font_obfuscation_1 = require("./font-obfuscation");
+Object.defineProperty(exports, "deobfuscateFont", { enumerable: true, get: function () { return font_obfuscation_1.deobfuscateFont; } });
+Object.defineProperty(exports, "obfuscateFont", { enumerable: true, get: function () { return font_obfuscation_1.obfuscateFont; } });
+Object.defineProperty(exports, "generateFontKey", { enumerable: true, get: function () { return font_obfuscation_1.generateFontKey; } });

package/dist/cjs/modules/word/document-io.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * DOCX Module - Document IO
+ *
+ * IO operations that depend on docx-packager and docx-reader.
+ * Separated from document.ts so that builder helpers can be imported
+ * without pulling in archive/xml/writer code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBuffer = toBuffer;
+exports.toBase64 = toBase64;
+exports.patchDocument = patchDocument;
+const docx_packager_1 = require("./docx-packager");
+const docx_reader_1 = require("./docx-reader");
+const internal_utils_1 = require("./internal-utils");
+// =============================================================================
+// Document IO (toBuffer / toBase64)
+// =============================================================================
+/** Package a DocxDocument model to DOCX bytes. */
+async function toBuffer(doc, compressionLevel) {
+    return (0, docx_packager_1.packageDocx)(doc, compressionLevel);
+}
+/** Package a DocxDocument model to base64 string. */
+async function toBase64(doc, compressionLevel) {
+    const bytes = await toBuffer(doc, compressionLevel);
+    return (0, internal_utils_1.bytesToBase64)(bytes);
+}
+/**
+ * Read an existing DOCX file, replace placeholders with content, and produce a new DOCX.
+ *
+ * Placeholders are strings like `{{name}}` embedded in the document text.
+ * They may span across multiple runs — the patcher handles cross-run matching.
+ *
+ * Supported patch content types:
+ * - `text` — simple text replacement (preserves formatting of the first run)
+ * - `paragraph` — replaces the entire paragraph containing the placeholder
+ * - `table` — replaces the entire paragraph with a table
+ * - `image` — replaces the placeholder with an inline image
+ *
+ * @param buffer - The source DOCX file as a Uint8Array.
+ * @param patches - Array of patch operations to apply.
+ * @param options - Optional compression settings.
+ * @returns New DOCX file as a Uint8Array.
+ */
+async function patchDocument(buffer, patches, options) {
+    const doc = await (0, docx_reader_1.readDocx)(buffer);
+    // Build lookup map for quick placeholder matching
+    const patchMap = new Map();
+    for (const patch of patches) {
+        patchMap.set(patch.placeholder, patch);
+    }
+    // Process body content
+    const newBody = [];
+    for (const block of doc.body) {
+        if (block.type === "paragraph") {
+            const result = patchParagraph(block, patchMap);
+            if (result) {
+                if (Array.isArray(result)) {
+                    newBody.push(...result);
+                }
+                else {
+                    newBody.push(result);
+                }
+            }
+        }
+        else if (block.type === "table") {
+            patchTable(block, patchMap);
+            newBody.push(block);
+        }
+        else {
+            newBody.push(block);
+        }
+    }
+    // Patch headers
+    if (doc.headers) {
+        for (const [, headerDef] of doc.headers) {
+            patchHeaderFooterContent(headerDef.content, patchMap);
+        }
+    }
+    // Patch footers
+    if (doc.footers) {
+        for (const [, footerDef] of doc.footers) {
+            patchHeaderFooterContent(footerDef.content, patchMap);
+        }
+    }
+    // Add any new images from patches
+    const images = doc.images ? [...doc.images] : [];
+    for (const patch of patches) {
+        if (patch.content.type === "image") {
+            const imgContent = patch.content;
+            const existing = images.find(i => i.fileName === imgContent.image.fileName);
+            if (!existing) {
+                images.push(imgContent.image);
+            }
+        }
+    }
+    const patched = {
+        ...doc,
+        body: newBody,
+        images: images.length > 0 ? images : undefined
+    };
+    return (0, docx_packager_1.packageDocx)(patched, options?.compressionLevel);
+}
+// =============================================================================
+// Internal helpers
+// =============================================================================
+/** Extract concatenated plain text from a paragraph's runs. */
+function paragraphText(para) {
+    let t = "";
+    for (const child of para.children) {
+        if ("content" in child && Array.isArray(child.content)) {
+            for (const c of child.content) {
+                if ("type" in c && c.type === "text" && "text" in c) {
+                    t += c.text;
+                }
+            }
+        }
+    }
+    return t;
+}
+/** Replace text within a single paragraph. */
+function replaceInParagraph(para, search, replacement) {
+    for (const child of para.children) {
+        if (!("content" in child) || !Array.isArray(child.content)) {
+            continue;
+        }
+        for (const c of child.content) {
+            if (!("type" in c) || c.type !== "text" || !("text" in c)) {
+                continue;
+            }
+            const before = c.text;
+            if (before.includes(search)) {
+                c.text = before.replaceAll(search, replacement);
+            }
+        }
+    }
+    // Cross-run replacement fallback
+    const fullText = paragraphText(para);
+    if (fullText.includes(search)) {
+        const newText = fullText.replaceAll(search, replacement);
+        let placed = false;
+        for (const child of para.children) {
+            if (!("content" in child) || !Array.isArray(child.content)) {
+                continue;
+            }
+            for (const c of child.content) {
+                if (!("type" in c) || c.type !== "text" || !("text" in c)) {
+                    continue;
+                }
+                if (!placed) {
+                    c.text = newText;
+                    placed = true;
+                }
+                else {
+                    c.text = "";
+                }
+            }
+        }
+    }
+}
+/** Patch a paragraph — returns replacement content or null to remove. */
+function patchParagraph(para, patchMap) {
+    const text = paragraphText(para);
+    for (const [placeholder, patch] of patchMap) {
+        if (!text.includes(placeholder)) {
+            continue;
+        }
+        switch (patch.content.type) {
+            case "text": {
+                replaceInParagraph(para, placeholder, patch.content.text);
+                return para;
+            }
+            case "paragraph": {
+                return patch.content.children;
+            }
+            case "table": {
+                return patch.content.table;
+            }
+            case "image": {
+                const img = patch.content.image;
+                const rId = img.rId ?? `rId_img_${img.fileName}`;
+                const imgContent = {
+                    type: "image",
+                    rId,
+                    width: patch.content.width,
+                    height: patch.content.height,
+                    altText: img.fileName,
+                    name: img.fileName
+                };
+                const newPara = {
+                    type: "paragraph",
+                    properties: para.properties,
+                    children: [{ content: [imgContent] }]
+                };
+                return newPara;
+            }
+        }
+    }
+    return para;
+}
+/** Patch text inside table cells recursively. */
+function patchTable(table, patchMap) {
+    for (const row of table.rows) {
+        for (const cell of row.cells) {
+            const newContent = [];
+            for (const block of cell.content) {
+                if (block.type === "paragraph") {
+                    const result = patchParagraph(block, patchMap);
+                    if (result) {
+                        if (Array.isArray(result)) {
+                            newContent.push(...result);
+                        }
+                        else {
+                            newContent.push(result);
+                        }
+                    }
+                }
+                else if (block.type === "table") {
+                    patchTable(block, patchMap);
+                    newContent.push(block);
+                }
+                else {
+                    newContent.push(block);
+                }
+            }
+            cell.content = newContent;
+        }
+    }
+}
+/** Patch text in header/footer content. */
+function patchHeaderFooterContent(content, patchMap) {
+    for (const child of content.children) {
+        if (child.type === "paragraph") {
+            for (const [placeholder, patch] of patchMap) {
+                if (patch.content.type === "text") {
+                    const text = paragraphText(child);
+                    if (text.includes(placeholder)) {
+                        replaceInParagraph(child, placeholder, patch.content.text);
+                    }
+                }
+            }
+        }
+    }
+}