@cj-tech-master/excelts 9.5.0 → 9.5.1

package/dist/browser/modules/pdf/excel-bridge.js

@@ -187,6 +187,31 @@ async function convertSheet(ws, workbook) {
             right: dimensions.model.right
         }
         : { top: 0, left: 0, bottom: 0, right: 0 };
+    // Expand bounds to include cells that only have styles (borders, fills, fonts)
+    // but no values — these are not tracked by dimensions.
+    if (hasData) {
+        for (let r = bounds.top; r <= bounds.bottom; r++) {
+            const row = ws.findRow(r);
+            if (!row) {
+                continue;
+            }
+            row.eachCell({ includeEmpty: true }, cell => {
+                if (cell.col > bounds.right) {
+                    const hasStyle = cell.style &&
+                        ((cell.style.border &&
+                            (cell.style.border.top ||
+                                cell.style.border.right ||
+                                cell.style.border.bottom ||
+                                cell.style.border.left)) ||
+                            cell.style.fill ||
+                            cell.style.font);
+                    if (hasStyle || (cell.type !== ValueType.Null && cell.type !== ValueType.Merge)) {
+                        bounds.right = cell.col;
+                    }
+                }
+            });
+        }
+    }
     // Convert columns
     const columns = new Map();
     if (hasData) {
@@ -480,7 +505,8 @@ function convertColor(color) {
     return {
         argb: color.argb,
         theme: color.theme,
-        tint: color.tint
+        tint: color.tint,
+        indexed: color.indexed
     };
 }
 function convertFill(fill) {

package/dist/browser/modules/pdf/render/layout-engine.js

@@ -551,7 +551,7 @@ function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options
         if (value && typeof value === "object" && "richText" in value) {
             const runs = value.richText;
             if (runs.length > 0) {
-                const wrappedCount = countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options);
+                const wrappedCount = countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options, cell.style?.font);
                 return Math.max(lineCount, wrappedCount);
             }
         }
@@ -571,7 +571,10 @@ function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options
  * This mirrors the logic in wrapRichTextLines (page-renderer) so that
  * the row height calculation matches the actual rendering.
  */
-function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options) {
+function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options, cellFont) {
+    // Use cell-level font as fallback for runs without their own font
+    const defaultFamily = cellFont?.name ?? options.defaultFontFamily;
+    const defaultSize = cellFont?.size ?? options.defaultFontSize;
     // Build character-to-run mapping
     const runForChar = [];
     for (let ri = 0; ri < runs.length; ri++) {
@@ -579,9 +582,20 @@ function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontMan
             runForChar.push(ri);
         }
     }
-    // Resolve font resources for each run
+    // Resolve font resources for each run (with cell font inheritance)
     const runResources = runs.map(run => {
-        const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
+        const effectiveRunFont = run.font
+            ? {
+                name: run.font.name ?? cellFont?.name,
+                size: run.font.size ?? cellFont?.size,
+                bold: run.font.bold ?? cellFont?.bold,
+                italic: run.font.italic ?? cellFont?.italic,
+                strike: run.font.strike ?? cellFont?.strike,
+                underline: run.font.underline ?? cellFont?.underline,
+                color: run.font.color ?? cellFont?.color
+            }
+            : cellFont;
+        const fontProps = extractFontProperties(effectiveRunFont, defaultFamily, defaultSize);
         const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
         return fontManager.hasEmbeddedFont()
             ? fontManager.getEmbeddedResourceName()
@@ -589,7 +603,15 @@ function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontMan
     });
     // Resolve scaled font sizes for each run
     const runFontSizes = runs.map(run => {
-        const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
+        const effectiveRunFont = run.font
+            ? {
+                name: run.font.name ?? cellFont?.name,
+                size: run.font.size ?? cellFont?.size,
+                bold: run.font.bold ?? cellFont?.bold,
+                italic: run.font.italic ?? cellFont?.italic
+            }
+            : cellFont;
+        const fontProps = extractFontProperties(effectiveRunFont, defaultFamily, defaultSize);
         return fontProps.fontSize * scaleFactor;
     });
     // Measure a range of fullText using per-character run font sizes
@@ -861,8 +883,10 @@ function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, f
         // Track non-WinAnsi code points for Type3 fallback font generation
         fontManager.trackText(text);
     }
