@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/browser/modules/excel/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -1,16 +1,30 @@
 import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { CellPositionXform } from "./cell-position-xform.js";
+import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
 import { SpXform } from "./sp-xform.js";
 import { StaticXform } from "../static-xform.js";
 class TwoCellAnchorXform extends BaseCellAnchorXform {
     constructor() {
         super();
+        // Parse state for the inner `<mc:AlternateContent>` block that
+        // chartEx drawings place in the shape slot of a `<xdr:twoCellAnchor>`.
+        // See `render()` for the canonical layout. When `_inFallback`
+        // flips on we swallow every open/close/text until the matching
+        // `</mc:Fallback>` — the Fallback contents are a legacy-Excel
+        // placeholder shape that structured consumers don't need to
+        // surface; `alternateContent.requires` on the model is enough
+        // to re-emit it verbatim on save.
+        this._acDepth = 0;
+        this._inFallback = false;
+        this._fallbackDepth = 0;
+        this._choiceRequires = undefined;
         this.map = {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new PicXform(),
             "xdr:sp": new SpXform(),
+            "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -21,40 +35,304 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
         if (model.picture) {
             this.map["xdr:pic"].prepare(model.picture, options);
         }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].prepare(model.graphicFrame, options);
+        }
     }
     render(xmlStream, model) {
-        const wrapAlternateContent = !!model.alternateContent;
-        if (wrapAlternateContent) {
+        // ChartEx anchors (sunburst, treemap, funnel, waterfall, boxplot,
+        // histogram, region map, …) MUST be wrapped in
+        // `<mc:AlternateContent>`. ChartEx is a Microsoft extension that
+        // was never in the base OOXML spec; Excel's strict loader
+        // rejects a bare `<xdr:graphicFrame><cx:chart/>` anchor with
+        // "Removed Part: /xl/drawings/drawingN.xml (Drawing shape)".
+        //
+        // CRITICAL: Excel emits `<mc:AlternateContent>` as the SHAPE slot
+        // INSIDE the `<xdr:twoCellAnchor>`, between `<xdr:to>` and
+        // `<xdr:clientData>` — NOT around the whole anchor. The Choice
+        // carries the `<xdr:graphicFrame>` and the Fallback carries the
+        // `<xdr:sp>`; they share the single `<xdr:from>`/`<xdr:to>` of
+        // the outer anchor. This is how Microsoft Excel itself writes
+        // chartEx drawings — see `tmp/ttttt.xlsx` (Excel 2021-authored)
+        // for the canonical byte layout. Earlier revisions of this file
+        // wrapped the ENTIRE anchor in `<mc:AlternateContent>` and
+        // duplicated `<xdr:from>`/`<xdr:to>` in both Choice and
+        // Fallback. Excel's strict loader rejected that nesting even
+        // though MC substitution rules permit it in theory — the
+        // "Removed Part: drawing1.xml" repair dialog users saw on open
+        // was caused by this exact mis-nesting.
+        //
+        // Canonical structure:
+        //
+        //   <xdr:twoCellAnchor>
+        //     <xdr:from>…</xdr:from>
+        //     <xdr:to>…</xdr:to>
+        //     <mc:AlternateContent>
+        //       <mc:Choice Requires="cx1" xmlns:cx1="…/2015/9/8/chartex">
+        //         <xdr:graphicFrame>…<cx:chart/>…</xdr:graphicFrame>
+        //       </mc:Choice>
+        //       <mc:Fallback>
+        //         <xdr:sp>…placeholder…</xdr:sp>
+        //       </mc:Fallback>
+        //     </mc:AlternateContent>
+        //     <xdr:clientData/>
+        //   </xdr:twoCellAnchor>
+        //
+        // The Fallback MUST NOT be empty — an empty fallback is spec-legal
+        // but Excel's validator treats an empty-choice+empty-fallback
+        // pair as "collapses to nothing" and drops the drawing. The
+        // placeholder shape we emit mirrors the "This chart isn't
+        // available in your version of Excel" message Office uses.
+        //
+        // The `a14`-requires branch (form-control shapes) uses the LEGACY
+        // wrap-the-whole-anchor form with an empty Fallback. That form
+        // was fine for 2010-era form controls and round-tripping code
+        // still depends on it; it is NOT the chartEx shape.
+        const requires = model.alternateContent?.requires;
+        const isChartEx = requires === "cx1" || requires === "cx";
+        const wrapAnchorInAc = !!requires && !isChartEx;
+        if (wrapAnchorInAc) {
+            // Legacy wrap-the-whole-anchor path (form controls, etc.)
             xmlStream.openNode("mc:AlternateContent", {
                 "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
             });
             xmlStream.openNode("mc:Choice", {
-                Requires: model.alternateContent?.requires,
-                ...(model.alternateContent?.requires === "a14"
-                    ? {
-                        "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
-                    }
+                Requires: requires,
+                ...(requires === "a14"
+                    ? { "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main" }
                     : {})
             });
         }
-        xmlStream.openNode(this.tag, { editAs: model.range.editAs ?? "oneCell" });
+        const editAs = model.range.editAs ?? (model.graphicFrame ? undefined : "oneCell");
+        // `editAs="twoCell"` is the default per the CT_TwoCellAnchor
+        // schema — Microsoft Excel omits the attribute in this case.
+        // Emitting it anyway is spec-valid but byte-diverges from
+        // Excel's own output for chartEx drawings, so suppress it when
+        // the effective value is the default.
+        const emitEditAs = editAs && editAs !== "twoCell" ? { editAs } : {};
+        xmlStream.openNode(this.tag, emitEditAs);
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:to"].render(xmlStream, model.range.br);
-        if (model.picture) {
+        if (isChartEx) {
+            // ChartEx: wrap the graphicFrame/shape INSIDE the anchor in
+            // mc:AlternateContent, matching Excel's emitted layout.
+            this.renderChartExAlternateContent(xmlStream, model);
+        }
+        else if (model.picture) {
             this.map["xdr:pic"].render(xmlStream, model.picture);
         }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
         else if (model.shape) {
             this.map["xdr:sp"].render(xmlStream, model.shape);
         }
         this.map["xdr:clientData"].render(xmlStream, {});
-        xmlStream.closeNode();
-        if (wrapAlternateContent) {
+        xmlStream.closeNode(); // xdr:twoCellAnchor
+        if (wrapAnchorInAc) {
             xmlStream.closeNode(); // mc:Choice
             xmlStream.leafNode("mc:Fallback");
             xmlStream.closeNode(); // mc:AlternateContent
         }
     }
+    /**
+     * Emit the ChartEx `<mc:AlternateContent>` block that occupies the
+     * shape slot inside a `<xdr:twoCellAnchor>` — between `<xdr:to>`
+     * and `<xdr:clientData>`.
+     *
+     * Structure mirrors Microsoft Excel's own output:
+     *
+     *   <mc:AlternateContent>
+     *     <mc:Choice Requires="cx1" xmlns:cx1="…/2015/9/8/chartex">
+     *       <xdr:graphicFrame>…<cx:chart/>…</xdr:graphicFrame>
+     *     </mc:Choice>
+     *     <mc:Fallback>
+     *       <xdr:sp>…placeholder shape…</xdr:sp>
+     *     </mc:Fallback>
+     *   </mc:AlternateContent>
+     *
+     * Both the Choice graphicFrame and the Fallback shape inherit
+     * sizing from the outer `<xdr:from>`/`<xdr:to>` cell range — they
+     * do NOT each re-declare the anchor; there is only one anchor.
+     */
+    renderChartExAlternateContent(xmlStream, model) {
+        xmlStream.openNode("mc:AlternateContent", {
+            "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+        });
+        xmlStream.openNode("mc:Choice", {
+            "xmlns:cx1": "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex",
+            Requires: "cx1"
+        });
+        if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
+        xmlStream.closeNode(); // mc:Choice
+        xmlStream.openNode("mc:Fallback");
+        this.renderChartExFallbackShape(xmlStream, model);
+        xmlStream.closeNode(); // mc:Fallback
+        xmlStream.closeNode(); // mc:AlternateContent
+    }
+    /**
+     * Emit the placeholder `<xdr:sp>` that lives inside the
+     * `<mc:Fallback>` of a ChartEx anchor. Legacy Excel (2010/2013)
+     * and non-Microsoft loaders that don't understand the `cx1`
+     * namespace render this in place of the `cx:chart`.
+     *
+     * Matches Microsoft Excel's convention: cNvPr id=0 / empty name
+     * (a deliberate placeholder, not a real drawing object), a white
+     * rectangle sized to the anchor's cell range, and the localizable
+     * "This chart isn't available" message. The shape's own xfrm
+     * carries concrete EMU values rather than zeros because the
+     * Fallback expansion is meant to be rendered standalone — a
+     * zero-size shape would collapse and Excel 2016+ flags that as
+     * "drawing shape" validation failure even though the outer
+     * twoCellAnchor provides sizing.
+     */
+    renderChartExFallbackShape(xmlStream, model) {
+        xmlStream.openNode("xdr:sp", { macro: "", textlink: "" });
+        xmlStream.openNode("xdr:nvSpPr");
+        // `id=0`, empty name — Microsoft's convention for Fallback
+        // placeholders. Using a real numeric id here would conflict with
+        // the real graphicFrame id in Choice on loaders that scan both
+        // branches during validation.
+        xmlStream.leafNode("xdr:cNvPr", { id: 0, name: "" });
+        xmlStream.openNode("xdr:cNvSpPr");
+        xmlStream.leafNode("a:spLocks", { noTextEdit: 1 });
+        xmlStream.closeNode(); // xdr:cNvSpPr
+        xmlStream.closeNode(); // xdr:nvSpPr
+        xmlStream.openNode("xdr:spPr");
+        xmlStream.openNode("a:xfrm");
+        // Non-zero placeholder geometry. Excel expects the fallback
+        // shape to have a concrete size even though the outer
+        // twoCellAnchor already pins its bounds to from/to. Using
+        // 6"×4" (5486400 × 3657600 EMU) here — the dimensions Excel
+        // uses in its own fallback shapes. The position (3917950,
+        // 698500) roughly tracks Excel's offset for the same fallback
+        // shape (the exact values don't matter for validation; they
+        // only affect legacy-client rendering).
+        xmlStream.leafNode("a:off", { x: 3917950, y: 698500 });
+        xmlStream.leafNode("a:ext", { cx: 5486400, cy: 3657600 });
+        xmlStream.closeNode(); // a:xfrm
+        xmlStream.openNode("a:prstGeom", { prst: "rect" });
+        xmlStream.leafNode("a:avLst");
+        xmlStream.closeNode(); // a:prstGeom
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:prstClr", { val: "white" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.openNode("a:ln", { w: 1 });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:prstClr", { val: "black" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.closeNode(); // a:ln
+        xmlStream.closeNode(); // xdr:spPr
+        xmlStream.openNode("xdr:txBody");
+        xmlStream.leafNode("a:bodyPr", { vertOverflow: "clip", horzOverflow: "clip" });
+        xmlStream.leafNode("a:lstStyle");
+        xmlStream.openNode("a:p");
+        xmlStream.openNode("a:r");
+        xmlStream.leafNode("a:rPr", { lang: "en-US", sz: 1100 });
+        xmlStream.openNode("a:t");
+        xmlStream.writeText("This chart isn't available in your version of Excel.\n\n" +
+            "Editing this shape or saving this workbook into a different file format will permanently break the chart.");
+        xmlStream.closeNode(); // a:t
+        xmlStream.closeNode(); // a:r
+        xmlStream.closeNode(); // a:p
+        xmlStream.closeNode(); // xdr:txBody
+        xmlStream.closeNode(); // xdr:sp
+    }
+    parseOpen(node) {
+        // Swallow everything inside `<mc:Fallback>` — it is a legacy
+        // placeholder shape the writer regenerates verbatim.
+        if (this._inFallback) {
+            this._fallbackDepth++;
+            return true;
+        }
+        // Intercept the MC substitution elements. The children of
+        // `<mc:Choice>` (a `<xdr:graphicFrame>`, typically) should be
+        // parsed by the existing xforms as if the wrapper weren't there.
+        switch (node.name) {
+            case "mc:AlternateContent":
+                this._acDepth++;
+                return true;
+            case "mc:Choice":
+                if (this._acDepth > 0) {
+                    this._choiceRequires = node.attributes?.Requires;
+                }
+                return true;
+            case "mc:Fallback":
+                if (this._acDepth > 0) {
+                    this._inFallback = true;
+                    this._fallbackDepth = 1;
+                }
+                return true;
+            default:
+                break;
+        }
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    range: {
+                        editAs: node.attributes.editAs
+                    }
+                };
+                this._acDepth = 0;
+                this._inFallback = false;
+                this._fallbackDepth = 0;
+                this._choiceRequires = undefined;
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this._inFallback) {
+            return;
+        }
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
     parseClose(name) {
+        // Close matching against the inner `<mc:Fallback>` skip window
+        // first. `_fallbackDepth` tracks nested opens inside the
+        // fallback shape (xdr:sp → xdr:spPr → …); only when it drops
+        // back to zero do we exit skip mode.
+        if (this._inFallback) {
+            this._fallbackDepth--;
+            if (this._fallbackDepth === 0) {
+                this._inFallback = false;
+            }
+            return true;
+        }
+        switch (name) {
+            case "mc:AlternateContent":
+                this._acDepth--;
+                if (this._acDepth <= 0) {
+                    this._acDepth = 0;
+                    // Tag the anchor model with the Requires value so the
+                    // writer re-emits the MC wrapper on save.
+                    if (this._choiceRequires) {
+                        this.model.alternateContent = { requires: this._choiceRequires };
+                    }
+                    this._choiceRequires = undefined;
+                }
+                return true;
+            case "mc:Choice":
+            case "mc:Fallback":
+                return true;
+            default:
+                break;
+        }
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
                 this.parser = undefined;
@@ -66,6 +344,7 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
                 this.model.range.tl = this.map["xdr:from"].model;
                 this.model.range.br = this.map["xdr:to"].model;
                 this.model.picture = this.map["xdr:pic"].model;
+                this.model.graphicFrame = this.map["xdr:graphicFrame"].model;
                 return false;
             default:
                 // could be some unrecognised tags
@@ -73,7 +352,10 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
         }
     }
     reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
+        if (model.picture) {
+            model.medium = this.reconcilePicture(model.picture, options);
+        }
+        // graphicFrame reconciliation handled at DrawingXform level
     }
 }
 export { TwoCellAnchorXform };

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.d.ts

@@ -1,4 +1,4 @@
-import type { CacheField, DataField, PivotTableSubtotal } from "../../../pivot-table.js";
+import type { CacheField, DataField, PivotTableChartFormat, PivotTableSubtotal } from "../../../pivot-table.js";
 import { BaseXform } from "../base-xform.js";
 import type { XmlSink } from "../../../../xml/types.js";
 /**
@@ -16,6 +16,17 @@ interface PivotTableRenderModel {
     cacheId: string | number;
     tableNumber: number;
     applyWidthHeightFormats: "0" | "1";
+    /**
+     * Optional top-left anchor (e.g. `"A3"`) for the pivot's displayed block.
+     * When set, the rendered `<location>` ref is computed from this anchor
+     * instead of the default `A{3 + pageOffset}`. The anchor represents the
+     * pivot's display origin — page filters (if any) occupy rows downward from
+     * the anchor, followed by a blank separator row and then the pivot body.
+     */
+    ref?: string;
+    name?: string;
+    chartFormat?: number;
+    chartFormats?: PivotTableChartFormat[];
 }
 /**
  * A single <item> element inside a pivotField's <items> collection.
@@ -151,7 +162,7 @@ interface RowColItem {
 /**
  * Chart format item for pivot charts
  */
-interface ChartFormatItem {
+interface ChartFormatItem extends PivotTableChartFormat {
     chart: number;
     format: number;
     series?: boolean;

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.js

@@ -110,17 +110,39 @@ class PivotTableXform extends BaseXform {
         const pageOffset = pageCount > 0 ? pageCount + 1 : 0;
         // Location ref: firstDataCol = number of row fields (row label columns),
         // endCol = row fields + data columns.
+        // When the caller supplies `ref`, it anchors the pivot's displayed block
+        // (page filters → blank separator → pivot body). The body — which is what
+        // <location ref="..."/> actually addresses in OOXML — therefore sits
+        // pageOffset rows below the anchor and shares its column.
         const firstDataCol = rows.length;
-        const startRow = 3 + pageOffset;
-        const endRow = startRow + 1; // header + 1 data row placeholder
         const dataColCount = isMultiValueNoCol ? values.length : 1;
-        const endCol = firstDataCol + dataColCount;
+        const totalPivotCols = firstDataCol + dataColCount;
+        let startRow;
+        let startCol;
+        if (model.ref) {
+            // `ref` is pre-normalised by makePivotTable to a canonical cell address,
+            // so decodeAddress cannot fail here. Guard anyway to surface any
+            // bypasses via `as any` with a clear error.
+            const addr = colCache.decodeAddress(model.ref);
+            if (!addr.col || !addr.row) {
+                throw new Error(`Pivot table ref "${model.ref}" must include both column and row (e.g. "A3").`);
+            }
+            startRow = addr.row + pageOffset;
+            startCol = addr.col;
+        }
+        else {
+            startRow = 3 + pageOffset;
+            startCol = 1;
+        }
+        const endRow = startRow + 1; // header + 1 data row placeholder
+        const endCol = startCol + totalPivotCols - 1;
+        const startColLetter = colCache.n2l(startCol);
         const endColLetter = colCache.n2l(endCol);
-        const locationRef = `A${startRow}:${endColLetter}${endRow}`;
+        const locationRef = `${startColLetter}${startRow}:${endColLetter}${endRow}`;
         xmlStream.openXml(StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
-            name: `PivotTable${tableNumber}`,
+            name: model.name ?? `PivotTable${tableNumber}`,
             cacheId,
             applyNumberFormats: "0",
             applyBorderFormats: "0",
@@ -137,7 +159,8 @@ class PivotTableXform extends BaseXform {
             indent: "0",
             compact: "0",
             compactData: "0",
-            multipleFieldFilters: "0"
+            multipleFieldFilters: "0",
+            chartFormat: model.chartFormat !== undefined ? String(model.chartFormat) : undefined
         });
         // Location
         const locAttrs = {
@@ -219,6 +242,9 @@ class PivotTableXform extends BaseXform {
         }
         // Data fields
         renderDataFields(xmlStream, cacheFields, values, model.valueMetrics);
+        if (model.chartFormats && model.chartFormats.length > 0) {
+            this.renderChartFormats(xmlStream, model.chartFormats);
+        }
         // Pivot table style info
         xmlStream.leafNode("pivotTableStyleInfo", {
             name: DEFAULT_PIVOT_STYLE,

package/dist/browser/modules/excel/xlsx/xform/sheet/chartsheet-xform.d.ts

@@ -0,0 +1,185 @@
+/**
+ * ChartsheetXform — parse and render OOXML chartsheet XML.
+ *
+ * A chartsheet is a simple sheet type that contains only a chart.
+ * Structure (ECMA-376 `CT_Chartsheet`):
+ * ```xml
+ * <chartsheet xmlns="...">
+ *   <sheetPr/>?
+ *   <sheetViews><sheetView .../></sheetViews>
+ *   <sheetProtection/>?
+ *   <customSheetViews/>?
+ *   <pageMargins .../>?
+ *   <pageSetup .../>?        CT_CsPageSetup — NOT CT_PageSetup
+ *   <headerFooter/>?
+ *   <drawing r:id="rId1"/>
+ *   <legacyDrawing/>?  legacyDrawingHF?  drawingHF?  picture?  webPublishItems?  extLst?
+ * </chartsheet>
+ * ```
+ *
+ * Note that chartsheets do NOT support `printOptions`, `pageBreaks`,
+ * `rowBreaks`, or `colBreaks` — those are worksheet-only elements
+ * per ECMA-376 `CT_Chartsheet`. Likewise `<c:pageSetup>` on a
+ * chartsheet is `CT_CsPageSetup`, which has a reduced attribute set
+ * compared to the worksheet's `CT_PageSetup` (no `scale`,
+ * `fitToWidth`, `fitToHeight`, `pageOrder`, `cellComments`, or
+ * `errors`).
+ */
+import { BaseXform } from "../base-xform.js";
+import type { XmlSink } from "../../../../xml/types.js";
+export interface ChartsheetModel {
+    /** Sheet number (positional index in the XLSX archive) */
+    sheetNo: number;
+    /** Sheet name (from workbook.xml) */
+    name: string;
+    /** Sheet ID (from workbook.xml) */
+    id: number;
+    /**
+     * Tab order index — the 0-based position in the workbook's
+     * `<sheets>` list, shared between worksheets and chartsheets so a
+     * combined sort preserves the author's interleaved layout. Assigned
+     * at add time (monotonic across both add paths) and at load time
+     * (from the workbook.xml `<sheet>` ordinal).
+     */
+    orderNo?: number;
+    /** Relationship ID linking to this chartsheet from workbook.xml.rels */
+    rId?: string;
+    /** Sheet visibility state */
+    state?: "visible" | "hidden" | "veryHidden";
+    /** Tab selected */
+    tabSelected?: boolean;
+    /** Zoom scale */
+    zoomScale?: number;
+    /**
+     * `CT_ChartsheetViewBase/@workbookViewId` — 0-based index into the
+     * workbook's `<bookViews>` list that this chartsheet view is bound
+     * to. Defaults to 0 per OOXML schema; round-tripped verbatim so
+     * multi-view workbooks don't get their view hierarchy rewritten.
+     */
+    workbookViewId?: number;
+    /**
+     * `CT_ChartsheetViewBase/@zoomToFit` — when true the chartsheet
+     * scales its content to fill the window. Schema default is false;
+     * captured/written only when explicitly set to preserve round-trip.
+     */
+    zoomToFit?: boolean;
+    /** Page margins */
+    pageMargins?: {
+        l?: number;
+        r?: number;
+        t?: number;
+        b?: number;
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+        header?: number;
+        footer?: number;
+    };
+    /**
+     * Chartsheet page setup — `CT_CsPageSetup`.
+     *
+     * Note the attribute set differs from the worksheet `CT_PageSetup`:
+     *   - **Supported**: paperSize, firstPageNumber, orientation,
+     *     usePrinterDefaults, blackAndWhite, draft, useFirstPageNumber,
+     *     horizontalDpi, verticalDpi, copies, paperHeight, paperWidth
+     *   - **Not supported on chartsheets** (worksheet-only, will be
+     *     silently ignored on write): scale, fitToWidth, fitToHeight,
+     *     pageOrder, cellComments, errors
+     */
+    pageSetup?: {
+        paperSize?: number;
+        firstPageNumber?: number;
+        orientation?: "default" | "portrait" | "landscape";
+        usePrinterDefaults?: boolean;
+        blackAndWhite?: boolean;
+        draft?: boolean;
+        useFirstPageNumber?: boolean;
+        horizontalDpi?: number;
+        verticalDpi?: number;
+        copies?: number;
+        /** Paper height in a unit-of-measure string (e.g. "11in", "297mm"). */
+        paperHeight?: string;
+        /** Paper width in a unit-of-measure string (e.g. "8.5in", "210mm"). */
+        paperWidth?: string;
+        /**
+         * Relationship id referencing a `printerSettings` part. Preserved
+         * verbatim through round-trip so an already-authored
+         * `xl/printerSettings/…` rel target keeps its XML reference from
+         * the chartsheet. Previously this attribute was dropped by the
+         * parser and never emitted by the writer, leaving the printer-
+         * settings part accessible via the chartsheet's `.rels` but
+         * unreferenced from the chartsheet XML — a dangling-rel-reverse
+         * that strict validators flag.
+         */
+        rId?: string;
+    };
+    /** Drawing relationship reference */
+    drawing?: {
+        rId: string;
+    };
+    /** Relationships parsed from the chartsheet .rels file */
+    relationships?: any[];
+    /** Drawing part name without extension (e.g. drawing2) */
+    drawingName?: string;
+    /** Classic chart number displayed by this chartsheet */
+    chartNumber?: number;
+    /** ChartEx number displayed by this chartsheet */
+    chartExNumber?: number;
+    /**
+     * Raw XML captured for elements the structured parser doesn't model
+     * (`sheetPr`, `sheetProtection`, `customSheetViews`, `headerFooter`,
+     * `legacyDrawing`, `legacyDrawingHF`, `drawingHF`, `picture`,
+     * `webPublishItems`, `extLst`). The writer emits these verbatim at
+     * the correct schema position so a round-trip through a workbook
+     * that uses chartsheet-specific features (e.g. password-protected
+     * chartsheets, printer-defined header/footer blocks) doesn't lose
+     * them.
+     *
+     * Keys are the element local name (e.g. `"sheetPr"`); values are the
+     * full `<tag …>…</tag>` serialised bytes.
+     *
+     * Note: `rowBreaks`, `colBreaks`, and `pageBreaks` are NOT captured —
+     * per ECMA-376 `CT_Chartsheet` they are worksheet-only elements.
+     * Similarly `printOptions` is worksheet-only. Legacy on-disk
+     * chartsheets that erroneously contained them are silently
+     * discarded on load to produce schema-valid output on save.
+     */
+    rawChildren?: Record<string, string>;
+}
+declare class ChartsheetXform extends BaseXform<ChartsheetModel> {
+    private inSheetView;
+    /**
+     * Raw-capture state for elements the structured parser doesn't model.
+     * When `parseOpen` sees one of the names in {@link RAW_CAPTURE_TAGS}
+     * at depth-1 of `<chartsheet>`, it starts recording the full
+     * serialised XML (open tags, text, nested children, close tags) into
+     * `captureParts`. The recording ends when `parseClose` fires with
+     * the matching root name; the assembled string is stored under
+     * `model.rawChildren[rootName]` for verbatim re-emission by
+     * {@link render}.
+     *
+     * Without this, elements like `<sheetProtection>` (password-protected
+     * chartsheets) and `<headerFooter>` silently disappeared on
+     * round-trip, breaking the author's layout / security configuration.
+     *
+     * `sheetDepth` tracks nesting depth inside `<chartsheet>`: the root
+     * itself sits at depth 1, its direct children at depth 2. Capture
+     * only ever starts at depth 2 so a nested element whose local name
+     * happens to overlap with one in {@link RAW_CAPTURE_TAGS} (e.g. an
+     * `<extLst>` inside `<customSheetViews>` as a leaf of that subtree)
+     * stays part of the outer capture rather than being promoted to a
+     * sibling root child.
+     */
+    private captureRoot;
+    private captureDepth;
+    private captureParts;
+    private skipNextCaptureClose;
+    private sheetDepth;
+    get tag(): string;
+    render(xmlStream: XmlSink, model?: ChartsheetModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { ChartsheetXform };