ooxml.js 6.0.0 → 6.2.0

package/dist/typed/util.d.cts

@@ -1,2 +1,2 @@
-import { a as elementsWithTag, c as textContent, i as decodeEntities, l as walk, n as attr, o as resolveRelationships, r as childrenWithTag, s as rootElement, t as Relationship } from "../util-M3JJlDhF.cjs";
+import { a as elementsWithTag, c as textContent, i as decodeEntities, l as walk, n as attr, o as resolveRelationships, r as childrenWithTag, s as rootElement, t as Relationship } from "../util-xRsVgH-g.cjs";
 export { Relationship, attr, childrenWithTag, decodeEntities, elementsWithTag, resolveRelationships, rootElement, textContent, walk };

package/dist/typed/util.d.ts

@@ -1,2 +1,2 @@
-import { a as elementsWithTag, c as textContent, i as decodeEntities, l as walk, n as attr, o as resolveRelationships, r as childrenWithTag, s as rootElement, t as Relationship } from "../util-DFe4UbvU.js";
+import { a as elementsWithTag, c as textContent, i as decodeEntities, l as walk, n as attr, o as resolveRelationships, r as childrenWithTag, s as rootElement, t as Relationship } from "../util-DKrYuajM.js";
 export { Relationship, attr, childrenWithTag, decodeEntities, elementsWithTag, resolveRelationships, rootElement, textContent, walk };

package/dist/typed/xlsx/build.cjs

@@ -10,6 +10,8 @@ const require_typed_xlsx_units = require("./units.cjs");
 const require_typed_xlsx_serial = require("./serial.cjs");
 const require_typed_xlsx_shared_strings = require("./shared-strings.cjs");
 const require_typed_xlsx_styles = require("./styles.cjs");
+const require_typed_xlsx_conditional_format = require("./conditional-format.cjs");
+const require_typed_xlsx_data_validation = require("./data-validation.cjs");
 let document_schema_js = require("document-schema.js");
 //#region src/typed/xlsx/build.ts
 const SML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
@@ -184,7 +186,7 @@ function buildSharedStringsPart(sharedStrings) {
 		uniqueCount: String(entries.length)
 	}, siElements));
 }
-function buildStylesPart(cellFormats) {
+function buildStylesPart(cellFormats, dxfTable) {
 	const children = [];
 	const declarations = cellFormats.declarations();
 	if (declarations.length > 0) {
@@ -250,6 +252,8 @@ function buildStylesPart(cellFormats) {
 		xfId: "0",
 		builtinId: "0"
 	})]));
+	const dxfElements = dxfTable.dxfElements();
+	if (dxfElements.length > 0) children.push(require_xml_fragment.el("dxfs", { count: String(dxfElements.length) }, [...dxfElements]));
 	return xmlPart(require_xml_fragment.el("styleSheet", { xmlns: SML_NS }, children));
 }
 function buildCorePropertiesPart(metadata) {
@@ -488,13 +492,16 @@ function buildBreaksElements(settings) {
 	}
 	return result;
 }
