@office-kit/xlsx 0.8.0

package/dist/worksheet-CmCNoIgD.mjs

@@ -0,0 +1,1726 @@
+import { o as OpenXmlSchemaError } from "./exceptions-D-CFwxgm.mjs";
+import { a as columnLetterFromIndex, g as tupleToCoordinate, h as rangeBoundaries, i as columnIndexFromLetter, n as MAX_ROW, r as boundariesToRangeString, s as coordinateToTuple, t as MAX_COL } from "./coordinate-96Ecci4d.mjs";
+import { o as cellValueAsString, y as makeCell } from "./cell-D9CaNKnU.mjs";
+//#region src/worksheet/cell-range.ts
+/** Build a CellRange from explicit 1-based bounds. */
+function makeCellRange(minRow, minCol, maxRow, maxCol) {
+	if (!Number.isInteger(minRow) || !Number.isInteger(minCol) || !Number.isInteger(maxRow) || !Number.isInteger(maxCol)) throw new OpenXmlSchemaError("CellRange bounds must be integers");
+	if (minRow < 1 || maxRow < 1 || minRow > 1048576 || maxRow > 1048576) throw new OpenXmlSchemaError(`CellRange row bounds must be in [1, ${MAX_ROW}]`);
+	if (minCol < 1 || maxCol < 1 || minCol > 16384 || maxCol > 16384) throw new OpenXmlSchemaError(`CellRange col bounds must be in [1, ${MAX_COL}]`);
+	return {
+		minRow: Math.min(minRow, maxRow),
+		minCol: Math.min(minCol, maxCol),
+		maxRow: Math.max(minRow, maxRow),
+		maxCol: Math.max(minCol, maxCol)
+	};
+}
+/** Parse a range expression — wraps {@link rangeBoundaries}. */
+function parseRange(input) {
+	return rangeBoundaries(input);
+}
+/** Format a CellRange back into the canonical OOXML string. */
+function rangeToString(r) {
+	return boundariesToRangeString(r);
+}
+/** Inclusive containment of a single (row, col) within a range. */
+function rangeContainsCell(r, row, col) {
+	return row >= r.minRow && row <= r.maxRow && col >= r.minCol && col <= r.maxCol;
+}
+/**
+* A1-string convenience for {@link rangeContainsCell}. Parses `cellRef` (e.g.
+* `"B3"`) and `rangeRef` (e.g. `"A1:C5"`) and returns `true` iff the cell sits
+* inside the range (boundary-inclusive). Throws when either input is malformed.
+*/
+function isCellInRange(cellRef, rangeRef) {
+	const { col, row } = coordinateToTuple(cellRef);
+	return rangeContainsCell(parseRange(rangeRef), row, col);
+}
+/**
+* A1-string convenience for {@link rangeContainsRange}. Returns `true` iff the
+* `inner` range is wholly contained by `outer` (boundary-inclusive).
+* Single-cell refs are accepted on either side via parseRange. Throws on
+* malformed input.
+*/
+function isRangeInRange(inner, outer) {
+	return rangeContainsRange(parseRange(outer), parseRange(inner));
+}
+/**
+* Expand (or shrink) an A1 range by adding `deltaRows` to its bottom edge and
+* `deltaCols` to its right edge. The top-left corner is preserved. Negative
+* deltas shrink the range; the result must still have at least 1 row and 1
+* column (otherwise throws).
+*
+* Useful for "this is the data range — also reserve room for a totals row" or
+* "include one more column to the right" patterns.
+*/
+function expandRangeStr(range, deltaRows, deltaCols) {
+	if (!Number.isInteger(deltaRows) || !Number.isInteger(deltaCols)) throw new OpenXmlSchemaError("expandRangeStr: deltas must be integers");
+	const r = parseRange(range);
+	return rangeToString(makeCellRange(r.minRow, r.minCol, r.maxRow + deltaRows, r.maxCol + deltaCols));
+}
+/** Inclusive containment of `inner` within `outer`. */
+function rangeContainsRange(outer, inner) {
+	return inner.minRow >= outer.minRow && inner.maxRow <= outer.maxRow && inner.minCol >= outer.minCol && inner.maxCol <= outer.maxCol;
+}
+/**
+* Shift a range by (dr, dc) integer offsets. The returned range is clamped to
+* the OOXML grid; callers that want hard bounds should pass values that keep
+* the result inside the spec.
+*/
+function shiftRange(r, dr, dc) {
+	if (!Number.isInteger(dr) || !Number.isInteger(dc)) throw new OpenXmlSchemaError("shiftRange: dr / dc must be integers");
+	return makeCellRange(r.minRow + dr, r.minCol + dc, r.maxRow + dr, r.maxCol + dc);
+}
+/** Bounding-box union of two ranges. Always non-null. */
+function unionRange(a, b) {
+	return {
+		minRow: Math.min(a.minRow, b.minRow),
+		minCol: Math.min(a.minCol, b.minCol),
+		maxRow: Math.max(a.maxRow, b.maxRow),
+		maxCol: Math.max(a.maxCol, b.maxCol)
+	};
+}
+/** Returns the rectangular intersection of two ranges, or `null` when disjoint. */
+function intersectionRange(a, b) {
+	const minRow = Math.max(a.minRow, b.minRow);
+	const minCol = Math.max(a.minCol, b.minCol);
+	const maxRow = Math.min(a.maxRow, b.maxRow);
+	const maxCol = Math.min(a.maxCol, b.maxCol);
+	if (minRow > maxRow || minCol > maxCol) return null;
+	return {
+		minRow,
+		minCol,
+		maxRow,
+		maxCol
+	};
+}
+/** True iff two ranges share at least one cell. */
+function rangesOverlap(a, b) {
+	return intersectionRange(a, b) !== null;
+}
+/** Inclusive cell count covered by a range. */
+function rangeArea(r) {
+	return (r.maxRow - r.minRow + 1) * (r.maxCol - r.minCol + 1);
+}
+/** Parse an sqref string: `"A1:B2 D5 E10:F20"`. Whitespace-delimited. */
+function parseMultiCellRange(input) {
+	const ranges = [];
+	for (const piece of input.split(/\s+/)) {
+		if (piece.length === 0) continue;
+		ranges.push(parseRange(piece));
+	}
+	return { ranges };
+}
+/** Format a MultiCellRange back into an sqref string. */
+function multiCellRangeToString(m) {
+	return m.ranges.map(rangeToString).join(" ");
+}
+/** True iff any contained range covers (row, col). */
+function multiCellRangeContainsCell(m, row, col) {
+	for (const r of m.ranges) if (rangeContainsCell(r, row, col)) return true;
+	return false;
+}
+//#endregion
+//#region src/styles/colors.ts
+/**
+* Legacy 64-entry palette indexed colours fall back to. Verbatim from
+* openpyxl/openpyxl/styles/colors.py — must not be reordered.
+*/
+const COLOR_INDEX = Object.freeze([
+	"00000000",
+	"00FFFFFF",
+	"00FF0000",
+	"0000FF00",
+	"000000FF",
+	"00FFFF00",
+	"00FF00FF",
+	"0000FFFF",
+	"00000000",
+	"00FFFFFF",
+	"00FF0000",
+	"0000FF00",
+	"000000FF",
+	"00FFFF00",
+	"00FF00FF",
+	"0000FFFF",
+	"00800000",
+	"00008000",
+	"00000080",
+	"00808000",
+	"00800080",
+	"00008080",
+	"00C0C0C0",
+	"00808080",
+	"009999FF",
+	"00993366",
+	"00FFFFCC",
+	"00CCFFFF",
+	"00660066",
+	"00FF8080",
+	"000066CC",
+	"00CCCCFF",
+	"00000080",
+	"00FF00FF",
+	"00FFFF00",
+	"0000FFFF",
+	"00800080",
+	"00800000",
+	"00008080",
+	"000000FF",
+	"0000CCFF",
+	"00CCFFFF",
+	"00CCFFCC",
+	"00FFFF99",
+	"0099CCFF",
+	"00FF99CC",
+	"00CC99FF",
+	"00FFCC99",
+	"003366FF",
+	"0033CCCC",
+	"0099CC00",
+	"00FFCC00",
+	"00FF9900",
+	"00FF6600",
+	"00666699",
+	"00969696",
+	"00003366",
+	"00339966",
+	"00003300",
+	"00333300",
+	"00993300",
+	"00993366",
+	"00333399",
+	"00333333"
+]);
+const ARGB_RE = /^([A-Fa-f0-9]{8}|[A-Fa-f0-9]{6})$/;
+/**
+* Normalise an aRGB hex string. Accepts either 6 or 8 hex digits; 6-digit input
+* is padded to 8 by prefixing `00` (alpha=0 = fully opaque per Excel
+* convention). Returns the canonical uppercase form.
+*/
+function normaliseRgb(value) {
+	if (typeof value !== "string" || !ARGB_RE.test(value)) throw new OpenXmlSchemaError(`Color rgb must be 6 or 8 hex digits; got "${value}"`);
+	return (value.length === 6 ? `00${value}` : value).toUpperCase();
+}
+/**
+* Build an immutable {@link Color}. Validates ranges (indexed in [0, 65], tint
+* in [-1, 1]) and normalises rgb hex.
+*/
+function makeColor(opts = {}) {
+	const out = {};
+	if (opts.rgb !== void 0) out.rgb = normaliseRgb(opts.rgb);
+	if (opts.indexed !== void 0) {
+		if (!Number.isInteger(opts.indexed) || opts.indexed < 0 || opts.indexed > 65) throw new OpenXmlSchemaError(`Color indexed must be in [0, 65]; got ${opts.indexed}`);
+		out.indexed = opts.indexed;
+	}
+	if (opts.theme !== void 0) {
+		if (!Number.isInteger(opts.theme) || opts.theme < 0) throw new OpenXmlSchemaError(`Color theme must be a non-negative integer; got ${opts.theme}`);
+		out.theme = opts.theme;
+	}
+	if (opts.auto !== void 0) out.auto = opts.auto;
+	if (opts.tint !== void 0) {
+		if (!Number.isFinite(opts.tint) || opts.tint < -1 || opts.tint > 1) throw new OpenXmlSchemaError(`Color tint must be in [-1, 1]; got ${opts.tint}`);
+		out.tint = opts.tint;
+	}
+	return Object.freeze(out);
+}
+/**
+* Resolve `indexed` references against {@link COLOR_INDEX}. Returns undefined
+* for 64/65 (system fg/bg, not in the palette) or out-of-range.
+*/
+function resolveIndexedColor(idx) {
+	return COLOR_INDEX[idx];
+}
+/** Shortcut for the common opaque solid colour. */
+function rgbColor(hex) {
+	return makeColor({ rgb: hex });
+}
+/**
+* Read a {@link Color} value-object back to a normalised ARGB hex. Resolution
+* order: explicit `rgb` → `indexed` palette lookup. Returns `undefined` for
+* `theme` / `auto` / empty inputs (unresolvable without a theme), so callers
+* can fall back to a default.
+*/
+function colorToHex(color) {
+	if (!color) return void 0;
+	if (color.rgb !== void 0) return normaliseRgb(color.rgb);
+	if (color.indexed !== void 0) {
+		const rgb = resolveIndexedColor(color.indexed);
+		if (rgb) return rgb.toUpperCase();
+	}
+}
+/**
+* Compute the relative luminance of an ARGB / RGB hex string per the WCAG 2.x
+* formula. Returns a value in `[0, 1]` where 0 is black and 1 is white. The
+* alpha channel (if present) is ignored.
+*/
+function luminance(hex) {
+	const rgb = normaliseRgb(hex);
+	const r = Number.parseInt(rgb.slice(2, 4), 16) / 255;
+	const g = Number.parseInt(rgb.slice(4, 6), 16) / 255;
+	const b = Number.parseInt(rgb.slice(6, 8), 16) / 255;
+	const lin = (c) => c <= .03928 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+	return .2126 * lin(r) + .7152 * lin(g) + .0722 * lin(b);
+}
+/**
+* WCAG contrast ratio between two ARGB hex colors. Returns a value in `[1,
+* 21]`; 1 = identical luminance, 21 = pure black on pure white. The order of
+* arguments doesn't matter.
+*/
+function contrastRatio(hexA, hexB) {
+	const lA = luminance(hexA);
+	const lB = luminance(hexB);
+	const [hi, lo] = lA >= lB ? [lA, lB] : [lB, lA];
+	return (hi + .05) / (lo + .05);
+}
+/**
+* Pick the higher-contrast text color (`'FF000000'` black or `'FFFFFFFF'`
+* white) for a background hex. Useful when applying a solid fill and wanting
+* the cell text to stay readable.
+*/
+function pickReadableTextColor(backgroundHex) {
+	return luminance(backgroundHex) < .179 ? "FFFFFFFF" : "FF000000";
+}
+const splitArgb = (hex) => {
+	const rgb = normaliseRgb(hex);
+	return {
+		a: Number.parseInt(rgb.slice(0, 2), 16),
+		r: Number.parseInt(rgb.slice(2, 4), 16),
+		g: Number.parseInt(rgb.slice(4, 6), 16),
+		b: Number.parseInt(rgb.slice(6, 8), 16)
+	};
+};
+const toHexByte = (n) => {
+	return Math.max(0, Math.min(255, Math.round(n))).toString(16).padStart(2, "0").toUpperCase();
+};
+const clampUnit = (x) => Math.max(0, Math.min(1, x));
+/**
+* Lighten a color by mixing it with white. `amount` is in `[0, 1]`: 0 returns
+* the input unchanged, 1 returns pure white. Alpha channel is preserved.
+* Equivalent to `mixColors(hex, 'FFFFFFFF', amount)`.
+*/
+function lighten(hex, amount) {
+	const t = clampUnit(amount);
+	const { a, r, g, b } = splitArgb(hex);
+	return `${toHexByte(a)}${toHexByte(r + (255 - r) * t)}${toHexByte(g + (255 - g) * t)}${toHexByte(b + (255 - b) * t)}`;
+}
+/**
+* Darken a color by mixing it with black. `amount` is in `[0, 1]`: 0 returns
+* the input unchanged, 1 returns pure black (preserving the alpha channel).
+*/
+function darken(hex, amount) {
+	const t = clampUnit(amount);
+	const { a, r, g, b } = splitArgb(hex);
+	return `${toHexByte(a)}${toHexByte(r * (1 - t))}${toHexByte(g * (1 - t))}${toHexByte(b * (1 - t))}`;
+}
+/**
+* Linearly interpolate between two ARGB colors. `t = 0` returns `hexA`; `t = 1`
+* returns `hexB`; intermediate values mix per channel (including alpha).
+*/
+function mixColors(hexA, hexB, t) {
+	const k = clampUnit(t);
+	const a = splitArgb(hexA);
+	const b = splitArgb(hexB);
+	return `${toHexByte(a.a + (b.a - a.a) * k)}${toHexByte(a.r + (b.r - a.r) * k)}${toHexByte(a.g + (b.g - a.g) * k)}${toHexByte(a.b + (b.b - a.b) * k)}`;
+}
+/**
+* Convert an ARGB / RGB hex to its HSL representation. Returns `{ h, s, l, a }`
+* with `h ∈ [0, 360)`, `s ∈ [0, 1]`, `l ∈ [0, 1]`, `a ∈ [0, 255]` (alpha as the
+* original byte). Useful for theme tweaking (rotate hue, desaturate, etc.)
+* before round-tripping through {@link hslToHex}.
+*/
+function hexToHsl(hex) {
+	const { a, r: rb, g: gb, b: bb } = splitArgb(hex);
+	const r = rb / 255;
+	const g = gb / 255;
+	const b = bb / 255;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	let h = 0;
+	let s = 0;
+	if (max !== min) {
+		const d = max - min;
+		s = l > .5 ? d / (2 - max - min) : d / (max + min);
+		if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+		else if (max === g) h = ((b - r) / d + 2) * 60;
+		else h = ((r - g) / d + 4) * 60;
+	}
+	return {
+		h,
+		s,
+		l,
+		a
+	};
+}
+/**
+* Rotate the hue of a color by `degrees` (positive = clockwise). Saturation and
+* lightness are preserved; alpha is preserved. Equivalent to `hexToHsl` →
+* adjust `h` → `hslToHex`.
+*/
+function rotateHue(hex, degrees) {
+	const { h, s, l, a } = hexToHsl(hex);
+	return hslToHex(h + degrees, s, l, a);
+}
+/**
+* Adjust the saturation of a color by `delta` (added directly to the `[0, 1]`
+* saturation channel and clamped). Positive = more vivid, negative = closer to
+* gray. Hue, lightness, and alpha are preserved.
+*/
+function adjustSaturation(hex, delta) {
+	const { h, s, l, a } = hexToHsl(hex);
+	return hslToHex(h, s + delta, l, a);
+}
+/**
+* Adjust the lightness of a color by `delta` (added directly to the `[0, 1]`
+* lightness channel and clamped). Positive = lighter, negative = darker.
+* Distinct from {@link lighten} / {@link darken} which mix toward white/black
+* in RGB space.
+*/
+function adjustLightness(hex, delta) {
+	const { h, s, l, a } = hexToHsl(hex);
+	return hslToHex(h, s, l + delta, a);
+}
+/**
+* Convert HSL components back to an ARGB hex string. `h` wraps mod-360, `s` and
+* `l` clamp to `[0, 1]`. `alpha` is the byte (default 255 = opaque), placed in
+* the high byte of the result.
+*/
+function hslToHex(h, s, l, alpha = 255) {
+	const hh = (h % 360 + 360) % 360;
+	const ss = clampUnit(s);
+	const ll = clampUnit(l);
+	const c = (1 - Math.abs(2 * ll - 1)) * ss;
+	const x = c * (1 - Math.abs(hh / 60 % 2 - 1));
+	const m = ll - c / 2;
+	let rp = 0;
+	let gp = 0;
+	let bp = 0;
+	if (hh < 60) {
+		rp = c;
+		gp = x;
+	} else if (hh < 120) {
+		rp = x;
+		gp = c;
+	} else if (hh < 180) {
+		gp = c;
+		bp = x;
+	} else if (hh < 240) {
+		gp = x;
+		bp = c;
+	} else if (hh < 300) {
+		rp = x;
+		bp = c;
+	} else {
+		rp = c;
+		bp = x;
+	}
+	return `${toHexByte(Math.max(0, Math.min(255, Math.round(alpha))))}${toHexByte((rp + m) * 255)}${toHexByte((gp + m) * 255)}${toHexByte((bp + m) * 255)}`;
+}
+//#endregion
+//#region src/worksheet/dimensions.ts
+/** Build a single-column ColumnDimension entry covering `col`. */
+function makeColumnDimension(col, opts = {}) {
+	return {
+		min: col,
+		max: col,
+		...opts.width !== void 0 ? { width: opts.width } : {},
+		...opts.customWidth !== void 0 ? { customWidth: opts.customWidth } : {},
+		...opts.hidden !== void 0 ? { hidden: opts.hidden } : {},
+		...opts.bestFit !== void 0 ? { bestFit: opts.bestFit } : {},
+		...opts.outlineLevel !== void 0 ? { outlineLevel: opts.outlineLevel } : {},
+		...opts.style !== void 0 ? { style: opts.style } : {},
+		...opts.collapsed !== void 0 ? { collapsed: opts.collapsed } : {}
+	};
+}
+function makeRowDimension(opts = {}) {
+	return {
+		...opts.height !== void 0 ? { height: opts.height } : {},
+		...opts.customHeight !== void 0 ? { customHeight: opts.customHeight } : {},
+		...opts.hidden !== void 0 ? { hidden: opts.hidden } : {},
+		...opts.outlineLevel !== void 0 ? { outlineLevel: opts.outlineLevel } : {},
+		...opts.collapsed !== void 0 ? { collapsed: opts.collapsed } : {},
+		...opts.style !== void 0 ? { style: opts.style } : {}
+	};
+}
+//#endregion
+//#region src/worksheet/hyperlinks.ts
+function makeHyperlink(opts) {
+	if (opts.ref === void 0 || opts.ref.length === 0) throw new OpenXmlSchemaError("Hyperlink: ref is required");
+	return {
+		ref: opts.ref,
+		...opts.target !== void 0 ? { target: opts.target } : {},
+		...opts.location !== void 0 ? { location: opts.location } : {},
+		...opts.tooltip !== void 0 ? { tooltip: opts.tooltip } : {},
+		...opts.display !== void 0 ? { display: opts.display } : {},
+		...opts.rId !== void 0 ? { rId: opts.rId } : {}
+	};
+}
+//#endregion
+//#region src/worksheet/views.ts
+/** Build a SheetView with sensible defaults. */
+function makeSheetView(opts = {}) {
+	return {
+		workbookViewId: opts.workbookViewId ?? 0,
+		...opts.tabSelected !== void 0 ? { tabSelected: opts.tabSelected } : {},
+		...opts.showGridLines !== void 0 ? { showGridLines: opts.showGridLines } : {},
+		...opts.showRowColHeaders !== void 0 ? { showRowColHeaders: opts.showRowColHeaders } : {},
+		...opts.showFormulas !== void 0 ? { showFormulas: opts.showFormulas } : {},
+		...opts.showZeros !== void 0 ? { showZeros: opts.showZeros } : {},
+		...opts.rightToLeft !== void 0 ? { rightToLeft: opts.rightToLeft } : {},
+		...opts.view !== void 0 ? { view: opts.view } : {},
+		...opts.topLeftCell !== void 0 ? { topLeftCell: opts.topLeftCell } : {},
+		...opts.zoomScale !== void 0 ? { zoomScale: opts.zoomScale } : {},
+		...opts.zoomScaleNormal !== void 0 ? { zoomScaleNormal: opts.zoomScaleNormal } : {},
+		...opts.pane ? { pane: opts.pane } : {},
+		...opts.selection ? { selection: opts.selection } : {}
+	};
+}
+/**
+* Build a frozen Pane from a top-left coordinate. Per Excel semantics:
+* - "B2" → freeze 1 row + 1 col → xSplit=1, ySplit=1, activePane='bottomRight'
+* - "A2" → freeze 1 row only → ySplit=1, activePane='bottomLeft'
+* - "B1" → freeze 1 col only → xSplit=1, activePane='topRight'
+* - "A1" → no freeze; throws (caller should clear `ws.views[].pane`).
+*/
+function makeFreezePane(topLeftRef) {
+	const { col, row } = coordinateToTuple(topLeftRef);
+	if (col === 1 && row === 1) throw new OpenXmlSchemaError("makeFreezePane: \"A1\" is not a valid freeze ref (no rows or columns to freeze)");
+	const xSplit = col - 1;
+	const ySplit = row - 1;
+	let activePane;
+	if (xSplit > 0 && ySplit > 0) activePane = "bottomRight";
+	else if (ySplit > 0) activePane = "bottomLeft";
+	else activePane = "topRight";
+	const pane = {
+		state: "frozen",
+		topLeftCell: topLeftRef,
+		activePane
+	};
+	if (xSplit > 0) pane.xSplit = xSplit;
+	if (ySplit > 0) pane.ySplit = ySplit;
+	return pane;
+}
+/** Inverse of {@link makeFreezePane}. Returns the top-left ref of the bottomRight pane, or undefined. */
+function freezePaneRef(view) {
+	const pane = view.pane;
+	if (!pane || pane.state !== "frozen") return void 0;
+	if (pane.topLeftCell) return pane.topLeftCell;
+	const xSplit = pane.xSplit ?? 0;
+	const ySplit = pane.ySplit ?? 0;
+	return tupleToCoordinate(xSplit + 1, ySplit + 1);
+}
+//#endregion
+//#region src/worksheet/comments.ts
+function makeLegacyComment(opts) {
+	return {
+		ref: opts.ref,
+		author: opts.author,
+		text: opts.text
+	};
+}
+//#endregion
+//#region src/worksheet/properties.ts
+const makeSheetProperties = (opts = {}) => {
+	const out = {};
+	if (opts.codeName !== void 0) out.codeName = opts.codeName;
+	if (opts.enableFormatConditionsCalculation !== void 0) out.enableFormatConditionsCalculation = opts.enableFormatConditionsCalculation;
+	if (opts.filterMode !== void 0) out.filterMode = opts.filterMode;
+	if (opts.published !== void 0) out.published = opts.published;
+	if (opts.syncHorizontal !== void 0) out.syncHorizontal = opts.syncHorizontal;
+	if (opts.syncRef !== void 0) out.syncRef = opts.syncRef;
+	if (opts.syncVertical !== void 0) out.syncVertical = opts.syncVertical;
+	if (opts.transitionEvaluation !== void 0) out.transitionEvaluation = opts.transitionEvaluation;
+	if (opts.transitionEntry !== void 0) out.transitionEntry = opts.transitionEntry;
+	if (opts.tabColor !== void 0) out.tabColor = opts.tabColor;
+	if (opts.outlinePr !== void 0) out.outlinePr = opts.outlinePr;
+	if (opts.pageSetUpPr !== void 0) out.pageSetUpPr = opts.pageSetUpPr;
+	return out;
+};
+//#endregion
+//#region src/worksheet/worksheet.ts
+/** Build a Worksheet shell. */
+function makeWorksheet(title) {
+	if (typeof title !== "string" || title.length === 0) throw new OpenXmlSchemaError("Worksheet title must be a non-empty string");
+	return {
+		title,
+		rows: /* @__PURE__ */ new Map(),
+		_appendRowCursor: 0,
+		mergedCells: [],
+		views: [],
+		columnDimensions: /* @__PURE__ */ new Map(),
+		rowDimensions: /* @__PURE__ */ new Map(),
+		hyperlinks: [],
+		dataValidations: [],
+		tables: [],
+		legacyComments: [],
+		conditionalFormatting: [],
+		cellWatches: [],
+		ignoredErrors: [],
+		rowBreaks: [],
+		colBreaks: [],
+		customProperties: [],
+		webPublishItems: [],
+		protectedRanges: [],
+		smartTags: [],
+		customSheetViews: [],
+		oleObjects: [],
+		controls: []
+	};
+}
+const validateRowCol = (row, col) => {
+	if (!Number.isInteger(row) || row < 1 || row > 1048576) throw new OpenXmlSchemaError(`Worksheet row ${row} out of range [1, ${MAX_ROW}]`);
+	if (!Number.isInteger(col) || col < 1 || col > 16384) throw new OpenXmlSchemaError(`Worksheet col ${col} out of range [1, ${MAX_COL}]`);
+};
+/** Resolve a 1-based or "A1" coordinate; returns the populated Cell or undefined. */
+function getCell(ws, row, col) {
+	return ws.rows.get(row)?.get(col);
+}
+/**
+* Create or update a Cell at (row, col). Existing cells keep their styleId /
+* hyperlinkId / commentId unless explicitly overridden.
+*/
+function setCell(ws, row, col, value = null, styleId) {
+	let rowMap = ws.rows.get(row);
+	let cell = rowMap?.get(col);
+	if (cell === void 0) {
+		cell = makeCell(row, col, value, styleId ?? 0);
+		if (rowMap === void 0) {
+			rowMap = /* @__PURE__ */ new Map();
+			ws.rows.set(row, rowMap);
+		}
+		rowMap.set(col, cell);
+	} else {
+		cell.value = value;
+		if (styleId !== void 0) cell.styleId = styleId;
+	}
+	if (row > ws._appendRowCursor) ws._appendRowCursor = row;
+	return cell;
+}
+/** Delete a single cell from the sheet. Empty rows are pruned. */
+function deleteCell(ws, row, col) {
+	const rowMap = ws.rows.get(row);
+	if (rowMap === void 0) return;
+	rowMap.delete(col);
+	if (rowMap.size === 0) ws.rows.delete(row);
+}
+/**
+* Delete every populated cell inside a range. Returns the number of cells
+* removed. Row maps that go empty are pruned. Column / row dimensions, merges,
+* comments etc. are left untouched.
+*/
+function clearRange(ws, range) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	let n = 0;
+	for (let r = minRow; r <= maxRow; r++) {
+		const rowMap = ws.rows.get(r);
+		if (!rowMap) continue;
+		for (let c = minCol; c <= maxCol; c++) if (rowMap.delete(c)) n++;
+		if (rowMap.size === 0) ws.rows.delete(r);
+	}
+	return n;
+}
+/**
+* Wipe every populated cell on the worksheet, leaving styles, dimensions,
+* merges, comments, hyperlinks etc. intact. Returns the count of cells removed.
+* Useful when a sheet should be re-filled from scratch but its formatting kept.
+*/
+function clearAllCells(ws) {
+	let n = 0;
+	for (const rowMap of ws.rows.values()) n += rowMap.size;
+	ws.rows.clear();
+	ws._appendRowCursor = 0;
+	return n;
+}
+/**
+* Append a row of values starting at the next empty row. Returns the row index
+* (1-based). Mirrors openpyxl's `Worksheet.append`. `null` / `undefined`
+* entries leave the cell empty.
+*/
+function appendRow(ws, values) {
+	const row = ws._appendRowCursor + 1;
+	for (let i = 0; i < values.length; i++) {
+		const value = values[i];
+		if (value === void 0 || value === null) continue;
+		setCell(ws, row, i + 1, value);
+	}
+	ws._appendRowCursor = row;
+	return row;
+}
+/**
+* Bulk version of {@link appendRow}: append a 2D array of values one row at a
+* time. Returns `{firstRow, lastRow}` — both 1-based, inclusive. An empty input
+* returns `{firstRow, lastRow: firstRow - 1}` so callers can detect the no-op
+* without throwing.
+*
+* Common usage: `appendRows(ws, csvParsedRows)` for fast import.
+*/
+function appendRows(ws, rows) {
+	const firstRow = ws._appendRowCursor + 1;
+	if (rows.length === 0) return {
+		firstRow,
+		lastRow: firstRow - 1
+	};
+	let lastRow = firstRow - 1;
+	for (const row of rows) lastRow = appendRow(ws, row);
+	return {
+		firstRow,
+		lastRow
+	};
+}
+/**
+* Write a 2D array of values to the sheet starting at the given A1 anchor cell.
+* Distinct from {@link appendRows} (which always writes past
+* `_appendRowCursor`) — this lets you place a block at an arbitrary location,
+* e.g. mid-sheet table updates.
+*
+* `null` / `undefined` entries leave the corresponding cell **untouched**
+* (existing cell + style are preserved). Pre-existing cells inside the written
+* rectangle are overwritten in place, so their `styleId` survives the write.
+*
+* Returns the bounding-box of the written area as 1-based inclusive
+* coordinates. An empty rows array returns `undefined` rather than an invalid
+* zero-area range.
+*/
+function writeRange(ws, startRef, values) {
+	if (values.length === 0) return void 0;
+	const { col: startCol, row: startRow } = coordinateToTuple(startRef);
+	let maxRow = startRow;
+	let maxCol = startCol;
+	for (let i = 0; i < values.length; i++) {
+		const row = values[i];
+		if (row === void 0) continue;
+		const r = startRow + i;
+		for (let j = 0; j < row.length; j++) {
+			const v = row[j];
+			if (v === void 0 || v === null) continue;
+			const c = startCol + j;
+			setCell(ws, r, c, v);
+			if (c > maxCol) maxCol = c;
+		}
+		if (r > maxRow) maxRow = r;
+	}
+	return {
+		minRow: startRow,
+		maxRow,
+		minCol: startCol,
+		maxCol
+	};
+}
+/**
+* Iterate the worksheet rows rectangularly. Yields one row per row in
+* `[minRow, maxRow]` — including entirely empty rows — and each yielded row
+* has length `maxCol - minCol + 1`. Missing cell positions are `undefined`
+* (no placeholder Cell allocations).
+*
+* Defaults: `minRow=1`, `maxRow=getMaxRow(ws)`, `minCol=1`,
+* `maxCol=getMaxCol(ws)`. The default extent is the populated bounding box,
+* not the 1M × 16K sheet limit, so the rectangular default doesn't iterate
+* the whole grid for a small sheet.
+*
+* To iterate populated rows only, filter:
+* `[...iterRows(ws)].filter(row => row.some((c) => c !== undefined))`. To
+* iterate populated cells without row boundaries, use {@link iterCells}.
+*/
+function* iterRows(ws, opts = {}) {
+	const { minRow = 1, maxRow = getMaxRow(ws), minCol = 1, maxCol = getMaxCol(ws) } = opts;
+	if (maxRow < minRow || maxCol < minCol) return;
+	const width = maxCol - minCol + 1;
+	for (let r = minRow; r <= maxRow; r++) {
+		const rowMap = ws.rows.get(r);
+		const out = new Array(width).fill(void 0);
+		if (rowMap !== void 0) for (let c = minCol; c <= maxCol; c++) {
+			const cell = rowMap.get(c);
+			if (cell !== void 0) out[c - minCol] = cell;
+		}
+		yield out;
+	}
+}
+/**
+* Same rectangular iteration as {@link iterRows}, but yields each cell's
+* `.value`. Missing cell positions become `null` — already the canonical empty
+* marker in `CellValue`.
+*/
+function* iterValues(ws, opts = {}) {
+	for (const row of iterRows(ws, opts)) yield row.map((c) => c === void 0 ? null : c.value);
+}
+/**
+* Yield every populated cell in the worksheet as a flat stream (row-major,
+* columns ascending). Distinct from {@link iterRows} which yields one row
+* per row in the bounding box — use this when the caller wants only the
+* populated cells without row boundaries or rectangular padding.
+*/
+function* iterCells(ws, opts = {}) {
+	for (const row of iterRows(ws, opts)) for (const cell of row) if (cell !== void 0) yield cell;
+}
+/** Effective max row index based on populated cells (0 when empty). */
+function getMaxRow(ws) {
+	let m = 0;
+	for (const r of ws.rows.keys()) if (r > m) m = r;
+	return m;
+}
+/** Effective max column index based on populated cells (0 when empty). */
+function getMaxCol(ws) {
+	let m = 0;
+	for (const rowMap of ws.rows.values()) for (const c of rowMap.keys()) if (c > m) m = c;
+	return m;
+}
+/**
+* Sorted list of every row index that holds at least one populated cell.
+* Returns `[]` for an empty worksheet. Useful when a caller wants to iterate
+* only the rows the user actually populated, without walking 1..maxRow in dense
+* fashion.
+*/
+function getPopulatedRowIndices(ws) {
+	const out = [];
+	for (const [r, rowMap] of ws.rows) if (rowMap.size > 0) out.push(r);
+	return out.sort((a, b) => a - b);
+}
+/**
+* Sorted list of every column index that holds at least one populated cell
+* anywhere on the sheet. Distinct columns only; returns `[]` for an empty
+* worksheet.
+*/
+function getPopulatedColumnIndices(ws) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const rowMap of ws.rows.values()) for (const c of rowMap.keys()) seen.add(c);
+	return [...seen].sort((a, b) => a - b);
+}
+/**
+* Bucket a single CellValue into one of the {@link CellsByKindCounts} keys.
+* Shared between {@link countCellsByKind} and the workbook-wide overview so
+* the two never drift in how they classify (e.g. `Date` vs `duration`).
+*/
+function classifyCellValue(v) {
+	if (v === null) return "null";
+	if (typeof v === "string") return "string";
+	if (typeof v === "number") return "number";
+	if (typeof v === "boolean") return "boolean";
+	if (v instanceof Date) return "date";
+	const kind = v.kind;
+	if (kind === "duration") return "duration";
+	if (kind === "error") return "error";
+	if (kind === "rich-text") return "rich-text";
+	return "formula";
+}
+function countCellsByKind(ws) {
+	const out = {
+		null: 0,
+		string: 0,
+		number: 0,
+		boolean: 0,
+		date: 0,
+		duration: 0,
+		error: 0,
+		"rich-text": 0,
+		formula: 0
+	};
+	for (const cell of iterCells(ws)) out[classifyCellValue(cell.value)]++;
+	return out;
+}
+/**
+* True iff the worksheet has zero non-empty cells. Equivalent to
+* `getNonEmptyCellCount(ws) === 0` but short-circuits on the first non-null
+* value found, so the cost is O(first non-empty cell) rather than O(populated
+* cells).
+*/
+function isWorksheetEmpty(ws) {
+	for (const cell of iterCells(ws)) if (cell.value !== null) return false;
+	return true;
+}
+/**
+* Count non-empty cells. Distinct from {@link countCells} which counts every
+* materialised cell (including ones whose `value === null`): this skips cells
+* with a `null` value, plus optionally formulas / rich-text per the opts.
+*
+* Useful for "how many real values does this sheet contain" stats vs the
+* materialised footprint.
+*/
+function getNonEmptyCellCount(ws, opts = {}) {
+	const includeFormulas = opts.includeFormulas ?? true;
+	const includeRichText = opts.includeRichText ?? true;
+	let n = 0;
+	for (const cell of iterCells(ws)) {
+		const v = cell.value;
+		if (v === null) continue;
+		if (typeof v === "object" && v !== null) {
+			const kind = v.kind;
+			if (kind === "formula" && !includeFormulas) continue;
+			if (kind === "rich-text" && !includeRichText) continue;
+		}
+		n++;
+	}
+	return n;
+}
+/** Total populated cell count. */
+function countCells(ws) {
+	let n = 0;
+	for (const rowMap of ws.rows.values()) n += rowMap.size;
+	return n;
+}
+/**
+* Bounding-box of the populated cells: `{ minRow, maxRow, minCol, maxCol }`
+* covering every cell in `ws.rows`. Returns `undefined` when the sheet is
+* empty. Walks the sparse store once.
+*/
+function getDataExtent(ws) {
+	let minRow = Number.POSITIVE_INFINITY;
+	let maxRow = 0;
+	let minCol = Number.POSITIVE_INFINITY;
+	let maxCol = 0;
+	let touched = false;
+	for (const [r, rowMap] of ws.rows) {
+		if (rowMap.size === 0) continue;
+		if (r < minRow) minRow = r;
+		if (r > maxRow) maxRow = r;
+		for (const c of rowMap.keys()) {
+			if (c < minCol) minCol = c;
+			if (c > maxCol) maxCol = c;
+		}
+		touched = true;
+	}
+	if (!touched) return void 0;
+	return {
+		minRow,
+		maxRow,
+		minCol,
+		maxCol
+	};
+}
+/**
+* Iterate every populated cell, yielding those for which `predicate` returns
+* true. Iteration order is row-then-column ascending. Cells whose `.value ===
+* null` (empty placeholders carrying only style or comment metadata) are still
+* visited.
+*/
+function* findCells(ws, predicate) {
+	const rowKeys = [...ws.rows.keys()].sort((a, b) => a - b);
+	for (const r of rowKeys) {
+		const rowMap = ws.rows.get(r);
+		if (!rowMap) continue;
+		const cols = [...rowMap.keys()].sort((a, b) => a - b);
+		for (const c of cols) {
+			const cell = rowMap.get(c);
+			if (cell !== void 0 && predicate(cell)) yield cell;
+		}
+	}
+}
+/**
+* Iterate the populated cells inside a rectangular range. Cells that don't
+* exist in the sparse store are skipped (no auto-allocate). Use {@link
+* applyToRange} when you need every coordinate visited regardless of
+* population.
+*/
+function* getCellsInRange(ws, range) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	for (let r = minRow; r <= maxRow; r++) {
+		const rowMap = ws.rows.get(r);
+		if (!rowMap) continue;
+		for (let col = minCol; col <= maxCol; col++) {
+			const cell = rowMap.get(col);
+			if (cell !== void 0) yield cell;
+		}
+	}
+}
+/** Resolve an "A1" coordinate to a numeric (col, row) pair on the sheet. */
+function setCellByCoord(ws, coord, value, styleId) {
+	const m = /^([A-Za-z]{1,3})([1-9][0-9]*)$/.exec(coord);
+	if (m === null || m[1] === void 0 || m[2] === void 0) throw new OpenXmlSchemaError(`setCellByCoord: invalid coordinate "${coord}"`);
+	const col = columnIndexFromLetter(m[1]);
+	return setCell(ws, Number.parseInt(m[2], 10), col, value, styleId);
+}
+/** Convenience getter accepting an "A1" coordinate. */
+function getCellByCoord(ws, coord) {
+	const m = /^([A-Za-z]{1,3})([1-9][0-9]*)$/.exec(coord);
+	if (m === null || m[1] === void 0 || m[2] === void 0) return void 0;
+	const col = columnIndexFromLetter(m[1]);
+	return getCell(ws, Number.parseInt(m[2], 10), col);
+}
+const toCellRange = (refOrRange) => typeof refOrRange === "string" ? parseRange(refOrRange) : refOrRange;
+/**
+* Merge a range. The top-left cell keeps its value; every other cell in the
+* range is dropped from `ws.rows` so the on-wire `<sheetData>` won't carry
+* phantom cells underneath the merge. Mirrors openpyxl's
+* `MergedCellRange.format()`. Idempotent for an identical range, throws when
+* the range overlaps an existing merge.
+*/
+function mergeCells(ws, refOrRange) {
+	const range = toCellRange(refOrRange);
+	for (const existing of ws.mergedCells) {
+		if (rangeToString(existing) === rangeToString(range)) return existing;
+		if (rangesOverlap(existing, range)) throw new OpenXmlSchemaError(`mergeCells: range ${rangeToString(range)} overlaps existing merged range ${rangeToString(existing)}`);
+	}
+	for (let r = range.minRow; r <= range.maxRow; r++) for (let c = range.minCol; c <= range.maxCol; c++) {
+		if (r === range.minRow && c === range.minCol) continue;
+		ws.rows.get(r)?.delete(c);
+		const row = ws.rows.get(r);
+		if (row && row.size === 0) ws.rows.delete(r);
+	}
+	ws.mergedCells.push(range);
+	return range;
+}
+/** Drop a previously-merged range. No-op if the range isn't registered. */
+function unmergeCells(ws, refOrRange) {
+	const target = rangeToString(toCellRange(refOrRange));
+	const idx = ws.mergedCells.findIndex((r) => rangeToString(r) === target);
+	if (idx < 0) return false;
+	ws.mergedCells.splice(idx, 1);
+	return true;
+}
+/** Read-only iterator over the worksheet's merged ranges. */
+function getMergedCells(ws) {
+	return ws.mergedCells;
+}
+/** True iff (row, col) sits inside any merged range — top-left included. */
+function isMergedCell(ws, row, col) {
+	for (const range of ws.mergedCells) if (rangeContainsCell(range, row, col)) return true;
+	return false;
+}
+/**
+* Look up the merged range covering (row, col), or `undefined` if the
+* coordinate isn't inside any merge. Lets callers introspect a merge without
+* iterating `getMergedCells` themselves.
+*/
+function getMergedRangeAt(ws, row, col) {
+	for (const range of ws.mergedCells) if (rangeContainsCell(range, row, col)) return range;
+}
+/**
+* Drop the merge that contains (row, col), if any. Returns `true` when a merge
+* was unregistered. Useful when callers know a cell coordinate but not the
+* original merge bounds.
+*/
+function unmergeCellsAt(ws, row, col) {
+	for (let i = 0; i < ws.mergedCells.length; i++) {
+		const r = ws.mergedCells[i];
+		if (r && rangeContainsCell(r, row, col)) {
+			ws.mergedCells.splice(i, 1);
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Drop every merged range on the worksheet. Returns the count of merges
+* removed. Cells that were inside the merges keep their values — only the merge
+* metadata is gone.
+*/
+function removeAllMergedRanges(ws) {
+	const n = ws.mergedCells.length;
+	ws.mergedCells = [];
+	return n;
+}
+/** Lazily get-or-create the primary SheetView so view-mutating helpers don't have to branch. */
+const ensurePrimaryView = (ws) => {
+	let view = ws.views[0];
+	if (!view) {
+		view = makeSheetView();
+		ws.views.push(view);
+	}
+	return view;
+};
+/**
+* Freeze rows / columns above + left of `topLeftRef` ("B2" → 1 row + 1 col).
+* Pass `undefined` to clear any existing freeze. Targets the workbook's primary
+* SheetView (`ws.views[0]`); creates one if absent.
+*/
+function setFreezePanes(ws, topLeftRef) {
+	if (topLeftRef === void 0) {
+		if (ws.views[0]) delete ws.views[0].pane;
+		return;
+	}
+	const view = ensurePrimaryView(ws);
+	view.pane = makeFreezePane(topLeftRef);
+}
+/** Inverse of {@link setFreezePanes}; returns the top-left ref or undefined when no freeze is active. */
+function getFreezePanes(ws) {
+	const view = ws.views[0];
+	if (!view) return void 0;
+	return freezePaneRef(view);
+}
+/** Freeze both top `rows` rows AND left `cols` columns. */
+function freezePanes(ws, rows, cols) {
+	if (!Number.isInteger(rows) || rows < 1) throw new OpenXmlSchemaError(`freezePanes: rows must be a positive integer; got ${rows}`);
+	if (!Number.isInteger(cols) || cols < 1) throw new OpenXmlSchemaError(`freezePanes: cols must be a positive integer; got ${cols}`);
+	setFreezePanes(ws, `${columnLetterFromIndex(cols + 1)}${rows + 1}`);
+}
+/** Lazily get-or-create `ws.sheetProperties` so tab-color helpers don't have to branch. */
+const ensureSheetProperties = (ws) => {
+	if (!ws.sheetProperties) ws.sheetProperties = makeSheetProperties();
+	return ws.sheetProperties;
+};
+const colorFrom = (input) => typeof input === "string" ? makeColor({ rgb: input }) : makeColor(input);
+/**
+* Set the sheet tab strip colour. Accepts either a hex string (`"FF0070C0"`) or
+* a partial `Color` object (`{ theme: 4, tint: 0.4 }`).
+*/
+function setSheetTabColor(ws, color) {
+	const c = colorFrom(color);
+	ensureSheetProperties(ws).tabColor = c;
+	return c;
+}
+/**
+* Set the zoom scale (percent) on the primary SheetView. Excel accepts integer
+* percentages in `[10, 400]`.
+*/
+function setSheetZoom(ws, scale) {
+	if (!Number.isInteger(scale) || scale < 10 || scale > 400) throw new OpenXmlSchemaError(`setSheetZoom: scale must be an integer in [10, 400]; got ${scale}`);
+	ensurePrimaryView(ws).zoomScale = scale;
+}
+/** Switch the sheet view between Excel's "Normal" / "Page Break Preview" / "Page Layout" modes. */
+function setSheetViewMode(ws, mode) {
+	ensurePrimaryView(ws).view = mode;
+}
+/**
+* Set values across a rectangular range from a 2-D array. `rows[0]` is laid
+* down starting at the top-left of `range`; subsequent rows follow. `null` /
+* `undefined` entries skip the cell. Useful for dropping a header + data block
+* in one call.
+*/
+function setRangeValues(ws, range, rows) {
+	const { minRow, minCol } = parseRange(range);
+	for (let i = 0; i < rows.length; i++) {
+		const row = rows[i];
+		if (!row) continue;
+		for (let j = 0; j < row.length; j++) {
+			const v = row[j];
+			if (v === null || v === void 0) continue;
+			setCell(ws, minRow + i, minCol + j, v);
+		}
+	}
+}
+/**
+* Iterate over every cell coordinate in a range, calling `visit` once per (row,
+* col). Allocates the cell on first touch so callers can mutate it freely.
+*/
+function applyToRange(ws, range, visit) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	for (let r = minRow; r <= maxRow; r++) for (let c = minCol; c <= maxCol; c++) {
+		let cell = ws.rows.get(r)?.get(c);
+		if (!cell) cell = setCell(ws, r, c);
+		visit(cell, r, c);
+	}
+}
+/**
+* Read a rectangular range as a dense 2-D array of values. Empty cells yield
+* `null`. The shape is `[maxRow - minRow + 1] × [maxCol - minCol + 1]`. Inverse
+* of {@link setRangeValues}.
+*/
+function getRangeValues(ws, range) {
+	const { minRow, maxRow, minCol, maxCol } = parseRange(range);
+	const rowsOut = [];
+	for (let r = minRow; r <= maxRow; r++) {
+		const rowMap = ws.rows.get(r);
+		const row = [];
+		for (let c = minCol; c <= maxCol; c++) {
+			const cell = rowMap?.get(c);
+			row.push(cell ? cell.value : null);
+		}
+		rowsOut.push(row);
+	}
+	return rowsOut;
+}
+/**
+* Copy every populated cell from `source` to `target` (within the same
+* worksheet, or across worksheets via `targetWs`). Cells are shallow-cloned:
+* `value` and `styleId` carry over but `row`/`col` are rewritten. The target's
+* existing cells in the destination extent are overwritten; cells outside are
+* untouched.
+*
+* The source and target ranges define the top-left corner — their dimensions
+* need not match. If the target range is smaller than the source, only the
+* cells that fit within the target's extent are copied; if larger, only the
+* source's extent is filled.
+*
+* Returns the number of cells copied.
+*/
+function copyRange(ws, source, target, opts = {}) {
+	const dest = opts.targetWs ?? ws;
+	const sameSheet = dest === ws;
+	const src = parseRange(source);
+	const dst = parseRange(target);
+	const dr = dst.minRow - src.minRow;
+	const dc = dst.minCol - src.minCol;
+	const maxRowOffset = Math.min(src.maxRow - src.minRow, dst.maxRow - dst.minRow);
+	const maxColOffset = Math.min(src.maxCol - src.minCol, dst.maxCol - dst.minCol);
+	let n = 0;
+	for (let i = 0; i <= maxRowOffset; i++) {
+		const srcRow = ws.rows.get(src.minRow + i);
+		if (!srcRow) continue;
+		for (let j = 0; j <= maxColOffset; j++) {
+			const srcCell = srcRow.get(src.minCol + j);
+			if (!srcCell) continue;
+			const newCell = setCell(dest, src.minRow + i + dr, src.minCol + j + dc, srcCell.value, srcCell.styleId);
+			if (sameSheet) {
+				if (srcCell.hyperlinkId !== void 0) newCell.hyperlinkId = srcCell.hyperlinkId;
+				if (srcCell.commentId !== void 0) newCell.commentId = srcCell.commentId;
+			}
+			n++;
+		}
+	}
+	return n;
+}
+/**
+* Move every populated cell from `source` to `target`. Equivalent to
+* `copyRange` followed by clearing the source. When the ranges overlap on the
+* same sheet, the copy walks in the direction that preserves data — high-to-low
+* along any axis where the move shifts forward, low-to-high otherwise — so
+* cells aren't overwritten before they've been read. Returns the number of
+* cells moved.
+*/
+function moveRange(ws, source, target, opts = {}) {
+	const dest = opts.targetWs ?? ws;
+	const sameSheet = dest === ws;
+	const src = parseRange(source);
+	const dst = parseRange(target);
+	const dr = dst.minRow - src.minRow;
+	const dc = dst.minCol - src.minCol;
+	const maxRowOffset = Math.min(src.maxRow - src.minRow, dst.maxRow - dst.minRow);
+	const maxColOffset = Math.min(src.maxCol - src.minCol, dst.maxCol - dst.minCol);
+	const snap = [];
+	for (let i = 0; i <= maxRowOffset; i++) {
+		const srcRow = ws.rows.get(src.minRow + i);
+		if (!srcRow) continue;
+		for (let j = 0; j <= maxColOffset; j++) {
+			const srcCell = srcRow.get(src.minCol + j);
+			if (!srcCell) continue;
+			snap.push({
+				row: src.minRow + i,
+				col: src.minCol + j,
+				cell: srcCell
+			});
+		}
+	}
+	for (let i = 0; i <= maxRowOffset; i++) {
+		const rowIdx = src.minRow + i;
+		const srcRow = ws.rows.get(rowIdx);
+		if (!srcRow) continue;
+		for (let j = 0; j <= maxColOffset; j++) srcRow.delete(src.minCol + j);
+		if (srcRow.size === 0) ws.rows.delete(rowIdx);
+	}
+	for (const entry of snap) {
+		const { row, col, cell } = entry;
+		const newCell = setCell(dest, row + dr, col + dc, cell.value, cell.styleId);
+		if (sameSheet) {
+			if (cell.hyperlinkId !== void 0) newCell.hyperlinkId = cell.hyperlinkId;
+			if (cell.commentId !== void 0) newCell.commentId = cell.commentId;
+		}
+	}
+	return snap.length;
+}
+/**
+* Enumerate the populated cells of a row in column order. Unlike {@link
+* getRowValues}, this skips empty columns and yields the cell objects (not just
+* their values). Returns `[]` when the row is absent or empty.
+*/
+function getCellsInRow(ws, row) {
+	const rowMap = ws.rows.get(row);
+	if (!rowMap || rowMap.size === 0) return [];
+	const sortedCols = [...rowMap.keys()].sort((a, b) => a - b);
+	const out = [];
+	for (const col of sortedCols) {
+		const cell = rowMap.get(col);
+		if (cell) out.push(cell);
+	}
+	return out;
+}
+/**
+* Enumerate the populated cells of a column in row order. Walks the row map and
+* collects whichever rows carry the column. Returns `[]` when the worksheet has
+* no cell in that column.
+*/
+function getCellsInColumn(ws, col) {
+	const sortedRows = [...ws.rows.keys()].sort((a, b) => a - b);
+	const out = [];
+	for (const r of sortedRows) {
+		const cell = ws.rows.get(r)?.get(col);
+		if (cell) out.push(cell);
+	}
+	return out;
+}
+/**
+* Look up the ColumnDimension covering `col`. The search walks every registered
+* entry's `min..max` range; that's fine for the typical spreadsheet (a handful
+* of column entries) and stays simple.
+*/
+function getColumnDimension(ws, col) {
+	for (const dim of ws.columnDimensions.values()) if (col >= dim.min && col <= dim.max) return dim;
+}
+/**
+* Set a single-column ColumnDimension entry covering `col`. Shadows any
+* existing run that overlaps — runs are not split for now (callers that need
+* range-spanning entries can write directly into `ws.columnDimensions`).
+*/
+function setColumnDimension(ws, col, opts) {
+	validateRowCol(1, col);
+	for (const [key, dim] of ws.columnDimensions) if (col >= dim.min && col <= dim.max) ws.columnDimensions.delete(key);
+	const entry = makeColumnDimension(col, opts);
+	ws.columnDimensions.set(col, entry);
+	return entry;
+}
+/** Convenience: set a column's width, leaving other fields untouched. */
+function setColumnWidth(ws, col, width) {
+	return setColumnDimension(ws, col, {
+		...getColumnDimension(ws, col),
+		width,
+		customWidth: true
+	});
+}
+/** Convenience: hide a column. */
+function hideColumn(ws, col) {
+	return setColumnDimension(ws, col, {
+		...getColumnDimension(ws, col),
+		hidden: true
+	});
+}
+/**
+* Convenience: unhide a column. Drops the `hidden` flag from the column's
+* dimension entry (and removes the entry altogether when no other fields
+* remain).
+*/
+function unhideColumn(ws, col) {
+	const existing = getColumnDimension(ws, col);
+	if (!existing) return;
+	const { hidden: _drop, ...rest } = existing;
+	const { min: _min, max: _max, ...passthrough } = rest;
+	if (Object.keys(passthrough).length === 0) ws.columnDimensions.delete(existing.min);
+	else setColumnDimension(ws, col, passthrough);
+}
+/** Bulk-hide every column in `[fromCol, toCol]`. */
+function hideColumns(ws, fromCol, toCol) {
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`hideColumns: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) hideColumn(ws, c);
+}
+/** Bulk-unhide every column in `[fromCol, toCol]`. */
+function unhideColumns(ws, fromCol, toCol) {
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`unhideColumns: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) unhideColumn(ws, c);
+}
+/**
+* Set the default column width (characters) for cells without an explicit
+* ColumnDimension entry. Mirrors Excel's "Default Width" dialog. Pass
+* `undefined` to clear.
+*/
+function setDefaultColumnWidth(ws, width) {
+	if (width === void 0) {
+		delete ws.defaultColumnWidth;
+		return;
+	}
+	if (!Number.isFinite(width) || width < 0) throw new OpenXmlSchemaError(`setDefaultColumnWidth: width must be a non-negative number; got ${width}`);
+	ws.defaultColumnWidth = width;
+}
+/**
+* Set the default row height (points) for rows without an explicit RowDimension
+* entry. Mirrors Excel's "Default Row Height" dialog. Pass `undefined` to
+* clear.
+*/
+function setDefaultRowHeight(ws, height) {
+	if (height === void 0) {
+		delete ws.defaultRowHeight;
+		return;
+	}
+	if (!Number.isFinite(height) || height < 0) throw new OpenXmlSchemaError(`setDefaultRowHeight: height must be a non-negative number; got ${height}`);
+	ws.defaultRowHeight = height;
+}
+const validateOutlineLevel = (level) => {
+	if (!Number.isInteger(level) || level < 1 || level > 7) throw new OpenXmlSchemaError(`outlineLevel must be an integer in [1, 7]; got ${level}`);
+};
+/**
+* Mirror Excel's "Data → Group → Rows" by stamping every row in `[fromRow,
+* toRow]` with an outline depth of `level` (default 1). Allocates a
+* RowDimension for each row that doesn't already have one. Ungroup with {@link
+* ungroupRows}.
+*/
+function groupRows(ws, fromRow, toRow, level = 1) {
+	validateOutlineLevel(level);
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`groupRows: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) {
+		const existing = getRowDimension(ws, r) ?? {};
+		setRowDimension(ws, r, {
+			...existing,
+			outlineLevel: level
+		});
+	}
+}
+/**
+* Drop the outline grouping for every row in `[fromRow, toRow]`. Removes the
+* `outlineLevel` field from each affected RowDimension.
+*/
+function ungroupRows(ws, fromRow, toRow) {
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`ungroupRows: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) {
+		const existing = ws.rowDimensions.get(r);
+		if (!existing) continue;
+		const { outlineLevel: _drop, ...rest } = existing;
+		if (Object.keys(rest).length === 0) ws.rowDimensions.delete(r);
+		else ws.rowDimensions.set(r, rest);
+	}
+}
+/**
+* Mirror Excel's "Data → Group → Columns" by stamping every column in
+* `[fromCol, toCol]` with an outline depth of `level` (default 1).
+*/
+function groupColumns(ws, fromCol, toCol, level = 1) {
+	validateOutlineLevel(level);
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`groupColumns: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) {
+		const existing = getColumnDimension(ws, c);
+		setColumnDimension(ws, c, {
+			...existing,
+			outlineLevel: level
+		});
+	}
+}
+/**
+* Drop the outline grouping for every column in `[fromCol, toCol]`. Removes the
+* `outlineLevel` field from each affected ColumnDimension.
+*/
+function ungroupColumns(ws, fromCol, toCol) {
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`ungroupColumns: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) {
+		const existing = getColumnDimension(ws, c);
+		if (!existing) continue;
+		const { outlineLevel: _drop, ...rest } = existing;
+		const { min: _min, max: _max, ...passthrough } = rest;
+		if (Object.keys(passthrough).length === 0) ws.columnDimensions.delete(existing.min);
+		else setColumnDimension(ws, c, passthrough);
+	}
+}
+/**
+* Collapse a row outline group: hide every row in `[fromRow, toRow]` and mark
+* them `collapsed: true`. Mirrors Excel's `−` button on a grouped row strip.
+* Rows must already carry an `outlineLevel` from {@link groupRows} for the
+* collapse to render correctly.
+*/
+function collapseRowGroup(ws, fromRow, toRow) {
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`collapseRowGroup: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) {
+		const existing = getRowDimension(ws, r) ?? {};
+		setRowDimension(ws, r, {
+			...existing,
+			hidden: true,
+			collapsed: true
+		});
+	}
+}
+/**
+* Expand a row outline group: drop the `hidden` and `collapsed` flags on every
+* row in `[fromRow, toRow]`. Leaves `outlineLevel` and other dimensions intact.
+*/
+function expandRowGroup(ws, fromRow, toRow) {
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`expandRowGroup: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) {
+		const existing = ws.rowDimensions.get(r);
+		if (!existing) continue;
+		const { hidden: _h, collapsed: _c, ...rest } = existing;
+		if (Object.keys(rest).length === 0) ws.rowDimensions.delete(r);
+		else ws.rowDimensions.set(r, rest);
+	}
+}
+/**
+* Collapse a column outline group: hide + mark `collapsed: true` for every
+* column in `[fromCol, toCol]`. Columns must already carry an `outlineLevel`
+* from {@link groupColumns} for the collapse to render correctly.
+*/
+function collapseColumnGroup(ws, fromCol, toCol) {
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`collapseColumnGroup: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) {
+		const existing = getColumnDimension(ws, c);
+		setColumnDimension(ws, c, {
+			...existing,
+			hidden: true,
+			collapsed: true
+		});
+	}
+}
+/**
+* Expand a column outline group: drop `hidden` and `collapsed` from every
+* column in `[fromCol, toCol]`. Leaves `outlineLevel` intact.
+*/
+function expandColumnGroup(ws, fromCol, toCol) {
+	if (!Number.isInteger(fromCol) || !Number.isInteger(toCol) || fromCol < 1 || toCol < fromCol) throw new OpenXmlSchemaError(`expandColumnGroup: invalid column range [${fromCol}, ${toCol}]`);
+	for (let c = fromCol; c <= toCol; c++) {
+		const existing = getColumnDimension(ws, c);
+		if (!existing) continue;
+		const { hidden: _h, collapsed: _coll, ...rest } = existing;
+		const { min: _min, max: _max, ...passthrough } = rest;
+		if (Object.keys(passthrough).length === 0) ws.columnDimensions.delete(existing.min);
+		else setColumnDimension(ws, c, passthrough);
+	}
+}
+/**
+* Per-cell effective string length, optionally scaled by the cell's font size
+* relative to Excel's default 11pt baseline.
+*/
+const effectiveLength = (cell, wb) => {
+	const len = cellValueAsString(cell.value).length;
+	if (!wb) return len;
+	const fontId = wb.styles.cellXfs[cell.styleId]?.fontId ?? 0;
+	return len * ((wb.styles.fonts[fontId]?.size ?? 11) / 11);
+};
+/**
+* Approximate autofit for every column with at least one populated cell. Walks
+* the worksheet once collecting per-column widest-length + applies {@link
+* autofitColumn} per column. `opts.workbook` enables font-size-aware scaling;
+* without it the helper falls back to plain string length.
+*/
+function autofitColumns(ws, opts = {}) {
+	const padding = opts.padding ?? 2;
+	const minWidth = opts.min ?? 4;
+	const maxWidth = Math.min(opts.max ?? 80, 255);
+	const widest = /* @__PURE__ */ new Map();
+	for (const rowMap of ws.rows.values()) for (const [col, cell] of rowMap) {
+		const len = effectiveLength(cell, opts.workbook);
+		if (len > (widest.get(col) ?? 0)) widest.set(col, len);
+	}
+	for (const [col, w] of widest) {
+		if (w === 0) continue;
+		setColumnWidth(ws, col, Math.max(minWidth, Math.min(maxWidth, w + padding)));
+	}
+}
+/**
+* Set widths for many columns in one call. `widths` maps either:
+* - an array `[12, 16, 20]` interpreted positionally starting at
+* column `startCol` (default 1), or
+* - a `Record<number, number>` keyed by 1-based column index.
+* Each entry sets `customWidth: true`.
+*/
+function setColumnWidths(ws, widths, startCol = 1) {
+	if (Array.isArray(widths)) for (let i = 0; i < widths.length; i++) {
+		const w = widths[i];
+		if (typeof w !== "number" || !Number.isFinite(w)) continue;
+		setColumnWidth(ws, startCol + i, w);
+	}
+	else for (const [k, w] of Object.entries(widths)) {
+		const col = Number.parseInt(k, 10);
+		if (!Number.isInteger(col) || col < 1) continue;
+		if (typeof w !== "number" || !Number.isFinite(w)) continue;
+		setColumnWidth(ws, col, w);
+	}
+}
+/** Look up a row's dimension entry. */
+function getRowDimension(ws, row) {
+	return ws.rowDimensions.get(row);
+}
+function setRowDimension(ws, row, opts) {
+	validateRowCol(row, 1);
+	const entry = makeRowDimension(opts);
+	ws.rowDimensions.set(row, entry);
+	return entry;
+}
+/** Convenience: set a row's height, marking customHeight=true. */
+function setRowHeight(ws, row, height) {
+	return setRowDimension(ws, row, {
+		...getRowDimension(ws, row),
+		height,
+		customHeight: true
+	});
+}
+/**
+* Set heights for many rows in one call. `heights` accepts an array (positional
+* from `startRow`, default 1) or a `Record<number, number>` keyed by 1-based
+* row index. Each entry sets `customHeight: true`.
+*/
+function setRowHeights(ws, heights, startRow = 1) {
+	if (Array.isArray(heights)) for (let i = 0; i < heights.length; i++) {
+		const h = heights[i];
+		if (typeof h !== "number" || !Number.isFinite(h)) continue;
+		setRowHeight(ws, startRow + i, h);
+	}
+	else for (const [k, h] of Object.entries(heights)) {
+		const row = Number.parseInt(k, 10);
+		if (!Number.isInteger(row) || row < 1) continue;
+		if (typeof h !== "number" || !Number.isFinite(h)) continue;
+		setRowHeight(ws, row, h);
+	}
+}
+/** Convenience: hide a row. */
+function hideRow(ws, row) {
+	return setRowDimension(ws, row, {
+		...getRowDimension(ws, row),
+		hidden: true
+	});
+}
+/**
+* Convenience: unhide a row. Drops the `hidden` flag from the row's dimension
+* entry (and removes the entry altogether when no other fields remain).
+*/
+function unhideRow(ws, row) {
+	const existing = ws.rowDimensions.get(row);
+	if (!existing) return;
+	const { hidden: _drop, ...rest } = existing;
+	if (Object.keys(rest).length === 0) ws.rowDimensions.delete(row);
+	else ws.rowDimensions.set(row, rest);
+}
+/** Bulk-hide every row in `[fromRow, toRow]`. */
+function hideRows(ws, fromRow, toRow) {
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`hideRows: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) hideRow(ws, r);
+}
+/** Bulk-unhide every row in `[fromRow, toRow]`. */
+function unhideRows(ws, fromRow, toRow) {
+	if (!Number.isInteger(fromRow) || !Number.isInteger(toRow) || fromRow < 1 || toRow < fromRow) throw new OpenXmlSchemaError(`unhideRows: invalid row range [${fromRow}, ${toRow}]`);
+	for (let r = fromRow; r <= toRow; r++) unhideRow(ws, r);
+}
+/**
+* Replace any prior hyperlink on the same `ref` with the given options. Pass `{
+* target }` for an external URL, `{ location }` for an internal jump, or both.
+* Returns the resulting Hyperlink record.
+*/
+function setHyperlink(ws, ref, opts) {
+	if (opts.target === void 0 && opts.location === void 0) throw new OpenXmlSchemaError("setHyperlink: one of target / location is required");
+	removeHyperlink(ws, ref);
+	const hl = makeHyperlink({
+		ref,
+		...opts
+	});
+	ws.hyperlinks.push(hl);
+	return hl;
+}
+/** Remove the hyperlink registered against `ref`. Returns true if anything was removed. */
+function removeHyperlink(ws, ref) {
+	const i = ws.hyperlinks.findIndex((h) => h.ref === ref);
+	if (i < 0) return false;
+	ws.hyperlinks.splice(i, 1);
+	return true;
+}
+/** Drop every hyperlink on the worksheet. Returns the count removed. */
+function removeAllHyperlinks(ws) {
+	const n = ws.hyperlinks.length;
+	ws.hyperlinks = [];
+	return n;
+}
+/** Read-only snapshot of every hyperlink on the sheet. */
+function listHyperlinks(ws) {
+	return ws.hyperlinks;
+}
+/**
+* Resolve a cell to its hyperlink (if any). Walks every hyperlink entry on the
+* worksheet and returns the first whose `ref` (a single cell `"A1"` or a range
+* `"A1:B5"`) covers the cell's coordinate. Returns `undefined` when no entry
+* matches.
+*/
+function getCellHyperlink(ws, c) {
+	for (const h of ws.hyperlinks) if (rangeContainsCell(parseRange(h.ref), c.row, c.col)) return h;
+}
+/**
+* Resolve a cell to its legacy comment (if any). Same matching rule as {@link
+* getCellHyperlink} — the comment's `ref` may be a single cell or a range, and
+* the first containing entry wins.
+*/
+function getCellComment(ws, c) {
+	for (const cm of ws.legacyComments) if (rangeContainsCell(parseRange(cm.ref), c.row, c.col)) return cm;
+}
+/** Append a DataValidation entry. */
+function addDataValidation(ws, dv) {
+	ws.dataValidations.push(dv);
+	return dv;
+}
+/** Drop every validation whose sqref overlaps `ref` (string parse). Returns count removed. */
+function removeDataValidations(ws, predicate) {
+	const before = ws.dataValidations.length;
+	ws.dataValidations = ws.dataValidations.filter((dv) => !predicate(dv));
+	return before - ws.dataValidations.length;
+}
+/** Read-only snapshot of every data validation block on the sheet. */
+function listDataValidations(ws) {
+	return ws.dataValidations;
+}
+/** Drop every data validation block on the worksheet. Returns the count removed. */
+function removeAllDataValidations(ws) {
+	const n = ws.dataValidations.length;
+	ws.dataValidations = [];
+	return n;
+}
+/** Set or replace the worksheet's AutoFilter. Pass `undefined` to clear. */
+function setAutoFilter(ws, filter) {
+	if (filter === void 0) {
+		delete ws.autoFilter;
+		return;
+	}
+	ws.autoFilter = filter;
+}
+/** Read the current AutoFilter, if any. */
+function getAutoFilter(ws) {
+	return ws.autoFilter;
+}
+/** Append a table. The id and displayName must be workbook-unique — the caller is responsible. */
+function addTable(ws, table) {
+	ws.tables.push(table);
+	return table;
+}
+/** Look up a table by displayName. */
+function getTable(ws, displayName) {
+	return ws.tables.find((t) => t.displayName === displayName);
+}
+/** Read-only snapshot of every Excel table defined on the sheet. */
+function listTables(ws) {
+	return ws.tables;
+}
+/** Drop a table by displayName. Returns true when something was removed. */
+function removeTable(ws, displayName) {
+	const i = ws.tables.findIndex((t) => t.displayName === displayName);
+	if (i < 0) return false;
+	ws.tables.splice(i, 1);
+	return true;
+}
+/** Drop every Excel table on the worksheet. Returns the count removed. */
+function removeAllTables(ws) {
+	const n = ws.tables.length;
+	ws.tables = [];
+	return n;
+}
+/** Add or replace the comment at `ref`. */
+function setComment(ws, opts) {
+	const i = ws.legacyComments.findIndex((c) => c.ref === opts.ref);
+	const c = makeLegacyComment(opts);
+	if (i < 0) ws.legacyComments.push(c);
+	else ws.legacyComments[i] = c;
+	return c;
+}
+/** Read-only snapshot of every legacy comment on the sheet. */
+function listComments(ws) {
+	return ws.legacyComments;
+}
+/** Drop every legacy comment on the worksheet. Returns the count removed. */
+function removeAllComments(ws) {
+	const n = ws.legacyComments.length;
+	ws.legacyComments = [];
+	return n;
+}
+/** Append a conditional formatting block. */
+function addConditionalFormatting(ws, cf) {
+	ws.conditionalFormatting.push(cf);
+	return cf;
+}
+/** Drop every conditional-formatting block on the worksheet. Returns the count removed. */
+function removeAllConditionalFormatting(ws) {
+	const n = ws.conditionalFormatting.length;
+	ws.conditionalFormatting = [];
+	return n;
+}
+/** Pin a cell to the Watch Window. Returns the pushed entry. */
+function addCellWatch(ws, watch) {
+	ws.cellWatches.push(watch);
+	return watch;
+}
+/** Remove cell watches matching `predicate`. Returns the count removed. */
+function removeCellWatches(ws, predicate) {
+	const before = ws.cellWatches.length;
+	ws.cellWatches = ws.cellWatches.filter((w) => !predicate(w));
+	return before - ws.cellWatches.length;
+}
+/** Append an ignored-error region. */
+function addIgnoredError(ws, ie) {
+	ws.ignoredErrors.push(ie);
+	return ie;
+}
+/** Remove ignored-error entries matching `predicate`. Returns the count removed. */
+function removeIgnoredErrors(ws, predicate) {
+	const before = ws.ignoredErrors.length;
+	ws.ignoredErrors = ws.ignoredErrors.filter((ie) => !predicate(ie));
+	return before - ws.ignoredErrors.length;
+}
+//#endregion
+export { iterRows as $, makeRowDimension as $t, getCellsInRow as A, unionRange as An, setRangeValues as At, getPopulatedRowIndices as B, unhideColumns as Bt, getAutoFilter as C, parseRange as Cn, setColumnWidth as Ct, getCellHyperlink as D, rangeToString as Dn, setDefaultRowHeight as Dt, getCellComment as E, rangeContainsRange as En, setDefaultColumnWidth as Et, getMaxRow as F, setSheetViewMode as Ft, groupRows as G, writeRange as Gt, getRowDimension as H, unhideRows as Ht, getMergedCells as I, setSheetZoom as It, hideRow as J, freezePaneRef as Jt, hideColumn as K, makeSheetProperties as Kt, getMergedRangeAt as L, ungroupColumns as Lt, getDataExtent as M, setRowHeight as Mt, getFreezePanes as N, setRowHeights as Nt, getCellsInColumn as O, rangesOverlap as On, setFreezePanes as Ot, getMaxCol as P, setSheetTabColor as Pt, iterCells as Q, makeColumnDimension as Qt, getNonEmptyCellCount as R, ungroupRows as Rt, freezePanes as S, parseMultiCellRange as Sn, setColumnDimension as St, getCellByCoord as T, rangeContainsCell as Tn, setComment as Tt, getTable as U, unmergeCells as Ut, getRangeValues as V, unhideRow as Vt, groupColumns as W, unmergeCellsAt as Wt, isMergedCell as X, makeSheetView as Xt, hideRows as Y, makeFreezePane as Yt, isWorksheetEmpty as Z, makeHyperlink as Zt, countCellsByKind as _, intersectionRange as _n, removeIgnoredErrors as _t, addTable as a, hexToHsl as an, makeWorksheet as at, expandRowGroup as b, multiCellRangeContainsCell as bn, setCell as bt, applyToRange as c, luminance as cn, removeAllComments as ct, clearAllCells as d, normaliseRgb as dn, removeAllHyperlinks as dt, adjustLightness as en, iterValues as et, clearRange as f, pickReadableTextColor as fn, removeAllMergedRanges as ft, countCells as g, expandRangeStr as gn, removeHyperlink as gt, copyRange as h, rotateHue as hn, removeDataValidations as ht, addIgnoredError as i, darken as in, listTables as it, getColumnDimension as j, setRowDimension as jt, getCellsInRange as k, shiftRange as kn, setHyperlink as kt, autofitColumns as l, makeColor as ln, removeAllConditionalFormatting as lt, collapseRowGroup as m, rgbColor as mn, removeCellWatches as mt, addConditionalFormatting as n, colorToHex as nn, listDataValidations as nt, appendRow as o, hslToHex as on, mergeCells as ot, collapseColumnGroup as p, resolveIndexedColor as pn, removeAllTables as pt, hideColumns as q, makeLegacyComment as qt, addDataValidation as r, contrastRatio as rn, listHyperlinks as rt, appendRows as s, lighten as sn, moveRange as st, addCellWatch as t, adjustSaturation as tn, listComments as tt, classifyCellValue as u, mixColors as un, removeAllDataValidations as ut, deleteCell as v, isCellInRange as vn, removeTable as vt, getCell as w, rangeArea as wn, setColumnWidths as wt, findCells as x, multiCellRangeToString as xn, setCellByCoord as xt, expandColumnGroup as y, isRangeInRange as yn, setAutoFilter as yt, getPopulatedColumnIndices as z, unhideColumn as zt };
+
+//# sourceMappingURL=worksheet-CmCNoIgD.mjs.map