reamkit 1.30.0 → 1.32.0

package/dist/esm/excel/table-style.d.ts

@@ -0,0 +1,13 @@
+import { TableStyleFormat, XlsxStyles } from '../core/spreadsheet-model/index.js';
+import { WorkbookColors } from './styles-parser.js';
+/**
+ * The style a table names, region by region, its colours resolved: the
+ * workbook's own style of that name when it defines one, else the style Excel
+ * builds in (TableStyleLight1…21, Medium1…28, Dark1…11).
+ *
+ * @param name   The style's name (`<tableStyleInfo name>`).
+ * @param styles The workbook's styles: its own table styles and their dxfs.
+ * @param colors The workbook's theme and palette, for a built-in style's colours.
+ * @returns The style, or undefined for a name that is neither.
+ */
+export declare function resolveTableStyleFormat(name: string, styles: XlsxStyles, colors: WorkbookColors): TableStyleFormat | undefined;

package/dist/esm/excel/table-style.js

@@ -0,0 +1,75 @@
+import { workbookColorHex } from "./styles-parser.js";
+import { presetTableStyle } from "./table-style-presets.js";
+//#region src/excel/table-style.ts
+/**
+* The style a table names, region by region, its colours resolved: the
+* workbook's own style of that name when it defines one, else the style Excel
+* builds in (TableStyleLight1…21, Medium1…28, Dark1…11).
+*
+* @param name   The style's name (`<tableStyleInfo name>`).
+* @param styles The workbook's styles: its own table styles and their dxfs.
+* @param colors The workbook's theme and palette, for a built-in style's colours.
+* @returns The style, or undefined for a name that is neither.
+*/
+function resolveTableStyleFormat(name, styles, colors) {
+	const own = styles.tableStyles?.get(name);
+	if (own) {
+		const out = {};
+		for (const el of own.elements) {
+			const dxf = styles.dxfs?.[el.dxfId];
+			if (dxf) out[el.type] = {
+				dxf,
+				...el.size !== void 0 ? { size: el.size } : {}
+			};
+		}
+		return out;
+	}
+	const preset = presetTableStyle(name);
+	if (!preset) return void 0;
+	const out = {};
+	for (const [type, dxf] of Object.entries(preset)) out[type] = { dxf: presetDxf(dxf, colors) };
+	return out;
+}
+/** A preset's format with its theme colours resolved. */
+function presetDxf(p, colors) {
+	const hex = (c) => workbookColorHex({
+		"@_theme": String(c[0]),
+		"@_tint": String(c[1])
+	}, colors);
+	const color = p.color ? hex(p.color) : void 0;
+	const fill = p.fill ? hex(p.fill) : void 0;
+	const edge = (e) => {
+		if (!e) return void 0;
+		const c = hex(e[1]);
+		return {
+			style: e[0],
+			...c !== void 0 ? { colorHex: c } : {}
+		};
+	};
+	const border = {};
+	for (const side of [
+		"left",
+		"right",
+		"top",
+		"bottom",
+		"vertical",
+		"horizontal"
+	]) {
+		const e = edge(p.border?.[side]);
+		if (e) border[side] = e;
+	}
+	return {
+		...p.bold || color !== void 0 ? { font: {
+			...p.bold ? { bold: true } : {},
+			...color !== void 0 ? { colorHex: color } : {}
+		} } : {},
+		...fill !== void 0 ? { fill: {
+			patternType: "solid",
+			fgColorHex: fill,
+			bgColorHex: fill
+		} } : {},
+		...Object.keys(border).length > 0 ? { border } : {}
+	};
+}
+//#endregion
+export { resolveTableStyleFormat };

package/dist/esm/excel/tint.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lighten a colour by a positive tint or darken it by a negative one, as Excel
+ * does (§18.8.19): a tint of 0.4 takes the luminance 40% of the way to white,
+ * one of -0.25 a quarter of the way to black.
+ *
+ * @param hex  The colour, RRGGBB.
+ * @param tint The tint, -1..1.
+ * @returns The tinted colour, RRGGBB in upper case; `hex` itself at no tint.
+ */
+export declare function applyTint(hex: string, tint: number): string;

