@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/word/index.base.js

@@ -0,0 +1,51 @@
+/**
+ * DOCX Module - Base Exports (Platform Independent)
+ *
+ * Shared exports for both Node.js and browser environments.
+ */
+// Errors
+export { DocxError, DocxParseError, DocxWriteError, DocxMissingPartError, DocxInvalidStructureError, DocxUnsupportedFeatureError, isDocxError } from "./errors.js";
+// Units
+export { inchesToTwips, twipsToInches, cmToTwips, twipsToCm, ptToTwips, twipsToPt, mmToTwips, inchesToEmu, emuToInches, cmToEmu, emuToCm, ptToEmu, pxToEmu, emuToPx, ptToHalfPoint, halfPointToPt, ptToEighthPoint, eighthPointToPt, lineMultiplierToSpacing, spacingToLineMultiplier, percentToTablePct, tablePctToPercent } from "./units.js";
+// Builder helpers
+export { DocumentBuilder, 
+// Run helpers
+text, bold, italic, pageBreak, lineBreak, columnBreak, tab, positionalTab, ruby, carriageReturn, noBreakHyphen, softHyphen, field, pageNumberField, totalPagesField, sectionPagesField, sectionField, dateField, sequenceField, timeField, authorField, titleField, subjectField, keywordsField, fileNameField, fileSizeField, styleRefField, refField, pageRefField, noteRefField, hyperlinkField, quoteField, tocField, tcField, indexEntryField, indexField, ifField, includeTextField, includePictureField, formTextField, formCheckboxField, formDropdownField, 
+// Paragraph helpers
+paragraph, textParagraph, heading, hyperlink, bookmarkStart, bookmarkEnd, 
+// Comment helpers
+commentRangeStart, commentRangeEnd, commentReference, 
+// Track changes helpers
+insertedRun, deletedRun, movedFromRun, movedToRun, moveFromRangeStart, moveFromRangeEnd, moveToRangeStart, moveToRangeEnd, 
+// CheckBox helper
+checkBox, 
+// Math helpers
+mathBlock, mathRun, mathFraction, mathSqrt, mathRoot, mathSum, mathIntegral, mathProduct, 
+// Additional math helpers
+mathSuperScript, mathSubScript, mathSubSuperScript, mathPreSubSuperScript, mathPhantom, mathGroupChar, mathBorderBox, mathDelimiter, mathNary, mathFunction, mathLimit, mathMatrix, mathAccent, mathBar, mathBox, mathEquationArray, 
+// Symbol helper
+symbol, 
+// Floating image helper
+floatingImage, 
+// Drawing shape helper
+drawingShape, 
+// Chart helper
+chart, 
+// SDT helper
+structuredDocumentTag, 
+// Table helpers
+border, gridBorders, cell, row, table, simpleTable, searchText, replaceText, resolveThemeColor, patchDocument, mailMerge, 
+// Query API
+paragraphCount, countWords, getHeadings, findBookmark, findComment, listImages, listTables, listHyperlinks, tableCount, extractText } from "./document.js";
+// Packager
+export { packageDocx } from "./docx-packager.js";
+// Reader
+export { readDocx } from "./docx-reader.js";
+// Font obfuscation utilities
+export { deobfuscateFont, obfuscateFont, generateFontKey } from "./font-obfuscation.js";
+// Encryption utilities
+export { isEncryptedDocx, verifyPassword, decryptPackage, parseEncryptionInfoXml, deriveEncryptionKey, AGILE_BLOCK_KEYS } from "./encryption.js";
+// Digital signature utilities
+export { hasDigitalSignatures, parseSignatureXml, extractSignatures, isWellFormedSignature } from "./digital-signatures.js";
+// HTML Renderer
+export { renderToHtml } from "./html-renderer.js";

package/dist/esm/modules/word/index.browser.js

@@ -0,0 +1,4 @@
+/**
+ * DOCX Module - Browser Entry Point
+ */
+export * from "./index.base.js";

