@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/io/xlsx/conditional-formatting.js

@@ -1,102 +1,201 @@
-import { isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isIconSetType, isCfTimePeriod, } from '../../core/conditional-formatting.js';
-import { stripFormulaEquals } from '../../core/formula.js';
-import { coerceNumericLiteral, enumToken, numFinite, numInteger } from '../../xml/xml-attrs.js';
-import { elementSubtrees, TextCapture, } from '../../xml/xml-read.js';
-import { boolPresent, boolStrict, localName } from '../../xml/xml-scan.js';
-import { boolAttr, checkedToken, escapeAttr, escapeText, numberText, textAttr, } from '../../xml/xml.js';
+import { isCfIconSetType, isCfTimePeriod, isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isDataBarAxisPosition, isDataBarDirection, isIconSetType, ruleNeedsExtension, } from '../../core/conditional-formatting.js';
+import { mangleFormula, stripFormulaEquals, unmangleFunctions } from '../../core/formula.js';
+import { decodeSqrefRects } from '../../core/merge.js';
+import { InternalError } from '../../errors.js';
+import { coerceNumericLiteral, enumToken, numInteger } from '../../xml/xml-attrs.js';
+import { elementRange, TextCapture, } from '../../xml/xml-read.js';
+import { boolStrict, boolTristate, localName } from '../../xml/xml-scan.js';
+import { boolAttr, checkedToken, escapeAttr, escapeText, intAttr, numberText, textAttr, } from '../../xml/xml.js';
+import { admitting } from '../read-policy/read-repair.js';
 import { colorAttrs, parseColor } from './color-xml.js';
-import { CF_EXT_URI, DATABAR_LINK_EXT_URI, isExtensionElement, XM_NS } from './namespaces.js';
+import { CF_EXT_URI, DATABAR_LINK_EXT_URI, isExtensionElement, isMainNamespaceElement, XM_NS, } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
 const DEFAULT_DATABAR_CFVO = [{ type: 'min' }, { type: 'max' }];
 const DEFAULT_DATABAR_COLOR = { argb: 'FF638EC6' };
+const CLASSIC_ANCHOR = {
+    autoMin: 'min',
+    autoMax: 'max',
+};
 function needsDataBarExt(rule) {
     return (rule.gradient !== undefined ||
+        rule.border !== undefined ||
+        rule.borderColor !== undefined ||
+        rule.direction !== undefined ||
         rule.negativeFillColor !== undefined ||
-        rule.axisColor !== undefined);
+        rule.negativeBorderColor !== undefined ||
+        rule.negativeBarColorSameAsPositive !== undefined ||
+        rule.negativeBarBorderColorSameAsPositive !== undefined ||
+        rule.axisPosition !== undefined ||
+        rule.axisColor !== undefined ||
+        (rule.cfvo ?? []).some((anchor) => CLASSIC_ANCHOR[anchor.type] !== undefined));
 }
