@cj-tech-master/excelts 3.1.0-canary.20260102071304.d80b29d → 4.0.0-canary.20260103013222.0e5d37f

package/dist/browser/modules/excel/xlsx/xform/sheet/row-xform.js

@@ -0,0 +1,152 @@
+import { BaseXform } from "../base-xform.js";
+import { CellXform } from "./cell-xform.js";
+import { parseBoolean } from "../../../../../utils/utils.browser.js";
+import { colCache } from "../../../utils/col-cache.js";
+class RowXform extends BaseXform {
+    constructor(options) {
+        super();
+        this.maxItems = options && options.maxItems;
+        this.map = {
+            c: new CellXform()
+        };
+    }
+    get tag() {
+        return "row";
+    }
+    reset() {
+        super.reset();
+        this.numRowsSeen = 0;
+        this.lastCellCol = 0;
+    }
+    prepare(model, options) {
+        const styleId = options.styles.addStyleModel(model.style);
+        if (styleId) {
+            model.styleId = styleId;
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.prepare(cellModel, options);
+        });
+    }
+    render(xmlStream, model, options) {
+        if (!model) {
+            return;
+        }
+        xmlStream.openNode("row");
+        xmlStream.addAttribute("r", model.number);
+        if (model.height) {
+            xmlStream.addAttribute("ht", model.height);
+            xmlStream.addAttribute("customHeight", "1");
+        }
+        if (model.hidden) {
+            xmlStream.addAttribute("hidden", "1");
+        }
+        if (model.min > 0 && model.max > 0 && model.min <= model.max) {
+            xmlStream.addAttribute("spans", `${model.min}:${model.max}`);
+        }
+        if (model.styleId) {
+            xmlStream.addAttribute("s", model.styleId);
+            xmlStream.addAttribute("customFormat", "1");
+        }
+        // Note: dyDescent is MS extension, not output by default (Excel auto-calculates)
+        if (model.outlineLevel) {
+            xmlStream.addAttribute("outlineLevel", model.outlineLevel);
+        }
+        if (model.collapsed) {
+            xmlStream.addAttribute("collapsed", "1");
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.render(xmlStream, cellModel, options);
+        });
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (node.name === "row") {
+            this.numRowsSeen += 1;
+            // Reset lastCellCol for each new row
+            this.lastCellCol = 0;
+            const spans = node.attributes.spans
+                ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
+                : [undefined, undefined];
+            // If r attribute is missing, use numRowsSeen as the row number
+            const rowNumber = node.attributes.r ? parseInt(node.attributes.r, 10) : this.numRowsSeen;
+            const model = (this.model = {
+                number: rowNumber,
+                min: spans[0],
+                max: spans[1],
+                cells: []
+            });
+            if (node.attributes.s) {
+                model.styleId = parseInt(node.attributes.s, 10);
+            }
+            if (parseBoolean(node.attributes.hidden)) {
+                model.hidden = true;
+            }
+            if (parseBoolean(node.attributes.bestFit)) {
+                model.bestFit = true;
+            }
+            if (node.attributes.ht) {
+                model.height = parseFloat(node.attributes.ht);
+            }
+            if (node.attributes.outlineLevel) {
+                model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
+            }
+            if (parseBoolean(node.attributes.collapsed)) {
+                model.collapsed = true;
+            }
+            return true;
+        }
+        this.parser = this.map[node.name];
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                const cellModel = this.parser.model;
+                // If cell has address, extract column number from it
+                // Otherwise, calculate address based on position
+                if (cellModel.address) {
+                    const decoded = colCache.decodeAddress(cellModel.address);
+                    this.lastCellCol = decoded.col;
+                }
+                else {
+                    // No r attribute, calculate address from position
+                    this.lastCellCol += 1;
+                    cellModel.address = colCache.encodeAddress(this.model.number, this.lastCellCol);
+                }
+                this.model.cells.push(cellModel);
+                if (this.maxItems && this.model.cells.length > this.maxItems) {
+                    throw new Error(`Max column count (${this.maxItems}) exceeded`);
+                }
+                this.parser = undefined;
+            }
+            return true;
+        }
+        return false;
+    }
+    reconcile(model, options) {
+        model.style = model.styleId ? options.styles.getStyleModel(model.styleId) : {};
+        if (model.styleId !== undefined) {
+            model.styleId = undefined;
+        }
+        const cellXform = this.map.c;
+        model.cells.forEach((cellModel) => {
+            cellXform.reconcile(cellModel, options);
+        });
+    }
+}
+export { RowXform };

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