-function buildWorksheetPart(sheet, sharedStrings, cellFormats) {
+function buildWorksheetPart(sheet, sharedStrings, cellFormats, dxfTable) {
 	const children = [buildSheetPrElement(sheet.printSettings), require_xml_fragment.el("dimension", { ref: computeDimension(sheet) })];
 	const colsElement = buildColsElement(sheet.columns);
 	if (colsElement !== void 0) children.push(colsElement);
 	children.push(buildSheetDataElement(sheet, sharedStrings, cellFormats));
 	const mergeCellsElement = buildMergeCellsElement(sheet.cells);
 	if (mergeCellsElement !== void 0) children.push(mergeCellsElement);
+	children.push(...require_typed_xlsx_conditional_format.buildConditionalFormattingElements(sheet.conditionalFormats ?? [], dxfTable));
+	const dataValidationsElement = require_typed_xlsx_data_validation.buildDataValidationsElement(sheet.dataValidations ?? []);
+	if (dataValidationsElement !== void 0) children.push(dataValidationsElement);
 	children.push(buildPrintOptionsElement(sheet.printSettings), buildPageMarginsElement(sheet.printSettings), buildPageSetupElement(sheet.printSettings));
 	const { rowBreaks, colBreaks } = buildBreaksElements(sheet.printSettings);
 	if (rowBreaks !== void 0) children.push(rowBreaks);
@@ -509,13 +516,14 @@ function buildXlsxPackageFromContent(document) {
 	const sheets = document.sheets;
 	const sharedStrings = new require_typed_xlsx_shared_strings.SharedStringTable();
 	const cellFormats = new require_typed_xlsx_styles.CellFormatTable();
-	const worksheetParts = sheets.map((sheet) => buildWorksheetPart(sheet, sharedStrings, cellFormats));
+	const dxfTable = new require_typed_xlsx_conditional_format.DxfTable();
+	const worksheetParts = sheets.map((sheet) => buildWorksheetPart(sheet, sharedStrings, cellFormats, dxfTable));
 	const parts = {
 		"[Content_Types].xml": buildContentTypesPart(sheets.length),
 		"_rels/.rels": buildPackageRelsPart(),
 		"xl/workbook.xml": buildWorkbookPart(sheets),
 		"xl/_rels/workbook.xml.rels": buildWorkbookRelsPart(sheets.length),
-		"xl/styles.xml": buildStylesPart(cellFormats),
+		"xl/styles.xml": buildStylesPart(cellFormats, dxfTable),
 		"xl/sharedStrings.xml": buildSharedStringsPart(sharedStrings),
 		"docProps/core.xml": buildCorePropertiesPart(document.metadata),
 		"docProps/app.xml": buildAppPropertiesPart(document.metadata)

package/dist/typed/xlsx/build.d.cts

@@ -1,2 +1,2 @@
-import { t as buildXlsxPackageFromContent } from "../../build-D-ldsmtA.cjs";
+import { t as buildXlsxPackageFromContent } from "../../build-BY9Mn-4K.cjs";
 export { buildXlsxPackageFromContent };

package/dist/typed/xlsx/build.d.ts

@@ -1,2 +1,2 @@
-import { t as buildXlsxPackageFromContent } from "../../build-q0qMH_ML.js";
+import { t as buildXlsxPackageFromContent } from "../../build-BOI7rIog.js";
 export { buildXlsxPackageFromContent };

package/dist/typed/xlsx/build.js

@@ -9,6 +9,8 @@ import { ptToColumnWidthChars } from "./units.js";
 import { isoDateTimeToSerial, isoDateToSerial, isoTimeToSerial } from "./serial.js";
 import { SharedStringTable } from "./shared-strings.js";
 import { CellFormatTable, RESERVED_BORDER_INDICES, RESERVED_FILL_INDICES } from "./styles.js";
+import { DxfTable, buildConditionalFormattingElements } from "./conditional-format.js";
+import { buildDataValidationsElement } from "./data-validation.js";
 import { cellReference, rangeReference } from "document-schema.js";
 //#region src/typed/xlsx/build.ts
 const SML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
@@ -183,7 +185,7 @@ function buildSharedStringsPart(sharedStrings) {
 		uniqueCount: String(entries.length)
 	}, siElements));
 }
-function buildStylesPart(cellFormats) {
+function buildStylesPart(cellFormats, dxfTable) {
 	const children = [];
 	const declarations = cellFormats.declarations();
 	if (declarations.length > 0) {
@@ -249,6 +251,8 @@ function buildStylesPart(cellFormats) {
 		xfId: "0",
 		builtinId: "0"
 	})]));
+	const dxfElements = dxfTable.dxfElements();
+	if (dxfElements.length > 0) children.push(el("dxfs", { count: String(dxfElements.length) }, [...dxfElements]));
 	return xmlPart(el("styleSheet", { xmlns: SML_NS }, children));
 }
 function buildCorePropertiesPart(metadata) {
@@ -487,13 +491,16 @@ function buildBreaksElements(settings) {
 	}
 	return result;
 }
