@shbernal/ts-xlsx 3.1.0 → 3.2.0

package/dist/io/xlsx/strict-parts.js

@@ -0,0 +1,171 @@
+import { XmlParseError } from '../../xml/errors.js';
+import { NamespaceScope } from '../../xml/xml-namespaces.js';
+import { tagRanges } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
+import { startTag } from '../../xml/xml.js';
+const STRICT = 'http://purl.oclc.org/ooxml/';
+const TRANSITIONAL = 'http://schemas.openxmlformats.org/';
+const NAMESPACES = new Map([
+    'drawingml/chart drawingml/2006/chart',
+    'drawingml/chartDrawing drawingml/2006/chartDrawing',
+    'drawingml/diagram drawingml/2006/diagram',
+    'drawingml/lockedCanvas drawingml/2006/lockedCanvas',
+    'drawingml/main drawingml/2006/main',
+    'drawingml/picture drawingml/2006/picture',
+    'drawingml/spreadsheetDrawing drawingml/2006/spreadsheetDrawing',
+    'drawingml/wordprocessingDrawing drawingml/2006/wordprocessingDrawing',
+    'officeDocument/bibliography officeDocument/2006/bibliography',
+    'officeDocument/characteristics officeDocument/2006/characteristics',
+    'officeDocument/customProperties officeDocument/2006/custom-properties',
+    'officeDocument/customXml officeDocument/2006/customXml',
+    'officeDocument/docPropsVTypes officeDocument/2006/docPropsVTypes',
+    'officeDocument/extendedProperties officeDocument/2006/extended-properties',
+    'officeDocument/math officeDocument/2006/math',
+    'officeDocument/relationships officeDocument/2006/relationships',
+    'officeDocument/sharedTypes officeDocument/2006/sharedTypes',
+    'presentationml/main presentationml/2006/main',
+    'schemaLibrary/main schemaLibrary/2006/main',
+    'spreadsheetml/main spreadsheetml/2006/main',
+    'wordprocessingml/main wordprocessingml/2006/main',
+].map((pair) => {
+    const [strict, transitional] = pair.split(' ');
+    return [`${STRICT}${strict}`, `${TRANSITIONAL}${transitional}`];
+}));
+const DRAWINGML = `${TRANSITIONAL}drawingml/2006/main`;
+const PERCENTAGES = new Map([
+    [
+        DRAWINGML,
+        percentageTable(1000, {
+            a: 'alphaRepl',
+            amt: 'alphaModFix tint',
+            b: 'fillRect fillToRect scrgbClr srcRect tileRect',
+            baseline: 'defRPr endParaRPr rPr',
+            bright: 'lum',
+            contrast: 'lum',
+            d: 'ds',
+            endA: 'reflection',
+            endPos: 'reflection',
+            fontScale: 'normAutofit',
+            g: 'scrgbClr',
+            l: 'fillRect fillToRect srcRect tileRect',
+            lim: 'miter',
+            lnSpcReduction: 'normAutofit',
+            lum: 'hsl hslClr',
+            pos: 'gs',
+            r: 'fillRect fillToRect scrgbClr srcRect tileRect',
+            sat: 'hsl hslClr',
+            sp: 'ds',
+            stA: 'reflection',
+            stPos: 'reflection',
+            sx: 'outerShdw reflection tile xfrm',
+            sy: 'outerShdw reflection tile xfrm',
+            t: 'fillRect fillToRect srcRect tileRect',
+            thresh: 'alphaBiLevel biLevel',
+            tx: 'relOff',
+            ty: 'relOff',
+            val: 'alpha alphaMod alphaOff blue blueMod blueOff green greenMod greenOff hueMod lum lumMod ' +
+                'lumOff red redMod redOff sat satMod satOff shade spcPct tint',
+            zoom: 'camera',
+        }),
+    ],
+    [
+        `${TRANSITIONAL}drawingml/2006/chart`,
+        percentageTable(1, {
+            val: 'bubbleScale depthPercent gapDepth gapWidth hPercent holeSize lblOffset overlap ' +
+                'secondPieSize thickness',
+        }),
+    ],
+    [
+        `${TRANSITIONAL}drawingml/2006/diagram`,
+        percentageTable(1000, Object.fromEntries([
+            'custLinFactNeighborX',
+            'custLinFactNeighborY',
+            'custLinFactX',
+            'custLinFactY',
+            'custRadScaleInc',
+            'custRadScaleRad',
+            'custScaleX',
+            'custScaleY',
+        ].map((attribute) => [attribute, 'prSet']))),
+    ],
+]);
+function percentageTable(scale, elementsByAttribute) {
+    const pairs = Object.entries(elementsByAttribute).flatMap(([attribute, elements]) => elements.split(' ').map((element) => `${element} ${attribute}`));
+    return { scale, pairs: new Set(pairs) };
+}
+const PERCENTAGE = /^-?[0-9]+(?:\.[0-9]+)?%$/;
+const STRICT_BYTES = new TextEncoder().encode(STRICT);
+export function transitionalPart(bytes, contentType) {
+    if (!isXmlContentType(contentType) || !includesBytes(bytes, STRICT_BYTES))
+        return bytes;
+    const source = new TextDecoder().decode(bytes);
+    let xml = '';
+    let copied = 0;
+    const scope = new NamespaceScope();
+    try {
+        for (const tag of tagRanges(source)) {
+            if (tag.close) {
+                scope.close();
+                continue;
+            }
+            scope.open(tag.attrs);
+            const translated = translatedAttributes(tag.name, tag.attrs, scope);
+            if (tag.selfClosing)
+                scope.close();
+            if (translated === undefined)
+                continue;
+            xml += source.slice(copied, tag.start) + startTag(tag.name, translated, tag.selfClosing);
+            copied = tag.end;
+        }
+    }
+    catch (error) {
+        if (error instanceof XmlParseError)
+            return bytes;
+        throw error;
+    }
+    return copied === 0 ? bytes : new TextEncoder().encode(xml + source.slice(copied));
+}
+function translatedAttributes(name, attrs, scope) {
+    let translated;
+    const set = (attribute, value) => {
+        translated ??= { ...attrs };
+        translated[attribute] = value;
+    };
+    const declared = scope.elementNamespace(name);
+    const namespace = (declared === undefined ? undefined : NAMESPACES.get(declared)) ?? declared;
+    const local = localName(name);
+    const percentages = PERCENTAGES.get(namespace ?? '');
+    for (const attribute in attrs) {
+        const value = attrs[attribute] ?? '';
+        if (attribute === 'xmlns' || attribute.startsWith('xmlns:')) {
+            const uri = NAMESPACES.get(value);
+            if (uri !== undefined)
+                set(attribute, uri);
+        }
+        else if (attribute === 'uri' && local === 'graphicData' && namespace === DRAWINGML) {
+            const uri = NAMESPACES.get(value);
+            if (uri !== undefined)
+                set(attribute, uri);
+        }
+        else if (percentages?.pairs.has(`${local} ${attribute}`) === true && PERCENTAGE.test(value)) {
+            set(attribute, String(Math.round(Number.parseFloat(value) * percentages.scale)));
+        }
+    }
+    return translated;
+}
+function isXmlContentType(contentType) {
+    const type = contentType.toLowerCase();
+    return type.endsWith('+xml') || type === 'application/xml' || type === 'text/xml';
+}
+function includesBytes(haystack, needle) {
+    const [first = 0] = needle;
+    const last = haystack.length - needle.length;
+    for (let i = haystack.indexOf(first); i !== -1 && i <= last; i = haystack.indexOf(first, i + 1)) {
+        let matched = 1;
+        while (matched < needle.length && haystack[i + matched] === needle[matched])
+            matched += 1;
+        if (matched === needle.length)
+            return true;
+    }
+    return false;
+}