-function dataBarExtGuid(index) {
+function inExtension(cf, rule) {
+    return cf.extended === true || ruleNeedsExtension(rule);
+}
+function extensionGuid(index) {
     return `{00000000-0000-0000-0000-${String(index + 1).padStart(12, '0')}}`;
 }
-export function dataBarExtLinks(formattings) {
-    const links = new Map();
-    let index = 0;
+export function planConditionalFormatting(formattings) {
+    const priorities = new Map();
+    const extensionIds = new Map();
+    let next = 1;
     for (const cf of formattings) {
         for (const rule of cf.rules) {
-            if (rule.type === 'dataBar' && needsDataBarExt(rule))
-                links.set(rule, dataBarExtGuid(index++));
+            const priority = rule.priority ?? next;
+            intAttr('priority', priority);
+            next = Math.max(next, priority) + 1;
+            priorities.set(rule, priority);
+            if (inExtension(cf, rule) || (rule.type === 'dataBar' && needsDataBarExt(rule))) {
+                extensionIds.set(rule, extensionGuid(extensionIds.size));
+            }
         }
     }
-    return links;
+    return { priorities, extensionIds };
+}
+function priorityOf(plan, rule) {
+    const priority = plan.priorities.get(rule);
+    if (priority === undefined) {
+        throw new InternalError('a conditional format rule reached a serialiser unplanned');
+    }
+    return priority;
 }
 const SCALE_KINDS = ['dataBar', 'colorScale', 'iconSet'];
 const SCALE_TYPES = new Set(SCALE_KINDS);
-export function conditionalFormattingsXml(formattings, styles, extLinks) {
-    if (formattings.length === 0)
-        return '';
-    const priority = { next: 1 };
-    return formattings.map((cf) => blockXml(cf, styles, priority, extLinks)).join('');
+export function conditionalFormattingsXml(formattings, styles, plan, formulaNames) {
+    return formattings.map((cf) => blockXml(cf, styles, plan, formulaNames)).join('');
 }
-export function conditionalFormattingsExtXml(formattings, extLinks) {
+export function conditionalFormattingsExtXml(formattings, styles, plan, formulaNames) {
     const items = [];
     for (const cf of formattings) {
+        const whole = cf.rules.filter((rule) => inExtension(cf, rule));
+        if (whole.length > 0) {
+            const rules = whole.map((rule) => extensionRuleXml(rule, styles, plan, formulaNames));
+            items.push(extensionBlockXml(cf.ref, rules.join('')));
+        }
         for (const rule of cf.rules) {
-            const guid = extLinks.get(rule);
-            if (guid !== undefined)
-                items.push(x14DataBarXml(cf.ref, rule, guid));
+            const guid = plan.extensionIds.get(rule);
+            if (guid === undefined || inExtension(cf, rule))
+                continue;
+            items.push(extensionBlockXml(cf.ref, `<x14:cfRule type="dataBar" id="${guid}">${x14DataBarXml(rule, formulaNames, false)}</x14:cfRule>`));
         }
     }
     if (items.length === 0)
         return '';
     return x14Ext(CF_EXT_URI, `<x14:conditionalFormattings>${items.join('')}</x14:conditionalFormattings>`);
 }
-function x14DataBarXml(ref, rule, guid) {
-    const anchors = dataBarAnchors(rule).map(x14Cfvo).join('');
-    const gradient = boolAttr('gradient', rule.gradient);
-    const negative = rule.negativeFillColor !== undefined
-        ? `<x14:negativeFillColor ${colorAttrs(rule.negativeFillColor)}/>`
-        : '';
-    const axis = rule.axisColor !== undefined ? `<x14:axisColor ${colorAttrs(rule.axisColor)}/>` : '';
-    return (`<x14:conditionalFormatting xmlns:xm="${XM_NS}">` +
-        `<x14:cfRule type="dataBar" id="${guid}">` +
-        `<x14:dataBar${gradient}>${anchors}${negative}${axis}</x14:dataBar>` +
-        `</x14:cfRule><xm:sqref>${escapeText(ref)}</xm:sqref></x14:conditionalFormatting>`);
+function extensionBlockXml(ref, rules) {
+    return (`<x14:conditionalFormatting xmlns:xm="${XM_NS}">${rules}` +
+        `<xm:sqref>${escapeText(ref)}</xm:sqref></x14:conditionalFormatting>`);
+}
+function extensionRuleXml(rule, styles, plan, formulaNames) {
+    const attrs = [typeAttr(rule), `priority="${priorityOf(plan, rule)}"`, ...ruleFlagAttrs(rule)];
+    const id = plan.extensionIds.get(rule);
+    if (id !== undefined)
+        attrs.push(`id="${id}"`);
+    const body = (SCALE_TYPES.has(rule.type)
+        ? extensionScaleXml(rule, formulaNames)
+        : operandsXml(rule.formulae, 'xm:f', formulaNames)) + inlineDxfXml(rule, styles);
+    return body === ''
+        ? `<x14:cfRule ${attrs.join(' ')}/>`
+        : `<x14:cfRule ${attrs.join(' ')}>${body}</x14:cfRule>`;
+}
+function inlineDxfXml(rule, styles) {
+    const id = resolveDxfId(rule, styles);
+    const fragment = id === undefined ? undefined : styles.differentialStyleFragment(id);
+    const range = fragment === undefined ? undefined : elementRange(fragment, ['dxf']);
+    if (fragment === undefined || range === undefined)
+        return '';
+    return `<x14:dxf>${fragment.slice(range.contentStart, range.contentEnd)}</x14:dxf>`;
+}
+function extensionScaleXml(rule, formulaNames) {
+    if (rule.type === 'dataBar')
+        return x14DataBarXml(rule, formulaNames, true);
+    const cfvoXml = cfvoWriter('x14', formulaNames);
+    if (rule.type === 'colorScale') {
+        const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
+        const colors = (rule.colors ?? []).map((c) => `<x14:color ${colorAttrs(c)}/>`).join('');
+        return `<x14:colorScale>${anchors}${colors}</x14:colorScale>`;
+    }
+    return iconSetXml(rule, cfvoXml, 'x14');
+}
+function x14DataBarXml(rule, formulaNames, whole) {
+    const attrs = intAttr('minLength', rule.minLength, 0) +
+        intAttr('maxLength', rule.maxLength, 0) +
+        (whole && rule.showValue === false ? ' showValue="0"' : '') +
+        boolAttr('border', rule.border) +
+        boolAttr('gradient', rule.gradient) +
+        tokenAttr('direction', rule.direction, isDataBarDirection, 'data bar direction') +
+        boolAttr('negativeBarColorSameAsPositive', rule.negativeBarColorSameAsPositive) +
+        boolAttr('negativeBarBorderColorSameAsPositive', rule.negativeBarBorderColorSameAsPositive) +
+        tokenAttr('axisPosition', rule.axisPosition, isDataBarAxisPosition, 'data bar axis position');
+    const children = dataBarAnchors(rule).map(cfvoWriter('x14', formulaNames)).join('') +
+        (whole ? x14ColorXml('fillColor', rule.color ?? DEFAULT_DATABAR_COLOR) : '') +
+        x14ColorXml('borderColor', rule.borderColor) +
+        x14ColorXml('negativeFillColor', rule.negativeFillColor) +
+        x14ColorXml('negativeBorderColor', rule.negativeBorderColor) +
+        x14ColorXml('axisColor', rule.axisColor);
+    return `<x14:dataBar${attrs}>${children}</x14:dataBar>`;
+}
+function x14ColorXml(name, color) {
+    return color === undefined ? '' : `<x14:${name} ${colorAttrs(color)}/>`;
+}
+function tokenAttr(name, value, isValid, kind) {
+    return value === undefined ? '' : ` ${name}="${checkedToken(value, isValid, kind)}"`;
 }
 function dataBarAnchors(rule) {
     return rule.cfvo && rule.cfvo.length > 0 ? rule.cfvo : DEFAULT_DATABAR_CFVO;
 }
-function cfvoWriter(form) {
+function cfvoWriter(form, formulaNames) {
     return (cfvo) => {
-        const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
+        const checked = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
+        const type = form === 'classic' ? (CLASSIC_ANCHOR[cfvo.type] ?? checked) : checked;
         const tag = form === 'classic' ? 'cfvo' : 'x14:cfvo';
+        const gte = cfvo.gte === false ? ' gte="0"' : '';
         if (cfvo.value === undefined)
-            return `<${tag} type="${type}"/>`;
-        const value = String(cfvo.value);
+            return `<${tag} type="${type}"${gte}/>`;
+        const value = typeof cfvo.value === 'number'
+            ? numberText(cfvo.value)
+            : type === 'formula'
+                ? mangleFormula(cfvo.value, formulaNames)
+                : cfvo.value;
         return form === 'classic'
-            ? `<${tag} type="${type}"${textAttr('val', value)}/>`
-            : `<${tag} type="${type}"><xm:f>${escapeText(value)}</xm:f></${tag}>`;
+            ? `<${tag} type="${type}"${textAttr('val', value)}${gte}/>`
+            : `<${tag} type="${type}"${gte}><xm:f>${escapeText(value)}</xm:f></${tag}>`;
     };
 }
-const cfvoXml = cfvoWriter('classic');
-const x14Cfvo = cfvoWriter('x14');
 function cfRuleExtLinkXml(guid) {
     return `<extLst>${x14Ext(DATABAR_LINK_EXT_URI, `<x14:id>${guid}</x14:id>`)}</extLst>`;
 }
-function blockXml(cf, styles, priority, extLinks) {
-    const rules = cf.rules.map((rule) => ruleXml(rule, styles, priority, extLinks)).join('');
+function blockXml(cf, styles, plan, formulaNames) {
+    const rules = cf.rules
+        .filter((rule) => !inExtension(cf, rule))
+        .map((rule) => ruleXml(rule, styles, plan, formulaNames))
+        .join('');
     if (rules === '')
         return '';
     return `<conditionalFormatting sqref="${escapeAttr(cf.ref)}">${rules}</conditionalFormatting>`;
 }
-function ruleXml(rule, styles, priority, extLinks) {
-    const p = rule.priority ?? priority.next;
-    priority.next = Math.max(priority.next, p) + 1;
-    const attrs = [
-        `type="${checkedToken(rule.type, isConditionalFormattingType, 'conditional formatting type')}"`,
-    ];
+function ruleXml(rule, styles, plan, formulaNames) {
+    const attrs = [typeAttr(rule)];
     const dxfId = resolveDxfId(rule, styles);
     if (dxfId !== undefined)
         attrs.push(`dxfId="${dxfId}"`);
-    attrs.push(`priority="${p}"`);
+    attrs.push(`priority="${priorityOf(plan, rule)}"`, ...ruleFlagAttrs(rule));
+    const extGuid = plan.extensionIds.get(rule);
+    let body = SCALE_TYPES.has(rule.type)
+        ? scaleXml(rule, formulaNames, extGuid !== undefined)
+        : operandsXml(rule.formulae, 'formula', formulaNames);
+    if (extGuid !== undefined)
+        body += cfRuleExtLinkXml(extGuid);
+    return body === ''
+        ? `<cfRule ${attrs.join(' ')}/>`
+        : `<cfRule ${attrs.join(' ')}>${body}</cfRule>`;
+}
+function typeAttr(rule) {
+    return `type="${checkedToken(rule.type, isConditionalFormattingType, 'conditional formatting type')}"`;
+}
+function ruleFlagAttrs(rule) {
+    const attrs = [];
     if (rule.stopIfTrue)
         attrs.push('stopIfTrue="1"');
     if (rule.aboveAverage === false)
@@ -116,16 +215,10 @@ function ruleXml(rule, styles, priority, extLinks) {
         attrs.push(`timePeriod="${checkedToken(rule.timePeriod, isCfTimePeriod, 'time period')}"`);
     }
     if (rule.rank !== undefined)
-        attrs.push(`rank="${numberText(rule.rank)}"`);
+        attrs.push(intAttr('rank', rule.rank, 0).trim());
     if (rule.stdDev !== undefined)
-        attrs.push(`stdDev="${numberText(rule.stdDev)}"`);
-    let body = SCALE_TYPES.has(rule.type) ? scaleXml(rule) : formulaeXml(rule.formulae);
-    const extGuid = extLinks.get(rule);
-    if (extGuid !== undefined)
-        body += cfRuleExtLinkXml(extGuid);
-    return body === ''
-        ? `<cfRule ${attrs.join(' ')}/>`
-        : `<cfRule ${attrs.join(' ')}>${body}</cfRule>`;
+        attrs.push(intAttr('stdDev', rule.stdDev).trim());
+    return attrs;
 }
 function resolveDxfId(rule, styles) {
     if (SCALE_TYPES.has(rule.type))
@@ -137,66 +230,221 @@ function resolveDxfId(rule, styles) {
         return styles.differentialStyleId(rule.style);
     return undefined;
 }
-function formulaeXml(formulae) {
+function operandsXml(formulae, tag, formulaNames) {
     if (formulae === undefined)
         return '';
-    return formulae.map((f) => `<formula>${escapeText(stripFormulaEquals(f))}</formula>`).join('');
+    return formulae
+        .map((f) => `<${tag}>${escapeText(mangleFormula(stripFormulaEquals(f), formulaNames))}</${tag}>`)
+        .join('');
 }
-function scaleXml(rule) {
+function scaleXml(rule, formulaNames, linked) {
+    const cfvoXml = cfvoWriter('classic', formulaNames);
     if (rule.type === 'dataBar')
-        return dataBarXml(rule);
+        return dataBarXml(rule, cfvoXml, linked);
     if (rule.type === 'colorScale')
-        return colorScaleXml(rule);
-    return iconSetXml(rule);
+        return colorScaleXml(rule, cfvoXml);
+    return iconSetXml(rule, cfvoXml, 'classic');
 }
-function dataBarXml(rule) {
+function dataBarXml(rule, cfvoXml, linked) {
     const color = rule.color ?? DEFAULT_DATABAR_COLOR;
     const anchors = dataBarAnchors(rule).map(cfvoXml).join('');
-    return `<dataBar>${anchors}<color ${colorAttrs(color)}/></dataBar>`;
+    const lengths = linked
+        ? ''
+        : intAttr('minLength', rule.minLength, 0) + intAttr('maxLength', rule.maxLength, 0);
+    const showValue = rule.showValue === false ? ' showValue="0"' : '';
+    return `<dataBar${lengths}${showValue}>${anchors}<color ${colorAttrs(color)}/></dataBar>`;
 }
-function colorScaleXml(rule) {
+function colorScaleXml(rule, cfvoXml) {
     const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
     const colors = (rule.colors ?? []).map((c) => `<color ${colorAttrs(c)}/>`).join('');
     return `<colorScale>${anchors}${colors}</colorScale>`;
 }
-function iconSetXml(rule) {
-    const name = rule.iconSet === undefined
-        ? ''
-        : ` iconSet="${checkedToken(rule.iconSet, isIconSetType, 'icon set')}"`;
+function iconSetXml(rule, cfvoXml, form) {
+    const tag = form === 'classic' ? 'iconSet' : 'x14:iconSet';
+    const icons = form === 'x14' ? (rule.icons ?? []) : [];
+    const attrs = tokenAttr('iconSet', rule.iconSet, isIconSetType, 'icon set') +
+        (rule.showValue === false ? ' showValue="0"' : '') +
+        (rule.reverse ? ' reverse="1"' : '') +
+        (icons.length > 0 ? ' custom="1"' : '');
     const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
-    return `<iconSet${name}>${anchors}</iconSet>`;
+    return `<${tag}${attrs}>${anchors}${icons.map(cfIconXml).join('')}</${tag}>`;
+}
+function cfIconXml(icon) {
+    const iconSet = checkedToken(icon.iconSet, isCfIconSetType, 'custom icon set');
+    return `<x14:cfIcon iconSet="${iconSet}"${intAttr('iconId', icon.iconId, 0)}/>`;
+}
+class DxfCapture {
+    #xml = '<dxf>';
+    #depth = 0;
+    #skippingFrom;
+    open(name, attrs, selfClosing, scope) {
+        const local = localName(name);
+        if (this.#skippingFrom === undefined) {
+            if (isMainNamespaceElement(scope, name) && local !== 'extLst') {
+                const attributes = Object.entries(attrs)
+                    .filter(([key]) => key !== 'xmlns' && !key.includes(':'))
+                    .map(([key, value]) => ` ${key}="${escapeAttr(value)}"`)
+                    .join('');
+                this.#xml += `<${local}${attributes}${selfClosing ? '/>' : '>'}`;
+            }
+            else if (!selfClosing) {
+                this.#skippingFrom = this.#depth;
+            }
+        }
+        if (!selfClosing)
+            this.#depth += 1;
+    }
+    close(name) {
+        if (this.#depth === 0) {
+            this.#xml += '</dxf>';
+            return true;
+        }
+        this.#depth -= 1;
+        if (this.#skippingFrom === undefined)
+            this.#xml += `</${localName(name)}>`;
+        else if (this.#skippingFrom === this.#depth)
+            this.#skippingFrom = undefined;
+        return false;
+    }
+    get fragment() {
+        return this.#xml;
+    }
 }
-export function conditionalFormattingPass() {
+export function conditionalFormattingPass(definedNames, adoptDifferentialStyle) {
     const blocks = [];
     let block;
     let draft;
     let scale;
     const formulaCapture = new TextCapture('formula');
     const linked = [];
+    const linkedIds = new Set();
     const extById = new Map();
-    let x14Ext;
-    let x14ExtId;
     const x14IdCapture = new TextCapture('id');
+    let extRules;
+    let extRule;
+    let extCfvo;
+    let extSqref = '';
+    const extCapture = new TextCapture(['f', 'sqref']);
+    let dxf;
+    const closeExtensionRule = () => {
+        if (extRule === undefined)
+            return;
+        const { draft: ruleDraft, id } = extRule;
+        extRule = undefined;
+        extCfvo = undefined;
+        if (id !== undefined && linkedIds.has(id)) {
+            extById.set(id, { bar: ruleDraft.bar, cfvo: ruleDraft.cfvo });
+            return;
+        }
+        if (ruleDraft.dxf !== undefined)
+            ruleDraft.dxfId = String(adoptDifferentialStyle(ruleDraft.dxf));
+        const rule = finalizeRule(ruleDraft);
+        if (rule !== undefined)
+            extRules?.push(rule);
+    };
+    const openExtension = (ln, attrs, selfClosing) => {
+        if (ln === 'id' && draft !== undefined) {
+            x14IdCapture.open(ln, selfClosing);
+        }
+        else if (ln === 'conditionalFormatting') {
+            extRules = [];
+            extSqref = '';
+        }
+        else if (ln === 'cfRule') {
+            extRule = { draft: newDraft(attrs), id: attrs.id };
+            if (selfClosing)
+                closeExtensionRule();
+        }
+        else if (extRule === undefined) {
+            if (extRules !== undefined && ln === 'sqref')
+                extCapture.open(ln, selfClosing);
+        }
+        else {
+            readExtensionRuleChild(extRule.draft, ln, attrs, selfClosing);
+        }
+    };
+    const readExtensionRuleChild = (rule, ln, attrs, selfClosing) => {
+        switch (ln) {
+            case 'dataBar':
+                readDataBarAttrs(rule, attrs);
+                break;
+            case 'iconSet':
+                readIconSetAttrs(rule, attrs);
+                break;
+            case 'cfvo':
+                extCfvo = parseCfvo(attrs, definedNames);
+                rule.cfvo.push(extCfvo);
+                if (selfClosing)
+                    extCfvo = undefined;
+                break;
+            case 'f':
+                extCapture.open(ln, selfClosing);
+                break;
+            case 'color':
+                rule.colors.push(parseColor(attrs));
+                break;
+            case 'fillColor':
+                rule.color = parseColor(attrs);
+                break;
+            case 'borderColor':
+            case 'negativeFillColor':
+            case 'negativeBorderColor':
+            case 'axisColor':
+                rule.bar[ln] = parseColor(attrs);
+                break;
+            case 'cfIcon': {
+                const icon = parseCfIcon(attrs);
+                if (icon === undefined)
+                    rule.icons = undefined;
+                else
+                    rule.icons?.push(icon);
+                break;
+            }
+            case 'dxf':
+                if (selfClosing)
+                    rule.dxf = '<dxf/>';
+                else
+                    dxf = new DxfCapture();
+                break;
+        }
+    };
+    const closeExtension = (ln) => {
+        const id = x14IdCapture.close(ln);
+        if (id !== undefined) {
+            if (draft !== undefined)
+                draft.x14Id = id;
+            return;
+        }
+        const text = extCapture.close(ln);
+        if (text !== undefined) {
+            if (ln === 'sqref')
+                extSqref = text;
+            else if (extCfvo !== undefined)
+                extCfvo.value = anchorValue(extCfvo.type, text, definedNames);
+            else
+                extRule?.draft.formulae.push(coerceNumericLiteral(unmangleFunctions(text, definedNames)));
+        }
+        else if (ln === 'cfvo') {
+            extCfvo = undefined;
+        }
+        else if (ln === 'cfRule') {
+            closeExtensionRule();
+        }
+        else if (ln === 'conditionalFormatting' && extRules !== undefined) {
+            if (extRules.length > 0)
+                blocks.push({ ref: extSqref, rules: extRules, extended: true });
+            extRules = undefined;
+        }
+    };
     const handlers = {
         onOpen(name, attrs, selfClosing, scope) {
+            if (dxf !== undefined) {
+                dxf.open(name, attrs, selfClosing, scope);
+                return;
+            }
             const ln = localName(name);
             if (isExtensionElement(scope, name)) {
-                if (ln === 'id' && draft !== undefined) {
-                    x14IdCapture.open(ln, selfClosing);
-                }
-                else if (ln === 'cfRule') {
-                    x14Ext = attrs.type === 'dataBar' && attrs.id !== undefined ? emptyExt() : undefined;
-                    x14ExtId = attrs.id;
-                }
-                else if (x14Ext !== undefined && ln === 'dataBar') {
-                    x14Ext.gradient = boolPresent(attrs.gradient);
-                }
-                else if (x14Ext !== undefined && ln === 'negativeFillColor') {
-                    x14Ext.negativeFillColor = parseColor(attrs);
-                }
-                else if (x14Ext !== undefined && ln === 'axisColor') {
-                    x14Ext.axisColor = parseColor(attrs);
-                }
+                openExtension(ln, attrs, selfClosing);
                 return;
             }
             if (ln === 'conditionalFormatting') {
@@ -217,10 +465,12 @@ export function conditionalFormattingPass() {
                 (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet')) {
                 scale = ln;
                 if (ln === 'iconSet')
-                    draft.iconSet = enumToken(attrs.iconSet, isIconSetType);
+                    readIconSetAttrs(draft, attrs);
+                else if (ln === 'dataBar')
+                    readDataBarAttrs(draft, attrs);
             }
             else if (draft !== undefined && ln === 'cfvo') {
-                draft.cfvo.push(parseCfvo(attrs));
+                draft.cfvo.push(parseCfvo(attrs, definedNames));
             }
             else if (draft !== undefined && ln === 'color') {
                 const color = parseColor(attrs);
@@ -236,26 +486,27 @@ export function conditionalFormattingPass() {
         onText(chunk) {
             formulaCapture.text(chunk);
             x14IdCapture.text(chunk);
+            extCapture.text(chunk);
         },
         onClose(name, scope) {
+            if (dxf !== undefined) {
+                if (dxf.close(name)) {
+                    if (extRule !== undefined)
+                        extRule.draft.dxf = dxf.fragment;
+                    dxf = undefined;
+                }
+                return;
+            }
             const ln = localName(name);
             if (isExtensionElement(scope, name)) {
-                const id = x14IdCapture.close(ln);
-                if (id !== undefined) {
-                    if (draft !== undefined)
-                        draft.x14Id = id;
-                }
-                else if (ln === 'cfRule' && x14Ext !== undefined && x14ExtId !== undefined) {
-                    extById.set(x14ExtId, x14Ext);
-                    x14Ext = undefined;
-                    x14ExtId = undefined;
-                }
+                closeExtension(ln);
                 return;
             }
             const formula = formulaCapture.close(ln);
             if (formula !== undefined) {
-                if (draft !== undefined)
-                    draft.formulae.push(coerceNumericLiteral(formula));
+                if (draft !== undefined) {
+                    draft.formulae.push(coerceNumericLiteral(unmangleFunctions(formula, definedNames)));
+                }
             }
             else if (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet') {
                 scale = undefined;
@@ -265,8 +516,10 @@ export function conditionalFormattingPass() {
                 if (rule !== undefined) {
                     if (block !== undefined)
                         block.rules.push(rule);
-                    if (draft.x14Id !== undefined)
+                    if (draft.x14Id !== undefined) {
                         linked.push({ rule, id: draft.x14Id });
+                        linkedIds.add(draft.x14Id);
+                    }
                 }
                 draft = undefined;
             }
@@ -281,47 +534,77 @@ export function conditionalFormattingPass() {
             const ext = extById.get(id);
             if (ext === undefined)
                 continue;
-            if (ext.gradient !== undefined)
-                rule.gradient = ext.gradient;
-            if (ext.negativeFillColor !== undefined)
-                rule.negativeFillColor = ext.negativeFillColor;
-            if (ext.axisColor !== undefined)
-                rule.axisColor = ext.axisColor;
+            Object.assign(rule, ext.bar);
+            if (ext.cfvo.length > 0)
+                rule.cfvo = [...ext.cfvo];
         }
         return blocks;
     };
     return { handlers, result };
 }
-function emptyExt() {
-    return { gradient: undefined, negativeFillColor: undefined, axisColor: undefined };
-}
-export function parseDxfs(stylesXml) {
-    const { fragments } = elementSubtrees(stylesXml, new Map([['dxfs', 'dxf']]));
-    return [...(fragments.get('dxfs') ?? [])];
+export function applyConditionalFormattings(sheet, blocks) {
+    for (const block of blocks) {
+        if (decodeSqrefRects(block.ref).length === 0)
+            continue;
+        admitting(() => {
+            sheet.addConditionalFormatting(block);
+        });
+    }
 }
 function newDraft(attrs) {
     return {
         type: enumToken(attrs.type, isConditionalFormattingType),
-        priority: numFinite(attrs.priority),
+        priority: numInteger(attrs.priority),
         stopIfTrue: boolStrict(attrs.stopIfTrue),
         operator: enumToken(attrs.operator, isConditionalFormattingOperator),
         text: attrs.text,
         timePeriod: enumToken(attrs.timePeriod, isCfTimePeriod),
-        rank: numFinite(attrs.rank),
-        stdDev: numFinite(attrs.stdDev),
+        rank: numInteger(attrs.rank, 0),
+        stdDev: numInteger(attrs.stdDev),
         percent: boolStrict(attrs.percent),
         bottom: boolStrict(attrs.bottom),
-        aboveAverage: attrs.aboveAverage === undefined ? undefined : boolPresent(attrs.aboveAverage),
+        aboveAverage: boolTristate(attrs.aboveAverage),
         equalAverage: boolStrict(attrs.equalAverage),
         dxfId: parseIndexAttr(attrs.dxfId),
         iconSet: undefined,
+        icons: [],
+        reverse: false,
+        showValue: undefined,
         formulae: [],
         cfvo: [],
         colors: [],
         color: undefined,
+        bar: {},
         x14Id: undefined,
+        dxf: undefined,
     };
 }
+function readIconSetAttrs(draft, attrs) {
+    draft.iconSet = enumToken(attrs.iconSet, isIconSetType);
+    draft.showValue = boolTristate(attrs.showValue);
+    draft.reverse = boolStrict(attrs.reverse);
+}
+function readDataBarAttrs(draft, attrs) {
+    const { bar } = draft;
+    draft.showValue = boolTristate(attrs.showValue);
+    setDefined(bar, 'minLength', numInteger(attrs.minLength, 0));
+    setDefined(bar, 'maxLength', numInteger(attrs.maxLength, 0));
+    setDefined(bar, 'border', boolTristate(attrs.border));
+    setDefined(bar, 'gradient', boolTristate(attrs.gradient));
+    setDefined(bar, 'direction', enumToken(attrs.direction, isDataBarDirection));
+    setDefined(bar, 'negativeBarColorSameAsPositive', boolTristate(attrs.negativeBarColorSameAsPositive));
+    setDefined(bar, 'negativeBarBorderColorSameAsPositive', boolTristate(attrs.negativeBarBorderColorSameAsPositive));
+    setDefined(bar, 'axisPosition', enumToken(attrs.axisPosition, isDataBarAxisPosition));
+}
+function setDefined(bar, key, value) {
+    if (value !== undefined)
+        bar[key] = value;
+}
+function parseCfIcon(attrs) {
+    const iconSet = enumToken(attrs.iconSet, isCfIconSetType);
+    const iconId = numInteger(attrs.iconId, 0);
+    return iconSet === undefined || iconId === undefined ? undefined : { iconSet, iconId };
+}
 function dxfIndex(value) {
     return numInteger(value, 0);
 }
@@ -358,6 +641,12 @@ function finalizeRule(draft) {
         rule.dxfId = draft.dxfId;
     if (draft.iconSet !== undefined)
         rule.iconSet = draft.iconSet;
+    if (draft.icons !== undefined && draft.icons.length > 0)
+        rule.icons = draft.icons;
+    if (draft.reverse)
+        rule.reverse = true;
+    if (draft.showValue === false)
+        rule.showValue = false;
     if (draft.formulae.length > 0)
         rule.formulae = draft.formulae;
     if (draft.cfvo.length > 0)
@@ -366,14 +655,20 @@ function finalizeRule(draft) {
         rule.colors = draft.colors;
     if (draft.color !== undefined)
         rule.color = draft.color;
+    if (draft.type === 'dataBar')
+        Object.assign(rule, draft.bar);
     return rule;
 }
-function parseCfvo(attrs) {
+function parseCfvo(attrs, definedNames) {
     const raw = attrs.type;
     const type = raw !== undefined && isCfValueObjectType(raw) ? raw : 'num';
     const cfvo = { type };
-    if (attrs.val !== undefined) {
-        cfvo.value = type === 'formula' ? attrs.val : coerceNumericLiteral(attrs.val);
-    }
+    if (attrs.val !== undefined)
+        cfvo.value = anchorValue(type, attrs.val, definedNames);
+    if (boolTristate(attrs.gte) === false)
+        cfvo.gte = false;
     return cfvo;
 }
+function anchorValue(type, text, definedNames) {
+    return type === 'formula' ? unmangleFunctions(text, definedNames) : coerceNumericLiteral(text);
+}