-function buildWorksheetPart(sheet, sharedStrings, cellFormats) {
+function buildWorksheetPart(sheet, sharedStrings, cellFormats, dxfTable) {
 	const children = [buildSheetPrElement(sheet.printSettings), el("dimension", { ref: computeDimension(sheet) })];
 	const colsElement = buildColsElement(sheet.columns);
 	if (colsElement !== void 0) children.push(colsElement);
 	children.push(buildSheetDataElement(sheet, sharedStrings, cellFormats));
 	const mergeCellsElement = buildMergeCellsElement(sheet.cells);
 	if (mergeCellsElement !== void 0) children.push(mergeCellsElement);
+	children.push(...buildConditionalFormattingElements(sheet.conditionalFormats ?? [], dxfTable));
+	const dataValidationsElement = buildDataValidationsElement(sheet.dataValidations ?? []);
+	if (dataValidationsElement !== void 0) children.push(dataValidationsElement);
 	children.push(buildPrintOptionsElement(sheet.printSettings), buildPageMarginsElement(sheet.printSettings), buildPageSetupElement(sheet.printSettings));
 	const { rowBreaks, colBreaks } = buildBreaksElements(sheet.printSettings);
 	if (rowBreaks !== void 0) children.push(rowBreaks);
@@ -508,13 +515,14 @@ function buildXlsxPackageFromContent(document) {
 	const sheets = document.sheets;
 	const sharedStrings = new SharedStringTable();
 	const cellFormats = new CellFormatTable();
-	const worksheetParts = sheets.map((sheet) => buildWorksheetPart(sheet, sharedStrings, cellFormats));
+	const dxfTable = new DxfTable();
+	const worksheetParts = sheets.map((sheet) => buildWorksheetPart(sheet, sharedStrings, cellFormats, dxfTable));
 	const parts = {
 		"[Content_Types].xml": buildContentTypesPart(sheets.length),
 		"_rels/.rels": buildPackageRelsPart(),
 		"xl/workbook.xml": buildWorkbookPart(sheets),
 		"xl/_rels/workbook.xml.rels": buildWorkbookRelsPart(sheets.length),
-		"xl/styles.xml": buildStylesPart(cellFormats),
+		"xl/styles.xml": buildStylesPart(cellFormats, dxfTable),
 		"xl/sharedStrings.xml": buildSharedStringsPart(sharedStrings),
 		"docProps/core.xml": buildCorePropertiesPart(document.metadata),
 		"docProps/app.xml": buildAppPropertiesPart(document.metadata)

package/dist/typed/xlsx/comments.d.cts

@@ -1,4 +1,4 @@
-import { r as Package } from "../../package-L24lkba-.cjs";
+import { r as Package } from "../../package-DMk9fuTI.cjs";
 import { ContentSheetCellComment } from "document-schema.js";
 //#region src/typed/xlsx/comments.d.ts
 interface SheetCellComment {

package/dist/typed/xlsx/comments.d.ts

@@ -1,4 +1,4 @@
-import { r as Package } from "../../package-BUojjTXf.js";
+import { r as Package } from "../../package-otZYrxiO.js";
 import { ContentSheetCellComment } from "document-schema.js";
 //#region src/typed/xlsx/comments.d.ts
 interface SheetCellComment {

package/dist/typed/xlsx/conditional-format.cjs

@@ -0,0 +1,519 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_xml_parse = require("../../xml/parse.cjs");
+const require_xml_build = require("../../xml/build.cjs");
+const require_xml_fragment = require("../../xml/fragment.cjs");
+const require_xml_entities = require("../../xml/entities.cjs");
+const require_typed_util = require("../util.cjs");
+const require_typed_xlsx_util = require("./util.cjs");
+const require_typed_xlsx_styles = require("./styles.cjs");
+const require_typed_xlsx_rule_residue = require("./rule-residue.cjs");
+const require_typed_xlsx_sqref = require("./sqref.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/typed/xlsx/conditional-format.ts
+const CF_RULE_MANAGED_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"type",
+	"dxfId",
+	"priority",
+	"stopIfTrue",
+	"operator",
+	"text",
+	"rank",
+	"percent",
+	"bottom",
+	"aboveAverage",
+	"equalAverage",
+	"stdDev",
+	"timePeriod",
+	"iconSet",
+	"reverse",
+	"showValue"
+]);
+function readConditionalFormats(worksheet, dxfs) {
+	const formats = [];
+	const residueElements = [];
+	for (const wrapper of require_typed_util.childrenWithTag(worksheet, "conditionalFormatting")) {
+		const ranges = require_typed_xlsx_sqref.parseSqref(require_typed_util.attr(wrapper, "sqref"));
+		for (const cfRule of require_typed_util.childrenWithTag(wrapper, "cfRule")) {
+			const promoted = ranges.length === 0 ? void 0 : readCfRule(cfRule, ranges, dxfs);
+			if (promoted === void 0) {
+				residueElements.push({
+					type: "element",
+					tag: "conditionalFormatting",
+					attributes: wrapper.attributes,
+					children: [cfRule]
+				});
+				continue;
+			}
+			formats.push(promoted);
+		}
+	}
+	return {
+		formats,
+		residueElements
+	};
+}
+function readCommonFields(cfRule, ranges) {
+	const result = { ranges: [...ranges] };
+	const priorityRaw = require_typed_util.attr(cfRule, "priority");
+	if (priorityRaw !== void 0) {
+		const priority = Number.parseInt(priorityRaw, 10);
+		if (Number.isInteger(priority)) result.priority = priority;
+	}
+	if (require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "stopIfTrue"))) result.stopIfTrue = true;
+	const source = require_typed_xlsx_rule_residue.captureResidualAttributes(cfRule, CF_RULE_MANAGED_ATTRIBUTES);
+	if (source !== void 0) result.source = source;
+	return result;
+}
+function readFormula(cfRule, index) {
+	const formulaEl = require_typed_util.childrenWithTag(cfRule, "formula")[index];
+	return formulaEl === void 0 ? void 0 : require_typed_util.textContent(formulaEl);
+}
+function isSheetRuleOperator(value) {
+	return value === "between" || value === "notBetween" || value === "equal" || value === "notEqual" || value === "greaterThan" || value === "greaterThanOrEqual" || value === "lessThan" || value === "lessThanOrEqual";
+}
+const TEXT_PREDICATE_TYPES = /* @__PURE__ */ new Set([
+	"containsText",
+	"notContainsText",
+	"beginsWith",
+	"endsWith"
+]);
+function isTextPredicateType(value) {
+	return value !== void 0 && TEXT_PREDICATE_TYPES.has(value);
+}
+const OPERAND_FREE_TYPES = /* @__PURE__ */ new Set([
+	"containsBlanks",
+	"notContainsBlanks",
+	"containsErrors",
+	"notContainsErrors",
+	"uniqueValues",
+	"duplicateValues"
+]);
+function isOperandFreeType(value) {
+	return value !== void 0 && OPERAND_FREE_TYPES.has(value);
+}
+const TIME_PERIODS = /* @__PURE__ */ new Set([
+	"yesterday",
+	"today",
+	"tomorrow",
+	"last7Days",
+	"thisMonth",
+	"lastMonth",
+	"nextMonth",
+	"thisWeek",
+	"lastWeek",
+	"nextWeek"
+]);
+function isTimePeriod(value) {
+	return value !== void 0 && TIME_PERIODS.has(value);
+}
+function isCfvoType(value) {
+	return value === "num" || value === "percent" || value === "max" || value === "min" || value === "formula" || value === "percentile";
+}
+function readCfvo(cfvoEl) {
+	const type = require_typed_util.attr(cfvoEl, "type");
+	if (!isCfvoType(type)) return;
+	if (type === "min" || type === "max") return { type };
+	const valRaw = require_typed_util.attr(cfvoEl, "val");
+	if (valRaw === void 0) return;
+	return {
+		type,
+		value: require_typed_util.decodeEntities(valRaw)
+	};
+}
+function readColorScaleStops(colorScaleEl) {
+	const cfvoEls = require_typed_util.childrenWithTag(colorScaleEl, "cfvo");
+	const colorEls = require_typed_util.childrenWithTag(colorScaleEl, "color");
+	if (cfvoEls.length !== colorEls.length || cfvoEls.length < 2 || cfvoEls.length > 3) return;
+	const stops = [];
+	for (let index = 0; index < cfvoEls.length; index++) {
+		const cfvoEl = cfvoEls[index];
+		const colorEl = colorEls[index];
+		if (cfvoEl === void 0 || colorEl === void 0) return;
+		const value = readCfvo(cfvoEl);
+		const color = require_typed_xlsx_styles.colorFromElement(colorEl);
+		if (value === void 0 || color === void 0) return;
+		stops.push({
+			value,
+			color
+		});
+	}
+	return stops;
+}
+function readDataBar(dataBarEl) {
+	const cfvoEls = require_typed_util.childrenWithTag(dataBarEl, "cfvo");
+	const minEl = cfvoEls[0];
+	const maxEl = cfvoEls[1];
+	const min = minEl === void 0 ? void 0 : readCfvo(minEl);
+	const max = maxEl === void 0 ? void 0 : readCfvo(maxEl);
+	const color = require_typed_xlsx_styles.colorFromElement(require_typed_util.childrenWithTag(dataBarEl, "color")[0]);
+	if (min === void 0 || max === void 0 || color === void 0) return;
+	const result = {
+		min,
+		max,
+		color
+	};
+	const showValueRaw = require_typed_util.attr(dataBarEl, "showValue");
+	if (showValueRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+const DEFAULT_ICON_SET_TYPE = "3TrafficLights1";
+function readIconSet(iconSetEl) {
+	const thresholds = [];
+	for (const cfvoEl of require_typed_util.childrenWithTag(iconSetEl, "cfvo")) {
+		const value = readCfvo(cfvoEl);
+		if (value === void 0) return;
+		thresholds.push(value);
+	}
+	if (thresholds.length === 0) return;
+	const result = {
+		iconSetType: require_typed_util.attr(iconSetEl, "iconSet") ?? DEFAULT_ICON_SET_TYPE,
+		thresholds
+	};
+	if (require_typed_xlsx_util.readXmlBool(require_typed_util.attr(iconSetEl, "reverse"))) result.reverse = true;
+	const showValueRaw = require_typed_util.attr(iconSetEl, "showValue");
+	if (showValueRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(showValueRaw)) result.showValue = false;
+	return result;
+}
+function styleFromDxf(dxf) {
+	const fontEl = require_typed_util.childrenWithTag(dxf, "font")[0];
+	const textColor = fontEl === void 0 ? void 0 : require_typed_xlsx_styles.readColorRgb(fontEl, "color");
+	const fillEl = require_typed_util.childrenWithTag(dxf, "fill")[0];
+	const patternFillEl = fillEl === void 0 ? void 0 : require_typed_util.childrenWithTag(fillEl, "patternFill")[0];
+	const background = patternFillEl === void 0 ? void 0 : require_typed_xlsx_styles.readColorRgb(patternFillEl, "bgColor");
+	const residueChildren = dxfResidueChildren(dxf, textColor !== void 0, background !== void 0);
+	const style = {};
+	if (textColor !== void 0) style.textColor = textColor;
+	if (background !== void 0) style.background = background;
+	if (residueChildren.length > 0) style.source = {
+		format: "xlsx",
+		xml: require_xml_build.buildXml(residueChildren)
+	};
+	return style.textColor === void 0 && style.background === void 0 && style.source === void 0 ? void 0 : style;
+}
+function withoutChildTag(element, tag) {
+	const remaining = element.children.filter((child) => !(child.type === "element" && child.tag === tag));
+	if (remaining.length === 0 && element.attributes.length === 0) return;
+	return {
+		...element,
+		children: remaining
+	};
+}
+function fillResidue(fillEl) {
+	const patternFillEl = require_typed_util.childrenWithTag(fillEl, "patternFill")[0];
+	const otherFillChildren = fillEl.children.filter((child) => !(child.type === "element" && child.tag === "patternFill"));
+	if (patternFillEl === void 0) return otherFillChildren.length === 0 && fillEl.attributes.length === 0 ? void 0 : {
+		...fillEl,
+		children: otherFillChildren
+	};
+	const patternFillResidue = withoutChildTag(patternFillEl, "bgColor");
+	if (patternFillResidue === void 0) return otherFillChildren.length === 0 && fillEl.attributes.length === 0 ? void 0 : {
+		...fillEl,
+		children: otherFillChildren
+	};
+	return {
+		...fillEl,
+		children: [patternFillResidue, ...otherFillChildren]
+	};
+}
+function dxfResidueChildren(dxf, textColorCaptured, backgroundCaptured) {
+	const residue = [];
+	for (const child of dxf.children) {
+		if (child.type !== "element") continue;
+		if (child.tag === "font" && textColorCaptured) {
+			const remainder = withoutChildTag(child, "color");
+			if (remainder !== void 0) residue.push(remainder);
+			continue;
+		}
+		if (child.tag === "fill" && backgroundCaptured) {
+			const remainder = fillResidue(child);
+			if (remainder !== void 0) residue.push(remainder);
+			continue;
+		}
+		residue.push(child);
+	}
+	return residue;
+}
+function resolveStyle(cfRule, dxfs) {
+	const dxfIdRaw = require_typed_util.attr(cfRule, "dxfId");
+	if (dxfIdRaw === void 0) return;
+	const dxfId = Number.parseInt(dxfIdRaw, 10);
+	const dxf = Number.isInteger(dxfId) ? dxfs[dxfId] : void 0;
+	return dxf === void 0 ? void 0 : styleFromDxf(dxf);
+}
+function readCfRule(cfRule, ranges, dxfs) {
+	const type = require_typed_util.attr(cfRule, "type");
+	const common = readCommonFields(cfRule, ranges);
+	const style = resolveStyle(cfRule, dxfs);
+	const styleField = style === void 0 ? {} : { style };
+	if (type === "cellIs") {
+		const operatorRaw = require_typed_util.attr(cfRule, "operator");
+		const formula1 = readFormula(cfRule, 0);
+		if (!isSheetRuleOperator(operatorRaw) || formula1 === void 0) return;
+		const formula2 = operatorRaw === "between" || operatorRaw === "notBetween" ? readFormula(cfRule, 1) : void 0;
+		return {
+			type: "cellIs",
+			...common,
+			operator: operatorRaw,
+			formula1,
+			...formula2 === void 0 ? {} : { formula2 },
+			...styleField
+		};
+	}
+	if (isTextPredicateType(type)) {
+		const text = require_typed_util.attr(cfRule, "text");
+		if (text === void 0) return;
+		return {
+			type,
+			...common,
+			text: require_typed_util.decodeEntities(text),
+			...styleField
+		};
+	}
+	if (isOperandFreeType(type)) return {
+		type,
+		...common,
+		...styleField
+	};
+	if (type === "top10") {
+		const rankRaw = require_typed_util.attr(cfRule, "rank");
+		const rank = rankRaw === void 0 ? void 0 : Number(rankRaw);
+		if (rank === void 0 || !Number.isFinite(rank) || rank <= 0) return;
+		return {
+			type: "top10",
+			...common,
+			rank,
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "percent")) ? { percent: true } : {},
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "bottom")) ? { bottom: true } : {},
+			...styleField
+		};
+	}
+	if (type === "aboveAverage") {
+		const aboveAverageRaw = require_typed_util.attr(cfRule, "aboveAverage");
+		const stdDevRaw = require_typed_util.attr(cfRule, "stdDev");
+		const stdDev = stdDevRaw === void 0 ? void 0 : Number.parseInt(stdDevRaw, 10);
+		return {
+			type: "aboveAverage",
+			...common,
+			...aboveAverageRaw !== void 0 && !require_typed_xlsx_util.readXmlBool(aboveAverageRaw) ? { aboveAverage: false } : {},
+			...require_typed_xlsx_util.readXmlBool(require_typed_util.attr(cfRule, "equalAverage")) ? { equalAverage: true } : {},
+			...stdDev !== void 0 && Number.isInteger(stdDev) && stdDev > 0 ? { stdDev } : {},
+			...styleField
+		};
+	}
+	if (type === "timePeriod") {
+		const timePeriod = require_typed_util.attr(cfRule, "timePeriod");
+		if (!isTimePeriod(timePeriod)) return;
+		return {
+			type: "timePeriod",
+			...common,
+			timePeriod,
+			...styleField
+		};
+	}
+	if (type === "colorScale") {
+		const colorScaleEl = require_typed_util.childrenWithTag(cfRule, "colorScale")[0];
+		const stops = colorScaleEl === void 0 ? void 0 : readColorScaleStops(colorScaleEl);
+		if (stops === void 0) return;
+		return {
+			type: "colorScale",
+			...common,
+			stops
+		};
+	}
+	if (type === "dataBar") {
+		const dataBarEl = require_typed_util.childrenWithTag(cfRule, "dataBar")[0];
+		const parsed = dataBarEl === void 0 ? void 0 : readDataBar(dataBarEl);
+		if (parsed === void 0) return;
+		return {
+			type: "dataBar",
+			...common,
+			min: parsed.min,
+			max: parsed.max,
+			color: parsed.color,
+			...parsed.showValue === void 0 ? {} : { showValue: parsed.showValue }
+		};
+	}
+	if (type === "iconSet") {
+		const iconSetEl = require_typed_util.childrenWithTag(cfRule, "iconSet")[0];
+		const parsed = iconSetEl === void 0 ? void 0 : readIconSet(iconSetEl);
+		if (parsed === void 0) return;
+		return {
+			type: "iconSet",
+			...common,
+			iconSetType: parsed.iconSetType,
+			thresholds: parsed.thresholds,
+			...parsed.reverse === void 0 ? {} : { reverse: parsed.reverse },
+			...parsed.showValue === void 0 ? {} : { showValue: parsed.showValue }
+		};
+	}
+}
+var DxfTable = class {
+	elements = [];
+	intern(style) {
+		const index = this.elements.length;
+		this.elements.push(buildDxfElement(style));
+		return index;
+	}
+	dxfElements() {
+		return this.elements;
+	}
+};
+function attrsRecord(attributes) {
+	const result = {};
+	for (const attribute of attributes) result[attribute.name] = attribute.value;
+	return result;
+}
+function extractResidueElements(source) {
+	if (source?.format !== "xlsx") return [];
+	const elements = [];
+	for (const node of require_xml_parse.parseXml(source.xml)) if (node.type === "element") elements.push(node);
+	return elements;
+}
+function buildDxfElement(style) {
+	const residueByTag = /* @__PURE__ */ new Map();
+	for (const element of extractResidueElements(style.source)) residueByTag.set(element.tag, element);
+	const children = [];
+	const residualFont = residueByTag.get("font");
+	if (style.textColor !== void 0) {
+		const fontChildren = residualFont === void 0 ? [] : residualFont.children;
+		const fontAttrs = residualFont === void 0 ? {} : attrsRecord(residualFont.attributes);
+		children.push(require_xml_fragment.el("font", fontAttrs, [...fontChildren, require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(style.textColor)}` })]));
+	} else if (residualFont !== void 0) children.push(residualFont);
+	const residualNumFmt = residueByTag.get("numFmt");
+	if (residualNumFmt !== void 0) children.push(residualNumFmt);
+	const residualFill = residueByTag.get("fill");
+	if (style.background !== void 0) {
+		const residualPatternFill = residualFill === void 0 ? void 0 : require_typed_util.childrenWithTag(residualFill, "patternFill")[0];
+		const patternFillChildren = residualPatternFill === void 0 ? [] : residualPatternFill.children;
+		const patternFillAttrs = residualPatternFill === void 0 ? {} : attrsRecord(residualPatternFill.attributes);
+		const otherFillChildren = residualFill === void 0 ? [] : residualFill.children.filter((child) => !(child.type === "element" && child.tag === "patternFill"));
+		children.push(require_xml_fragment.el("fill", residualFill === void 0 ? {} : attrsRecord(residualFill.attributes), [require_xml_fragment.el("patternFill", patternFillAttrs, [...patternFillChildren, require_xml_fragment.el("bgColor", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(style.background)}` })]), ...otherFillChildren]));
+	} else if (residualFill !== void 0) children.push(residualFill);
+	for (const tag of [
+		"alignment",
+		"border",
+		"protection"
+	]) {
+		const residual = residueByTag.get(tag);
+		if (residual !== void 0) children.push(residual);
+	}
+	return require_xml_fragment.el("dxf", {}, children);
+}
+function rangeSetKey(ranges) {
+	return ranges.map((range) => `${range.startRow}:${range.startColumn}:${range.endRow}:${range.endColumn}`).join("|");
+}
+const TEXT_PREDICATE_OPERATOR = {
+	containsText: "containsText",
+	notContainsText: "notContains",
+	beginsWith: "beginsWith",
+	endsWith: "endsWith"
+};
+function buildCfvoElement(value) {
+	const attrs = { type: value.type };
+	if (value.value !== void 0) attrs.val = require_xml_entities.encodeXmlText(value.value);
+	return require_xml_fragment.el("cfvo", attrs);
+}
+function buildCfRuleElement(rule, priority, dxfTable) {
+	const attrs = require_typed_xlsx_rule_residue.residualAttributesFor(rule.source, "cfRule");
+	attrs.type = rule.type;
+	attrs.priority = String(priority);
+	if (rule.stopIfTrue === true) attrs.stopIfTrue = require_typed_xlsx_util.writeXmlBool(true);
+	const children = [];
+	let style;
+	switch (rule.type) {
+		case "cellIs":
+			attrs.operator = rule.operator;
+			children.push(require_xml_fragment.el("formula", {}, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(rule.formula1))]));
+			if (rule.formula2 !== void 0) children.push(require_xml_fragment.el("formula", {}, [require_xml_fragment.txt(require_xml_entities.encodeXmlText(rule.formula2))]));
+			style = rule.style;
+			break;
+		case "containsText":
+		case "notContainsText":
+		case "beginsWith":
+		case "endsWith":
+			attrs.operator = TEXT_PREDICATE_OPERATOR[rule.type];
+			attrs.text = require_xml_entities.encodeXmlText(rule.text);
+			style = rule.style;
+			break;
+		case "containsBlanks":
+		case "notContainsBlanks":
+		case "containsErrors":
+		case "notContainsErrors":
+		case "uniqueValues":
+		case "duplicateValues":
+			style = rule.style;
+			break;
+		case "top10":
+			attrs.rank = String(rule.rank);
+			if (rule.percent === true) attrs.percent = require_typed_xlsx_util.writeXmlBool(true);
+			if (rule.bottom === true) attrs.bottom = require_typed_xlsx_util.writeXmlBool(true);
+			style = rule.style;
+			break;
+		case "aboveAverage":
+			if (rule.aboveAverage === false) attrs.aboveAverage = require_typed_xlsx_util.writeXmlBool(false);
+			if (rule.equalAverage === true) attrs.equalAverage = require_typed_xlsx_util.writeXmlBool(true);
+			if (rule.stdDev !== void 0) attrs.stdDev = String(rule.stdDev);
+			style = rule.style;
+			break;
+		case "timePeriod":
+			attrs.timePeriod = rule.timePeriod;
+			style = rule.style;
+			break;
+		case "colorScale":
+			children.push(require_xml_fragment.el("colorScale", {}, [...rule.stops.map((stop) => buildCfvoElement(stop.value)), ...rule.stops.map((stop) => require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(stop.color)}` }))]));
+			break;
+		case "dataBar": {
+			const dataBarChildren = [
+				buildCfvoElement(rule.min),
+				buildCfvoElement(rule.max),
+				require_xml_fragment.el("color", { rgb: `FF${(0, document_schema_js.colorToRgbHex)(rule.color)}` })
+			];
+			const dataBarAttrs = rule.showValue === false ? { showValue: require_typed_xlsx_util.writeXmlBool(false) } : {};
+			children.push(require_xml_fragment.el("dataBar", dataBarAttrs, dataBarChildren));
+			break;
+		}
+		case "iconSet": {
+			const iconSetAttrs = {};
+			if (rule.iconSetType !== DEFAULT_ICON_SET_TYPE) iconSetAttrs.iconSet = rule.iconSetType;
+			if (rule.reverse === true) iconSetAttrs.reverse = require_typed_xlsx_util.writeXmlBool(true);
+			if (rule.showValue === false) iconSetAttrs.showValue = require_typed_xlsx_util.writeXmlBool(false);
+			children.push(require_xml_fragment.el("iconSet", iconSetAttrs, rule.thresholds.map(buildCfvoElement)));
+			break;
+		}
+	}
+	if (style !== void 0) attrs.dxfId = String(dxfTable.intern(style));
+	return require_xml_fragment.el("cfRule", attrs, children);
+}
+function buildConditionalFormattingElements(formats, dxfTable) {
+	const groupsByKey = /* @__PURE__ */ new Map();
+	const groupOrder = [];
+	for (const format of formats) {
+		const key = rangeSetKey(format.ranges);
+		const existing = groupsByKey.get(key);
+		if (existing === void 0) {
+			const group = {
+				ranges: format.ranges,
+				rules: [format]
+			};
+			groupsByKey.set(key, group);
+			groupOrder.push(group);
+		} else existing.rules.push(format);
+	}
+	const usedPriorities = /* @__PURE__ */ new Set();
+	for (const format of formats) if (format.priority !== void 0) usedPriorities.add(format.priority);
+	let nextPriority = 1;
+	const assignPriority = (explicit) => {
+		if (explicit !== void 0) return explicit;
+		while (usedPriorities.has(nextPriority)) nextPriority++;
+		usedPriorities.add(nextPriority);
+		return nextPriority++;
+	};
+	return groupOrder.map((group) => {
+		const cfRuleElements = group.rules.map((rule) => buildCfRuleElement(rule, assignPriority(rule.priority), dxfTable));
+		return require_xml_fragment.el("conditionalFormatting", { sqref: require_typed_xlsx_sqref.formatSqref(group.ranges) }, cfRuleElements);
+	});
+}
+//#endregion
+exports.DxfTable = DxfTable;
+exports.buildConditionalFormattingElements = buildConditionalFormattingElements;
+exports.readConditionalFormats = readConditionalFormats;