-    // Rich text runs
-    const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor);
+    // Rich text runs — pass cell-level font as the fallback for runs without
+    // their own font definition (e.g. the first run often has no font object
+    // and should inherit the cell's style font including bold/italic).
+    const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor, style.font);
     const borders = excelBordersToPdf(style.border);
     return {
         text,
@@ -1305,6 +1329,30 @@ function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleC
             }
             if (overflowAvailable > 0) {
                 cell.textOverflowWidth = Math.min(overflowNeeded, overflowAvailable);
+                // Hide internal vertical borders in the overflow region.
+                // In Excel, when text overflows into adjacent empty cells, the shared
+                // vertical borders between them are not drawn (the text appears to
+                // span across seamlessly). We suppress:
+                // - The overflowing cell's right border
+                // - Each covered neighbor's left border (and right border if fully covered)
+                let accumulated = 0;
+                const actualOverflow = cell.textOverflowWidth;
+                // Remove the source cell's right border if text overflows
+                cell.borders.right = null;
+                for (let j = gci + 1; j < colGroup.length; j++) {
+                    const neighborCell = cellGrid.get(`${ri}:${j}`);
+                    if (!neighborCell) {
+                        break;
+                    }
+                    // Remove the neighbor's left border (shared edge with previous cell)
+                    neighborCell.borders.left = null;
+                    accumulated += groupColWidths[j];
+                    if (accumulated >= actualOverflow) {
+                        break;
+                    }
+                    // If fully covered, also remove the neighbor's right border
+                    neighborCell.borders.right = null;
+                }
             }
         }
     }
