@cj-tech-master/excelts 9.5.0 → 9.5.1

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

@@ -0,0 +1,94 @@
+/**
+ * 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.
+ */
+/**
+ * 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.
+ */
+export 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/esm/modules/word/content-types.js

@@ -2,52 +2,48 @@
  * DOCX Module - Content Types Generator
  *
  * Generates [Content_Types].xml for the DOCX package.
+ * Uses a plain data record + free functions for tree-shakeability.
  */
 import { NS_CONTENT_TYPES, STD_DOC_ATTRIBUTES, ContentType, IMAGE_CONTENT_TYPES } from "./constants.js";
-/**
- * Generates the [Content_Types].xml part.
- */
-export class ContentTypesManager {
-    constructor() {
-        this._defaults = new Map();
-        this._overrides = [];
-        // Always include rels and xml defaults
-        this._defaults.set("rels", ContentType.Relationships);
-        this._defaults.set("xml", 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 = IMAGE_CONTENT_TYPES[ext.toLowerCase()];
-            if (ct) {
-                this._defaults.set(ext.toLowerCase(), ct);
-            }
+/** Create a new ContentTypesState with standard defaults (rels, xml). */
+export function createContentTypes() {
+    const defaults = new Map();
+    defaults.set("rels", ContentType.Relationships);
+    defaults.set("xml", ContentType.Xml);
+    return { defaults, overrides: [] };
+}
+/** Add a default content type for a file extension. */
+export function addContentTypeDefault(state, extension, contentType) {
+    state.defaults.set(extension, contentType);
+}
+/** Add an override content type for a specific part. */
+export function addContentTypeOverride(state, partName, contentType) {
+    state.overrides.push({
+        partName: partName.startsWith("/") ? partName : `/${partName}`,
+        contentType
+    });
+}
+/** Add image extension defaults from a set of used extensions. */
+export function addImageContentTypeDefaults(state, extensions) {
+    for (const ext of extensions) {
+        const ct = 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(STD_DOC_ATTRIBUTES);
-        xml.openNode("Types", { xmlns: 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. */
+export function renderContentTypes(state, xml) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("Types", { xmlns: 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();
 }

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

@@ -0,0 +1,18 @@
+/**
+ * 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";
+ * ```
+ */
+// Encryption utilities
+export { isEncryptedDocx, verifyPassword, decryptPackage, parseEncryptionInfoXml, deriveEncryptionKey, AGILE_BLOCK_KEYS } from "./encryption.js";
+// Digital signature utilities
+export { hasDigitalSignatures, parseSignatureXml, extractSignatures, isWellFormedSignature } from "./digital-signatures.js";
+// Font obfuscation utilities
+export { deobfuscateFont, obfuscateFont, generateFontKey } from "./font-obfuscation.js";

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

@@ -0,0 +1,239 @@
+/**
+ * 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.
+ */
+import { packageDocx } from "./docx-packager.js";
+import { readDocx } from "./docx-reader.js";
+import { bytesToBase64 } from "./internal-utils.js";
+// =============================================================================
+// Document IO (toBuffer / toBase64)
+// =============================================================================
+/** Package a DocxDocument model to DOCX bytes. */
+export async function toBuffer(doc, compressionLevel) {
+    return packageDocx(doc, compressionLevel);
+}
+/** Package a DocxDocument model to base64 string. */
+export async function toBase64(doc, compressionLevel) {
+    const bytes = await toBuffer(doc, compressionLevel);
+    return 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.
+ */
+export async function patchDocument(buffer, patches, options) {
+    const doc = await 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 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);
+                    }
+                }
+            }
+        }
+    }
+}