@cj-tech-master/excelts 9.2.1 → 9.3.0

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

@@ -0,0 +1,66 @@
+import { BaseXform } from "../base-xform.js";
+class WorkbookProtectionXform extends BaseXform {
+    get tag() {
+        return "workbookProtection";
+    }
+    render(xmlStream, model) {
+        if (!model) {
+            return;
+        }
+        const attributes = {};
+        if (model.lockStructure) {
+            attributes.lockStructure = "1";
+        }
+        if (model.lockWindows) {
+            attributes.lockWindows = "1";
+        }
+        if (model.lockRevision) {
+            attributes.lockRevision = "1";
+        }
+        if (model.workbookPassword) {
+            attributes.workbookPassword = model.workbookPassword;
+        }
+        if (model.revisionsPassword) {
+            attributes.revisionsPassword = model.revisionsPassword;
+        }
+        if (model.algorithmName) {
+            attributes.workbookAlgorithmName = model.algorithmName;
+            attributes.workbookHashValue = model.hashValue;
+            attributes.workbookSaltValue = model.saltValue;
+            attributes.workbookSpinCount = model.spinCount?.toString();
+        }
+        if (Object.values(attributes).some(v => v !== undefined)) {
+            xmlStream.leafNode(this.tag, attributes);
+        }
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case this.tag: {
+                const a = node.attributes;
+                this.model = {
+                    lockStructure: a.lockStructure === "1" || undefined,
+                    lockWindows: a.lockWindows === "1" || undefined,
+                    lockRevision: a.lockRevision === "1" || undefined,
+                    workbookPassword: a.workbookPassword || undefined,
+                    revisionsPassword: a.revisionsPassword || undefined
+                };
+                if (a.workbookAlgorithmName) {
+                    this.model.algorithmName = a.workbookAlgorithmName;
+                    this.model.hashValue = a.workbookHashValue;
+                    this.model.saltValue = a.workbookSaltValue;
+                    this.model.spinCount = a.workbookSpinCount
+                        ? parseInt(a.workbookSpinCount, 10)
+                        : undefined;
+                }
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+export { WorkbookProtectionXform };

package/dist/browser/modules/excel/xlsx/xform/book/workbook-xform.js

@@ -1,10 +1,12 @@
 import { colCache } from "../../../utils/col-cache.js";
 import { BaseXform } from "../base-xform.js";
 import { DefinedNamesXform } from "./defined-name-xform.js";
+import { ExternalReferenceXform } from "./external-reference-xform.js";
 import { WorksheetXform } from "./sheet-xform.js";
 import { WorkbookCalcPropertiesXform } from "./workbook-calc-properties-xform.js";
 import { WorkbookPivotCacheXform } from "./workbook-pivot-cache-xform.js";
 import { WorkbookPropertiesXform } from "./workbook-properties-xform.js";
+import { WorkbookProtectionXform } from "./workbook-protection-xform.js";
 import { WorkbookViewXform } from "./workbook-view-xform.js";
 import { ListXform } from "../list-xform.js";
 import { StaticXform } from "../static-xform.js";
@@ -15,6 +17,7 @@ class WorkbookXform extends BaseXform {
         this.map = {
             fileVersion: WorkbookXform.STATIC_XFORMS.fileVersion,
             workbookPr: new WorkbookPropertiesXform(),
+            workbookProtection: new WorkbookProtectionXform(),
             bookViews: new ListXform({
                 tag: "bookViews",
                 count: false,
@@ -31,6 +34,11 @@ class WorkbookXform extends BaseXform {
                 tag: "pivotCaches",
                 count: false,
                 childXform: new WorkbookPivotCacheXform()
+            }),
+            externalReferences: new ListXform({
+                tag: "externalReferences",
+                count: false,
+                childXform: new ExternalReferenceXform()
             })
         };
     }
@@ -90,6 +98,7 @@ class WorkbookXform extends BaseXform {
         xmlStream.openNode("workbook", WorkbookXform.WORKBOOK_ATTRIBUTES);
         this.map.fileVersion.render(xmlStream);
         this.map.workbookPr.render(xmlStream, model.properties);
+        this.map.workbookProtection.render(xmlStream, model.protection);
         this.map.bookViews.render(xmlStream, model.views);
         this.map.sheets.render(xmlStream, model.sheets);
         this.map.definedNames.render(xmlStream, model.definedNames);
@@ -107,6 +116,15 @@ class WorkbookXform extends BaseXform {
             return true;
         });
         this.map.pivotCaches.render(xmlStream, uniquePivotCaches);
+        // <externalReferences> order matters: one entry per externalLink in
+        // declaration order, each carrying the r:id that resolves (via
+        // workbook.xml.rels) to `xl/externalLinks/externalLink{N}.xml`. The
+        // index inside this list is exactly the `[N]` used in formula strings.
+        const externalLinks = model.externalLinks ?? [];
+        if (externalLinks.length > 0) {
+            const externalReferenceModels = externalLinks.map((link) => ({ rId: link.rId }));
+            this.map.externalReferences.render(xmlStream, externalReferenceModels);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -142,8 +160,9 @@ class WorkbookXform extends BaseXform {
                 this.model = {
                     sheets: this.map.sheets.model,
                     properties: this.map.workbookPr.model || {},
+                    protection: this.map.workbookProtection.model,
                     views: this.map.bookViews.model,
-                    calcProperties: {}
+                    calcProperties: this.map.calcPr.model || {}
                 };
                 if (this.map.definedNames.model) {
                     this.model.definedNames = this.map.definedNames.model;
@@ -151,6 +170,13 @@ class WorkbookXform extends BaseXform {
                 if (this.map.pivotCaches.model && this.map.pivotCaches.model.length > 0) {
                     this.model.pivotCaches = this.map.pivotCaches.model;
                 }
+                // Attach parsed <externalReferences> as a list of { rId } objects.
+                // The reader in xlsx.browser.ts will later join each entry with the
+                // matching workbookRels row (to pick up the externalLink Target) and
+                // the parsed externalLinkN.xml part (to pick up sheetNames / cache).
+                if (this.map.externalReferences.model && this.map.externalReferences.model.length > 0) {
+                    this.model.externalReferences = this.map.externalReferences.model;
+                }
                 return false;
             default:
                 // not quite sure how we get here!
@@ -190,13 +216,20 @@ class WorkbookXform extends BaseXform {
         const definedNames = [];
         if (model.definedNames) {
             model.definedNames.forEach((definedName) => {
+                // For print area/titles, use rawText to extract ranges since the xform
+                // layer no longer pre-classifies content (two-phase design).
+                const effectiveRanges = definedName.ranges?.length > 0
+                    ? definedName.ranges
+                    : definedName.rawText
+                        ? [definedName.rawText]
+                        : [];
                 if (definedName.name === "_xlnm.Print_Area") {
                     worksheet = worksheets[definedName.localSheetId];
-                    if (worksheet && definedName.ranges?.length > 0) {
+                    if (worksheet && effectiveRanges.length > 0) {
                         if (!worksheet.pageSetup) {
                             worksheet.pageSetup = {};
                         }
-                        const range = colCache.decodeEx(definedName.ranges[0]);
+                        const range = colCache.decodeEx(effectiveRanges[0]);
                         worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
                             ? `${worksheet.pageSetup.printArea}&&${range.dimensions}`
                             : range.dimensions;
@@ -204,11 +237,11 @@ class WorkbookXform extends BaseXform {
                 }
                 else if (definedName.name === "_xlnm.Print_Titles") {
                     worksheet = worksheets[definedName.localSheetId];
-                    if (worksheet && definedName.ranges?.length > 0) {
+                    if (worksheet && effectiveRanges.length > 0) {
                         if (!worksheet.pageSetup) {
                             worksheet.pageSetup = {};
                         }
-                        const rangeString = definedName.ranges.join(",");
+                        const rangeString = effectiveRanges.join(",");
                         const dollarRegex = /\$/g;
                         const rowRangeRegex = /\$\d+:\$\d+/;
                         const rowRangeMatches = rangeString.match(rowRangeRegex);

package/dist/browser/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -1,4 +1,4 @@
-import { OOXML_PATHS, commentsPathFromName, ctrlPropPath, drawingPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
+import { OOXML_PATHS, commentsPathFromName, ctrlPropPath, drawingPath, externalLinkPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
 import { BaseXform } from "../base-xform.js";
 import { StdDocAttributes } from "../../../../xml/writer.js";
 // used for rendering the [Content_Types].xml file
@@ -74,6 +74,17 @@ class ContentTypesXform extends BaseXform {
             PartName: toContentTypesPartName(OOXML_PATHS.xlStyles),
             ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"
         });
+        // Each externalLink part needs its own Override. Omitted entries make
+        // Excel fail to load the external reference (and, in some builds,
+        // trigger a "the workbook is damaged" dialog).
+        if (model.externalLinks && model.externalLinks.length > 0) {
+            for (const link of model.externalLinks) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(externalLinkPath(link.index)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"
+                });
+            }
+        }
         // Add FeaturePropertyBag if checkboxes are used
         if (model.hasCheckboxes) {
             xmlStream.leafNode("Override", {
@@ -81,6 +92,13 @@ class ContentTypesXform extends BaseXform {
                 ContentType: "application/vnd.ms-excel.featurepropertybag+xml"
             });
         }
+        // Add metadata part for dynamic array formulas
+        if (model.hasDynamicArrayFormulas) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(OOXML_PATHS.xlMetadata),
+                ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml"
+            });
+        }
         const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
         if (hasSharedStrings) {
             xmlStream.leafNode("Override", {

package/dist/browser/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/browser/modules/excel/xlsx/xform/core/metadata-xform.js

@@ -0,0 +1,158 @@
+import { BaseXform } from "../base-xform.js";
+import { StdDocAttributes } from "../../../../xml/writer.js";
+// Namespace URIs
+const NS_SPREADSHEETML = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const NS_DYNAMIC_ARRAY = "http://schemas.microsoft.com/office/spreadsheetml/2017/dynamicarray";
+const XLDAPR_EXT_URI = "{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}";
+class MetadataXform extends BaseXform {
+    constructor() {
+        super(...arguments);
+        // Parsing state
+        /** metadataType names in declaration order (1-indexed in OOXML) */
+        this._metadataTypeNames = [];
+        /** Per cellMetadata bk: the rc.t value (metadataType index, 1-indexed) */
+        this._cellMetadataTypeRefs = [];
+        /** Whether we are currently inside <cellMetadata> */
+        this._inCellMetadata = false;
+        /** Current rc.t value being collected inside a <bk> */
+        this._currentRcType = undefined;
+    }
+    get tag() {
+        return "metadata";
+    }
+    /**
+     * Render xl/metadata.xml for the given model.
+     * Only emits content when dynamicArrayCount > 0.
+     */
+    render(xmlStream, model) {
+        if (!model || model.dynamicArrayCount <= 0) {
+            return;
+        }
+        xmlStream.openXml(StdDocAttributes);
+        xmlStream.openNode("metadata", {
+            xmlns: NS_SPREADSHEETML,
+            "xmlns:xda": NS_DYNAMIC_ARRAY
+        });
+        // metadataTypes: declare XLDAPR
+        xmlStream.openNode("metadataTypes", { count: "1" });
+        xmlStream.leafNode("metadataType", {
+            name: "XLDAPR",
+            minSupportedVersion: "120000",
+            copy: "1",
+            pasteAll: "1",
+            pasteValues: "1",
+            merge: "1",
+            splitFirst: "1",
+            rowColShift: "1",
+            clearFormats: "1",
+            clearComments: "1",
+            assign: "1",
+            coerce: "1",
+            adjust: "1",
+            cellMeta: "1"
+        });
+        xmlStream.closeNode(); // </metadataTypes>
+        // futureMetadata: one shared block for all DA formulas
+        xmlStream.openNode("futureMetadata", { name: "XLDAPR", count: "1" });
+        xmlStream.openNode("bk");
+        xmlStream.openNode("extLst");
+        xmlStream.openNode("ext", { uri: XLDAPR_EXT_URI });
+        xmlStream.leafNode("xda:dynamicArrayProperties", {
+            fDynamic: "1",
+            fCollapsed: "0"
+        });
+        xmlStream.closeNode(); // </ext>
+        xmlStream.closeNode(); // </extLst>
+        xmlStream.closeNode(); // </bk>
+        xmlStream.closeNode(); // </futureMetadata>
+        // cellMetadata: one record (all DA cells share cm="1" which points here)
+        xmlStream.openNode("cellMetadata", { count: "1" });
+        xmlStream.openNode("bk");
+        // t="1" → metadataType index (1-indexed), v="0" → futureMetadata block index (0-indexed)
+        xmlStream.leafNode("rc", { t: "1", v: "0" });
+        xmlStream.closeNode(); // </bk>
+        xmlStream.closeNode(); // </cellMetadata>
+        xmlStream.closeNode(); // </metadata>
+    }
+    // =========================================================================
+    // Parse: build precise cm → metadataType mapping
+    // =========================================================================
+    reset() {
+        this._metadataTypeNames = [];
+        this._cellMetadataTypeRefs = [];
+        this._inCellMetadata = false;
+        this._currentRcType = undefined;
+    }
+    parseOpen(node) {
+        switch (node.name) {
+            case "metadata":
+                this.reset();
+                return true;
+            case "metadataType":
+                // Collect type names in declaration order (1-indexed in OOXML,
+                // but stored 0-indexed here — we adjust when looking up).
+                this._metadataTypeNames.push(node.attributes.name || "");
+                return true;
+            case "cellMetadata":
+                this._inCellMetadata = true;
+                return true;
+            case "bk":
+                if (this._inCellMetadata) {
+                    this._currentRcType = undefined;
+                }
+                return true;
+            case "rc":
+                if (this._inCellMetadata && node.attributes.t !== undefined) {
+                    this._currentRcType = parseInt(node.attributes.t, 10);
+                }
+                return true;
+            // Parse nested elements without action
+            case "metadataTypes":
+            case "futureMetadata":
+            case "extLst":
+            case "ext":
+            case "xda:dynamicArrayProperties":
+                return true;
+            default:
+                return false;
+        }
+    }
+    parseText() { }
+    parseClose(name) {
+        switch (name) {
+            case "bk":
+                if (this._inCellMetadata) {
+                    // Record the metadataType reference for this cellMetadata entry.
+                    // rc.t is 1-indexed into metadataTypes; store as-is.
+                    this._cellMetadataTypeRefs.push(this._currentRcType ?? 0);
+                    this._currentRcType = undefined;
+                }
+                return true;
+            case "cellMetadata":
+                this._inCellMetadata = false;
+                return true;
+            case "metadata": {
+                // Build the set of cm values (1-indexed) that map to XLDAPR.
+                // cm on <c> is 1-indexed into cellMetadata bk entries.
+                const dynamicArrayCmIndices = new Set();
+                for (let i = 0; i < this._cellMetadataTypeRefs.length; i++) {
+                    const typeIndex = this._cellMetadataTypeRefs[i]; // 1-indexed
+                    // metadataTypeNames is 0-indexed, so subtract 1
+                    const typeName = this._metadataTypeNames[typeIndex - 1];
+                    if (typeName === "XLDAPR") {
+                        // cm is 1-indexed: bk[0] → cm=1, bk[1] → cm=2, etc.
+                        dynamicArrayCmIndices.add(i + 1);
+                    }
+                }
+                this.model = {
+                    hasDynamicArrays: dynamicArrayCmIndices.size > 0,
+                    dynamicArrayCmIndices
+                };
+                return false; // done parsing
+            }
+            default:
+                return true;
+        }
+    }
+}
+export { MetadataXform };

package/dist/browser/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/browser/modules/excel/xlsx/xform/drawing/absolute-anchor-xform.js

@@ -0,0 +1,105 @@
+import { BaseXform } from "../base-xform.js";
+import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
+import { ExtXform } from "./ext-xform.js";
+import { PicXform } from "./pic-xform.js";
+import { StaticXform } from "../static-xform.js";
+/** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
+const EMU_PER_PIXEL_AT_96_DPI = 9525;
+/**
+ * Xform for the <xdr:pos> element (absolute position in EMU).
+ * Converts between EMU (in XML) and pixels (in model).
+ */
+class PosXform extends BaseXform {
+    constructor() {
+        super();
+        this.map = {};
+        this.model = { x: 0, y: 0 };
+    }
+    get tag() {
+        return "xdr:pos";
+    }
+    render(xmlStream, model) {
+        xmlStream.leafNode(this.tag, {
+            x: Math.floor(model.x * EMU_PER_PIXEL_AT_96_DPI),
+            y: Math.floor(model.y * EMU_PER_PIXEL_AT_96_DPI)
+        });
+    }
+    parseOpen(node) {
+        if (node.name === this.tag) {
+            this.model = {
+                x: parseInt(node.attributes.x ?? "0", 10) / EMU_PER_PIXEL_AT_96_DPI,
+                y: parseInt(node.attributes.y ?? "0", 10) / EMU_PER_PIXEL_AT_96_DPI
+            };
+            return true;
+        }
+        return false;
+    }
+    parseText() { }
+    parseClose() {
+        return false;
+    }
+}
+/**
+ * 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>
+ * ```
+ */
+class AbsoluteAnchorXform extends BaseCellAnchorXform {
+    constructor() {
+        super();
+        this.map = {
+            "xdr:pos": new PosXform(),
+            "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
+            "xdr:pic": new PicXform(),
+            "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
+        };
+    }
+    get tag() {
+        return "xdr:absoluteAnchor";
+    }
+    prepare(model, options) {
+        if (model.picture) {
+            this.map["xdr:pic"].prepare(model.picture, options);
+        }
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag);
+        this.map["xdr:pos"].render(xmlStream, model.range.pos ?? { x: 0, y: 0 });
+        this.map["xdr:ext"].render(xmlStream, model.range.ext);
+        if (model.picture) {
+            this.map["xdr:pic"].render(xmlStream, model.picture);
+        }
+        this.map["xdr:clientData"].render(xmlStream, {});
+        xmlStream.closeNode();
+    }
+    parseClose(name) {
+        if (this.parser) {
+            if (!this.parser.parseClose(name)) {
+                this.parser = undefined;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                this.model.range.pos = this.map["xdr:pos"].model;
+                this.model.range.ext = this.map["xdr:ext"].model;
+                this.model.picture = this.map["xdr:pic"].model;
+                return false;
+            default:
+                return true;
+        }
+    }
+    reconcile(model, options) {
+        model.medium = this.reconcilePicture(model.picture, options);
+    }
+}
+export { AbsoluteAnchorXform };

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

@@ -31,6 +31,9 @@ class BaseCellAnchorXform extends BaseXform {
     reconcilePicture(model, options) {
         if (model && model.rId) {
             const rel = options.rels[model.rId];
+            if (!rel) {
+                return undefined;
+            }
             const match = rel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
             if (match) {
                 const name = match[1];

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

@@ -1,10 +1,14 @@
 import { colCache } from "../../../utils/col-cache.js";
 import { BaseXform } from "../base-xform.js";
+import { AbsoluteAnchorXform } from "./absolute-anchor-xform.js";
 import { OneCellAnchorXform } from "./one-cell-anchor-xform.js";
 import { TwoCellAnchorXform } from "./two-cell-anchor-xform.js";
 import { StdDocAttributes } from "../../../../xml/writer.js";
 function getAnchorType(model) {
     const range = typeof model.range === "string" ? colCache.decode(model.range) : model.range;
+    if (range.pos !== undefined) {
+        return "xdr:absoluteAnchor";
+    }
     return range.br ? "xdr:twoCellAnchor" : "xdr:oneCellAnchor";
 }
 class DrawingXform extends BaseXform {
@@ -12,7 +16,8 @@ class DrawingXform extends BaseXform {
         super();
         this.map = {
             "xdr:twoCellAnchor": new TwoCellAnchorXform(),
-            "xdr:oneCellAnchor": new OneCellAnchorXform()
+            "xdr:oneCellAnchor": new OneCellAnchorXform(),
+            "xdr:absoluteAnchor": new AbsoluteAnchorXform()
         };
         this.model = { anchors: [] };
     }
@@ -80,7 +85,10 @@ class DrawingXform extends BaseXform {
     }
     reconcile(model, options) {
         model.anchors.forEach(anchor => {
-            if (anchor.br) {
+            if (anchor.range?.pos !== undefined) {
+                this.map["xdr:absoluteAnchor"].reconcile(anchor, options);
+            }
+            else if (anchor.br) {
                 this.map["xdr:twoCellAnchor"].reconcile(anchor, options);
             }
             else {

package/dist/browser/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();