@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/types/modules/excel/workbook.browser.d.ts

@@ -14,9 +14,10 @@ import { DefinedNames, type DefinedNameModel } from "./defined-names.js";
 import type { PivotTable } from "./pivot-table.js";
 import { WorkbookReader, type WorkbookReaderOptions } from "./stream/workbook-reader.js";
 import { WorkbookWriter, type WorkbookWriterOptions } from "./stream/workbook-writer.js";
-import type { AddWorksheetOptions, CalculationProperties, ImageData, WorkbookProperties, WorkbookView, Buffer as ExcelBuffer } from "./types.js";
+import type { AddWorksheetOptions, CalculationProperties, CellValue, Font, ImageData, WorkbookProperties, WorkbookProtection, WorkbookView, Buffer as ExcelBuffer } from "./types.js";
 import { Worksheet, type WorksheetModel } from "./worksheet.js";
 import { XLSX } from "./xlsx/xlsx.js";
+import type { SyntaxProbe } from "../formula/default-syntax-probe.js";
 import type { MarkdownOptions } from "../markdown/types.js";
 import type { Readable } from "../stream/index.js";
 import type { IReadable, IWritable } from "../stream/types.js";
@@ -38,6 +39,7 @@ export interface WorkbookModel {
     created: Date;
     modified: Date;
     properties: Partial<WorkbookProperties>;
+    protection?: WorkbookProtectionModel;
     worksheets: WorksheetModel[];
     sheets?: WorksheetModel[];
     definedNames: DefinedNameModel[];
@@ -56,14 +58,101 @@ export interface WorkbookModel {
     media: WorkbookMedia[];
     pivotTables: PivotTable[];
     /** Loaded pivot tables from file - used during reconciliation */
-    loadedPivotTables?: any[];
+    loadedPivotTables?: PivotTable[];
     calcProperties: Partial<CalculationProperties>;
     /** Passthrough files (charts, etc.) preserved for round-trip */
     passthrough?: Record<string, Uint8Array>;
     /** Raw drawing XML data for passthrough (when drawing contains chart references) */
     rawDrawings?: Record<string, Uint8Array>;
     /** Default font preserved from the original file for round-trip fidelity */
-    defaultFont?: any;
+    defaultFont?: Partial<Font>;
+    /**
+     * External workbook references in declaration order. Matches the on-disk
+     * `[N]Sheet!Ref` indexing (1-based). Empty or undefined when the workbook
+     * has no external references.
+     */
+    externalLinks?: ExternalLinkModel[];
+}
+/** Internal model for workbook-level protection (serialized to <workbookProtection>) */
+export interface WorkbookProtectionModel {
+    lockStructure?: boolean;
+    lockWindows?: boolean;
+    lockRevision?: boolean;
+    workbookPassword?: string;
+    revisionsPassword?: string;
+    algorithmName?: string;
+    hashValue?: string;
+    saltValue?: string;
+    spinCount?: number;
+}
+/**
+ * Cached values for a single sheet of an external workbook. Keys are the
+ * A1-notation cell addresses *in uppercase* (e.g. `"A1"`, `"B12"`). Values
+ * are the cached primitives Excel displays when the external file is not
+ * currently available — must be JSON primitives: string, number, boolean, or
+ * null for an explicitly blank cell.
+ */
+export type ExternalLinkCachedSheet = Record<string, string | number | boolean | null>;
+/**
+ * A single external workbook reference. Each entry corresponds to one
+ * `xl/externalLinks/externalLink{N}.xml` part in the output file, and to
+ * one `<externalReference r:id="...">` entry in `xl/workbook.xml`.
+ *
+ * The on-disk formula syntax for referring to this workbook is `[N]Sheet!A1`
+ * where `N` is the 1-based `index` below.
+ */
+export interface ExternalLinkModel {
+    /**
+     * The 1-based index used in `[N]Sheet!A1` formulas. This is the position
+     * in the workbook's `<externalReferences>` list (in declaration order).
+     * Assigned automatically on read/write; treat as read-only when produced
+     * by the library.
+     */
+    index: number;
+    /**
+     * The rel Target that will be written into
+     * `xl/externalLinks/_rels/externalLink{N}.xml.rels`. For relative paths
+     * (which is what users almost always want), pass the bare filename or a
+     * path relative to the current workbook: `"测试.xlsx"`, `"data/ref.xlsx"`.
+     * Office resolves bare relative paths from the current workbook's
+     * directory — *that* is the fix for the "Office goes to the Documents
+     * folder" problem described in exceljs#3039.
+     *
+     * Absolute `file:///` or `http(s)://` URIs are accepted and written
+     * through unchanged.
+     */
+    target: string;
+    /**
+     * Almost always `"External"`. `"Internal"` is for embedded workbooks
+     * (rare) and is preserved on round-trip when present in the source file.
+     */
+    targetMode: "External" | "Internal";
+    /**
+     * The relationship id inside `xl/_rels/workbook.xml.rels` pointing to this
+     * external link's XML part. Populated automatically on read and
+     * re-assigned on write. Callers should leave this undefined.
+     */
+    rId?: string;
+    /**
+     * The sheet names exposed by the external workbook, in declaration order.
+     * Excel writes one `<sheetName val="..."/>` per entry under
+     * `<sheetNames>` inside the externalLink part.
+     *
+     * At minimum you must declare every sheet that appears in a formula
+     * targeting this external workbook, otherwise Excel will fail to link
+     * the cached values and show `#REF!`.
+     */
+    sheetNames: string[];
+    /**
+     * Cached primitive values per sheet. Key is the *sheet name* (matching an
+     * entry in `sheetNames`), value is a map from A1 address to primitive.
+     *
+     * Cached values are what Excel displays when the referenced external file
+     * is not available (e.g. freshly-downloaded workbook on another machine).
+     * Writing them turns your file from "opens with errors" into "opens,
+     * shows values, offers to update links".
+     */
+    cachedValues?: Record<string, ExternalLinkCachedSheet>;
 }
 /**
  * Supported input types for CSV parsing
@@ -94,7 +183,19 @@ interface CsvOptionsExtras {
     dateFormats?: readonly DateFormat[];
     dateFormat?: string;
     dateUTC?: boolean;
-    map?(value: any, index: number): any;
+    /**
+     * Transform each cell value as rows are parsed from CSV or formatted for
+     * CSV output.
+     *
+     * - During parse: `value` is the raw JS value produced by the CSV parser
+     *   (string, number, boolean, Date, ...) and already narrows to `CellValue`.
+     * - During format: `value` is the worksheet cell's `CellValue`.
+     *
+     * The function should return a `CellValue`; returning non-`CellValue`
+     * types (functions, symbols, ...) is unsupported and will break downstream
+     * serialization.
+     */
+    map?(value: CellValue, index: number): CellValue;
     includeEmptyRows?: boolean;
     requestHeaders?: Record<string, string>;
     requestBody?: BodyInit;
@@ -145,6 +246,17 @@ declare class Workbook {
     views: WorkbookView[];
     media: WorkbookMedia[];
     pivotTables: PivotTable[];
+    protection?: WorkbookProtectionModel;
+    /**
+     * External workbook references, in declaration order. The 1-based index
+     * of each entry matches the `[N]` prefix used inside formula strings
+     * (e.g. the first entry is referenced as `[1]Sheet1!A1` on disk).
+     *
+     * Prefer {@link addExternalLink} for appending — it handles index
+     * assignment and sheet-name deduplication. Direct mutation of this array
+     * is supported but callers must keep indices contiguous starting at 1.
+     */
+    externalLinks: ExternalLinkModel[];
     protected _worksheets: Worksheet[];
     protected _definedNames: DefinedNames;
     protected _themes?: unknown;
@@ -153,9 +265,50 @@ declare class Workbook {
     /** Raw drawing XML data for passthrough (when drawing contains chart references) */
     protected _rawDrawings: Record<string, Uint8Array>;
     /** Default font preserved from original file for round-trip fidelity */
-    protected _defaultFont?: any;
+    protected _defaultFont?: Partial<Font>;
+    /**
+     * Cache of external-workbook references auto-discovered from formula
+     * strings during previous `writeBuffer()` calls. This is an internal
+     * stash used to keep subsequent writes fixed-point stable: once a
+     * formula has been normalised to `[N]Sheet!A1`, the writer needs the
+     * corresponding link metadata on the next write too, but we don't want
+     * those auto-discovered entries to appear on the user-facing
+     * `externalLinks` list. Indexed by lower-cased target path.
+     *
+     * Entries explicitly added via `addExternalLink()` live on `externalLinks`
+     * instead — the writer combines both at serialisation time.
+     */
+    protected _writerExternalLinkCache: Map<string, ExternalLinkModel>;
+    /** Global registry of table names (lowercase) for cross-worksheet uniqueness checks. */
+    readonly _tableNames: Set<string>;
     private _xlsx?;
-    constructor();
+    /**
+     * @param options Optional construction options.
+     *   - `formulaSyntaxProbe`: An explicit tokenizer+parser probe used to
+     *     classify defined-name text during XLSX load. Providing this makes
+     *     classification deterministic for *this* workbook regardless of
+     *     whether `installFormulaEngine()` has been called. Most callers
+     *     don't need it — `installFormulaEngine()` registers a
+     *     process-wide default probe that is picked up automatically.
+     */
+    constructor(options?: {
+        formulaSyntaxProbe?: SyntaxProbe;
+    });
+    /**
+     * The default font for the workbook (fontId=0 / "Normal" style).
+     * Cells without explicit font styles will inherit this font in Excel.
+     *
+     * @example
+     * ```ts
+     * wb.defaultFont = { name: "Arial", size: 12 };
+     * ```
+     *
+     * When reading an existing XLSX file, this preserves the original default font
+     * for round-trip fidelity. Setting it on a new workbook changes the default
+     * from Calibri 11 to your chosen font.
+     */
+    get defaultFont(): Partial<Font> | undefined;
+    set defaultFont(font: Partial<Font> | undefined);
     /**
      * Import a worksheet from another workbook (or a standalone worksheet).
      * Deep-copies all worksheet properties via the model getter/setter, including
@@ -168,6 +321,18 @@ declare class Workbook {
      * @returns The newly created worksheet
      */
     importSheet(source: Worksheet, name?: string): Worksheet;
+    /**
+     * Protect the workbook structure with an optional password.
+     * Prevents users from adding, deleting, renaming, moving, or copying worksheets.
+     *
+     * @param password - Optional password to protect the structure
+     * @param options  - Optional protection flags (lockStructure, lockWindows, lockRevision)
+     */
+    protect(password?: string, options?: Partial<WorkbookProtection>): Promise<void>;
+    /**
+     * Remove workbook structure protection.
+     */
+    unprotect(): void;
     /**
      * xlsx file format operations
      * Node.js: readFile, writeFile, read (stream), write (stream), load (buffer), writeBuffer
@@ -399,12 +564,98 @@ declare class Workbook {
      */
     eachSheet(callback: (sheet: Worksheet, id: number) => void): void;
     get definedNames(): DefinedNames;
+    /**
+     * Recalculate all formula cells in this workbook.
+     *
+     * Evaluates every formula cell using the built-in calculation engine and updates
+     * each cell's cached `result` value in-place. Formulas are evaluated with
+     * recursive dependency resolution, memoization, and circular reference detection.
+     *
+     * Call this after programmatically modifying cell values that are referenced by
+     * formulas, to ensure formula results reflect the latest data.
+     *
+     * Unsupported functions preserve their original cached result if one exists.
+     *
+     * ## Tree-shaking note
+     *
+     * The formula engine ships ~200KB of code (433 Excel functions, parser,
+     * evaluator, dependency graph, spill materialiser). To keep it out of
+     * bundles that don't need it, the engine is registered at runtime
+     * rather than imported by the core `Workbook` module. Call
+     * {@link installFormulaEngine} once at startup before the first call
+     * to this method, or a clear error will be thrown explaining what to do.
+     *
+     * ```ts
+     * import { installFormulaEngine } from "@cj-tech-master/excelts/formula";
+     *
+     * installFormulaEngine();                   // once, at startup
+     *
+     * sheet.getCell("A1").value = 100;
+     * workbook.calculateFormulas();             // now works
+     * ```
+     *
+     * Callers who prefer a zero-side-effect, tree-shakeable surface can
+     * use the functional equivalent directly:
+     *
+     * ```ts
+     * import { calculateFormulas } from "@cj-tech-master/excelts/formula";
+     * calculateFormulas(workbook);
+     * ```
+     */
+    calculateFormulas(): void;
     clearThemes(): void;
     /**
      * Add Image to Workbook and return the id
      */
     addImage(image: ImageData): number;
     getImage(id: number | string): WorkbookMedia | undefined;
+    /**
+     * Declare that formulas in this workbook may reference an external
+     * workbook. Registers the target so the output file contains the required
+     * `xl/externalLinks/externalLink{N}.xml` part plus its `.rels` sibling
+     * and Office/WPS can resolve the reference correctly.
+     *
+     * When Office opens the file, it resolves a relative `target` like
+     * `"测试.xlsx"` **relative to the current workbook's directory** — which
+     * is the exact behaviour the user expects when they write
+     * `=[测试.xlsx]Sheet1!A1`. Absolute `file:///…` or `http(s)://…` URIs
+     * are accepted and written through unchanged.
+     *
+     * @returns the registered {@link ExternalLinkModel}. Its `index` field is
+     *   the 1-based number used inside the `[N]` prefix of on-disk formula
+     *   strings (the library rewrites `[target]` forms to `[index]` at write
+     *   time automatically).
+     *
+     * @example
+     * ```ts
+     * const wb = new Workbook();
+     * const ws = wb.addWorksheet("Main");
+     *
+     * // Declare the link once — sheet names and cached values are optional
+     * // but improve interoperability (Excel displays cached values when the
+     * // external file is unavailable).
+     * wb.addExternalLink({
+     *   target: "测试.xlsx",
+     *   sheetNames: ["Sheet1"],
+     *   cachedValues: { Sheet1: { A1: 42 } }
+     * });
+     *
+     * // Write the formula using either the target name OR the numeric index;
+     * // the library normalises both to the on-disk `[N]` form.
+     * ws.getCell("A1").value = { formula: "=[测试.xlsx]Sheet1!A1", result: 42 };
+     * ```
+     */
+    addExternalLink(input: {
+        target: string;
+        sheetNames?: string[];
+        cachedValues?: ExternalLinkModel["cachedValues"];
+        targetMode?: ExternalLinkModel["targetMode"];
+    }): ExternalLinkModel;
+    /**
+     * Retrieve an external link by its 1-based on-disk index (the number
+     * inside the `[N]` formula prefix) or by matching target path.
+     */
+    getExternalLink(indexOrTarget: number | string): ExternalLinkModel | undefined;
     get model(): WorkbookModel;
     set model(value: WorkbookModel);
 }

package/dist/types/modules/excel/workbook.d.ts

@@ -60,4 +60,4 @@ declare class Workbook extends WorkbookBrowser {
     writeMarkdownFile(filename: string, options?: MarkdownOptions): Promise<void>;
 }
 export { Workbook };
-export type { CsvOptions, CsvInput, WorkbookModel, WorkbookMedia } from "./workbook.browser.js";
+export type { CsvOptions, CsvInput, WorkbookModel, WorkbookMedia, WorkbookProtectionModel, ExternalLinkModel, ExternalLinkCachedSheet } from "./workbook.browser.js";

package/dist/types/modules/excel/worksheet.d.ts

@@ -7,7 +7,7 @@ import { type PivotTable, type PivotTableModel } from "./pivot-table.js";
 import { Range, type RangeInput } from "./range.js";
 import { Row, type RowModel } from "./row.js";
 import { Table, type TableModel } from "./table.js";
-import type { AddImageRange, AutoFilter, CellValue, ColBreak, ConditionalFormattingOptions, DataValidation, RowBreak, RowValues, TableProperties, WatermarkOptions, WorksheetProperties, WorksheetState, WorksheetView } from "./types.js";
+import type { AddImageRange, AutoFilter, CellValue, ColBreak, ConditionalFormattingOptions, DataValidation, IgnoredError, RowBreak, RowValues, TableProperties, WatermarkOptions, WorksheetProperties, WorksheetState, WorksheetView } from "./types.js";
 import { type Origin } from "./utils/address.js";
 import type { Workbook } from "./workbook.js";
 type DataValidationModel = {
@@ -108,6 +108,7 @@ interface WorksheetModel {
     pivotTables: PivotTable[];
     conditionalFormattings: ConditionalFormattingOptions[];
     formControls: FormCheckboxModel[];
+    ignoredErrors: IgnoredError[];
     watermark?: WatermarkOptions | null;
     cols?: ColumnModel[];
     rows?: RowModel[];
@@ -142,6 +143,7 @@ declare class Worksheet {
     pivotTables: PivotTable[];
     conditionalFormattings: ConditionalFormattingOptions[];
     formControls: FormCheckbox[];
+    ignoredErrors: IgnoredError[];
     private _headerRowCount?;
     /** Loaded drawing data (for charts, etc.) - preserved for round-trip */
     private _drawing;

package/dist/types/modules/excel/xlsx/rel-type.d.ts

@@ -17,5 +17,20 @@ declare const RelType: {
     PivotTable: string;
     FeaturePropertyBag: string;
     CtrlProp: string;
+    SheetMetadata: string;
+    /**
+     * Relationship type for the externalLink part referenced from
+     * xl/_rels/workbook.xml.rels. Target is an internal path like
+     * `externalLinks/externalLink1.xml`.
+     */
+    ExternalLink: string;
+    /**
+     * Relationship type used *inside* xl/externalLinks/_rels/externalLinkN.xml.rels
+     * to point at the actual external workbook. When `TargetMode="External"` and
+     * `Target` is a bare relative path (e.g. `"测试.xlsx"`), Office resolves it
+     * relative to the current workbook's directory — exactly the behaviour users
+     * expect from `=[测试.xlsx]Sheet1!A1`.
+     */
+    ExternalLinkPath: string;
 };
 export { RelType };

package/dist/types/modules/excel/xlsx/xform/book/defined-name-xform.d.ts

@@ -1,9 +1,5 @@
+import type { DefinedNameModel } from "../../../defined-names.js";
 import { BaseXform } from "../base-xform.js";
-interface DefinedNameModel {
-    name: string;
-    ranges: string[];
-    localSheetId?: number;
-}
 declare class DefinedNamesXform extends BaseXform {
     private _parsedName?;
     private _parsedLocalSheetId?;
@@ -12,6 +8,11 @@ declare class DefinedNamesXform extends BaseXform {
     render(xmlStream: any, model: DefinedNameModel): void;
     parseOpen(node: any): boolean;
     parseText(text: string): void;
+    /**
+     * Stage 1 of the two-phase defined name design: the XLSX layer only
+     * preserves the raw XML text.  Semantic classification (reference vs
+     * formula vs opaque) is deferred to `DefinedNames.set model()`.
+     */
     parseClose(): boolean;
 }
 export { DefinedNamesXform };

package/dist/types/modules/excel/xlsx/xform/book/external-link-xform.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ExternalLinkXform — read and write `xl/externalLinks/externalLinkN.xml`.
+ *
+ * This part describes one external workbook referenced by the current file:
+ * the list of sheets inside the foreign workbook, plus an optional cache of
+ * the primitive values at each referenced address. The `r:id` attribute on
+ * `<externalBook>` points (via the neighbouring `_rels/externalLinkN.xml.rels`)
+ * at the actual file; that resolution is handled by the writer/reader in
+ * `xlsx.browser.ts`, not here.
+ *
+ * Schema shape:
+ *
+ *   <externalLink xmlns=".../spreadsheetml/2006/main"
+ *                 xmlns:r=".../relationships">
+ *     <externalBook r:id="rId1">
+ *       <sheetNames>
+ *         <sheetName val="Sheet1"/>
+ *         <sheetName val="Sheet2"/>
+ *       </sheetNames>
+ *       <sheetDataSet>
+ *         <sheetData sheetId="0">                (0-based index into sheetNames)
+ *           <row r="1">
+ *             <cell r="A1" t="n"><v>123</v></cell>
+ *             <cell r="B1" t="str"><v>hello</v></cell>
+ *           </row>
+ *           <row r="2">
+ *             <cell r="A2" t="b"><v>1</v></cell>
+ *           </row>
+ *         </sheetData>
+ *         <sheetData sheetId="1" refreshError="1"/>   (no cached values)
+ *       </sheetDataSet>
+ *     </externalBook>
+ *   </externalLink>
+ *
+ * The `t` attribute on `<cell>` mirrors the inline-value types used inside a
+ * worksheet's `<c>` element: "n" (number, default), "str" (string), "b"
+ * (boolean), "e" (error). We don't emit shared-string indices here because
+ * the externalLink part is self-contained — each cached string is serialised
+ * inline as plain text inside `<v>`.
+ *
+ * Parser state machine:
+ *   externalLink → externalBook → sheetNames → sheetName  (stores names in order)
+ *                            \→ sheetDataSet → sheetData → row → cell → v  (values)
+ *
+ * The parser tolerates missing cache data (Excel's `refreshError="1"` mode);
+ * sheets without a matching `<sheetData>` simply have no entry in
+ * `cachedValues`.
+ */
+import type { ExternalLinkCachedSheet, ExternalLinkModel } from "../../../workbook.browser.js";
+import { BaseXform } from "../base-xform.js";
+import type { XmlSink } from "../../../../xml/types.js";
+/**
+ * Parsed shape of a single externalLinkN.xml part. Callers (xlsx.browser.ts)
+ * merge `rId` with the matching `workbookRels` entry to recover the model's
+ * `target` / `targetMode`, since those live in the sibling `.rels` file.
+ */
+export interface ParsedExternalLink {
+    /** r:id on <externalBook>. Points at the rel inside externalLinkN.xml.rels. */
+    externalBookRId: string;
+    sheetNames: string[];
+    cachedValues: Record<string, ExternalLinkCachedSheet>;
+}
+declare class ExternalLinkXform extends BaseXform<ParsedExternalLink> {
+    /** Sheet name indexed by sheetId (0-based) — filled during parse. */
+    private sheetNamesByIndex;
+    /** Current sheet's accumulated cached cells. */
+    private currentSheetCells;
+    /** Current sheet's name (looked up from sheetId). */
+    private currentSheetName;
+    /** Current cell being parsed: address + type. */
+    private currentCellAddress;
+    private currentCellType;
+    /** Accumulated text content of the current <v> element. */
+    private currentCellValue;
+    /** Which element we're currently inside. */
+    private inV;
+    get tag(): string;
+    reset(): void;
+    render(xmlStream: XmlSink, model: ExternalLinkModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { ExternalLinkXform };

package/dist/types/modules/excel/xlsx/xform/book/external-reference-xform.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Xform for a single `<externalReference r:id="..."/>` element inside
+ * `<externalReferences>` in `xl/workbook.xml`. Each `<externalReference>`
+ * maps positionally (in document order, 1-based) to an `[N]Sheet!Ref`
+ * prefix in formula strings.
+ */
+import { BaseXform } from "../base-xform.js";
+export interface ExternalReferenceModel {
+    rId: string;
+}
+declare class ExternalReferenceXform extends BaseXform<ExternalReferenceModel> {
+    render(xmlStream: any, model: ExternalReferenceModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { ExternalReferenceXform };

package/dist/types/modules/excel/xlsx/xform/book/workbook-calc-properties-xform.d.ts

@@ -1,6 +1,9 @@
 import { BaseXform } from "../base-xform.js";
 interface CalcPropertiesModel {
     fullCalcOnLoad?: boolean;
+    iterate?: boolean;
+    iterateCount?: number;
+    iterateDelta?: number;
 }
 declare class WorkbookCalcPropertiesXform extends BaseXform {
     render(xmlStream: any, model: CalcPropertiesModel): void;

package/dist/types/modules/excel/xlsx/xform/book/workbook-protection-xform.d.ts

@@ -0,0 +1,20 @@
+import { BaseXform } from "../base-xform.js";
+interface WorkbookProtectionModel {
+    lockStructure?: boolean;
+    lockWindows?: boolean;
+    lockRevision?: boolean;
+    workbookPassword?: string;
+    revisionsPassword?: string;
+    algorithmName?: string;
+    hashValue?: string;
+    saltValue?: string;
+    spinCount?: number;
+}
+declare class WorkbookProtectionXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: WorkbookProtectionModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookProtectionXform };

package/dist/types/modules/excel/xlsx/xform/core/metadata-xform.d.ts

@@ -0,0 +1,56 @@
+import { BaseXform } from "../base-xform.js";
+/**
+ * Internal model for xl/metadata.xml.
+ *
+ * The metadata file supports various metadata types via futureMetadata blocks.
+ * For dynamic array formulas, the only type we care about is "XLDAPR" (Excel
+ * Dynamic Array PRoperties). The structure is:
+ *
+ *   metadataTypes: declares which metadata types exist (always XLDAPR for DA)
+ *   futureMetadata: per-type blocks with ext data (dynamicArrayProperties)
+ *   cellMetadata: maps cm indices (1-indexed on <c>) to futureMetadata entries
+ *
+ * For simplicity, all dynamic array formulas share a single XLDAPR futureMetadata
+ * block with fDynamic="1" fCollapsed="0", and a single cellMetadata record
+ * pointing to it. Every dynamic array cell gets cm="1".
+ */
+interface MetadataModel {
+    /** Number of cells that reference dynamic array metadata */
+    dynamicArrayCount: number;
+}
+/**
+ * Parsed result from xl/metadata.xml.
+ *
+ * `dynamicArrayCmIndices` is a set of cm values (1-indexed, matching the `cm`
+ * attribute on `<c>` elements) whose corresponding cellMetadata record points
+ * to an XLDAPR metadataType. This allows precise per-cell identification of
+ * dynamic array formulas without assuming all cm values are XLDAPR.
+ *
+ * `hasDynamicArrays` is a convenience shorthand: `dynamicArrayCmIndices.size > 0`.
+ */
+interface MetadataParseResult {
+    hasDynamicArrays: boolean;
+    dynamicArrayCmIndices: Set<number>;
+}
+declare class MetadataXform extends BaseXform {
+    /** metadataType names in declaration order (1-indexed in OOXML) */
+    private _metadataTypeNames;
+    /** Per cellMetadata bk: the rc.t value (metadataType index, 1-indexed) */
+    private _cellMetadataTypeRefs;
+    /** Whether we are currently inside <cellMetadata> */
+    private _inCellMetadata;
+    /** Current rc.t value being collected inside a <bk> */
+    private _currentRcType;
+    get tag(): string;
+    /**
+     * Render xl/metadata.xml for the given model.
+     * Only emits content when dynamicArrayCount > 0.
+     */
+    render(xmlStream: any, model: MetadataModel): void;
+    reset(): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { MetadataXform };
+export type { MetadataModel, MetadataParseResult };

package/dist/types/modules/excel/xlsx/xform/drawing/absolute-anchor-xform.d.ts

@@ -0,0 +1,26 @@
+import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
+/**
+ * Xform for <xdr:absoluteAnchor> — images positioned by absolute coordinates
+ * rather than cell references.
+ *
+ * Structure:
+ * ```xml
+ * <xdr:absoluteAnchor>
+ *   <xdr:pos x="0" y="0"/>
+ *   <xdr:ext cx="1000000" cy="1000000"/>
+ *   <xdr:pic>...</xdr:pic>
+ *   <xdr:clientData/>
+ * </xdr:absoluteAnchor>
+ * ```
+ */
+declare class AbsoluteAnchorXform extends BaseCellAnchorXform {
+    constructor();
+    get tag(): string;
+    prepare(model: any, options: {
+        index: number;
+    }): void;
+    render(xmlStream: any, model: any): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any, options: any): void;
+}
+export { AbsoluteAnchorXform };

package/dist/types/modules/excel/xlsx/xform/sheet/cell-xform.d.ts

@@ -1,7 +1,7 @@
 import { BaseXform } from "../base-xform.js";
 declare class CellXform extends BaseXform {
     private richTextXform;
-    parser: any;
+    parser: BaseXform | undefined;
     private t;
     private currentNode;
     constructor();

package/dist/types/modules/excel/xlsx/xform/sheet/ignored-errors-xform.d.ts

@@ -0,0 +1,21 @@
+import type { IgnoredError } from "../../../types.js";
+import { BaseXform } from "../base-xform.js";
+/**
+ * Xform for the <ignoredErrors> element in a worksheet.
+ *
+ * Renders:
+ * ```xml
+ * <ignoredErrors>
+ *   <ignoredError sqref="A1:B10" numberStoredAsText="1" />
+ * </ignoredErrors>
+ * ```
+ */
+declare class IgnoredErrorsXform extends BaseXform {
+    model: IgnoredError[];
+    get tag(): string;
+    render(xmlStream: any, model: IgnoredError[] | undefined): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { IgnoredErrorsXform };