package/dist/io/xlsx/style-elements.d.ts

@@ -34,10 +34,8 @@ export declare function cellStyleTag(entry: {
 }): string;
 export declare function alignmentAttrs(alignment: Alignment): string;
 export declare function protectionAttrs(protection: Protection): string;
-export declare function tableStyleName(fragment: string): string;
 export declare function dxfXml(style: DifferentialStyle): string;
 export declare function borderXml(border: Border): string;
-export declare function fillSignature(fill: Fill): string;
 export declare function patternFillXml(fill: Fill, { solidBgFallback }: {
     solidBgFallback: boolean;
 }): string;

package/dist/io/xlsx/style-elements.js

@@ -1,6 +1,5 @@
 import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, } from '../../core/style.js';
-import { decodeEntities } from '../../xml/xml-scan.js';
-import { checkedToken, escapeAttr, escapeFormatCode, numberText } from '../../xml/xml.js';
+import { checkedToken, escapeAttr, escapeFormatCode, nonDefaultNumAttr, numberText, } from '../../xml/xml.js';
 import { colorAttrs } from './color-xml.js';
 import { fontXml } from './font-xml.js';
 export const CUSTOM_NUMFMT_BASE = 164;
@@ -56,10 +55,9 @@ export function alignmentAttrs(alignment) {
                 break;
             }
             case 'number': {
-                const value = alignment[facet.key];
-                if (value === undefined || value === 0)
-                    break;
-                parts.push(`${facet.key}="${numberText(value)}"`);
+                const attr = nonDefaultNumAttr(facet.key, alignment[facet.key], 0);
+                if (attr !== '')
+                    parts.push(attr.trimStart());
                 break;
             }
             case 'flag':