package/dist/esm/modules/word/index.js

@@ -0,0 +1,4 @@
+/**
+ * DOCX Module - Node.js Entry Point
+ */
+export * from "./index.base.js";

package/dist/esm/modules/word/internal-utils.js

@@ -0,0 +1,54 @@
+/**
+ * DOCX Module - Internal utilities (shared helpers)
+ */
+/**
+ * Encode a byte array to base64. Uses native Node `Buffer` if available;
+ * otherwise falls back to chunked `btoa()` for browser environments.
+ *
+ * The chunked approach avoids the O(n²) string concatenation cost that naïve
+ * `String.fromCharCode(...data)` implementations exhibit on large buffers.
+ */
+export function bytesToBase64(data) {
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(data).toString("base64");
+    }
+    const CHUNK = 0x8000;
+    const parts = [];
+    for (let i = 0; i < data.length; i += CHUNK) {
+        const slice = data.subarray(i, i + CHUNK);
+        // `apply` on Uint8Array works in all modern JS engines
+        parts.push(String.fromCharCode.apply(null, slice));
+    }
+    return btoa(parts.join(""));
+}
+/**
+ * Decode a base64 string to a byte array. Uses native Node `Buffer` if available.
+ */
+export function base64ToBytes(s) {
+    if (typeof Buffer !== "undefined") {
+        return new Uint8Array(Buffer.from(s, "base64"));
+    }
+    const binary = atob(s);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Build an XML attributes object from an array of [name, value] entries,
+ * omitting entries whose value is `undefined` or `false`. Numeric and boolean
+ * values are stringified: `number → String(n)`, `boolean → "1"`.
+ *
+ * Reduces repetitive `if (x !== undefined) attrs["w:x"] = String(x)` patterns.
+ */
+export function buildAttrs(entries) {
+    const out = {};
+    for (const [k, v] of entries) {
+        if (v === undefined || v === null || v === false) {
+            continue;
+        }
+        out[k] = typeof v === "boolean" ? "1" : String(v);
+    }
+    return out;
+}

package/dist/esm/modules/word/relationships.js

@@ -0,0 +1,56 @@
+/**
+ * DOCX Module - Relationship Manager
+ *
+ * Manages OPC relationships for the DOCX package.
+ * Generates .rels files for package-level and part-level relationships.
+ */
+import { NS_PKG_RELS, STD_DOC_ATTRIBUTES } from "./constants.js";
+/**
+ * Manages relationships and generates .rels XML.
+ */
+export class RelationshipManager {
+    constructor() {
+        this._rels = [];
+        this._nextId = 1;
+    }
+    /** Add a relationship and return its assigned rId. */
+    add(type, target, targetMode) {
+        const id = `rId${this._nextId++}`;
+        this._rels.push({ id, type, target, targetMode });
+        return id;
+    }
+    /** Add a relationship with a specific ID. */
+    addWithId(id, type, target, targetMode) {
+        this._rels.push({ id, type, target, targetMode });
+        // Keep nextId above any manually-assigned IDs
+        const num = parseInt(id.replace("rId", ""), 10);
+        if (!isNaN(num) && num >= this._nextId) {
+            this._nextId = num + 1;
+        }
+    }
+    /** Get all relationships. */
+    get relationships() {
+        return this._rels;
+    }
+    /** Get the number of relationships. */
+    get count() {
+        return this._rels.length;
+    }
+    /** Render the relationships XML to a sink. */
+    render(xml) {
+        xml.openXml(STD_DOC_ATTRIBUTES);
+        xml.openNode("Relationships", { xmlns: NS_PKG_RELS });
+        for (const rel of this._rels) {
+            const attrs = {
+                Id: rel.id,
+                Type: rel.type,
+                Target: rel.target
+            };
+            if (rel.targetMode) {
+                attrs.TargetMode = rel.targetMode;
+            }
+            xml.leafNode("Relationship", attrs);
+        }
+        xml.closeNode();
+    }
+}

package/dist/esm/modules/word/types.js

@@ -0,0 +1,10 @@
+/**
+ * DOCX Module - Core Types
+ *
+ * Comprehensive type definitions for WordprocessingML (OOXML) documents.
+ * Covers paragraphs, runs, tables, images, headers/footers, numbering,
+ * styles, sections, footnotes/endnotes, bookmarks, hyperlinks, comments,
+ * track changes, TOC, math equations, text boxes, checkboxes, custom
+ * properties, page borders, document background, and more.
+ */
+export {};

package/dist/esm/modules/word/units.js

@@ -0,0 +1,111 @@
+/**
+ * DOCX Module - Unit Conversion Utilities
+ *
+ * Conversion functions between common measurement units used in OOXML.
+ */
+// =============================================================================
+// Twips conversions (1 inch = 1440 twips, 1 pt = 20 twips, 1 cm = 567 twips)
+// =============================================================================
+/** Convert inches to twips. */
+export function inchesToTwips(inches) {
+    return Math.round(inches * 1440);
+}
+/** Convert twips to inches. */
+export function twipsToInches(twips) {
+    return twips / 1440;
+}
+/** Convert centimeters to twips. */
+export function cmToTwips(cm) {
+    return Math.round(cm * 567);
+}
+/** Convert twips to centimeters. */
+export function twipsToCm(twips) {
+    return twips / 567;
+}
+/** Convert points to twips. */
+export function ptToTwips(pt) {
+    return Math.round(pt * 20);
+}
+/** Convert twips to points. */
+export function twipsToPt(twips) {
+    return twips / 20;
+}
+/** Convert millimeters to twips. */
+export function mmToTwips(mm) {
+    return Math.round(mm * 56.7);
+}
+// =============================================================================
+// EMU conversions (1 inch = 914400 EMU, 1 cm = 360000 EMU, 1 pt = 12700 EMU)
+// =============================================================================
+/** Convert inches to EMU. */
+export function inchesToEmu(inches) {
+    return Math.round(inches * 914400);
+}
+/** Convert EMU to inches. */
+export function emuToInches(emu) {
+    return emu / 914400;
+}
+/** Convert centimeters to EMU. */
+export function cmToEmu(cm) {
+    return Math.round(cm * 360000);
+}
+/** Convert EMU to centimeters. */
+export function emuToCm(emu) {
+    return emu / 360000;
+}
+/** Convert points to EMU. */
+export function ptToEmu(pt) {
+    return Math.round(pt * 12700);
+}
+/** Convert pixels (at 96 DPI) to EMU. */
+export function pxToEmu(px) {
+    return Math.round(px * 9525);
+}
+/** Convert EMU to pixels (at 96 DPI). */
+export function emuToPx(emu) {
+    return emu / 9525;
+}
+// =============================================================================
+// Half-point conversions (font sizes: 1 pt = 2 half-points)
+// =============================================================================
+/** Convert points to half-points (for w:sz). */
+export function ptToHalfPoint(pt) {
+    return Math.round(pt * 2);
+}
+/** Convert half-points to points. */
+export function halfPointToPt(hp) {
+    return hp / 2;
+}
+// =============================================================================
+// Eighth-point conversions (border widths: 1 pt = 8 eighth-points)
+// =============================================================================
+/** Convert points to eighth-points (for border w:sz). */
+export function ptToEighthPoint(pt) {
+    return Math.round(pt * 8);
+}
+/** Convert eighth-points to points. */
+export function eighthPointToPt(ep) {
+    return ep / 8;
+}
+// =============================================================================
+// Line spacing conversions (auto mode: 240ths of a line)
+// =============================================================================
+/** Convert line multiplier to line spacing value (auto mode). */
+export function lineMultiplierToSpacing(multiplier) {
+    return Math.round(multiplier * 240);
+}
+/** Convert line spacing value to multiplier (auto mode). */
+export function spacingToLineMultiplier(spacing) {
+    return spacing / 240;
+}
+// =============================================================================
+// Table width percent (fiftieths of a percent: 5000 = 100%)
+// =============================================================================
+/** Convert percentage (0-100) to table width pct value. */
+export function percentToTablePct(percent) {
+    return Math.round(percent * 50);
+}
+/** Convert table width pct value to percentage. */
+export function tablePctToPercent(pct) {
+    return pct / 50;
+}

package/dist/esm/modules/word/writers/chart-writer.js

@@ -0,0 +1,385 @@
+/**
+ * DOCX Module - Chart Writer
+ *
+ * Generates DrawingML chart part XML (word/charts/chartN.xml) from
+ * high-level Chart definitions.
+ */
+import { STD_DOC_ATTRIBUTES } from "../constants.js";
+const NS_C = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const NS_A_LOCAL = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const NS_R_LOCAL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+const CHART_TYPE_CATEGORY = {
+    bar: { tag: "barChart", direction: "bar", grouping: "clustered" },
+    barStacked: { tag: "barChart", direction: "bar", grouping: "stacked" },
+    barPercentStacked: { tag: "barChart", direction: "bar", grouping: "percentStacked" },
+    column: { tag: "barChart", direction: "col", grouping: "clustered" },
+    columnStacked: { tag: "barChart", direction: "col", grouping: "stacked" },
+    columnPercentStacked: { tag: "barChart", direction: "col", grouping: "percentStacked" },
+    line: { tag: "lineChart", grouping: "standard" },
+    lineStacked: { tag: "lineChart", grouping: "stacked" },
+    lineMarked: { tag: "lineChart", grouping: "standard", marked: true },
+    area: { tag: "areaChart", grouping: "standard" },
+    areaStacked: { tag: "areaChart", grouping: "stacked" },
+    pie: { tag: "pieChart" },
+    pie3D: { tag: "pie3DChart" },
+    doughnut: { tag: "doughnutChart" },
+    scatter: { tag: "scatterChart", scatterStyle: "marker" },
+    scatterSmooth: { tag: "scatterChart", scatterStyle: "smoothMarker" },
+    radar: { tag: "radarChart" }
+};
+/** Render a chart part (word/charts/chartN.xml). */
+export function renderChartPart(xml, chart) {
+    xml.openXml(STD_DOC_ATTRIBUTES);
+    xml.openNode("c:chartSpace", {
+        "xmlns:c": NS_C,
+        "xmlns:a": NS_A_LOCAL,
+        "xmlns:r": NS_R_LOCAL
+    });
+    // Date1904 (calendar base)
+    xml.leafNode("c:date1904", { val: "0" });
+    // Language
+    xml.leafNode("c:lang", { val: "en-US" });
+    // Round text
+    xml.leafNode("c:roundedCorners", { val: "0" });
+    // Chart style (optional, defaults to 2)
+    if (chart.style !== undefined) {
+        xml.openNode("mc:AlternateContent", {
+            "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+        });
+        xml.openNode("mc:Choice", {
+            Requires: "c14",
+            "xmlns:c14": "http://schemas.microsoft.com/office/drawing/2007/8/2/chart"
+        });
+        xml.leafNode("c14:style", { val: String(chart.style) });
+        xml.closeNode();
+        xml.openNode("mc:Fallback");
+        xml.leafNode("c:style", { val: String(Math.min(chart.style, 48)) });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    // Chart
+    xml.openNode("c:chart");
+    // Title
+    if (chart.title) {
+        renderTitle(xml, chart.title);
+        xml.leafNode("c:autoTitleDeleted", { val: "0" });
+    }
+    else {
+        xml.leafNode("c:autoTitleDeleted", { val: "1" });
+    }
+    // 3D view
+    if (chart.view3d) {
+        xml.openNode("c:view3D");
+        xml.leafNode("c:rotX", { val: "15" });
+        xml.leafNode("c:rotY", { val: "20" });
+        xml.leafNode("c:depthPercent", { val: "100" });
+        xml.leafNode("c:rAngAx", { val: "1" });
+        xml.closeNode();
+    }
+    // Plot area
+    xml.openNode("c:plotArea");
+    xml.leafNode("c:layout");
+    // Chart type-specific rendering
+    const catAxId = "111111111";
+    const valAxId = "222222222";
+    renderChartTypeElement(xml, chart, catAxId, valAxId);
+    // Axes (unless pie/doughnut which use no axes)
+    const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
+    if (!noAxes) {
+        // Category axis
+        renderAxis(xml, "catAx", catAxId, valAxId, chart.categoryAxis, "b");
+        // Value axis
+        renderAxis(xml, "valAx", valAxId, catAxId, chart.valueAxis, "l");
+    }
+    // Plot area background
+    if (chart.plotAreaColor) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: chart.plotAreaColor });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    xml.closeNode(); // c:plotArea
+    // Legend
+    if (chart.legend !== "none") {
+        xml.openNode("c:legend");
+        xml.leafNode("c:legendPos", { val: chart.legend ?? "r" });
+        xml.leafNode("c:overlay", { val: "0" });
+        xml.closeNode();
+    }
+    xml.leafNode("c:plotVisOnly", { val: "1" });
+    xml.leafNode("c:dispBlanksAs", { val: "gap" });
+    xml.closeNode(); // c:chart
+    // Chart area background
+    if (chart.chartAreaColor) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: chart.chartAreaColor });
+        xml.closeNode();
+        xml.closeNode();
+    }
+    xml.closeNode(); // c:chartSpace
+}
+function renderTitle(xml, title) {
+    xml.openNode("c:title");
+    xml.openNode("c:tx");
+    xml.openNode("c:rich");
+    xml.leafNode("a:bodyPr", {
+        rot: "0",
+        spcFirstLastPara: "1",
+        vertOverflow: "ellipsis",
+        wrap: "square",
+        anchor: "ctr",
+        anchorCtr: "1"
+    });
+    xml.leafNode("a:lstStyle");
+    xml.openNode("a:p");
+    xml.openNode("a:pPr");
+    xml.leafNode("a:defRPr", {
+        sz: "1400",
+        b: "0",
+        i: "0",
+        u: "none",
+        strike: "noStrike",
+        kern: "1200",
+        spc: "0",
+        baseline: "0"
+    });
+    xml.closeNode();
+    xml.openNode("a:r");
+    xml.leafNode("a:rPr", { lang: "en-US" });
+    xml.openNode("a:t");
+    xml.writeText(title);
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:rich
+    xml.closeNode(); // c:tx
+    xml.leafNode("c:overlay", { val: "0" });
+    xml.closeNode(); // c:title
+}
+function renderChartTypeElement(xml, chart, catAxId, valAxId) {
+    const info = CHART_TYPE_CATEGORY[chart.type] ?? { tag: "barChart" };
+    const tagName = `c:${info.tag}`;
+    xml.openNode(tagName);
+    // Direction (bar vs col)
+    if ("direction" in info && info.direction) {
+        xml.leafNode("c:barDir", { val: info.direction });
+    }
+    // Grouping (stacked/clustered/percentStacked)
+    if ("grouping" in info && info.grouping) {
+        xml.leafNode("c:grouping", { val: info.grouping });
+    }
+    // Scatter style
+    if ("scatterStyle" in info && info.scatterStyle) {
+        xml.leafNode("c:scatterStyle", { val: info.scatterStyle });
+    }
+    xml.leafNode("c:varyColors", {
+        val: chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut" ? "1" : "0"
+    });
+    // Series
+    chart.series.forEach((series, idx) => {
+        renderSeries(xml, series, idx, chart.type, "marked" in info && info.marked);
+    });
+    // Gap width / overlap (bar/column)
+    if (info.tag === "barChart") {
+        xml.leafNode("c:gapWidth", { val: "150" });
+        if (chart.type === "barStacked" ||
+            chart.type === "barPercentStacked" ||
+            chart.type === "columnStacked" ||
+            chart.type === "columnPercentStacked") {
+            xml.leafNode("c:overlap", { val: "100" });
+        }
+    }
+    // Axes IDs
+    const noAxes = chart.type === "pie" || chart.type === "pie3D" || chart.type === "doughnut";
+    if (!noAxes) {
+        xml.leafNode("c:axId", { val: catAxId });
+        xml.leafNode("c:axId", { val: valAxId });
+    }
+    xml.closeNode(); // chart type tag
+}
+function renderSeries(xml, series, index, chartType, markedLine) {
+    xml.openNode("c:ser");
+    xml.leafNode("c:idx", { val: String(index) });
+    xml.leafNode("c:order", { val: String(index) });
+    // Series name
+    xml.openNode("c:tx");
+    xml.openNode("c:strRef");
+    xml.openNode("c:f");
+    xml.writeText(`Sheet1!$${String.fromCharCode(66 + index)}$1`);
+    xml.closeNode();
+    xml.openNode("c:strCache");
+    xml.leafNode("c:ptCount", { val: "1" });
+    xml.openNode("c:pt", { idx: "0" });
+    xml.openNode("c:v");
+    xml.writeText(series.name);
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:tx
+    // Series fill color
+    if (series.color) {
+        xml.openNode("c:spPr");
+        xml.openNode("a:solidFill");
+        xml.leafNode("a:srgbClr", { val: series.color });
+        xml.closeNode();
+        if (chartType.startsWith("line") || chartType === "scatter" || chartType === "scatterSmooth") {
+            xml.openNode("a:ln", { w: "28575" });
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: series.color });
+            xml.closeNode();
+            xml.closeNode();
+        }
+        xml.closeNode();
+    }
+    // Per-point colors (for pie)
+    if (series.pointColors && series.pointColors.length > 0) {
+        series.pointColors.forEach((color, i) => {
+            xml.openNode("c:dPt");
+            xml.leafNode("c:idx", { val: String(i) });
+            xml.leafNode("c:bubble3D", { val: "0" });
+            xml.openNode("c:spPr");
+            xml.openNode("a:solidFill");
+            xml.leafNode("a:srgbClr", { val: color });
+            xml.closeNode();
+            xml.closeNode();
+            xml.closeNode();
+        });
+    }
+    // Markers for line charts
+    if (markedLine) {
+        xml.openNode("c:marker");
+        xml.leafNode("c:symbol", { val: "circle" });
+        xml.leafNode("c:size", { val: "5" });
+        xml.closeNode();
+    }
+    else if (chartType.startsWith("line")) {
+        xml.openNode("c:marker");
+        xml.leafNode("c:symbol", { val: "none" });
+        xml.closeNode();
+    }
+    // Smooth for line/scatter smooth
+    if (chartType === "scatterSmooth") {
+        xml.leafNode("c:smooth", { val: "1" });
+    }
+    // Data labels
+    if (series.showDataLabels) {
+        xml.openNode("c:dLbls");
+        xml.leafNode("c:showLegendKey", { val: "0" });
+        xml.leafNode("c:showVal", { val: "1" });
+        xml.leafNode("c:showCatName", { val: "0" });
+        xml.leafNode("c:showSerName", { val: "0" });
+        xml.leafNode("c:showPercent", { val: "0" });
+        xml.leafNode("c:showBubbleSize", { val: "0" });
+        xml.closeNode();
+    }
+    // Categories (c:cat)
+    if (chartType !== "scatter" && chartType !== "scatterSmooth") {
+        xml.openNode("c:cat");
+        xml.openNode("c:strRef");
+        xml.openNode("c:f");
+        xml.writeText(`Sheet1!$A$2:$A$${series.categories.length + 1}`);
+        xml.closeNode();
+        xml.openNode("c:strCache");
+        xml.leafNode("c:ptCount", { val: String(series.categories.length) });
+        series.categories.forEach((cat, i) => {
+            xml.openNode("c:pt", { idx: String(i) });
+            xml.openNode("c:v");
+            xml.writeText(cat);
+            xml.closeNode();
+            xml.closeNode();
+        });
+        xml.closeNode();
+        xml.closeNode();
+        xml.closeNode();
+    }
+    else {
+        // For scatter: xVal
+        xml.openNode("c:xVal");
+        xml.openNode("c:numRef");
+        xml.openNode("c:f");
+        xml.writeText(`Sheet1!$A$2:$A$${series.categories.length + 1}`);
+        xml.closeNode();
+        xml.openNode("c:numCache");
+        xml.leafNode("c:formatCode", { val: "General" });
+        xml.leafNode("c:ptCount", { val: String(series.categories.length) });
+        series.categories.forEach((cat, i) => {
+            xml.openNode("c:pt", { idx: String(i) });
+            xml.openNode("c:v");
+            xml.writeText(cat);
+            xml.closeNode();
+            xml.closeNode();
+        });
+        xml.closeNode();
+        xml.closeNode();
+        xml.closeNode();
+    }
+    // Values (c:val or c:yVal)
+    const valTag = chartType === "scatter" || chartType === "scatterSmooth" ? "c:yVal" : "c:val";
+    xml.openNode(valTag);
+    xml.openNode("c:numRef");
+    xml.openNode("c:f");
+    xml.writeText(`Sheet1!$B$2:$B$${series.values.length + 1}`);
+    xml.closeNode();
+    xml.openNode("c:numCache");
+    xml.leafNode("c:formatCode", { val: "General" });
+    xml.leafNode("c:ptCount", { val: String(series.values.length) });
+    series.values.forEach((val, i) => {
+        xml.openNode("c:pt", { idx: String(i) });
+        xml.openNode("c:v");
+        xml.writeText(String(val));
+        xml.closeNode();
+        xml.closeNode();
+    });
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode();
+    xml.closeNode(); // c:ser
+}
+function renderAxis(xml, tagName, axId, crossAxId, axis, defaultPos) {
+    xml.openNode(`c:${tagName}`);
+    xml.leafNode("c:axId", { val: axId });
+    // Scaling
+    xml.openNode("c:scaling");
+    xml.leafNode("c:orientation", { val: "minMax" });
+    if (axis?.min !== undefined) {
+        xml.leafNode("c:min", { val: String(axis.min) });
+    }
+    if (axis?.max !== undefined) {
+        xml.leafNode("c:max", { val: String(axis.max) });
+    }
+    xml.closeNode();
+    xml.leafNode("c:delete", { val: axis?.hidden ? "1" : "0" });
+    xml.leafNode("c:axPos", { val: defaultPos });
+    // Title
+    if (axis?.title) {
+        renderTitle(xml, axis.title);
+    }
+    // Number format
+    if (axis?.numberFormat) {
+        xml.leafNode("c:numFmt", { formatCode: axis.numberFormat, sourceLinked: "0" });
+    }
+    else {
+        xml.leafNode("c:numFmt", { formatCode: "General", sourceLinked: "1" });
+    }
+    xml.leafNode("c:majorTickMark", { val: "out" });
+    xml.leafNode("c:minorTickMark", { val: "none" });
+    xml.leafNode("c:tickLblPos", { val: "nextTo" });
+    xml.leafNode("c:crossAx", { val: crossAxId });
+    xml.leafNode("c:crosses", { val: "autoZero" });
+    if (tagName === "catAx") {
+        xml.leafNode("c:auto", { val: "1" });
+        xml.leafNode("c:lblAlgn", { val: "ctr" });
+        xml.leafNode("c:lblOffset", { val: "100" });
+        xml.leafNode("c:noMultiLvlLbl", { val: "0" });
+    }
+    else {
+        xml.leafNode("c:crossBetween", { val: "between" });
+        if (axis?.majorUnit) {
+            xml.leafNode("c:majorUnit", { val: String(axis.majorUnit) });
+        }
+    }
+    xml.closeNode();
+}