@@ -1316,7 +1364,7 @@ function computeTextOverflows(cellGrid, rowPage, colGroup, visibleRows, visibleC
  * Build rich text runs from a RichText cell.
  * Returns null for non-RichText cells.
  */
-function buildRichTextRuns(cell, options, fontManager, scaleFactor) {
+function buildRichTextRuns(cell, options, fontManager, scaleFactor, cellFont) {
     if (!cell || cell.type !== PdfCellType.RichText) {
         return null;
     }
@@ -1328,8 +1376,25 @@ function buildRichTextRuns(cell, options, fontManager, scaleFactor) {
     if (runs.length === 0) {
         return null;
     }
+    // Use cell-level font as fallback for runs without their own font,
+    // falling back to global defaults only if cell font is not available.
+    const defaultFamily = cellFont?.name ?? options.defaultFontFamily;
+    const defaultSize = cellFont?.size ?? options.defaultFontSize;
     return runs.map(run => {
-        const fontProps = extractFontProperties(run.font, options.defaultFontFamily, options.defaultFontSize);
+        // When a run has no font at all, use cell font entirely.
+        // When a run has a partial font, merge with cell font for missing properties.
+        const effectiveFont = run.font
+            ? {
+                name: run.font.name ?? cellFont?.name,
+                size: run.font.size ?? cellFont?.size,
+                bold: run.font.bold ?? cellFont?.bold,
+                italic: run.font.italic ?? cellFont?.italic,
+                strike: run.font.strike ?? cellFont?.strike,
+                underline: run.font.underline ?? cellFont?.underline,
+                color: run.font.color ?? cellFont?.color
+            }
+            : cellFont;
+        const fontProps = extractFontProperties(effectiveFont, defaultFamily, defaultSize);
         // Register font for this run
         if (fontManager.hasEmbeddedFont()) {
             fontManager.trackText(run.text);

package/dist/browser/modules/pdf/render/style-converter.d.ts

@@ -16,7 +16,7 @@ import type { PdfColor, LayoutBorders, PdfColorData, PdfFontStyle, PdfFillData,
 export declare function argbToPdfColor(argb: string | undefined): PdfColor | null;
 /**
  * Convert a color data object to PDF color.
- * Handles both ARGB and theme-based colors.
+ * Handles ARGB, theme-based, and indexed colors.
  */
 export declare function excelColorToPdf(color: Partial<PdfColorData> | undefined): PdfColor | null;
 /**

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

@@ -50,7 +50,7 @@ export 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.
  */
 export function excelColorToPdf(color) {
     if (!color) {
@@ -72,6 +72,10 @@ export function excelColorToPdf(color) {
         }
         return base;
     }
+    // Indexed colors (legacy Excel color palette)
+    if (color.indexed !== undefined) {
+        return indexedColorToPdf(color.indexed);
+    }
     return null;
 }
 /**
@@ -97,6 +101,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/browser/modules/pdf/types.d.ts

@@ -26,6 +26,7 @@ export interface PdfColorData {
     argb?: string;
     theme?: number;
     tint?: number;
+    indexed?: number;
 }
 /** Font style in the PDF input model. */
 export interface PdfFontStyle {

package/dist/browser/modules/word/color-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+import type { DocumentTheme, ColorSpec, HexColor } from "./types.js";
+/**
+ * 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 declare function resolveThemeColor(color: HexColor | ColorSpec | undefined, theme?: DocumentTheme): HexColor | undefined;

package/dist/browser/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/browser/modules/word/content-types.d.ts

@@ -2,6 +2,7 @@
  * DOCX Module - Content Types Generator
  *
  * Generates [Content_Types].xml for the DOCX package.
+ * Uses a plain data record + free functions for tree-shakeability.
  */
 import type { XmlSink } from "../xml/types.js";
 /** Content type override entry. */
@@ -9,19 +10,18 @@ export interface ContentTypeOverride {
     readonly partName: string;
     readonly contentType: string;
 }
-/**
- * Generates the [Content_Types].xml part.
- */
-export declare class ContentTypesManager {
-    private readonly _defaults;
-    private readonly _overrides;
-    constructor();
-    /** Add a default content type for a file extension. */
-    addDefault(extension: string, contentType: string): void;
-    /** Add an override content type for a specific part. */
-    addOverride(partName: string, contentType: string): void;
-    /** Add image extension defaults from a set of used extensions. */
-    addImageDefaults(extensions: Iterable<string>): void;
-    /** Render the [Content_Types].xml to a sink. */
-    render(xml: XmlSink): void;
+/** Internal state for content types (plain record, not a class). */
+export interface ContentTypesState {
+    readonly defaults: Map<string, string>;
+    readonly overrides: ContentTypeOverride[];
 }
+/** Create a new ContentTypesState with standard defaults (rels, xml). */
+export declare function createContentTypes(): ContentTypesState;
+/** Add a default content type for a file extension. */
+export declare function addContentTypeDefault(state: ContentTypesState, extension: string, contentType: string): void;
+/** Add an override content type for a specific part. */
+export declare function addContentTypeOverride(state: ContentTypesState, partName: string, contentType: string): void;
+/** Add image extension defaults from a set of used extensions. */
+export declare function addImageContentTypeDefaults(state: ContentTypesState, extensions: Iterable<string>): void;
+/** Render the [Content_Types].xml to a sink. */
+export declare function renderContentTypes(state: ContentTypesState, xml: XmlSink): void;

package/dist/browser/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/browser/modules/word/crypto.d.ts

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

package/dist/browser/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/browser/modules/word/document-io.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 type { DocxDocument, Paragraph, Table, ImageDef } from "./types.js";
+/** Package a DocxDocument model to DOCX bytes. */
+export declare function toBuffer(doc: DocxDocument, compressionLevel?: number): Promise<Uint8Array>;
+/** Package a DocxDocument model to base64 string. */
+export declare function toBase64(doc: DocxDocument, compressionLevel?: number): Promise<string>;
+/** Type of content to patch into a placeholder. */
+export type PatchContent = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "paragraph";
+    readonly children: readonly Paragraph[];
+} | {
+    readonly type: "table";
+    readonly table: Table;
+} | {
+    readonly type: "image";
+    readonly image: ImageDef;
+    readonly width: number;
+    readonly height: number;
+};
+/** A single patch operation mapping a placeholder to replacement content. */
+export interface PatchOperation {
+    /** Placeholder string to find (e.g. "{{name}}"). */
+    readonly placeholder: string;
+    /** Content to replace the placeholder with. */
+    readonly content: PatchContent;
+}
+/** Options for patchDocument. */
+export interface PatchOptions {
+    /** Compression level (0-9). Default: 6. */
+    readonly compressionLevel?: number;
+}
+/**
+ * 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 declare function patchDocument(buffer: Uint8Array, patches: readonly PatchOperation[], options?: PatchOptions): Promise<Uint8Array>;