@shbernal/ts-xlsx 1.3.1 → 2.1.0

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

@@ -1,5 +1,6 @@
-import { boolAttr, escapeAttr, escapeText, stripFormulaEquals } from '../../xml/xml.js';
-import { boolStrict, coerceNumericLiteral, localName, parseXml } from '../../xml/xml-read.js';
+import { isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isIconSetType, isCfTimePeriod, } from '../../core/conditional-formatting.js';
+import { boolPresent, boolStrict, coerceNumericLiteral, enumToken, localName, numFinite, numInteger, parseXml, TextCapture, } from '../../xml/xml-read.js';
+import { boolAttr, checkedToken, escapeAttr, escapeText, numberText, stripFormulaEquals, textAttr, } from '../../xml/xml.js';
 import { colorAttrs, parseColor } from './color-xml.js';
 import { CF_EXT_URI, DATABAR_LINK_EXT_URI, XM_NS } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
@@ -61,7 +62,7 @@ function x14DataBarXml(ref, rule, guid) {
         `</x14:cfRule><xm:sqref>${escapeText(ref)}</xm:sqref></x14:conditionalFormatting>`);
 }
 function x14CfvoXml(cfvo) {
-    const type = escapeAttr(cfvo.type);
+    const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
     if (cfvo.value === undefined)
         return `<x14:cfvo type="${type}"/>`;
     return `<x14:cfvo type="${type}"><xm:f>${escapeText(String(cfvo.value))}</xm:f></x14:cfvo>`;
@@ -71,12 +72,16 @@ function cfRuleExtLinkXml(guid) {
 }
 function blockXml(cf, styles, priority, extLinks) {
     const rules = cf.rules.map((rule) => ruleXml(rule, styles, priority, extLinks)).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="${escapeAttr(rule.type)}"`];
+    const attrs = [
+        `type="${checkedToken(rule.type, isConditionalFormattingType, 'conditional formatting type')}"`,
+    ];
     const dxfId = resolveDxfId(rule, styles);
     if (dxfId !== undefined)
         attrs.push(`dxfId="${dxfId}"`);
@@ -91,16 +96,18 @@ function ruleXml(rule, styles, priority, extLinks) {
         attrs.push('bottom="1"');
     if (rule.percent)
         attrs.push('percent="1"');
-    if (rule.operator !== undefined)
-        attrs.push(`operator="${escapeAttr(rule.operator)}"`);
+    if (rule.operator !== undefined) {
+        attrs.push(`operator="${checkedToken(rule.operator, isConditionalFormattingOperator, 'conditional formatting operator')}"`);
+    }
     if (rule.text !== undefined)
         attrs.push(`text="${escapeAttr(rule.text)}"`);
-    if (rule.timePeriod !== undefined)
-        attrs.push(`timePeriod="${escapeAttr(rule.timePeriod)}"`);
+    if (rule.timePeriod !== undefined) {
+        attrs.push(`timePeriod="${checkedToken(rule.timePeriod, isCfTimePeriod, 'time period')}"`);
+    }
     if (rule.rank !== undefined)
-        attrs.push(`rank="${rule.rank}"`);
+        attrs.push(`rank="${numberText(rule.rank)}"`);
     if (rule.stdDev !== undefined)
-        attrs.push(`stdDev="${rule.stdDev}"`);
+        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)
@@ -112,8 +119,9 @@ function ruleXml(rule, styles, priority, extLinks) {
 function resolveDxfId(rule, styles) {
     if (SCALE_TYPES.has(rule.type))
         return undefined;
-    if (rule.dxfId !== undefined)
-        return Number(rule.dxfId);
+    const preserved = dxfIndex(rule.dxfId);
+    if (preserved !== undefined)
+        return preserved;
     if (rule.style !== undefined)
         return styles.differentialStyleId(rule.style);
     return undefined;
@@ -142,41 +150,41 @@ function colorScaleXml(rule) {
     return `<colorScale>${anchors}${colors}</colorScale>`;
 }
 function iconSetXml(rule) {
-    const name = rule.iconSet !== undefined ? ` iconSet="${escapeAttr(rule.iconSet)}"` : '';
+    const name = rule.iconSet === undefined
+        ? ''
+        : ` iconSet="${checkedToken(rule.iconSet, isIconSetType, 'icon set')}"`;
     const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
     return `<iconSet${name}>${anchors}</iconSet>`;
 }
 function cfvoXml(cfvo) {
-    const val = cfvo.value !== undefined ? ` val="${escapeAttr(String(cfvo.value))}"` : '';
-    return `<cfvo type="${escapeAttr(cfvo.type)}"${val}/>`;
+    const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
+    const val = cfvo.value === undefined ? '' : textAttr('val', String(cfvo.value));
+    return `<cfvo type="${type}"${val}/>`;
 }
 export function parseConditionalFormattings(xml) {
     const blocks = [];
     let block;
     let draft;
     let scale;
-    let capturingFormula = false;
-    let formulaText = '';
+    const formulaCapture = new TextCapture('formula');
     const linked = [];
     const extById = new Map();
     let x14Ext;
     let x14ExtId;
-    let capturingX14Id = false;
-    let x14IdText = '';
+    const x14IdCapture = new TextCapture('id');
     parseXml(xml, {
         onOpen(name, attrs, selfClosing) {
             const ln = localName(name);
             if (name.includes(':')) {
                 if (ln === 'id' && draft !== undefined) {
-                    capturingX14Id = true;
-                    x14IdText = '';
+                    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 = attrs.gradient !== '0';
+                    x14Ext.gradient = boolPresent(attrs.gradient);
                 }
                 else if (x14Ext !== undefined && ln === 'negativeFillColor') {
                     x14Ext.negativeFillColor = parseColor(attrs);
@@ -191,7 +199,9 @@ export function parseConditionalFormattings(xml) {
             }
             else if (ln === 'cfRule' && block !== undefined) {
                 if (selfClosing) {
-                    block.rules.push(finalizeRule(newDraft(attrs)));
+                    const rule = finalizeRule(newDraft(attrs));
+                    if (rule !== undefined)
+                        block.rules.push(rule);
                 }
                 else {
                     draft = newDraft(attrs);
@@ -201,8 +211,8 @@ export function parseConditionalFormattings(xml) {
             else if (draft !== undefined &&
                 (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet')) {
                 scale = ln;
-                if (ln === 'iconSet' && attrs.iconSet !== undefined)
-                    draft.iconSet = attrs.iconSet;
+                if (ln === 'iconSet')
+                    draft.iconSet = enumToken(attrs.iconSet, isIconSetType);
             }
             else if (draft !== undefined && ln === 'cfvo') {
                 draft.cfvo.push(parseCfvo(attrs));
@@ -215,23 +225,20 @@ export function parseConditionalFormattings(xml) {
                     draft.colors.push(color);
             }
             else if (draft !== undefined && ln === 'formula') {
-                capturingFormula = true;
-                formulaText = '';
+                formulaCapture.open(ln, selfClosing);
             }
         },
         onText(chunk) {
-            if (capturingFormula)
-                formulaText += chunk;
-            if (capturingX14Id)
-                x14IdText += chunk;
+            formulaCapture.text(chunk);
+            x14IdCapture.text(chunk);
         },
         onClose(name) {
             const ln = localName(name);
             if (name.includes(':')) {
-                if (ln === 'id' && capturingX14Id) {
+                const id = x14IdCapture.close(ln);
+                if (id !== undefined) {
                     if (draft !== undefined)
-                        draft.x14Id = x14IdText;
-                    capturingX14Id = false;
+                        draft.x14Id = id;
                 }
                 else if (ln === 'cfRule' && x14Ext !== undefined && x14ExtId !== undefined) {
                     extById.set(x14ExtId, x14Ext);
@@ -240,20 +247,22 @@ export function parseConditionalFormattings(xml) {
                 }
                 return;
             }
-            if (ln === 'formula' && capturingFormula) {
+            const formula = formulaCapture.close(ln);
+            if (formula !== undefined) {
                 if (draft !== undefined)
-                    draft.formulae.push(coerceNumericLiteral(formulaText));
-                capturingFormula = false;
+                    draft.formulae.push(coerceNumericLiteral(formula));
             }
             else if (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet') {
                 scale = undefined;
             }
             else if (ln === 'cfRule' && draft !== undefined) {
                 const rule = finalizeRule(draft);
-                if (block !== undefined)
-                    block.rules.push(rule);
-                if (draft.x14Id !== undefined)
-                    linked.push({ rule, id: draft.x14Id });
+                if (rule !== undefined) {
+                    if (block !== undefined)
+                        block.rules.push(rule);
+                    if (draft.x14Id !== undefined)
+                        linked.push({ rule, id: draft.x14Id });
+                }
                 draft = undefined;
             }
             else if (ln === 'conditionalFormatting' && block !== undefined) {
@@ -287,17 +296,17 @@ export function parseDxfs(stylesXml) {
 }
 function newDraft(attrs) {
     return {
-        type: attrs.type ?? '',
-        priority: parseFiniteAttr(attrs.priority),
+        type: enumToken(attrs.type, isConditionalFormattingType),
+        priority: numFinite(attrs.priority),
         stopIfTrue: boolStrict(attrs.stopIfTrue),
-        operator: attrs.operator,
+        operator: enumToken(attrs.operator, isConditionalFormattingOperator),
         text: attrs.text,
-        timePeriod: attrs.timePeriod,
-        rank: parseFiniteAttr(attrs.rank),
-        stdDev: parseFiniteAttr(attrs.stdDev),
+        timePeriod: enumToken(attrs.timePeriod, isCfTimePeriod),
+        rank: numFinite(attrs.rank),
+        stdDev: numFinite(attrs.stdDev),
         percent: boolStrict(attrs.percent),
         bottom: boolStrict(attrs.bottom),
-        aboveAverage: attrs.aboveAverage === undefined ? undefined : attrs.aboveAverage !== '0',
+        aboveAverage: attrs.aboveAverage === undefined ? undefined : boolPresent(attrs.aboveAverage),
         equalAverage: boolStrict(attrs.equalAverage),
         dxfId: parseIndexAttr(attrs.dxfId),
         iconSet: undefined,
@@ -308,19 +317,15 @@ function newDraft(attrs) {
         x14Id: undefined,
     };
 }
-function parseFiniteAttr(value) {
-    if (value === undefined)
-        return undefined;
-    const n = Number(value);
-    return Number.isFinite(n) ? n : undefined;
+function dxfIndex(value) {
+    return numInteger(value, 0);
 }
 function parseIndexAttr(value) {
-    if (value === undefined)
-        return undefined;
-    const n = Number(value);
-    return Number.isInteger(n) && n >= 0 ? value : undefined;
+    return dxfIndex(value) === undefined ? undefined : value;
 }
 function finalizeRule(draft) {
+    if (draft.type === undefined)
+        return undefined;
     const rule = { type: draft.type };
     if (draft.priority !== undefined)
         rule.priority = draft.priority;
@@ -359,7 +364,8 @@ function finalizeRule(draft) {
     return rule;
 }
 function parseCfvo(attrs) {
-    const type = (attrs.type ?? 'num');
+    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);

package/dist/io/xlsx/data-validation.d.ts

@@ -1,12 +1,12 @@
-import type { DataValidationEntry } from '../../core/data-validation.ts';
+import { type DataValidationEntry } from '../../core/data-validation.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 /** The standard `<dataValidations>` element for the rules stored in the legacy form, or '' when the
- * sheet has none of them — so a sheet with only extended (or no) validations stays byte-clean here.
+ * sheet has none of them, so a sheet with only extended (or no) validations stays byte-clean here.
  * The extended rules are emitted separately by {@link dataValidationsExtXml}. */
 export declare function dataValidationsXml(entries: readonly DataValidationEntry[]): string;
 /** The `<ext>` carrying the extended (`<x14:dataValidation>`) rules, or '' when the sheet declares
  * none. Emitted bare (no `<extLst>` wrapper) so the worksheet serialiser can gather it into a single
- * `<extLst>` beside the conditional-formatting extension — a worksheet may carry at most one. */
+ * `<extLst>` beside the conditional-formatting extension: a worksheet may carry at most one. */
 export declare function dataValidationsExtXml(entries: readonly DataValidationEntry[]): string;
 /** Parse every standard `<dataValidation>` out of a worksheet part into range-bound rules. */
 export declare function parseDataValidations(xml: string): DataValidationEntry[];

package/dist/io/xlsx/data-validation.js

@@ -1,5 +1,7 @@
-import { escapeAttr, escapeText, stripFormulaEquals } from '../../xml/xml.js';
-import { boolStrict, coerceNumericLiteral, localName, parseXml } from '../../xml/xml-read.js';
+import { isDataValidationErrorStyle, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { decodeSqrefRects } from '../../core/merge.js';
+import { boolStrict, coerceNumericLiteral, localName, parseXml, TextCapture, } from '../../xml/xml-read.js';
+import { checkedToken, escapeAttr, escapeText, stripFormulaEquals, textAttr } from '../../xml/xml.js';
 import { DATA_VALIDATION_EXT_URI, XM_NS } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
 const TYPED = new Set(['whole', 'decimal', 'date', 'time', 'textLength']);
@@ -18,16 +20,20 @@ export function dataValidationsExtXml(entries) {
     return x14Ext(DATA_VALIDATION_EXT_URI, `<x14:dataValidations count="${extended.length}" xmlns:xm="${XM_NS}">${items}</x14:dataValidations>`);
 }
 function ruleAttrs(rule) {
-    return (` type="${rule.type}"` +
-        (rule.errorStyle !== undefined ? ` errorStyle="${rule.errorStyle}"` : '') +
-        (rule.operator !== undefined ? ` operator="${rule.operator}"` : '') +
+    return (` type="${checkedToken(rule.type, isDataValidationType, 'data validation type')}"` +
+        (rule.errorStyle === undefined
+            ? ''
+            : ` errorStyle="${checkedToken(rule.errorStyle, isDataValidationErrorStyle, 'data validation error style')}"`) +
+        (rule.operator === undefined
+            ? ''
+            : ` operator="${checkedToken(rule.operator, isDataValidationOperator, 'data validation operator')}"`) +
         (rule.allowBlank ? ' allowBlank="1"' : '') +
         (rule.showInputMessage ? ' showInputMessage="1"' : '') +
         (rule.showErrorMessage ? ' showErrorMessage="1"' : '') +
-        (rule.errorTitle !== undefined ? ` errorTitle="${escapeAttr(rule.errorTitle)}"` : '') +
-        (rule.error !== undefined ? ` error="${escapeAttr(rule.error)}"` : '') +
-        (rule.promptTitle !== undefined ? ` promptTitle="${escapeAttr(rule.promptTitle)}"` : '') +
-        (rule.prompt !== undefined ? ` prompt="${escapeAttr(rule.prompt)}"` : ''));
+        textAttr('errorTitle', rule.errorTitle) +
+        textAttr('error', rule.error) +
+        textAttr('promptTitle', rule.promptTitle) +
+        textAttr('prompt', rule.prompt));
 }
 function dataValidationXml(sqref, rule) {
     const [f1, f2] = operands(rule);
@@ -100,11 +106,12 @@ function buildEntry(attrs, formulae) {
 }
 function buildRule(attrs, formulae) {
     const { type } = attrs;
-    if (type === undefined)
+    if (type === undefined || !isDataValidationType(type))
         return undefined;
-    const rule = { type: type };
+    const rule = { type };
     if (attrs.operator !== undefined) {
-        rule.operator = attrs.operator;
+        if (isDataValidationOperator(attrs.operator))
+            rule.operator = attrs.operator;
     }
     else if (TYPED.has(type)) {
         rule.operator = 'between';
@@ -115,7 +122,7 @@ function buildRule(attrs, formulae) {
         rule.showInputMessage = true;
     if (boolStrict(attrs.showErrorMessage))
         rule.showErrorMessage = true;
-    if (attrs.errorStyle !== undefined)
+    if (attrs.errorStyle !== undefined && isDataValidationErrorStyle(attrs.errorStyle))
         rule.errorStyle = attrs.errorStyle;
     if (attrs.error !== undefined)
         rule.error = attrs.error;
@@ -136,10 +143,9 @@ export function parseExtendedDataValidations(xml) {
     const entries = [];
     let current;
     let slot;
-    let capture;
-    let text = '';
+    const capture = new TextCapture(['f', 'sqref']);
     parseXml(xml, {
-        onOpen(name, attrs) {
+        onOpen(name, attrs, selfClosing) {
             const ln = localName(name);
             const prefixed = name.includes(':');
             if (ln === 'dataValidation' && prefixed) {
@@ -151,30 +157,24 @@ export function parseExtendedDataValidations(xml) {
             else if (current !== undefined && prefixed && ln === 'formula2') {
                 slot = 1;
             }
-            else if (current !== undefined && ln === 'f') {
-                capture = 'formula';
-                text = '';
-            }
-            else if (current !== undefined && ln === 'sqref') {
-                capture = 'sqref';
-                text = '';
+            else if (current !== undefined) {
+                capture.open(ln, selfClosing);
             }
         },
         onText(chunk) {
-            if (capture !== undefined)
-                text += chunk;
+            capture.text(chunk);
         },
         onClose(name) {
             const ln = localName(name);
-            if (ln === 'f' && capture === 'formula') {
-                if (current !== undefined && slot !== undefined)
-                    current.formulae[slot] = text;
-                capture = undefined;
-            }
-            else if (ln === 'sqref' && capture === 'sqref') {
-                if (current !== undefined)
+            const text = capture.close(ln);
+            if (text !== undefined) {
+                if (ln === 'f') {
+                    if (current !== undefined && slot !== undefined)
+                        current.formulae[slot] = text;
+                }
+                else if (current !== undefined) {
                     current.sqref = text;
-                capture = undefined;
+                }
             }
             else if ((ln === 'formula1' || ln === 'formula2') && name.includes(':')) {
                 slot = undefined;
@@ -197,6 +197,8 @@ function buildExtendedEntry(attrs, formulae, sqref) {
 }
 export function applyDataValidations(sheet, entries) {
     for (const { sqref, rule, extended } of entries) {
+        if (decodeSqrefRects(sqref).length === 0)
+            continue;
         sheet.addDataValidation(sqref, rule, extended ? { extended: true } : {});
     }
 }

package/dist/io/xlsx/errors.d.ts

@@ -1,14 +1,14 @@
 import { XlsxError } from '../../errors.ts';
 /**
  * Thrown when an `.xlsx` package's XML content is well-formed but does not describe a workbook this
- * library can act on — a `xl/workbook.xml` that declares no worksheets, say.
+ * library can act on: a `xl/workbook.xml` that declares no worksheets, say.
  *
  * It sits between two neighbours. {@link XmlParseError} reports that the *markup* did not parse;
  * {@link UnsupportedFormatError} reports that the *container* is not one we read at all. This one
  * fires when both of those were fine and the document itself is nonetheless not a workbook.
  *
- * The reader is deliberately lenient about content it does not recognise — an unknown element is
- * skipped, not fatal — so this is rare by design, and reaching it means something a workbook cannot
+ * The reader is deliberately lenient about content it does not recognise (an unknown element is
+ * skipped, not fatal) so this is rare by design, and reaching it means something a workbook cannot
  * do without being corrupt.
  */
 export declare class XlsxParseError extends XlsxError {

package/dist/io/xlsx/hyperlinks.d.ts

@@ -37,6 +37,8 @@ interface ParsedHyperlink {
 /** Parse every `<hyperlink>` element out of a worksheet part. */
 export declare function parseSheetHyperlinks(xml: string): ParsedHyperlink[];
 /** Fold parsed hyperlinks onto a sheet's cells, wrapping each cell's existing value (its visible
- * label) into a {@link HyperlinkValue}. `rels` maps a relationship id to its target URL. */
-export declare function applyHyperlinks(sheet: Worksheet, links: readonly ParsedHyperlink[], rels: Map<string, string>): void;
+ * label) into a {@link HyperlinkValue}. `targetOf` resolves a relationship id to its raw Target: a
+ * URL for the external links hyperlinks almost always are, so it must stay unresolved against the
+ * package rather than being handed over as a part path. */
+export declare function applyHyperlinks(sheet: Worksheet, links: readonly ParsedHyperlink[], targetOf: (relId: string) => string | undefined): void;
 export {};

package/dist/io/xlsx/hyperlinks.js

@@ -1,7 +1,7 @@
-import { decodeRange } from '../../core/address.js';
+import { tryDecodeRange } from '../../core/address.js';
 import { isHyperlinkValue, isRichTextValue } from '../../core/value.js';
-import { escapeAttr } from '../../xml/xml.js';
 import { localName, parseXml } from '../../xml/xml-read.js';
+import { escapeAttr, textAttr } from '../../xml/xml.js';
 export function collectHyperlinks(sheet) {
     const links = [];
     for (const { cells } of sheet.rows()) {
@@ -33,8 +33,8 @@ export function hyperlinksXml(links) {
     const items = links
         .map((link) => {
         const rid = link.relId !== undefined ? ` r:id="${link.relId}"` : '';
-        const location = link.location !== undefined ? ` location="${escapeAttr(link.location)}"` : '';
-        const tooltip = link.tooltip !== undefined ? ` tooltip="${escapeAttr(link.tooltip)}"` : '';
+        const location = textAttr('location', link.location);
+        const tooltip = textAttr('tooltip', link.tooltip);
         return `<hyperlink ref="${escapeAttr(link.ref)}"${rid}${location}${tooltip}/>`;
     })
         .join('');
@@ -59,13 +59,13 @@ export function parseSheetHyperlinks(xml) {
     });
     return links;
 }
-export function applyHyperlinks(sheet, links, rels) {
+export function applyHyperlinks(sheet, links, targetOf) {
     for (const link of links) {
-        const target = resolveTarget(link, rels);
+        const target = resolveTarget(link, targetOf);
         if (target === undefined)
             continue;
-        const decoded = decodeRefSafe(link.ref);
-        if (decoded === undefined)
+        const decoded = tryDecodeRange(link.ref);
+        if (decoded === undefined || decoded.tl.col === undefined || decoded.tl.row === undefined)
             continue;
         const cell = sheet.getCell(decoded.tl.address);
         const cellValue = cell.value;
@@ -80,17 +80,9 @@ export function applyHyperlinks(sheet, links, rels) {
         cell.value = value;
     }
 }
-function decodeRefSafe(ref) {
-    try {
-        return decodeRange(ref);
-    }
-    catch {
-        return undefined;
-    }
-}
-function resolveTarget(link, rels) {
+function resolveTarget(link, targetOf) {
     if (link.rid !== undefined) {
-        const base = rels.get(link.rid);
+        const base = targetOf(link.rid);
         if (base === undefined)
             return undefined;
         return link.location !== undefined ? `${base}#${link.location}` : base;

package/dist/io/xlsx/images.d.ts

@@ -27,7 +27,7 @@ export interface ParsedImageAnchor {
  * Anchors that are not pictures (a chart, a shape) carry no `<a:blip r:embed>` and are skipped, so a
  * mixed drawing yields only its images. */
 export declare function parseDrawing(xml: string): ParsedImageAnchor[];
-/** Whether a drawing part holds anchor content beyond plain pictures — a chart, shape, connector, or
+/** Whether a drawing part holds anchor content beyond plain pictures: a chart, shape, connector, or
  * group. Excel packs every one of a sheet's anchors into a single drawing part, so a sheet with both a
  * picture and a chart yields a mixed drawing; modeling only its pictures and re-serialising from them
  * would drop the chart. The reader uses this to fall back to whole-drawing byte-preservation instead. */

package/dist/io/xlsx/images.js

@@ -1,6 +1,6 @@
-import { isOneCellAnchor, } from '../../core/image.js';
-import { XML_DECLARATION } from '../../xml/xml.js';
-import { localName, parseXml } from '../../xml/xml-read.js';
+import { isImageEditAs, isOneCellAnchor, } from '../../core/image.js';
+import { enumToken, localName, numFinite, parseXml, TextCapture } from '../../xml/xml-read.js';
+import { checkedToken, numAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
 import { RELATIONSHIPS_NS } from '../opc/namespaces.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { DRAWINGML_NS, XDR_NS } from './namespaces.js';
@@ -35,7 +35,7 @@ function anchorXml(image, id) {
         : twoCellAnchorXml(anchor.from, anchor.to, anchor.editAs ?? 'oneCell', anchor.rotation, image.embedId, id);
 }
 function twoCellAnchorXml(from, to, editAs, rotation, embedId, id) {
-    return (`<xdr:twoCellAnchor editAs="${editAs}">` +
+    return (`<xdr:twoCellAnchor editAs="${checkedToken(editAs, isImageEditAs, 'image anchor edit mode')}">` +
         `<xdr:from>${anchorPointXml(from)}</xdr:from>` +
         `<xdr:to>${anchorPointXml(to)}</xdr:to>` +
         picXml(embedId, id, rotation) +
@@ -45,13 +45,13 @@ function twoCellAnchorXml(from, to, editAs, rotation, embedId, id) {
 function oneCellAnchorXml(from, ext, rotation, embedId, id) {
     return ('<xdr:oneCellAnchor>' +
         `<xdr:from>${anchorPointXml(from)}</xdr:from>` +
-        `<xdr:ext cx="${ext.cx}" cy="${ext.cy}"/>` +
+        `<xdr:ext${numAttr('cx', ext.cx)}${numAttr('cy', ext.cy)}/>` +
         picXml(embedId, id, rotation) +
         '<xdr:clientData/>' +
         '</xdr:oneCellAnchor>');
 }
 function picXml(embedId, id, rotation) {
-    const xfrm = rotation !== undefined ? `<a:xfrm rot="${rotation}"/>` : '';
+    const xfrm = rotation !== undefined ? `<a:xfrm${numAttr('rot', rotation)}/>` : '';
     return ('<xdr:pic>' +
         `<xdr:nvPicPr><xdr:cNvPr id="${id}" name="Picture ${id}"/>` +
         '<xdr:cNvPicPr><a:picLocks noChangeAspect="1"/></xdr:cNvPicPr></xdr:nvPicPr>' +
@@ -61,8 +61,10 @@ function picXml(embedId, id, rotation) {
         '</xdr:pic>');
 }
 function anchorPointXml(point) {
-    return (`<xdr:col>${point.col}</xdr:col><xdr:colOff>${point.colOff ?? 0}</xdr:colOff>` +
-        `<xdr:row>${point.row}</xdr:row><xdr:rowOff>${point.rowOff ?? 0}</xdr:rowOff>`);
+    return (`<xdr:col>${numberText(point.col)}</xdr:col>` +
+        `<xdr:colOff>${numberText(point.colOff ?? 0)}</xdr:colOff>` +
+        `<xdr:row>${numberText(point.row)}</xdr:row>` +
+        `<xdr:rowOff>${numberText(point.rowOff ?? 0)}</xdr:rowOff>`);
 }
 export function drawingRelsXml(mediaTargets) {
     return relationshipsPart(mediaTargets.map((target, i) => relationship(`rId${i + 1}`, IMAGE_REL_TYPE, target)));
@@ -70,7 +72,6 @@ export function drawingRelsXml(mediaTargets) {
 function blankPoint() {
     return { col: 0, row: 0, colOff: 0, rowOff: 0 };
 }
-const EDIT_AS = new Set(['oneCell', 'twoCell', 'absolute']);
 export function parseDrawing(xml) {
     const anchors = [];
     let from = null;
@@ -81,10 +82,9 @@ export function parseDrawing(xml) {
     let embed;
     let target = null;
     let picDepth = 0;
-    let coord = '';
-    let text = '';
+    const coord = new TextCapture(COORDINATES);
     parseXml(xml, {
-        onOpen(name, attrs) {
+        onOpen(name, attrs, selfClosing) {
             const local = localName(name);
             if (local === 'twoCellAnchor' || local === 'oneCellAnchor') {
                 from = blankPoint();
@@ -92,15 +92,14 @@ export function parseDrawing(xml) {
                 ext = undefined;
                 rotation = undefined;
                 embed = undefined;
-                const mode = attrs.editAs;
-                editAs = mode !== undefined && EDIT_AS.has(mode) ? mode : undefined;
+                editAs = enumToken(attrs.editAs, isImageEditAs);
             }
             else if (local === 'pic') {
                 picDepth++;
             }
             else if (local === 'xfrm' && picDepth > 0) {
-                const rot = Number(attrs.rot);
-                if (Number.isFinite(rot) && rot !== 0)
+                const rot = numFinite(attrs.rot);
+                if (rot !== undefined && rot !== 0)
                     rotation = rot;
             }
             else if (local === 'from') {
@@ -110,9 +109,9 @@ export function parseDrawing(xml) {
                 target = to;
             }
             else if (local === 'ext' && picDepth === 0) {
-                const cx = Number(attrs.cx);
-                const cy = Number(attrs.cy);
-                if (Number.isFinite(cx) && Number.isFinite(cy))
+                const cx = numFinite(attrs.cx, 0);
+                const cy = numFinite(attrs.cy, 0);
+                if (cx !== undefined && cy !== undefined)
                     ext = { cx, cy };
             }
             else if (local === 'blip') {
@@ -120,22 +119,20 @@ export function parseDrawing(xml) {
                 if (value !== undefined)
                     embed = value;
             }
-            else if (target !== null && COORDINATES.has(local)) {
-                coord = local;
-                text = '';
+            else if (target !== null) {
+                coord.open(local, selfClosing);
             }
         },
         onText(chunk) {
-            if (coord !== '')
-                text += chunk;
+            coord.text(chunk);
         },
         onClose(name) {
             const local = localName(name);
-            if (target !== null && coord === local && COORDINATES.has(local)) {
-                const value = Number(text);
-                if (Number.isFinite(value))
+            const text = coord.close(local);
+            if (text !== undefined) {
+                const value = numFinite(text);
+                if (target !== null && value !== undefined)
                     setCoordinate(target, local, value);
-                coord = '';
             }
             else if (local === 'from' || local === 'to') {
                 target = null;