package/dist/esm/excel/tint.js

@@ -0,0 +1,75 @@
+//#region src/excel/tint.ts
+/** The top of the HLS scale. */
+var HLS_MAX = 240;
+/** The top of an RGB channel. */
+var RGB_MAX = 255;
+/** Integer division of a non-negative numerator, as C divides unsigned values. */
+var div = (a, b) => Math.floor(a / b);
+/** RGB to hue, luminance and saturation, each 0..240, rounded as Windows rounds. */
+function toHls(r, g, b) {
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const sum = max + min;
+	const l = div(sum * HLS_MAX + RGB_MAX, 2 * RGB_MAX);
+	if (max === min) return [
+		HLS_MAX * 2 / 3,
+		l,
+		0
+	];
+	const range = max - min;
+	const s = l <= HLS_MAX / 2 ? div(range * HLS_MAX + div(sum, 2), sum) : div(range * HLS_MAX + div(2 * RGB_MAX - sum, 2), 2 * RGB_MAX - sum);
+	const away = (c) => div((max - c) * (HLS_MAX / 6) + div(range, 2), range);
+	let h = r === max ? away(b) - away(g) : g === max ? HLS_MAX / 3 + away(r) - away(b) : HLS_MAX * 2 / 3 + away(g) - away(r);
+	if (h < 0) h += HLS_MAX;
+	if (h > HLS_MAX) h -= HLS_MAX;
+	return [
+		h,
+		l,
+		s
+	];
+}
+/** Hue, luminance and saturation, each 0..240, back to RGB as Windows rounds it. */
+function toRgb(h, l, s) {
+	const channel = (v) => div(v * RGB_MAX + HLS_MAX / 2, HLS_MAX);
+	if (s === 0) {
+		const grey = channel(l);
+		return [
+			grey,
+			grey,
+			grey
+		];
+	}
+	const hi = l <= HLS_MAX / 2 ? div(l * (HLS_MAX + s) + HLS_MAX / 2, HLS_MAX) : l + s - div(l * s + HLS_MAX / 2, HLS_MAX);
+	const lo = 2 * l - hi;
+	const at = (hue) => {
+		const x = hue < 0 ? hue + HLS_MAX : hue > HLS_MAX ? hue - HLS_MAX : hue;
+		if (x < HLS_MAX / 6) return lo + div((hi - lo) * x + HLS_MAX / 12, HLS_MAX / 6);
+		if (x < HLS_MAX / 2) return hi;
+		if (x < HLS_MAX * 2 / 3) return lo + div((hi - lo) * (HLS_MAX * 2 / 3 - x) + HLS_MAX / 12, HLS_MAX / 6);
+		return lo;
+	};
+	return [
+		channel(at(h + HLS_MAX / 3)),
+		channel(at(h)),
+		channel(at(h - HLS_MAX / 3))
+	];
+}
+/**
+* Lighten a colour by a positive tint or darken it by a negative one, as Excel
+* does (§18.8.19): a tint of 0.4 takes the luminance 40% of the way to white,
+* one of -0.25 a quarter of the way to black.
+*
+* @param hex  The colour, RRGGBB.
+* @param tint The tint, -1..1.
+* @returns The tinted colour, RRGGBB in upper case; `hex` itself at no tint.
+*/
+function applyTint(hex, tint) {
+	if (!Number.isFinite(tint)) return hex;
+	const thousandths = Math.max(-1e3, Math.min(1e3, Math.round(tint * 1e3)));
+	if (thousandths === 0) return hex;
+	const v = parseInt(hex, 16);
+	const [h, l, s] = toHls(v >> 16 & 255, v >> 8 & 255, v & 255);
+	return toRgb(h, thousandths > 0 ? l + div((HLS_MAX - l) * thousandths, 1e3) : div(l * (1e3 + thousandths), 1e3), s).map((c) => c.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+//#endregion
+export { applyTint };

package/dist/esm/excel/vml-drawing.d.ts

@@ -3,9 +3,10 @@
  * CSS `style` attribute (`margin-left`/`margin-top`/`width`/`height`).
  *
  * The same rectangle is also expressed by `<x:ClientData><x:Anchor>` as
- * (column, offset px, row, offset px) pairs, which needs the sheet's column
- * widths and row heights to resolve. The style is already absolute, and the two
- * agree exactly in every file checked, so this reads the simpler one.
+ * (column, offset px, row, offset px) pairs (VmlAnchor). The style is in the
+ * producer's own measure of the columns, which is not ours wherever the two
+ * measure a digit differently; the anchor counts cells, and lands on the grid
+ * we draw. A reader takes the anchor where there is one.
  */
 export interface VmlShapeBox {
     readonly xPt: number;
@@ -13,6 +14,11 @@ export interface VmlShapeBox {
     readonly widthPt: number;
     readonly heightPt: number;
 }
+/**
+ * `<x:Anchor>` — LeftColumn, LeftOffset, TopRow, TopOffset, RightColumn,
+ * RightOffset, BottomRow, BottomOffset: cells, 0-based, and pixels into them.
+ */
+export type VmlAnchor = readonly [number, number, number, number, number, number, number, number];
 /** A form control declared by a legacy VML shape's `<x:ClientData>`. */
 export interface VmlFormControl {
     /** `ST_ObjectType` — `Radio`, `CheckBox`, `GBox`, `Button`, `Drop`, … */
@@ -27,12 +33,42 @@ export interface VmlFormControl {
     readonly firstButton?: boolean;
     /** Where the control sits, from the shape's `style` (§{@link VmlShapeBox}). */
     readonly box?: VmlShapeBox;
+    /** …and by the cells it covers, `<x:Anchor>` ({@link VmlAnchor}). */
+    readonly anchor?: VmlAnchor;
     /** `<v:textbox><font size>` — twentieths of a point, so 160 is 8pt. */
     readonly fontSizePt?: number;
 }
+/**
+ * A cell note's box — the `ObjectType="Note"` shape Excel keeps beside every
+ * legacy comment. The comment part holds what the note SAYS; this says whether
+ * it is shown and where, and what it is painted with.
+ */
+export interface VmlNote {
+    /** `<x:Row>` / `<x:Column>` — the cell the note belongs to, 0-based. */
+    readonly row: number;
+    readonly column: number;
+    /** `<x:Visible/>` — the note is shown, not merely flagged in its cell. */
+    readonly visible: boolean;
+    /**
+     * `<x:Anchor>` — LeftColumn, LeftOffset, TopRow, TopOffset, RightColumn,
+     * RightOffset, BottomRow, BottomOffset: the box in cells, offsets in pixels.
+     */
+    readonly anchor?: VmlAnchor;
+    /** The same box from the shape's `style`, already in points. */
+    readonly box?: VmlShapeBox;
+    /** `fillcolor` / `strokecolor`, as 6-hex. */
+    readonly fillHex: string;
+    readonly lineHex: string;
+    /** `<v:shadow on="t">` — the hard shadow a note casts down and to the right. */
+    readonly shadow: boolean;
+    /** `<v:textbox><div style="text-align">` — the side its text is set to. */
+    readonly textAlign?: 'left' | 'center' | 'right';
+}
 /** A parsed legacy VML drawing: its form controls plus every shape's box. */
 export interface VmlDrawing {
     readonly controls: ReadonlyArray<VmlFormControl>;
+    /** Every cell note's box, shown or not, in document order. */
+    readonly notes: ReadonlyArray<VmlNote>;
     /**
      * Shape id (`o:spid` without its `_x0000_s` prefix) → box, for EVERY shape in
      * the part, controls or not. An ActiveX control's box lives nowhere else: its
@@ -41,6 +77,8 @@ export interface VmlDrawing {
      * the one thing that says where it goes.
      */
     readonly boxes: ReadonlyMap<string, VmlShapeBox>;
+    /** Shape id → `<x:Anchor>`, for every shape that carries one. */
+    readonly anchors: ReadonlyMap<string, VmlAnchor>;
     /**
      * Shape ids whose `<x:ClientData>` clears `<x:PrintObject>` — Excel's "Print
      * object" checkbox, the legacy spelling of §18.3.1.20 `<controlPr print>`.

package/dist/esm/excel/vml-drawing.js

@@ -43,26 +43,33 @@ function parseVmlDrawing(data) {
 	const tree = parser.parse(decoder.decode(data));
 	const root = asObject(tree["xml"]) ?? tree;
 	const out = [];
+	const notes = [];
 	const boxes = /* @__PURE__ */ new Map();
+	const anchors = /* @__PURE__ */ new Map();
 	const nonPrinting = /* @__PURE__ */ new Set();
-	for (const raw of asArray(root["shape"])) {
-		const shape = asObject(raw);
-		if (!shape) continue;
+	for (const { shape, box } of shapesOf(root)) {
 		const idAttr = strAttr(shape, "id");
 		const shapeId = (strAttr(shape, "spid") ?? (idAttr !== void 0 && SPID_PREFIX.test(idAttr) ? idAttr : void 0))?.replace(SPID_PREFIX, "");
-		const box = shapeBox(strAttr(shape, "style"));
 		if (shapeId && box) boxes.set(shapeId, box);
 		const client = asObject(shape["ClientData"]);
 		if (!client) continue;
+		const anchor = anchorOf(client);
+		if (shapeId && anchor) anchors.set(shapeId, anchor);
 		if (!(flatText(client["PrintObject"])?.toLowerCase() !== "false")) {
 			if (shapeId) nonPrinting.add(shapeId);
 			continue;
 		}
 		const objectType = strAttr(client, "ObjectType");
+		if (objectType === "Note") {
+			const note = noteOf(shape, client, box);
+			if (note) notes.push(note);
+			continue;
+		}
 		if (!objectType || !CONTROL_TYPES.has(objectType)) continue;
 		const control = { objectType };
 		if (shapeId) control.shapeId = shapeId;
 		if (box) control.box = box;
+		if (anchor) control.anchor = anchor;
 		const caption = textboxText(shape["textbox"]);
 		if (caption) control.caption = caption;
 		const fontSizePt = textboxFontSizePt(shape["textbox"]);
@@ -73,10 +80,68 @@ function parseVmlDrawing(data) {
 	}
 	return {
 		controls: out,
+		notes,
 		boxes,
+		anchors,
 		nonPrinting
 	};
 }
+/** `<x:Anchor>`'s eight whole numbers, or undefined when it is not that. */
+function anchorOf(client) {
+	const numbers = (flatText(client["Anchor"]) ?? "").split(",").map((n) => Number(n.trim()));
+	return numbers.length === 8 && numbers.every((n) => Number.isInteger(n)) ? numbers : void 0;
+}
+function noteOf(shape, client, box) {
+	const row = Number(flatText(client["Row"])?.trim());
+	const column = Number(flatText(client["Column"])?.trim());
+	if (!Number.isInteger(row) || !Number.isInteger(column) || row < 0 || column < 0) return;
+	const anchor = anchorOf(client);
+	const shadowNode = asObject(shape["shadow"]);
+	const shadowOn = shadowNode ? strAttr(shadowNode, "on") : void 0;
+	const textAlign = /text-align:\s*(left|center|right)/i.exec(styleWithin(shape["textbox"]) ?? "")?.[1]?.toLowerCase();
+	return {
+		row,
+		column,
+		visible: "Visible" in client,
+		...anchor ? { anchor } : {},
+		...box ? { box } : {},
+		fillHex: vmlColorHex(strAttr(shape, "fillcolor")) ?? "FFFFE1",
+		lineHex: vmlColorHex(strAttr(shape, "strokecolor")) ?? "000000",
+		shadow: shadowOn === "t" || shadowOn === "true",
+		...textAlign ? { textAlign } : {}
+	};
+}
+/** The first `style` declared anywhere under `node` — a textbox's `<div style>`. */
+function styleWithin(node) {
+	if (Array.isArray(node)) {
+		for (const n of node) {
+			const found = styleWithin(n);
+			if (found !== void 0) return found;
+		}
+		return;
+	}
+	const obj = asObject(node);
+	if (!obj) return void 0;
+	const own = strAttr(obj, "style");
+	if (own !== void 0 && /text-align/i.test(own)) return own;
+	for (const [key, value] of Object.entries(obj)) {
+		if (key.startsWith("@_")) continue;
+		const found = styleWithin(value);
+		if (found !== void 0) return found;
+	}
+}
+/** A VML colour — `#rrggbb`, `#rgb`, or one of the few names notes use — as 6-hex. */
+function vmlColorHex(value) {
+	if (value === void 0) return void 0;
+	const v = value.trim().toLowerCase();
+	const long = /^#([0-9a-f]{6})\b/.exec(v);
+	if (long) return long[1].toUpperCase();
+	const short = /^#([0-9a-f]{3})\b/.exec(v);
+	if (short) return [...short[1]].map((c) => c + c).join("").toUpperCase();
+	if (v.startsWith("infobackground")) return "FFFFE1";
+	if (v.startsWith("infotext") || v.startsWith("black")) return "000000";
+	if (v.startsWith("white")) return "FFFFFF";
+}
 /** CSS length → points. A bare number is pixels, VML's implicit unit. */
 var CSS_UNITS = new Map([
 	["pt", 1],
@@ -96,25 +161,93 @@ function cssLengthPt(value) {
 	const factor = unit === "" ? .75 : CSS_UNITS.get(unit);
 	return factor === void 0 ? void 0 : n * factor;
 }
-/** The shape's rectangle from its `style` declaration; undefined if incomplete. */
-function shapeBox(style) {
-	if (style === void 0) return void 0;
+/** A `style` attribute's declarations, by lower-cased name. */
+function styleProps(style) {
 	const props = /* @__PURE__ */ new Map();
-	for (const decl of style.split(";")) {
+	for (const decl of (style ?? "").split(";")) {
 		const i = decl.indexOf(":");
 		if (i < 0) continue;
 		props.set(decl.slice(0, i).trim().toLowerCase(), decl.slice(i + 1).trim());
 	}
+	return props;
+}
+/** The shape's rectangle from its `style` declaration; undefined if incomplete. */
+function shapeBox(style) {
+	if (style === void 0) return void 0;
+	const props = styleProps(style);
 	const widthPt = cssLengthPt(props.get("width"));
 	const heightPt = cssLengthPt(props.get("height"));
 	if (widthPt === void 0 || heightPt === void 0) return void 0;
 	return {
-		xPt: cssLengthPt(props.get("margin-left")) ?? 0,
-		yPt: cssLengthPt(props.get("margin-top")) ?? 0,
+		xPt: (cssLengthPt(props.get("margin-left")) ?? 0) + (cssLengthPt(props.get("left")) ?? 0),
+		yPt: (cssLengthPt(props.get("margin-top")) ?? 0) + (cssLengthPt(props.get("top")) ?? 0),
 		widthPt,
 		heightPt
 	};
 }
+function groupSpace(group, box) {
+	const pair = (value, fallback) => {
+		const [a, b] = (value ?? "").split(",").map((n) => Number.parseFloat(n));
+		return [Number.isFinite(a) ? a : fallback, Number.isFinite(b) ? b : fallback];
+	};
+	const [ox, oy] = pair(strAttr(group, "coordorigin"), 0);
+	const [cw, ch] = pair(strAttr(group, "coordsize"), 1e3);
+	const sx = cw !== 0 ? box.widthPt / cw : 0;
+	const sy = ch !== 0 ? box.heightPt / ch : 0;
+	return {
+		x: (u) => box.xPt + (u - ox) * sx,
+		y: (u) => box.yPt + (u - oy) * sy,
+		sx,
+		sy
+	};
+}
+/** A child's box in its group's space: bare numbers, the group's units. */
+function boxInGroup(style, space) {
+	const props = styleProps(style);
+	const units = (name) => {
+		const n = Number.parseFloat(props.get(name) ?? "");
+		return Number.isFinite(n) ? n : void 0;
+	};
+	const width = units("width");
+	const height = units("height");
+	if (width === void 0 || height === void 0) return void 0;
+	const left = (units("margin-left") ?? 0) + (units("left") ?? 0);
+	const top = (units("margin-top") ?? 0) + (units("top") ?? 0);
+	return {
+		xPt: space.x(left),
+		yPt: space.y(top),
+		widthPt: width * space.sx,
+		heightPt: height * space.sy
+	};
+}
+/**
+* Every shape in the drawing with its box on the sheet — those at the top and
+* those inside a `<v:group>`, whose `left`/`top` count in the group's own
+* space. Reading only the top level lost every control a group held:
+* 45540_form_Footer.xlsx groups the 27 check boxes of its "What industry are
+* you in?" block, and they ended up in a list after the form.
+*/
+function shapesOf(root) {
+	const out = [];
+	const visit = (node, space, depth) => {
+		const boxOf = (style) => space ? boxInGroup(style, space) : shapeBox(style);
+		for (const raw of asArray(node["shape"])) {
+			const shape = asObject(raw);
+			if (shape) out.push({
+				shape,
+				box: boxOf(strAttr(shape, "style"))
+			});
+		}
+		if (depth >= 8) return;
+		for (const raw of asArray(node["group"])) {
+			const group = asObject(raw);
+			const box = group ? boxOf(strAttr(group, "style")) : void 0;
+			if (group && box) visit(group, groupSpace(group, box), depth + 1);
+		}
+	};
+	visit(root, void 0, 0);
+	return out;
+}
 /** `<v:textbox>`'s `<font size>` — twentieths of a point (160 ⇒ 8pt). */
 function textboxFontSizePt(node) {
 	const box = asObject(node);

package/dist/esm/excel/worksheet-parser.js

@@ -3,7 +3,7 @@ import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { parseCellRef } from "./cell-reference.js";
 import { parseAreaRef } from "./defined-name-ref.js";
 import { decodeXstring } from "./escaped-text.js";
-import { parseDxf } from "./styles-parser.js";
+import { parseDxf, workbookColorHex } from "./styles-parser.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/worksheet-parser.ts
 var decoder = new TextDecoder("utf-8");
@@ -49,11 +49,16 @@ function parseWorksheet(data, theme) {
 	const rowBreaks = parseBreaks(wsObj, "rowBreaks");
 	const colBreaks = parseBreaks(wsObj, "colBreaks");
 	const pane = parsePane(wsObj);
+	const showGridLines = parseShowGridLines(wsObj);
+	const rightToLeft = parseRightToLeft(wsObj);
 	const drawingNode = wsObj["drawing"];
 	const drawingRelId = drawingNode && typeof drawingNode === "object" ? strAttr(drawingNode, "id") : void 0;
 	const legacyNode = wsObj["legacyDrawing"];
 	const legacyDrawingRelId = legacyNode && typeof legacyNode === "object" ? strAttr(legacyNode, "id") : void 0;
-	const conditionalFormats = [...parseConditionalFormatting(wsObj), ...parseX14ConditionalFormatting(wsObj, {
+	const conditionalFormats = [...parseConditionalFormatting(wsObj, {
+		...theme ? { theme } : {},
+		indexed: INDEXED_COLORS
+	}, x14DataBars(wsObj)), ...parseX14ConditionalFormatting(wsObj, {
 		...theme ? { theme } : {},
 		indexed: INDEXED_COLORS
 	})];
@@ -73,7 +78,10 @@ function parseWorksheet(data, theme) {
 		...rowBreaks.length > 0 ? { rowBreaks } : {},
 		...colBreaks.length > 0 ? { colBreaks } : {},
 		...pane ? { pane } : {},
+		...showGridLines === false ? { showGridLines } : {},
+		...rightToLeft ? { rightToLeft } : {},
 		...drawingRelId !== void 0 ? { drawingRelId } : {},
+		...tree["worksheet"] === void 0 ? { chartSheet: true } : {},
 		...legacyDrawingRelId !== void 0 ? { legacyDrawingRelId } : {},
 		...conditionalFormats.length > 0 ? { conditionalFormats } : {},
 		...dataValidations.length > 0 ? { dataValidations } : {},
@@ -257,6 +265,24 @@ function parsePane(ws) {
 		frozenCols
 	};
 }
+function parseShowGridLines(ws) {
+	const views = ws["sheetViews"];
+	if (!views || typeof views !== "object") return void 0;
+	const viewRaw = views["sheetView"];
+	const view = Array.isArray(viewRaw) ? viewRaw[0] : viewRaw;
+	if (!view || typeof view !== "object") return void 0;
+	const raw = strAttr(view, "showGridLines");
+	return raw === "0" || raw === "false" ? false : void 0;
+}
+function parseRightToLeft(ws) {
+	const views = ws["sheetViews"];
+	if (!views || typeof views !== "object") return void 0;
+	const viewRaw = views["sheetView"];
+	const view = Array.isArray(viewRaw) ? viewRaw[0] : viewRaw;
+	if (!view || typeof view !== "object") return void 0;
+	const raw = strAttr(view, "rightToLeft");
+	return raw === "1" || raw === "true" ? true : void 0;
+}
 function parseBreaks(ws, tag) {
 	const node = ws[tag];
 	if (!node || typeof node !== "object") return [];
@@ -369,7 +395,44 @@ function parseMerges(ws) {
 	}
 	return out;
 }
-function parseConditionalFormatting(ws) {
+/**
+* The 2009 extension's half of each data bar (`<x14:cfRule type="dataBar"
+* id>`): what the 2006 rule of the same id cannot say — whether the bar is
+* faded or solid. Excel writes the two halves of one rule apart, the 2006
+* one pointing at this by `<x14:id>`.
+*
+* @param ws The worksheet element.
+* @returns The extension's options by rule id.
+*/
+function x14DataBars(ws) {
+	const out = /* @__PURE__ */ new Map();
+	for (const ext of toArray(asObjectNode(ws["extLst"])?.["ext"])) {
+		const group = asObjectNode(asObjectNode(ext)?.["conditionalFormattings"]);
+		for (const cf of toArray(group?.["conditionalFormatting"])) for (const rn of toArray(asObjectNode(cf)?.["cfRule"])) {
+			const node = asObjectNode(rn);
+			const bar = asObjectNode(node?.["dataBar"]);
+			const id = node ? strAttr(node, "id") : void 0;
+			if (!bar || id === void 0) continue;
+			const gradient = strAttr(bar, "gradient");
+			const minLength = parseNumericAttr(bar, "minLength");
+			const maxLength = parseNumericAttr(bar, "maxLength");
+			out.set(id, {
+				...gradient === "0" || gradient === "false" ? { gradient: false } : {},
+				...minLength !== void 0 ? { minLength } : {},
+				...maxLength !== void 0 ? { maxLength } : {}
+			});
+		}
+	}
+	return out;
+}
+/** A 2006 rule's `<extLst><ext><x14:id>` — the id of its 2009 half, if any. */
+function x14IdOf(rule) {
+	for (const ext of toArray(asObjectNode(rule["extLst"])?.["ext"])) {
+		const id = asObjectNode(ext)?.["id"];
+		if (typeof id === "string") return id;
+	}
+}
+function parseConditionalFormatting(ws, colors, x14Bars) {
 	const raw = ws["conditionalFormatting"];
 	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
 	const out = [];
@@ -385,7 +448,7 @@ function parseConditionalFormatting(ws) {
 		const rules = [];
 		for (const rn of ruleItems) {
 			if (!rn || typeof rn !== "object") continue;
-			const rule = parseCfRule(rn);
+			const rule = parseCfRule(rn, colors, x14Bars);
 			if (rule) rules.push(rule);
 		}
 		if (rules.length > 0) out.push({
@@ -418,7 +481,7 @@ function parseX14ConditionalFormatting(ws, colors) {
 			for (const rn of toArray(obj["cfRule"])) {
 				const node = asObjectNode(rn);
 				if (!node) continue;
-				const rule = parseCfRule(asBaseCfRule(node));
+				const rule = parseCfRule(asBaseCfRule(node), colors);
 				if (!rule) continue;
 				const dxf = parseDxf(node["dxf"], colors);
 				rules.push("dxfId" in rule && Object.keys(dxf).length > 0 ? {
@@ -564,13 +627,21 @@ var CF_OPERATORS = new Set([
 	"between",
 	"notBetween"
 ]);
-function parseCfRule(obj) {
+function parseCfRule(obj, colors, x14Bars) {
 	const priority = parseNumericAttr(obj, "priority") ?? 0;
 	const type = strAttr(obj, "type");
 	switch (type) {
 		case "cellIs": return parseCellIsRule(obj, priority);
-		case "colorScale": return parseColorScaleRule(obj, priority);
-		case "dataBar": return parseDataBarRule(obj, priority);
+		case "colorScale": return parseColorScaleRule(obj, priority, colors);
+		case "dataBar": {
+			const rule = parseDataBarRule(obj, priority, colors);
+			const id = x14IdOf(obj);
+			const ext = id !== void 0 ? x14Bars?.get(id) : void 0;
+			return rule && ext ? {
+				...rule,
+				...ext
+			} : rule;
+		}
 		case "iconSet": return parseIconSetRule(obj, priority);
 		case "top10": return parseTop10Rule(obj, priority);
 		case "aboveAverage": return parseAboveAverageRule(obj, priority);
@@ -682,21 +753,24 @@ function parseIconSetRule(obj, priority) {
 	const iconSet = strAttr(isObj, "iconSet") ?? "3TrafficLights1";
 	const reverseRaw = strAttr(isObj, "reverse");
 	const reverse = reverseRaw === "1" || reverseRaw === "true";
+	const showValueRaw = strAttr(isObj, "showValue");
+	const showValue = showValueRaw === "0" || showValueRaw === "false" ? false : void 0;
 	return {
 		type: "iconSet",
 		priority,
 		iconSet,
 		cfvos,
-		...reverse ? { reverse } : {}
+		...reverse ? { reverse } : {},
+		...showValue === false ? { showValue } : {}
 	};
 }
-function parseDataBarRule(obj, priority) {
+function parseDataBarRule(obj, priority, colors) {
 	const db = obj["dataBar"];
 	if (!db || typeof db !== "object") return void 0;
 	const dbObj = db;
 	const cfvos = parseCfvos(dbObj["cfvo"]);
 	if (cfvos.length < 2) return void 0;
-	const colorHex = colorRgbHex(dbObj["color"]);
+	const colorHex = workbookColorHex(dbObj["color"], colors);
 	if (!colorHex) return void 0;
 	const minLength = parseNumericAttr(dbObj, "minLength");
 	const maxLength = parseNumericAttr(dbObj, "maxLength");
@@ -743,12 +817,12 @@ var CFVO_TYPES = new Set([
 	"autoMin",
 	"autoMax"
 ]);
-function parseColorScaleRule(obj, priority) {
+function parseColorScaleRule(obj, priority, colors) {
 	const cs = obj["colorScale"];
 	if (!cs || typeof cs !== "object") return void 0;
 	const csObj = cs;
 	const cfvos = parseCfvos(csObj["cfvo"]);
-	const colorsHex = parseScaleColors(csObj["color"]);
+	const colorsHex = parseScaleColors(csObj["color"], colors);
 	if (cfvos.length < 2 || cfvos.length !== colorsHex.length) return void 0;
 	return {
 		type: "colorScale",
@@ -773,11 +847,11 @@ function parseCfvos(raw) {
 	}
 	return out;
 }
-function parseScaleColors(raw) {
+function parseScaleColors(raw, colors) {
 	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
 	const out = [];
 	for (const it of items) {
-		const hex = colorRgbHex(it);
+		const hex = workbookColorHex(it, colors);
 		if (!hex) return [];
 		out.push(hex);
 	}