@@ -0,0 +1,16 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface SheetFormatPropertiesModel {
+    defaultRowHeight: number;
+    dyDescent?: number;
+    outlineLevelRow: number;
+    outlineLevelCol: number;
+    defaultColWidth?: number;
+}
+declare class SheetFormatPropertiesXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: SheetFormatPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { SheetFormatPropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/sheet-format-properties-xform.js

@@ -0,0 +1,49 @@
+import { BaseXform } from "../base-xform.js";
+class SheetFormatPropertiesXform extends BaseXform {
+    get tag() {
+        return "sheetFormatPr";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                defaultRowHeight: model.defaultRowHeight,
+                // Only output outlineLevelRow/Col when non-zero (matches Excel behavior)
+                outlineLevelRow: model.outlineLevelRow || undefined,
+                outlineLevelCol: model.outlineLevelCol || undefined,
+                // Only output dyDescent if explicitly set (MS extension, not ECMA-376 standard)
+                "x14ac:dyDescent": model.dyDescent || undefined
+            };
+            // Only output defaultColWidth if explicitly set
+            if (model.defaultColWidth) {
+                attributes.defaultColWidth = model.defaultColWidth;
+            }
+            // default value for 'defaultRowHeight' is 15, this should not be 'custom'
+            if (!model.defaultRowHeight || model.defaultRowHeight !== 15) {
+                attributes.customHeight = "1";
+            }
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode("sheetFormatPr", attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        if (node.name === "sheetFormatPr") {
+            this.model = {
+                defaultRowHeight: parseFloat(node.attributes.defaultRowHeight || "0"),
+                dyDescent: parseFloat(node.attributes["x14ac:dyDescent"] || "0"),
+                outlineLevelRow: parseInt(node.attributes.outlineLevelRow || "0", 10),
+                outlineLevelCol: parseInt(node.attributes.outlineLevelCol || "0", 10)
+            };
+            if (node.attributes.defaultColWidth) {
+                this.model.defaultColWidth = parseFloat(node.attributes.defaultColWidth);
+            }
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { SheetFormatPropertiesXform };

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

@@ -0,0 +1,19 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface SheetPropertiesModel {
+    tabColor?: any;
+    pageSetup?: any;
+    outlineProperties?: any;
+}
+declare class SheetPropertiesXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser?: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model?: SheetPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): boolean;
+    parseClose(_name: string): boolean;
+}
+export { SheetPropertiesXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/sheet-properties-xform.js

@@ -0,0 +1,82 @@
+import { BaseXform } from "../base-xform.js";
+import { ColorXform } from "../style/color-xform.js";
+import { PageSetupPropertiesXform } from "./page-setup-properties-xform.js";
+import { OutlinePropertiesXform } from "./outline-properties-xform.js";
+class SheetPropertiesXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {
+            tabColor: new ColorXform("tabColor"),
+            pageSetUpPr: new PageSetupPropertiesXform(),
+            outlinePr: new OutlinePropertiesXform()
+        };
+    }
+    get tag() {
+        return "sheetPr";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            xmlStream.addRollback();
+            xmlStream.openNode("sheetPr");
+            let inner = false;
+            inner = this.map.tabColor.render(xmlStream, model.tabColor) || inner;
+            inner = this.map.pageSetUpPr.render(xmlStream, model.pageSetup) || inner;
+            inner = this.map.outlinePr.render(xmlStream, model.outlineProperties) || inner;
+            if (inner) {
+                xmlStream.closeNode();
+                xmlStream.commit();
+            }
+            else {
+                xmlStream.rollback();
+            }
+        }
+    }
+    parseOpen(node) {
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        if (node.name === this.tag) {
+            this.reset();
+            return true;
+        }
+        if (this.map[node.name]) {
+            this.parser = this.map[node.name];
+            this.parser.parseOpen(node);
+            return true;
+        }
+        return false;
+    }
+    parseText(text) {
+        if (this.parser) {
+            this.parser.parseText(text);
+            return true;
+        }
+        return false;
+    }
+    parseClose(_name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(_name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        if (this.map.tabColor.model || this.map.pageSetUpPr.model || this.map.outlinePr.model) {
+            this.model = {};
+            if (this.map.tabColor.model) {
+                this.model.tabColor = this.map.tabColor.model;
+            }
+            if (this.map.pageSetUpPr.model) {
+                this.model.pageSetup = this.map.pageSetUpPr.model;
+            }
+            if (this.map.outlinePr.model) {
+                this.model.outlineProperties = this.map.outlinePr.model;
+            }
+        }
+        else {
+            this.model = null;
+        }
+        return false;
+    }
+}
+export { SheetPropertiesXform };

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

@@ -0,0 +1,31 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface SheetProtectionModel {
+    sheet?: boolean;
+    objects?: boolean;
+    scenarios?: boolean;
+    selectLockedCells?: boolean;
+    selectUnlockedCells?: boolean;
+    formatCells?: boolean;
+    formatColumns?: boolean;
+    formatRows?: boolean;
+    insertColumns?: boolean;
+    insertRows?: boolean;
+    insertHyperlinks?: boolean;
+    deleteColumns?: boolean;
+    deleteRows?: boolean;
+    sort?: boolean;
+    autoFilter?: boolean;
+    pivotTables?: boolean;
+    algorithmName?: string;
+    hashValue?: string;
+    saltValue?: string;
+    spinCount?: number;
+}
+declare class SheetProtectionXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: SheetProtectionModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { SheetProtectionXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/sheet-protection-xform.js

@@ -0,0 +1,80 @@
+import { BaseXform } from "../base-xform.js";
+function booleanToXml(model, value) {
+    return model ? value : undefined;
+}
+function xmlToBoolean(value, equals) {
+    return value === equals ? true : undefined;
+}
+class SheetProtectionXform extends BaseXform {
+    get tag() {
+        return "sheetProtection";
+    }
+    render(xmlStream, model) {
+        if (model) {
+            const attributes = {
+                sheet: booleanToXml(model.sheet, "1"),
+                selectLockedCells: model.selectLockedCells === false ? "1" : undefined,
+                selectUnlockedCells: model.selectUnlockedCells === false ? "1" : undefined,
+                formatCells: booleanToXml(model.formatCells, "0"),
+                formatColumns: booleanToXml(model.formatColumns, "0"),
+                formatRows: booleanToXml(model.formatRows, "0"),
+                insertColumns: booleanToXml(model.insertColumns, "0"),
+                insertRows: booleanToXml(model.insertRows, "0"),
+                insertHyperlinks: booleanToXml(model.insertHyperlinks, "0"),
+                deleteColumns: booleanToXml(model.deleteColumns, "0"),
+                deleteRows: booleanToXml(model.deleteRows, "0"),
+                sort: booleanToXml(model.sort, "0"),
+                autoFilter: booleanToXml(model.autoFilter, "0"),
+                pivotTables: booleanToXml(model.pivotTables, "0")
+            };
+            if (model.sheet) {
+                attributes.algorithmName = model.algorithmName;
+                attributes.hashValue = model.hashValue;
+                attributes.saltValue = model.saltValue;
+                attributes.spinCount = model.spinCount;
+                attributes.objects = booleanToXml(model.objects === false, "1");
+                attributes.scenarios = booleanToXml(model.scenarios === false, "1");
+            }
+            if (Object.values(attributes).some((value) => value !== undefined)) {
+                xmlStream.leafNode(this.tag, attributes);
+            }
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag:
+                this.model = {
+                    sheet: xmlToBoolean(node.attributes.sheet, "1"),
+                    objects: node.attributes.objects === "1" ? false : undefined,
+                    scenarios: node.attributes.scenarios === "1" ? false : undefined,
+                    selectLockedCells: node.attributes.selectLockedCells === "1" ? false : undefined,
+                    selectUnlockedCells: node.attributes.selectUnlockedCells === "1" ? false : undefined,
+                    formatCells: xmlToBoolean(node.attributes.formatCells, "0"),
+                    formatColumns: xmlToBoolean(node.attributes.formatColumns, "0"),
+                    formatRows: xmlToBoolean(node.attributes.formatRows, "0"),
+                    insertColumns: xmlToBoolean(node.attributes.insertColumns, "0"),
+                    insertRows: xmlToBoolean(node.attributes.insertRows, "0"),
+                    insertHyperlinks: xmlToBoolean(node.attributes.insertHyperlinks, "0"),
+                    deleteColumns: xmlToBoolean(node.attributes.deleteColumns, "0"),
+                    deleteRows: xmlToBoolean(node.attributes.deleteRows, "0"),
+                    sort: xmlToBoolean(node.attributes.sort, "0"),
+                    autoFilter: xmlToBoolean(node.attributes.autoFilter, "0"),
+                    pivotTables: xmlToBoolean(node.attributes.pivotTables, "0")
+                };
+                if (node.attributes.algorithmName) {
+                    this.model.algorithmName = node.attributes.algorithmName;
+                    this.model.hashValue = node.attributes.hashValue;
+                    this.model.saltValue = node.attributes.saltValue;
+                    this.model.spinCount = parseInt(node.attributes.spinCount, 10);
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { SheetProtectionXform };

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

@@ -0,0 +1,32 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface SheetViewModel {
+    workbookViewId?: number;
+    rightToLeft?: boolean;
+    tabSelected?: boolean;
+    showRuler?: boolean;
+    showRowColHeaders?: boolean;
+    showGridLines?: boolean;
+    zoomScale?: number;
+    zoomScaleNormal?: number;
+    style?: string;
+    state?: string;
+    xSplit?: number;
+    ySplit?: number;
+    topLeftCell?: string;
+    activePane?: string;
+    activeCell?: string;
+}
+declare class SheetViewXform extends BaseXform {
+    model: SheetViewModel;
+    private sheetView;
+    private pane;
+    private selections;
+    get tag(): string;
+    prepare(model: SheetViewModel): void;
+    render(xmlStream: any, model: SheetViewModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+    reconcile(): void;
+}
+export { SheetViewXform };

package/dist/browser/modules/excel/xlsx/xform/sheet/sheet-view-xform.js

@@ -0,0 +1,193 @@
+import { colCache } from "../../../utils/col-cache.js";
+import { BaseXform } from "../base-xform.js";
+const VIEW_STATES = {
+    frozen: "frozen",
+    frozenSplit: "frozen",
+    split: "split"
+};
+class SheetViewXform extends BaseXform {
+    get tag() {
+        return "sheetView";
+    }
+    prepare(model) {
+        switch (model.state) {
+            case "frozen":
+            case "split":
+                break;
+            default:
+                model.state = "normal";
+                break;
+        }
+    }
+    render(xmlStream, model) {
+        // Build initial attributes with correct order to match Excel output
+        const initialAttrs = {};
+        if (model.tabSelected) {
+            initialAttrs.tabSelected = "1";
+        }
+        initialAttrs.workbookViewId = model.workbookViewId || 0;
+        xmlStream.openNode("sheetView", initialAttrs);
+        const add = function (name, value, included) {
+            if (included) {
+                xmlStream.addAttribute(name, value);
+            }
+        };
+        add("rightToLeft", "1", model.rightToLeft === true);
+        // tabSelected is now in initialAttrs
+        add("showRuler", "0", model.showRuler === false);
+        add("showRowColHeaders", "0", model.showRowColHeaders === false);
+        add("showGridLines", "0", model.showGridLines === false);
+        add("zoomScale", model.zoomScale, model.zoomScale);
+        add("zoomScaleNormal", model.zoomScaleNormal, model.zoomScaleNormal);
+        add("view", model.style, model.style);
+        let topLeftCell;
+        let xSplit;
+        let ySplit;
+        let activePane;
+        switch (model.state) {
+            case "frozen":
+                xSplit = model.xSplit || 0;
+                ySplit = model.ySplit || 0;
+                topLeftCell = model.topLeftCell || colCache.getAddress(ySplit + 1, xSplit + 1).address;
+                activePane =
+                    (model.xSplit && model.ySplit && "bottomRight") ||
+                        (model.xSplit && "topRight") ||
+                        "bottomLeft";
+                xmlStream.leafNode("pane", {
+                    xSplit: model.xSplit || undefined,
+                    ySplit: model.ySplit || undefined,
+                    topLeftCell,
+                    activePane,
+                    state: "frozen"
+                });
+                xmlStream.leafNode("selection", {
+                    pane: activePane,
+                    activeCell: model.activeCell,
+                    sqref: model.activeCell
+                });
+                break;
+            case "split":
+                if (model.activePane === "topLeft") {
+                    model.activePane = undefined;
+                }
+                xmlStream.leafNode("pane", {
+                    xSplit: model.xSplit || undefined,
+                    ySplit: model.ySplit || undefined,
+                    topLeftCell: model.topLeftCell,
+                    activePane: model.activePane
+                });
+                xmlStream.leafNode("selection", {
+                    pane: model.activePane,
+                    activeCell: model.activeCell,
+                    sqref: model.activeCell
+                });
+                break;
+            case "normal":
+                if (model.activeCell) {
+                    xmlStream.leafNode("selection", {
+                        activeCell: model.activeCell,
+                        sqref: model.activeCell
+                    });
+                }
+                break;
+            default:
+                break;
+        }
+        xmlStream.closeNode();
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "sheetView":
+                this.sheetView = {
+                    workbookViewId: parseInt(node.attributes.workbookViewId, 10),
+                    rightToLeft: node.attributes.rightToLeft === "1",
+                    tabSelected: node.attributes.tabSelected === "1",
+                    showRuler: !(node.attributes.showRuler === "0"),
+                    showRowColHeaders: !(node.attributes.showRowColHeaders === "0"),
+                    showGridLines: !(node.attributes.showGridLines === "0"),
+                    zoomScale: parseInt(node.attributes.zoomScale || "100", 10),
+                    zoomScaleNormal: parseInt(node.attributes.zoomScaleNormal || "100", 10),
+                    style: node.attributes.view
+                };
+                this.pane = undefined;
+                this.selections = {};
+                return true;
+            case "pane":
+                this.pane = {
+                    xSplit: parseInt(node.attributes.xSplit || "0", 10),
+                    ySplit: parseInt(node.attributes.ySplit || "0", 10),
+                    topLeftCell: node.attributes.topLeftCell,
+                    activePane: node.attributes.activePane || "topLeft",
+                    state: node.attributes.state
+                };
+                return true;
+            case "selection": {
+                const name = node.attributes.pane || "topLeft";
+                this.selections[name] = {
+                    pane: name,
+                    activeCell: node.attributes.activeCell
+                };
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        let model;
+        let selection;
+        switch (name) {
+            case "sheetView":
+                if (this.sheetView && this.pane) {
+                    model = this.model = {
+                        workbookViewId: this.sheetView.workbookViewId,
+                        rightToLeft: this.sheetView.rightToLeft,
+                        state: VIEW_STATES[this.pane.state] || "split", // split is default
+                        xSplit: this.pane.xSplit,
+                        ySplit: this.pane.ySplit,
+                        topLeftCell: this.pane.topLeftCell,
+                        showRuler: this.sheetView.showRuler,
+                        showRowColHeaders: this.sheetView.showRowColHeaders,
+                        showGridLines: this.sheetView.showGridLines,
+                        zoomScale: this.sheetView.zoomScale,
+                        zoomScaleNormal: this.sheetView.zoomScaleNormal
+                    };
+                    if (this.model.state === "split") {
+                        model.activePane = this.pane.activePane;
+                    }
+                    selection = this.selections[this.pane.activePane];
+                    if (selection && selection.activeCell) {
+                        model.activeCell = selection.activeCell;
+                    }
+                    if (this.sheetView.style) {
+                        model.style = this.sheetView.style;
+                    }
+                }
+                else {
+                    model = this.model = {
+                        workbookViewId: this.sheetView.workbookViewId,
+                        rightToLeft: this.sheetView.rightToLeft,
+                        state: "normal",
+                        showRuler: this.sheetView.showRuler,
+                        showRowColHeaders: this.sheetView.showRowColHeaders,
+                        showGridLines: this.sheetView.showGridLines,
+                        zoomScale: this.sheetView.zoomScale,
+                        zoomScaleNormal: this.sheetView.zoomScaleNormal
+                    };
+                    selection = this.selections.topLeft;
+                    if (selection && selection.activeCell) {
+                        model.activeCell = selection.activeCell;
+                    }
+                    if (this.sheetView.style) {
+                        model.style = this.sheetView.style;
+                    }
+                }
+                return false;
+            default:
+                return true;
+        }
+    }
+    reconcile() { }
+}
+export { SheetViewXform };

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

@@ -0,0 +1,12 @@
+import { BaseXform } from "@excel/xlsx/xform/base-xform";
+interface TablePartModel {
+    rId: string;
+}
+declare class TablePartXform extends BaseXform {
+    get tag(): string;
+    render(xmlStream: any, model?: TablePartModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { TablePartXform };