documonster 0.13.1 → 0.14.0

package/README.md

@@ -211,7 +211,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script tag (no bundler) — one IIFE per module, each under the shared `Documonster` global -->
-<script src="https://unpkg.com/documonster@0.13.1/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.14.0/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();

package/README_zh.md

@@ -198,7 +198,7 @@ const buffer = await Workbook.toBuffer(wb);
 
 ```html
 <!-- Script 标签（无需打包工具）— 每个模块一个 IIFE，共享同一个 `Documonster` 全局 -->
-<script src="https://unpkg.com/documonster@0.13.1/dist/iife/documonster.excel.iife.min.js"></script>
+<script src="https://unpkg.com/documonster@0.14.0/dist/iife/documonster.excel.iife.min.js"></script>
 <script>
   const { Workbook, Cell } = Documonster.Excel;
   const wb = Workbook.create();

package/dist/esm/modules/excel/core/cell.js

@@ -2,14 +2,20 @@ import { dataValidationAdd, dataValidationFind } from "./data-validations.js";
 import { definedNamesAddEx, definedNamesGetNamesEx, definedNamesRemoveAllNames, definedNamesRemoveEx } from "./defined-names.js";
 import { Enums } from "./enums.js";
 import { isNoteData, noteCreate, noteFromModel, noteModel } from "./note.js";
+import { EMPTY_CELL_STYLE, sharedCellContainer, sharedCellFacet } from "./style-sharing.js";
 import { isTemporalPlainValue, partsToTemporal, temporalKindOf, temporalRefusal, temporalToParts } from "./temporal.js";
 import { ExcelError, InvalidValueTypeError } from "../errors.js";
 import { dateFormatKind, getCellDisplayText } from "../utils/cell-format.js";
 import { colCache } from "../utils/col-cache.js";
-import { copyStyle } from "../utils/copy-style.js";
+import { copyStyle, copyStyleFacet } from "../utils/copy-style.js";
 import { slideFormula } from "../utils/shared-formula.js";
 import { isExcelPhantomDay, partsToSerial, partsToUtcDate, serialToParts, utcDateToParts } from "../../../utils/excel-serial.js";
 import { excelToDate } from "#platform/utils/utils";
+/**
+ * The style facets that are objects, and therefore the ones that can be shared by
+ * reference or need copying. `numFmt` and `styleName` are primitives.
+ */
+const OBJECT_FACETS = ["font", "alignment", "protection", "border", "fill"];
 function hasOwnKeys(v) {
     return !!v && (typeof v !== "object" || Object.keys(v).length > 0);
 }
@@ -54,30 +60,43 @@ export function mergeCellStyle(rowStyle, colStyle, style) {
     if (numFmt) {
         style.numFmt = numFmt;
     }
-    const font = (rowStyle && hasOwnKeys(rowStyle.font) && rowStyle.font) ||
-        (colStyle && hasOwnKeys(colStyle.font) && colStyle.font);
-    if (font) {
-        style.font = structuredClone(font);
+    // Object facets are taken from the owner's shared snapshot rather than deep-copied
+    // per cell — see `style-sharing.ts`. Callers mark the cell `_sharedStyle`.
+    //
+    // Written out per facet rather than as a loop over a key list on purpose. This runs
+    // once per cell created — the hottest path in the library — and a loop reads
+    // `rowStyle[key]` through a variable, which V8 cannot inline the way it inlines
+    // `rowStyle.font`. Measured on 20k `Cell.setValue` calls into unstyled rows and
+    // columns, the loop cost 46% over this.
+    if (hasOwnKeys(rowStyle.font)) {
+        style.font = sharedCellFacet(rowStyle, "font");
+    }
+    else if (hasOwnKeys(colStyle.font)) {
+        style.font = sharedCellFacet(colStyle, "font");
+    }
+    if (hasOwnKeys(rowStyle.alignment)) {
+        style.alignment = sharedCellFacet(rowStyle, "alignment");
+    }
+    else if (hasOwnKeys(colStyle.alignment)) {
+        style.alignment = sharedCellFacet(colStyle, "alignment");
     }
-    const alignment = (rowStyle && hasOwnKeys(rowStyle.alignment) && rowStyle.alignment) ||
-        (colStyle && hasOwnKeys(colStyle.alignment) && colStyle.alignment);
-    if (alignment) {
-        style.alignment = structuredClone(alignment);
+    if (hasOwnKeys(rowStyle.border)) {
+        style.border = sharedCellFacet(rowStyle, "border");
     }
-    const border = (rowStyle && hasOwnKeys(rowStyle.border) && rowStyle.border) ||
-        (colStyle && hasOwnKeys(colStyle.border) && colStyle.border);
-    if (border) {
-        style.border = structuredClone(border);
+    else if (hasOwnKeys(colStyle.border)) {
+        style.border = sharedCellFacet(colStyle, "border");
     }
-    const fill = (rowStyle && hasOwnKeys(rowStyle.fill) && rowStyle.fill) ||
-        (colStyle && hasOwnKeys(colStyle.fill) && colStyle.fill);
-    if (fill) {
-        style.fill = structuredClone(fill);
+    if (hasOwnKeys(rowStyle.fill)) {
+        style.fill = sharedCellFacet(rowStyle, "fill");
     }
-    const protection = (rowStyle && hasOwnKeys(rowStyle.protection) && rowStyle.protection) ||
-        (colStyle && hasOwnKeys(colStyle.protection) && colStyle.protection);
-    if (protection) {
-        style.protection = structuredClone(protection);
+    else if (hasOwnKeys(colStyle.fill)) {
+        style.fill = sharedCellFacet(colStyle, "fill");
+    }
+    if (hasOwnKeys(rowStyle.protection)) {
+        style.protection = sharedCellFacet(rowStyle, "protection");
+    }
+    else if (hasOwnKeys(colStyle.protection)) {
+        style.protection = sharedCellFacet(colStyle, "protection");
     }
     return style;
 }
@@ -98,6 +117,11 @@ export function cellCreate(row, column, address) {
         column,
         address,
         style: mergeCellStyle(row.style, column.style, {}),
+        // Declared here rather than assigned conditionally so every cell keeps one
+        // hidden class. `mergeCellStyle` may have pointed a facet at the row's or
+        // column's shared snapshot; the flag only claims it *may* have, and
+        // `cellOwnStyle` is a cheap no-op when it did not.
+        _sharedStyle: true,
         _mergeCount: 0
     };
     cell._value = Value.create(Types.Null, cell);
@@ -120,75 +144,153 @@ export function cellNumFmt(c) {
     return c.style.numFmt;
 }
 export function cellSetNumFmt(c, value) {
-    c.style.numFmt = value;
+    ownStyleContainer(c).numFmt = value;
 }
 export function cellFont(c) {
     return c.style.font;
 }
 export function cellSetFont(c, value) {
-    c.style.font = value;
+    ownStyleContainer(c).font = value;
+    if (value !== null && typeof value === "object") {
+        // Stored by reference, so the caller still holds it — see {@link cellSetStyle}.
+        c._sharedStyle = true;
+    }
 }
 export function cellAlignment(c) {
     return c.style.alignment;
 }
 export function cellSetAlignment(c, value) {
-    c.style.alignment = value;
+    ownStyleContainer(c).alignment = value;
+    if (value !== null && typeof value === "object") {
+        // Stored by reference, so the caller still holds it — see {@link cellSetStyle}.
+        c._sharedStyle = true;
+    }
 }
 export function cellBorder(c) {
     return c.style.border;
 }
 export function cellSetBorder(c, value) {
-    c.style.border = value;
+    ownStyleContainer(c).border = value;
+    if (value !== null && typeof value === "object") {
+        // Stored by reference, so the caller still holds it — see {@link cellSetStyle}.
+        c._sharedStyle = true;
+    }
 }
 export function cellFill(c) {
     return c.style.fill;
 }
 export function cellSetFill(c, value) {
-    c.style.fill = value;
+    ownStyleContainer(c).fill = value;
+    if (value !== null && typeof value === "object") {
+        // Stored by reference, so the caller still holds it — see {@link cellSetStyle}.
+        c._sharedStyle = true;
+    }
 }
 export function cellProtection(c) {
     return c.style.protection;
 }
 export function cellSetProtection(c, value) {
-    c.style.protection = value;
+    ownStyleContainer(c).protection = value;
+    if (value !== null && typeof value === "object") {
+        // Stored by reference, so the caller still holds it — see {@link cellSetStyle}.
+        c._sharedStyle = true;
+    }
+}
+/**
+ * Give the cell its own style *container*, so it can be written to.
+ *
+ * A cell whose style came wholly from one source — every cell that loaded with a given
+ * `styleId` — points at one shared container rather than holding a copy of it, which
+ * is worth ~85 bytes per cell. The container is frozen, and **that is also the marker**:
+ * no second flag is needed, and any write that forgets to come through here throws
+ * instead of rewriting every cell that shares it.
+ *
+ * Only the container is unshared. The facets inside it stay shared until
+ * {@link cellOwnStyle}, because replacing one facet is no reason to copy the rest.
+ */
+function ownStyleContainer(c) {
+    if (Object.isFrozen(c.style)) {
+        c.style = { ...c.style };
+    }
+    return c.style;
 }
-/** Read the cell's full style record (numFmt / font / alignment / border / fill / protection). */
+/**
+ * Give the cell its own copy of any facet it may be sharing, then return its style.
+ *
+ * This is the boundary that keeps "style isolation" true while cells share facets:
+ * a facet may be shared with the row/column snapshot it was inherited from, with
+ * sibling cells sharing that snapshot, or with a caller who handed it to a setter —
+ * so anything that lets a caller reach a facet must come through here first.
+ * `surface/` calls it on every reader that returns a facet; core internals and the
+ * writers read `c.style` directly and never materialise, which is what keeps a
+ * styled sheet's memory flat.
+ *
+ * Idempotent and allocation-free once the cell owns its facets.
+ */
+export function cellOwnStyle(c) {
+    if (c._sharedStyle) {
+        c._sharedStyle = false;
+        const style = ownStyleContainer(c);
+        for (const key of OBJECT_FACETS) {
+            const facet = style[key];
+            if (facet) {
+                style[key] = copyStyleFacet(key, facet);
+            }
+        }
+    }
+    return ownStyleContainer(c);
+}
+/**
+ * Read the cell's full style record (numFmt / font / alignment / border / fill /
+ * protection) **without** materialising it. Internal readers and the writers use
+ * this; a public reader must use {@link cellOwnStyle}.
+ */
 export function cellGetStyle(c) {
     return c.style;
 }
 /** Merge a partial style into the cell's existing style. */
 export function cellSetStyle(c, style) {
     if (style.numFmt !== undefined) {
-        c.style.numFmt = style.numFmt;
+        ownStyleContainer(c).numFmt = style.numFmt;
     }
     if (style.styleName !== undefined) {
-        c.style.styleName = style.styleName;
-    }
-    if (style.font !== undefined) {
-        c.style.font = style.font;
-    }
-    if (style.alignment !== undefined) {
-        c.style.alignment = style.alignment;
-    }
-    if (style.border !== undefined) {
-        c.style.border = style.border;
-    }
-    if (style.fill !== undefined) {
-        c.style.fill = style.fill;
-    }
-    if (style.protection !== undefined) {
-        c.style.protection = style.protection;
+        ownStyleContainer(c).styleName = style.styleName;
+    }
+    // Object facets are stored by reference, so the caller — and any other cell set
+    // from the same object — still holds them, and the cell has to be marked as
+    // sharing. Before that flag existed, setting two cells from one style object
+    // aliased them permanently: mutating `Cell.getStyle(a).font` changed the other
+    // cell *and* the caller's object.
+    //
+    // Only mark when an object facet is actually stored. Marking unconditionally
+    // meant that a `numFmt`-only update re-shared the cell, so the *next* read
+    // re-copied facets the cell already owned privately — silently detaching a
+    // reference the caller was still holding from an earlier `Cell.getStyle`.
+    for (const key of OBJECT_FACETS) {
+        const facet = style[key];
+        if (facet !== undefined) {
+            ownStyleContainer(c)[key] = facet;
+            if (facet !== null && typeof facet === "object") {
+                c._sharedStyle = true;
+            }
+        }
     }
 }
 /**
- * Assign a single style facet onto `target`, deep-cloning the value so the
- * target never aliases a shared sub-object (`numFmt` is a primitive and is
- * effectively copied by value). The generic `K` keeps the key and value types
- * linked — a widened `keyof Style` loop variable would collapse the index type
- * to the intersection of all facet types and break assignment.
+ * Point a cell's facet at `value` without copying it, and mark the cell as sharing.
+ *
+ * This is the row/column propagation path — once per cell per facet — and `value` is
+ * the owner's shared snapshot, so every cell in a styled column ends up pointing at
+ * one object instead of holding its own copy. {@link cellOwnStyle} separates a cell
+ * again the moment a caller can reach the facet.
+ *
+ * The generic `K` keeps the key and value types linked — a widened `keyof Style` loop
+ * variable would collapse the index type to the intersection of all facet types and
+ * break assignment.
  */
-export function setFacetCloned(target, key, value) {
-    target[key] = typeof value === "object" && value !== null ? structuredClone(value) : value;
+export function setFacetShared(cell, key, value) {
+    ownStyleContainer(cell)[key] = value;
+    cell._sharedStyle = true;
 }
 /**
  * Assign a single style facet onto `target` by reference (no clone). Companion
@@ -289,7 +391,7 @@ export function cellSetValue(c, v) {
     if (kind !== undefined && c.style.numFmt === undefined) {
         // Only when the cell has none of its own: an explicit format the caller set is theirs, and a value assignment
         // is not the place to overrule it.
-        c.style.numFmt = defaultNumFmtFor(kind);
+        ownStyleContainer(c).numFmt = defaultNumFmtFor(kind);
     }
 }
 /** Upper bound for each calendar field. `day` is checked against the month once the month is known. */
@@ -398,7 +500,7 @@ export function cellSetDateParts(c, parts, kind) {
     // serial (60) but no `Date`, and building one would silently move it to March 1.
     cellSetValue(c, excelToDate(partsToSerial(filled, date1904), date1904));
     if (c.style.numFmt === undefined) {
-        c.style.numFmt = defaultNumFmtFor(resolved);
+        ownStyleContainer(c).numFmt = defaultNumFmtFor(resolved);
     }
 }
 /**
@@ -494,6 +596,7 @@ export function cellMerge(c, master, ignoreStyle) {
     c._value = Value.create(Types.Merge, c, master);
     if (!ignoreStyle) {
         c.style = copyStyle(master.style) ?? {};
+        c._sharedStyle = false;
     }
 }
 export function cellUnmerge(c) {
@@ -502,6 +605,7 @@ export function cellUnmerge(c) {
         c._value.release();
         c._value = Value.create(Types.Null, c);
         c.style = mergeCellStyle(c.row.style, c.column.style, { ...c.style });
+        c._sharedStyle = true;
     }
 }
 export function cellIsMergedTo(c, master) {
@@ -688,10 +792,21 @@ export function cellSetModel(c, value) {
         }
     }
     if (value.style) {
-        c.style = copyStyle(value.style) ?? {};
+        // Share the model's whole style *container*, not just its facets. The read path
+        // hands the same style model to every cell carrying a given `styleId`
+        // (`StylesXform.getStyleModel` caches one per id), so one container and one set of
+        // facet snapshots covers all of them — loading a 200k-cell sheet with a single
+        // logical style cost 110 MB of duplicated style objects before this.
+        //
+        // The container is frozen, which both enforces the sharing and marks it: a write
+        // has to come through `ownStyleContainer` and a missed one throws. `_sharedStyle`
+        // separately marks the facets inside it.
+        c.style = sharedCellContainer(value.style);
+        c._sharedStyle = true;
     }
     else {
-        c.style = {};
+        c.style = EMPTY_CELL_STYLE;
+        c._sharedStyle = false;
     }
 }
 class NullValue {

package/dist/esm/modules/excel/core/row.js

@@ -1,5 +1,6 @@
-import { cellCol, cellGetModel, cellGetValue, cellType, setFacet, setFacetCloned } from "./cell.js";
+import { cellCol, cellGetModel, cellGetValue, cellType, setFacet, setFacetShared } from "./cell.js";
 import { Enums } from "./enums.js";
+import { invalidateSharedCellStyle, sharedCellFacet } from "./style-sharing.js";
 /**
  * Assign one style facet to the row and to every cell it already holds.
  *
@@ -12,9 +13,12 @@ import { Enums } from "./enums.js";
  */
 function applyStyle(r, name, value) {
     r.style[name] = value;
+    invalidateSharedCellStyle(r.style);
+    // One snapshot for the whole row, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(r.style, name);
     r.cells.forEach(cell => {
         if (cell) {
-            setFacetCloned(cell.style, name, value);
+            setFacetShared(cell, name, shared);
         }
     });
 }
@@ -142,10 +146,12 @@ export function rowSetStyle(r, style) {
     for (const k of keys) {
         setFacet(r.style, k, style[k]);
     }
+    invalidateSharedCellStyle(r.style);
+    const shared = keys.map(k => sharedCellFacet(r.style, k));
     r.cells.forEach(cell => {
         if (cell) {
-            for (const k of keys) {
-                setFacetCloned(cell.style, k, style[k]);
+            for (let i = 0; i < keys.length; i++) {
+                setFacetShared(cell, keys[i], shared[i]);
             }
         }
     });

package/dist/esm/modules/excel/core/style-sharing.js

@@ -0,0 +1,132 @@
+import { copyStyleFacet } from "../utils/copy-style.js";
+/**
+ * The single copy of a row's or column's style facets that every cell it covers
+ * points at.
+ *
+ * Without it each cell kept its own deep copy of the same facets — measured at 382
+ * bytes per cell, so a 200k-cell sheet carrying one logical style paid 73 MB to say
+ * the same thing 200,000 times.
+ *
+ * **A copy, not the owner's own facet object.** That is what leaves the owner's
+ * semantics untouched: `Column.getStyle(ws, 1).font.bold = false` must not reach
+ * cells that were already styled, exactly as it does not today. Cells point into the
+ * snapshot; a caller mutating the column mutates the column's own object.
+ *
+ * **Keyed by the style object, not the owner.** Ten places replace a row's or
+ * column's `style` wholesale (`applyDefn`, `rowSetModel`, `duplicateRow`,
+ * `spliceRows`, …). Keying on the object means every one of those invalidates by
+ * construction — a field on the owner would have needed all ten to remember, and the
+ * one that forgot would hand cells a snapshot of a style the owner no longer has.
+ * Only mutating a facet *on the same object* needs {@link invalidateSharedCellStyle},
+ * and those sites are the handful of `set*` calls in this module's callers.
+ */
+const snapshots = new WeakMap();
+/**
+ * Freeze a snapshot facet and everything under it.
+ *
+ * A shared facet is reachable from hundreds of thousands of cells, so mutating one
+ * in place would silently rewrite all of them. Freezing turns that into a `TypeError`
+ * at the offending line — ESM is strict mode, so the assignment throws rather than
+ * being ignored. It is the enforcement half of the sharing invariant: `cellOwnStyle`
+ * hands out private copies, and this guarantees anything that skipped it fails loudly
+ * instead of corrupting a neighbour.
+ *
+ * `Cell.view` is the case that needs it most: it is documented as a read-only
+ * projection and its `font`/`alignment` are the shared objects, deliberately not
+ * materialised so that iterating a row stays allocation-free.
+ *
+ * Shape-agnostic on purpose — the per-facet nesting is already spelled out once in
+ * `copy-style.ts` and repeating it here would be a second definition to drift. Runs
+ * once per snapshot, not per cell. The `isFrozen` check also terminates on a cycle.
+ */
+function deepFreeze(value) {
+    if (value && typeof value === "object" && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const key of Object.keys(value)) {
+            deepFreeze(value[key]);
+        }
+    }
+}
+/**
+ * The facet a cell covered by `style`'s owner should point at: the same object for
+ * every such cell, built on first use and frozen.
+ *
+ * `numFmt` and `styleName` are primitives, so they are returned as-is and never enter
+ * a snapshot.
+ */
+export function sharedCellFacet(style, key) {
+    const value = style[key];
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    let snapshot = snapshots.get(style);
+    if (!snapshot) {
+        snapshot = {};
+        snapshots.set(style, snapshot);
+    }
+    let facet = snapshot[key];
+    if (facet === undefined) {
+        facet = copyStyleFacet(key, value);
+        deepFreeze(facet);
+        snapshot[key] = facet;
+    }
+    return facet;
+}
+/**
+ * The frozen style container every cell resolving to `style` should point at.
+ *
+ * A cell whose style comes wholly from one source — every cell that loaded with a
+ * given `styleId`, since the reader caches one style model per id — needs no container
+ * of its own. Sharing it is worth ~85 bytes per cell on top of the facets, and it is
+ * the last per-cell cost of a style that many cells agree on.
+ *
+ * Frozen for the same reason the facets are: it both enforces the sharing and marks
+ * it, so `ownStyleContainer` can recognise a shared container without a second flag
+ * and a write that skips it throws rather than rewriting every cell that shares it.
+ *
+ * The container's own facets are the snapshots, so `sharedCellFacet` and this agree by
+ * construction. Fields that are not facets — `numFmt`, `styleName`, and the xf-level
+ * `pivotButton`/`apply*` flags the reader preserves — are carried across verbatim.
+ */
+export function sharedCellContainer(style) {
+    let container = containers.get(style);
+    if (!container) {
+        container = { ...style };
+        for (const key of OBJECT_FACETS) {
+            if (container[key] !== undefined) {
+                container[key] = sharedCellFacet(style, key);
+            }
+        }
+        Object.freeze(container);
+        containers.set(style, container);
+    }
+    return container;
+}
+const containers = new WeakMap();
+/**
+ * The container an unstyled cell points at.
+ *
+ * A cell always has a `style` object because 182 readers say `cell.style.font`, but a
+ * cell with no style has nothing to put in it, and allocating one per cell is pure
+ * overhead — 200k of them on a plain sheet. Frozen like every shared container, so
+ * `ownStyleContainer` gives a cell its own the moment anything writes to it.
+ */
+export const EMPTY_CELL_STYLE = Object.freeze({});
+/** The style facets that are objects, and so the ones that can be shared or copied. */
+const OBJECT_FACETS = ["font", "alignment", "protection", "border", "fill"];
+/**
+ * Drop the snapshot of `style`, so the next cell that needs a facet takes a fresh one.
+ *
+ * Needed when a facet is replaced **on this same object** — a wholesale
+ * `owner.style = …` invalidates on its own, because the snapshot is keyed by object.
+ * Call it in two situations:
+ *
+ *  - A `set*` that writes `owner.style.font = …` in place.
+ *  - Handing the style to a caller, who may mutate it in place. Today a cell created
+ *    after such a mutation copies the mutated facet, and invalidating on handout is
+ *    what preserves that.
+ */
+export function invalidateSharedCellStyle(style) {
+    snapshots.delete(style);
+    containers.delete(style);
+}

package/dist/esm/modules/excel/core/table.js

@@ -1,4 +1,5 @@
-import { cellGetValue, cellSetValue } from "./cell.js";
+import { cellGetValue, cellSetValue, setFacetShared } from "./cell.js";
+import { sharedCellFacet } from "./style-sharing.js";
 import { getRow, getSheetWorkbook, rowGetCell } from "./worksheet-core.js";
 import { TableError } from "../errors.js";
 import { colCache } from "../utils/col-cache.js";
@@ -225,9 +226,20 @@ export function tableValidate(t) {
 }
 export function tableStore(t) {
     // where the table needs to store table data, headers, footers in the sheet...
+    //
+    // A table column's style is one object applied to its header, every body row and
+    // its totals cell, so it is a style owner in the sense of `style-sharing.ts`: the
+    // cells share one frozen snapshot of it rather than each holding a copy, and they
+    // are marked so that `Cell.get*` separates them again.
+    //
+    // This used to be `Object.assign(cell.style, style)`, which shared the facets *and*
+    // said nothing about it, so every cell in a table column was permanently aliased —
+    // `Cell.getStyle(a).font.bold = false` rewrote the whole column.
     const assignStyle = (cell, style) => {
         if (style) {
-            Object.assign(cell.style, style);
+            for (const key of Object.keys(style)) {
+                setFacetShared(cell, key, sharedCellFacet(style, key));
+            }
         }
     };
     const { worksheet, table } = t;

package/dist/esm/modules/excel/core/worksheet-core.js

@@ -1,8 +1,9 @@
-import { CellTypes, cellComment, cellCreate, cellGetValue, cellSetAlignment, cellSetBorder, cellSetComment, cellSetFill, cellSetFont, cellSetModel, cellSetNumFmt, cellSetProtection, cellSetValue, cellType, setFacet, setFacetCloned } from "./cell.js";
+import { CellTypes, cellComment, cellCreate, cellGetValue, cellSetComment, cellSetModel, cellSetNumFmt, cellSetValue, cellType, setFacet, setFacetShared } from "./cell.js";
 import { columnHeaders } from "./column.js";
 import { Enums } from "./enums.js";
 import { rangeCreate, rangeRange } from "./range.js";
 import { rowCreate, rowFindCell, rowHasValues, rowValues, resolveColumnKeyValue } from "./row.js";
+import { invalidateSharedCellStyle, sharedCellFacet } from "./style-sharing.js";
 import { ExcelError, InvalidAddressError } from "../errors.js";
 import { colCache } from "../utils/col-cache.js";
 import { copyStyle } from "../utils/copy-style.js";
@@ -416,32 +417,47 @@ export function columnSetNumFmt(c, value) {
 }
 export function columnSetFont(c, value) {
     c.style.font = value;
+    invalidateSharedCellStyle(c.style);
+    // One snapshot for the whole column, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(c.style, "font");
     columnEachCell(c, cell => {
-        cellSetFont(cell, value ? structuredClone(value) : value);
+        setFacetShared(cell, "font", shared);
     });
 }
 export function columnSetAlignment(c, value) {
     c.style.alignment = value;
+    invalidateSharedCellStyle(c.style);
+    // One snapshot for the whole column, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(c.style, "alignment");
     columnEachCell(c, cell => {
-        cellSetAlignment(cell, value ? structuredClone(value) : value);
+        setFacetShared(cell, "alignment", shared);
     });
 }
 export function columnSetProtection(c, value) {
     c.style.protection = value;
+    invalidateSharedCellStyle(c.style);
+    // One snapshot for the whole column, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(c.style, "protection");
     columnEachCell(c, cell => {
-        cellSetProtection(cell, value ? structuredClone(value) : value);
+        setFacetShared(cell, "protection", shared);
     });
 }
 export function columnSetBorder(c, value) {
     c.style.border = value;
+    invalidateSharedCellStyle(c.style);
+    // One snapshot for the whole column, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(c.style, "border");
     columnEachCell(c, cell => {
-        cellSetBorder(cell, value ? structuredClone(value) : value);
+        setFacetShared(cell, "border", shared);
     });
 }
 export function columnSetFill(c, value) {
     c.style.fill = value;
+    invalidateSharedCellStyle(c.style);
+    // One snapshot for the whole column, shared by every cell — see `style-sharing.ts`.
+    const shared = sharedCellFacet(c.style, "fill");
     columnEachCell(c, cell => {
-        cellSetFill(cell, value ? structuredClone(value) : value);
+        setFacetShared(cell, "fill", shared);
     });
 }
 /**
@@ -460,14 +476,16 @@ export function columnSetStyle(c, style) {
     if (keys.length === 0) {
         return;
     }
-    // The column's own style holds each facet by reference; every cell gets a
-    // deep-cloned copy so cells never alias the column's style sub-objects.
+    // The column's own style holds each facet by reference; the cells share a single
+    // snapshot of it, so a column of 200k cells stores one copy rather than 200k.
     for (const k of keys) {
         setFacet(c.style, k, style[k]);
     }
+    invalidateSharedCellStyle(c.style);
+    const shared = keys.map(k => sharedCellFacet(c.style, k));
     columnEachCell(c, cell => {
-        for (const k of keys) {
-            setFacetCloned(cell.style, k, style[k]);
+        for (let i = 0; i < keys.length; i++) {
+            setFacetShared(cell, keys[i], shared[i]);
         }
     });
 }

package/dist/esm/modules/excel/core/xlsx-io.js

@@ -33,6 +33,13 @@ export function getXlsxIo(wb) {
  * and the fallback wraps the existing memory (`Buffer.from(buffer, byteOffset,
  * byteLength)` is a view, never a copy). Either way no bytes are duplicated, and
  * the declared type cannot silently drift from the runtime one.
+ *
+ * **Timing this?** Measure with `NODE_ENV=production`. Outside production (and outside
+ * vitest) every write runs the OOXML self-check, which re-parses the package it just
+ * produced — measured at 38 ms against 124 ms on a 100-column × 200-row table, so a
+ * development-mode figure is roughly **3.3× the real one** and is not distributed
+ * across the write in the way a profile suggests. Pass `{ validate: false }` to
+ * suppress it explicitly; see `XlsxWriteOptions.validate`.
  */
 export async function toBuffer(wb, options) {
     const bytes = options?.format === "xlsb"