@@ -78,9 +76,6 @@ export function protectionAttrs(protection) {
         parts.push('hidden="1"');
     return parts.join(' ');
 }
-export function tableStyleName(fragment) {
-    return decodeEntities(/<tableStyle\b[^>]*\bname="([^"]*)"/.exec(fragment)?.[1] ?? '');
-}
 export function dxfXml(style) {
     const parts = [];
     if (style.font !== undefined) {
@@ -99,19 +94,16 @@ export function dxfXml(style) {
 }
 function gradientFillXml(fill) {
     const attrs = (fill.gradient === 'path' ? ' type="path"' : '') +
-        (fill.degree ? ` degree="${numberText(fill.degree)}"` : '') +
-        insetAttr('left', fill.left) +
-        insetAttr('right', fill.right) +
-        insetAttr('top', fill.top) +
-        insetAttr('bottom', fill.bottom);
+        nonDefaultNumAttr('degree', fill.degree, 0) +
+        nonDefaultNumAttr('left', fill.left, 0) +
+        nonDefaultNumAttr('right', fill.right, 0) +
+        nonDefaultNumAttr('top', fill.top, 0) +
+        nonDefaultNumAttr('bottom', fill.bottom, 0);
     const stops = fill.stops
         .map((stop) => `<stop position="${numberText(stop.position)}"><color ${colorAttrs(stop.color)}/></stop>`)
         .join('');
     return `<gradientFill${attrs}>${stops}</gradientFill>`;
 }
-function insetAttr(name, value) {
-    return value ? ` ${name}="${numberText(value)}"` : '';
-}
 export function borderXml(border) {
     const attrs = (border.diagonalUp ? ' diagonalUp="1"' : '') + (border.diagonalDown ? ' diagonalDown="1"' : '');
     return (`<border${attrs}>` +
@@ -130,18 +122,6 @@ function edgeXml(tag, edge) {
         return `<${tag} style="${style}"/>`;
     return `<${tag} style="${style}"><color ${colorAttrs(edge.color)}/></${tag}>`;
 }
-export function fillSignature(fill) {
-    if (fill.type === 'gradient') {
-        const stops = fill.stops.map((s) => `${s.position}:${colorSignature(s.color)}`).join(',');
-        return `grad|${fill.gradient}|${fill.degree ?? ''}|${fill.left ?? ''}/${fill.right ?? ''}/${fill.top ?? ''}/${fill.bottom ?? ''}|${stops}`;
-    }
-    return `${fill.pattern}|${colorSignature(fill.fgColor)}|${colorSignature(fill.bgColor)}`;
-}
-function colorSignature(color) {
-    if (color === undefined)
-        return '';
-    return `${color.argb ?? ''}/${color.theme ?? ''}/${color.tint ?? ''}/${color.indexed ?? ''}`;
-}
 export function patternFillXml(fill, { solidBgFallback }) {
     if (fill.type === 'gradient')
         return `<fill>${gradientFillXml(fill)}</fill>`;

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

@@ -101,6 +101,11 @@ export declare class StyleRegistry {
      * keeps every preserved reference pointing where it did.
      */
     differentialStyleId(style: DifferentialStyle): number;
+    /**
+     * The `<dxf>` fragment at a differential-style index, or `undefined` past the end of the table: what
+     * a conditional format in the extension form writes inline, since that form names no `dxfId`.
+     */
+    differentialStyleFragment(id: number): string | undefined;
     /** Serialise the accumulated table into a complete, valid styles.xml part. */
     toXml(): string;
 }

package/dist/io/xlsx/styles.js

@@ -1,9 +1,9 @@
 import {} from '../../core/style.js';
 import { TABLE_STYLE_ELEMENT_TYPES } from '../../core/table-style.js';
-import { escapeAttr, escapeFormatCode, numAttr, XML_DECLARATION } from '../../xml/xml.js';
+import { escapeAttr, escapeFormatCode, nonDefaultNumAttr, XML_DECLARATION } from '../../xml/xml.js';
 import { fontXml } from './font-xml.js';
 import { MARKUP_COMPATIBILITY_NS, SPREADSHEETML_NS } from './namespaces.js';
-import { alignmentAttrs, borderXml, cellStyleTag, CUSTOM_NUMFMT_BASE, DEFAULT_BORDER, DEFAULT_FONT_BODY, DEFAULT_FORMAT, dxfXml, fillSignature, formatSignature, isDefaultFormat, patternFillXml, protectionAttrs, tableStyleName, xfXml, } from './style-elements.js';
+import { alignmentAttrs, borderXml, cellStyleTag, CUSTOM_NUMFMT_BASE, DEFAULT_BORDER, DEFAULT_FONT_BODY, DEFAULT_FORMAT, dxfXml, formatSignature, isDefaultFormat, patternFillXml, protectionAttrs, xfXml, } from './style-elements.js';
 const RESERVED_FILL_COUNT = 2;
 const RESERVED_FONT_COUNT = 1;
 const RESERVED_BORDER_COUNT = 1;
@@ -124,7 +124,7 @@ export class StyleRegistry {
             const element = style.elements[type];
             if (element === undefined)
                 return [];
-            const size = element.size === 1 ? '' : numAttr('size', element.size);
+            const size = nonDefaultNumAttr('size', element.size, 1);
             return [
                 `<tableStyleElement type="${type}"${size} dxfId="${this.differentialStyleId(element)}"/>`,
             ];
@@ -137,8 +137,12 @@ export class StyleRegistry {
         const fragment = dxfXml(style);
         return this.#dxfs.intern(fragment, fragment);
     }
+    differentialStyleFragment(id) {
+        return this.#dxfs.entries[id];
+    }
     #internFill(fill) {
-        return this.#fills.intern(fillSignature(fill), patternFillXml(fill, { solidBgFallback: true }));
+        const xml = patternFillXml(fill, { solidBgFallback: true });
+        return this.#fills.intern(xml, xml);
     }
     #internNumFmt(code) {
         return this.#numFmts.intern(code, code);
@@ -193,7 +197,9 @@ export class StyleRegistry {
     #tableStylesXml() {
         const { defaultTableStyle, defaultPivotStyle } = this.#tableStyles;
         const authored = this.#authoredTableStyles;
-        const preserved = this.#tableStyles.styles.filter((fragment) => !authored.has(tableStyleName(fragment)));
+        const preserved = this.#tableStyles.styles
+            .filter((style) => !authored.has(style.name))
+            .map((style) => style.xml);
         const styles = [...preserved, ...authored.values()];
         if (styles.length === 0 && defaultTableStyle === undefined && defaultPivotStyle === undefined) {
             return '';

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

@@ -1,9 +1,17 @@
 import { type Table, type TableOptions } from '../../core/table.ts';
-export declare function tableXml(table: Table, id: number): string;
+/**
+ * The table part. A column's calculated and totals formulas are stored with the function prefixes a
+ * cell formula takes, as Excel stores them; `formulaNames` is `formulaNamesInScope` for the table's
+ * sheet.
+ */
+export declare function tableXml(table: Table, id: number, formulaNames: ReadonlySet<string>): string;
 /**
  * Parse a `<table>` part into the options that reconstruct it, or `undefined` when the XML is not a
  * usable table (no name, no ref, or no columns: Excel treats such a part as corrupt, so we drop it
  * rather than fabricate a degenerate table). Duplicate column names are not resolved here, since the
  * {@link Table} constructor disambiguates them, so authoring and loading share one implementation.
+ *
+ * A column's formulas shed their function prefixes as a cell formula's do, against `definedNames`,
+ * the workbook's names as `definedNameKeys` spells them.
  */
-export declare function parseTable(xml: string): TableOptions | undefined;
+export declare function parseTable(xml: string, definedNames: ReadonlySet<string>): TableOptions | undefined;

package/dist/io/xlsx/tables.js

@@ -1,21 +1,23 @@
-import { encodeAddress, MAX_COLUMN, tryDecodeRange } from '../../core/address.js';
-import { isTotalsRowFunction, } from '../../core/table.js';
+import { encodeAddress, tryDecodeRange } from '../../core/address.js';
+import { mangleFormula, unmangleFunctions } from '../../core/formula.js';
+import { isTotalsRowFunction, TABLE_STYLE_FLAGS, } from '../../core/table.js';
 import { numInteger } from '../../xml/xml-attrs.js';
 import { parseXml, TextCapture } from '../../xml/xml-read.js';
-import { boolPresent, localName } from '../../xml/xml-scan.js';
+import { boolTristate, localName } from '../../xml/xml-scan.js';
 import { boolAttr, checkedToken, escapeAttr, escapeText, XML_DECLARATION } from '../../xml/xml.js';
 import { NS } from './relationships.js';
-export function tableXml(table, id) {
+export function tableXml(table, id, formulaNames) {
     const name = escapeAttr(table.name);
-    const displayName = escapeAttr(table.displayName);
     const headerRowCount = table.headerRow ? '' : ' headerRowCount="0"';
     const totals = table.totalsRow
         ? ' totalsRowCount="1"'
         : boolAttr('totalsRowShown', table.totalsRowShown);
     const autoFilter = table.autoFilterRef !== undefined ? `<autoFilter ref="${table.autoFilterRef}"/>` : '';
-    const columns = table.columns.map((column, i) => tableColumnXml(column, i + 1)).join('');
+    const columns = table.columns
+        .map((column, i) => tableColumnXml(column, i + 1, formulaNames))
+        .join('');
     return (XML_DECLARATION +
-        `<table xmlns="${NS.main}" id="${id}" name="${name}" displayName="${displayName}" ` +
+        `<table xmlns="${NS.main}" id="${id}" name="${name}" displayName="${name}" ` +
         `ref="${table.range}"${headerRowCount}${totals}>` +
         autoFilter +
         `<tableColumns count="${table.columns.length}">${columns}</tableColumns>` +
@@ -30,14 +32,10 @@ function tableStyleInfoXml(style) {
     let attrs = '';
     if (style.name !== undefined)
         attrs += ` name="${escapeAttr(style.name)}"`;
-    attrs +=
-        boolAttr('showFirstColumn', style.showFirstColumn) +
-            boolAttr('showLastColumn', style.showLastColumn) +
-            boolAttr('showRowStripes', style.showRowStripes) +
-            boolAttr('showColumnStripes', style.showColumnStripes);
+    attrs += TABLE_STYLE_FLAGS.map((flag) => boolAttr(flag, style[flag])).join('');
     return `<tableStyleInfo${attrs}/>`;
 }
-function tableColumnXml(column, id) {
+function tableColumnXml(column, id, formulaNames) {
     let attrs = `id="${id}" name="${escapeAttr(column.name)}"`;
     if (column.totalsRowLabel !== undefined) {
         attrs += ` totalsRowLabel="${escapeAttr(column.totalsRowLabel)}"`;
@@ -45,14 +43,21 @@ function tableColumnXml(column, id) {
     if (column.totalsRowFunction !== undefined) {
         attrs += ` totalsRowFunction="${checkedToken(column.totalsRowFunction, isTotalsRowFunction, 'totals row function')}"`;
     }
+    let children = '';
+    if (column.calculatedColumnFormula !== undefined) {
+        const stored = mangleFormula(column.calculatedColumnFormula, formulaNames);
+        children += `<calculatedColumnFormula>${escapeText(stored)}</calculatedColumnFormula>`;
+    }
     if (column.totalsRowFormula !== undefined) {
-        return `<tableColumn ${attrs}><totalsRowFormula>${escapeText(column.totalsRowFormula)}</totalsRowFormula></tableColumn>`;
+        const stored = mangleFormula(column.totalsRowFormula, formulaNames);
+        children += `<totalsRowFormula>${escapeText(stored)}</totalsRowFormula>`;
     }
-    return `<tableColumn ${attrs}/>`;
+    return children === ''
+        ? `<tableColumn ${attrs}/>`
+        : `<tableColumn ${attrs}>${children}</tableColumn>`;
 }
-export function parseTable(xml) {
+export function parseTable(xml, definedNames) {
     let name;
-    let displayName;
     let ref;
     let headerRowCount = 1;
     let totalsRowCount = 0;
@@ -60,18 +65,17 @@ export function parseTable(xml) {
     let style;
     let hasAutoFilter = false;
     const columns = [];
-    const totalsFormula = new TextCapture('totalsRowFormula');
+    let currentColumn;
+    const formula = new TextCapture(['totalsRowFormula', 'calculatedColumnFormula']);
     parseXml(xml, {
         onOpen(elementName, attrs, selfClosing) {
             switch (localName(elementName)) {
                 case 'table':
-                    name = attrs.name ?? attrs.displayName;
-                    displayName = attrs.displayName ?? attrs.name;
+                    name = attrs.displayName ?? attrs.name;
                     ref = attrs.ref;
                     headerRowCount = numInteger(attrs.headerRowCount, 0) ?? headerRowCount;
                     totalsRowCount = numInteger(attrs.totalsRowCount, 0) ?? totalsRowCount;
-                    if (attrs.totalsRowShown !== undefined)
-                        totalsRowShown = boolPresent(attrs.totalsRowShown);
+                    totalsRowShown = boolTristate(attrs.totalsRowShown);
                     break;
                 case 'autoFilter':
                     hasAutoFilter = true;
@@ -80,22 +84,21 @@ export function parseTable(xml) {
                     const captured = {};
                     if (attrs.name !== undefined)
                         captured.name = attrs.name;
-                    if (attrs.showFirstColumn !== undefined)
-                        captured.showFirstColumn = boolPresent(attrs.showFirstColumn);
-                    if (attrs.showLastColumn !== undefined)
-                        captured.showLastColumn = boolPresent(attrs.showLastColumn);
-                    if (attrs.showRowStripes !== undefined)
-                        captured.showRowStripes = boolPresent(attrs.showRowStripes);
-                    if (attrs.showColumnStripes !== undefined) {
-                        captured.showColumnStripes = boolPresent(attrs.showColumnStripes);
+                    for (const flag of TABLE_STYLE_FLAGS) {
+                        const value = boolTristate(attrs[flag]);
+                        if (value !== undefined)
+                            captured[flag] = value;
                     }
                     style = captured;
                     break;
                 }
                 case 'tableColumn': {
-                    if (attrs.name === undefined)
+                    if (attrs.name === undefined) {
+                        currentColumn = undefined;
                         break;
+                    }
                     const column = { name: attrs.name };
+                    currentColumn = column;
                     if (attrs.totalsRowLabel !== undefined)
                         column.totalsRowLabel = attrs.totalsRowLabel;
                     if (attrs.totalsRowFunction !== undefined &&
@@ -106,20 +109,24 @@ export function parseTable(xml) {
                     break;
                 }
                 case 'totalsRowFormula':
-                    totalsFormula.open('totalsRowFormula', selfClosing);
+                case 'calculatedColumnFormula':
+                    formula.open(localName(elementName), selfClosing);
                     break;
             }
         },
         onText(text) {
-            totalsFormula.text(text);
+            formula.text(text);
         },
         onClose(elementName) {
-            const formula = totalsFormula.close(localName(elementName));
-            if (formula === undefined)
+            const local = localName(elementName);
+            const text = formula.close(local);
+            if (text === undefined || currentColumn === undefined)
                 return;
-            const column = columns[columns.length - 1];
-            if (column !== undefined)
-                column.totalsRowFormula = formula;
+            const formulaText = unmangleFunctions(text, definedNames);
+            if (local === 'totalsRowFormula')
+                currentColumn.totalsRowFormula = formulaText;
+            else
+                currentColumn.calculatedColumnFormula = formulaText;
         },
     });
     if (name === undefined || ref === undefined || columns.length === 0)
@@ -127,17 +134,17 @@ export function parseTable(xml) {
     const decoded = tryDecodeRange(ref);
     if (decoded === undefined)
         return undefined;
-    const { top, left, bottom } = decoded;
-    if (top === undefined || left === undefined || bottom === undefined)
+    const { top, left, bottom, right } = decoded;
+    if (top === undefined || left === undefined || bottom === undefined || right === undefined) {
         return undefined;
-    if (left + columns.length - 1 > MAX_COLUMN)
+    }
+    if (columns.length !== right - left + 1)
         return undefined;
     const headerRow = headerRowCount !== 0;
     const totalsRow = totalsRowCount > 0;
     const dataRows = bottom - top + 1 - (headerRow ? 1 : 0) - (totalsRow ? 1 : 0);
     const options = {
         name,
-        displayName: displayName ?? name,
         ref: encodeAddress(left, top),
         columns,
         rowCount: Math.max(0, dataRows),

package/dist/io/xlsx/theme-xml.d.ts

@@ -12,6 +12,12 @@ import { type ThemeColorScheme, type ThemeColorSlot, type ThemeFontScheme, type
 export declare function parseThemeColorScheme(themeXml: string): ThemeColorScheme;
 /** Extract the major/minor latin typefaces from a theme part's `<fontScheme>`. */
 export declare function parseThemeFontScheme(themeXml: string): ThemeFontScheme;
+/** {@link parseThemeColorScheme} and {@link parseThemeFontScheme} from one scan of the part, for the
+ * reader, which wants both. */
+export declare function parseThemeSchemes(themeXml: string): {
+    readonly colors: ThemeColorScheme;
+    readonly fonts: ThemeFontScheme;
+};
 declare const SCHEME_ELEMENT_ORDER: readonly ["dk1", "lt1", "dk2", "lt2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hlink", "folHlink"];
 /**
  * The half of the proof the list above owes: `satisfies` covers "no invented slot", this covers "no

package/dist/io/xlsx/theme-xml.js

@@ -1,7 +1,7 @@
-import { DEFAULT_THEME_COLOR_SCHEME, isThemeColorSlot, normalizeThemeColor, } from '../../core/theme.js';
+import { DEFAULT_THEME_COLOR_SCHEME, isThemeColorSlot, isThemeRgb, } from '../../core/theme.js';
 import { elementRange, parseXml } from '../../xml/xml-read.js';
 import { localName } from '../../xml/xml-scan.js';
-import { escapeAttr } from '../../xml/xml.js';
+import { startTag } from '../../xml/xml.js';
 const COLOR_ELEMENTS = new Set(['srgbClr', 'sysClr']);
 function readThemeScheme(themeXml) {
     const colors = {};
@@ -12,7 +12,7 @@ function readThemeScheme(themeXml) {
     let slot;
     let fontSlot;
     parseXml(themeXml, {
-        onOpen(name, attrs, _selfClosing, scope) {
+        onOpen(name, attrs) {
             const local = localName(name);
             if (local === 'theme') {
                 const colon = name.indexOf(':');
@@ -29,9 +29,9 @@ function readThemeScheme(themeXml) {
                 }
                 else if (slot !== undefined && COLOR_ELEMENTS.has(local)) {
                     const value = local === 'sysClr' ? attrs.lastClr : attrs.val;
-                    if (value !== undefined && /^[0-9a-fA-F]{6}$/.test(value))
-                        colors[slot] = value;
-                    elements[slot] = emptyElement(name, attrs);
+                    if (value !== undefined && isThemeRgb(value))
+                        colors[slot] = value.toUpperCase();
+                    elements[slot] = startTag(name, attrs, true);
                     slot = undefined;
                 }
                 return;
@@ -45,7 +45,6 @@ function readThemeScheme(themeXml) {
                     fonts[fontSlot] ??= attrs.typeface;
                 }
             }
-            void scope;
         },
         onClose(name) {
             const local = localName(name);
@@ -69,18 +68,16 @@ function readThemeScheme(themeXml) {
         scheme.minor = fonts.minor;
     return { colors, elements, fonts: scheme, prefix };
 }
-function emptyElement(name, attrs) {
-    let out = `<${name}`;
-    for (const key in attrs)
-        out += ` ${key}="${escapeAttr(attrs[key] ?? '')}"`;
-    return `${out}/>`;
-}
 export function parseThemeColorScheme(themeXml) {
     return readThemeScheme(themeXml).colors;
 }
 export function parseThemeFontScheme(themeXml) {
     return readThemeScheme(themeXml).fonts;
 }
+export function parseThemeSchemes(themeXml) {
+    const { colors, fonts } = readThemeScheme(themeXml);
+    return { colors, fonts };
+}
 const SCHEME_ELEMENT_ORDER = [
     'dk1',
     'lt1',
@@ -105,7 +102,7 @@ export function applyThemeOverrides(baseXml, overrides) {
             const body = SCHEME_ELEMENT_ORDER.map((slot) => {
                 const authored = colors[slot];
                 const inner = authored !== undefined
-                    ? `<${prefix}srgbClr val="${normalizeThemeColor(authored)}"/>`
+                    ? `<${prefix}srgbClr val="${authored}"/>`
                     : (sourceElements[slot] ??
                         `<${prefix}srgbClr val="${DEFAULT_THEME_COLOR_SCHEME[slot]}"/>`);
                 return `<${prefix}${slot}>${inner}</${prefix}${slot}>`;
@@ -118,11 +115,11 @@ export function applyThemeOverrides(baseXml, overrides) {
         const found = elementRange(baseXml, [which, 'latin']);
         if (found === undefined)
             return;
-        const attrs = { ...found.attrs, typeface };
-        let rendered = `<${found.name}`;
-        for (const key in attrs)
-            rendered += ` ${key}="${escapeAttr(attrs[key] ?? '')}"`;
-        edits.push({ start: found.start, end: found.end, text: `${rendered}/>` });
+        edits.push({
+            start: found.start,
+            end: found.end,
+            text: startTag(found.name, { ...found.attrs, typeface }, true),
+        });
     };
     if (major !== undefined)
         latin('majorFont', major);

package/dist/io/xlsx/threaded-comments.d.ts

@@ -78,8 +78,13 @@ export declare function buildCommentThreads(messages: readonly ParsedThreadedCom
  *
  * A thread with no messages writes nothing: it has neither text to say nor a head id for its replies and
  * its legacy fallback to hang off.
+ *
+ * A message with no author is written under the null GUID, Excel's own spelling for one. `personById` is
+ * the workbook's registry, and a message naming an id it does not hold is refused.
+ *
+ * @throws {AuthoringError} if a message's author is not a registered person.
  */
-export declare function threadedCommentsXml(threads: readonly CommentThread[]): string;
+export declare function threadedCommentsXml(threads: readonly CommentThread[], personById: (id: string) => Person | undefined): string;
 /**
  * Serialise the workbook's identity registry into `xl/persons/person.xml`: singular and unnumbered,
  * unlike the per-sheet thread parts.