@shbernal/ts-xlsx 3.0.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

@@ -0,0 +1,41 @@
+import { type Alignment, type Border, type Fill, type Protection } from '../../core/style.ts';
+import type { DifferentialStyle } from '../../core/workbook-styles.ts';
+export declare const CUSTOM_NUMFMT_BASE = 164;
+export declare const DEFAULT_FONT_BODY = "<sz val=\"11\"/><color theme=\"1\"/><name val=\"Calibri\"/><family val=\"2\"/><scheme val=\"minor\"/>";
+export declare const DEFAULT_BORDER = "<border><left/><right/><top/><bottom/><diagonal/></border>";
+export interface CellFormat {
+    readonly fillId: number;
+    readonly numFmtId: number;
+    readonly fontId: number;
+    readonly borderId: number;
+    readonly alignment: string;
+    readonly protection: string;
+    readonly quotePrefix: boolean;
+    readonly xfId: number;
+}
+export declare const DEFAULT_FORMAT: CellFormat;
+export declare function formatSignature(format: CellFormat): string;
+/**
+ * Whether a format is the do-nothing default: no facet, General number format, no quote prefix, and
+ * linked to the Normal named style. Such a cellXfs entry adds nothing, so its owner needs no `s`.
+ *
+ * Asked of the signature rather than field by field, because the two questions have to be answered
+ * from the same field set and both answer silently when they are not. A facet the signature forgets
+ * makes two distinct formats intern to one entry, and every cell carrying the facet quietly loses it;
+ * a facet *this* forgets forces a spurious entry and an `s` attribute onto every cell in the book.
+ * Neither is a type error, and neither is visible in the file until someone compares two of them.
+ */
+export declare function isDefaultFormat(format: CellFormat): boolean;
+export declare function xfXml(format: CellFormat, xfId: number | null): string;
+export declare function cellStyleTag(entry: {
+    name: string;
+    builtinId?: number;
+    xfId: number;
+}): string;
+export declare function alignmentAttrs(alignment: Alignment): string;
+export declare function protectionAttrs(protection: Protection): string;
+export declare function dxfXml(style: DifferentialStyle): string;
+export declare function borderXml(border: Border): string;
+export declare function patternFillXml(fill: Fill, { solidBgFallback }: {
+    solidBgFallback: boolean;
+}): string;

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

@@ -0,0 +1,136 @@
+import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, } from '../../core/style.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;
+export const DEFAULT_FONT_BODY = '<sz val="11"/><color theme="1"/><name val="Calibri"/><family val="2"/><scheme val="minor"/>';
+export const DEFAULT_BORDER = '<border><left/><right/><top/><bottom/><diagonal/></border>';
+export const DEFAULT_FORMAT = {
+    fillId: 0,
+    numFmtId: 0,
+    fontId: 0,
+    borderId: 0,
+    alignment: '',
+    protection: '',
+    quotePrefix: false,
+    xfId: 0,
+};
+export function formatSignature(format) {
+    return (`fill:${format.fillId}|numFmt:${format.numFmtId}|font:${format.fontId}|border:${format.borderId}|` +
+        `align:${format.alignment}|protect:${format.protection}|quote:${format.quotePrefix}|xfId:${format.xfId}`);
+}
+const DEFAULT_FORMAT_SIGNATURE = formatSignature(DEFAULT_FORMAT);
+export function isDefaultFormat(format) {
+    return formatSignature(format) === DEFAULT_FORMAT_SIGNATURE;
+}
+export function xfXml(format, xfId) {
+    const applyNumberFormat = format.numFmtId !== 0 ? ' applyNumberFormat="1"' : '';
+    const applyFont = format.fontId !== 0 ? ' applyFont="1"' : '';
+    const applyFill = format.fillId !== 0 ? ' applyFill="1"' : '';
+    const applyBorder = format.borderId !== 0 ? ' applyBorder="1"' : '';
+    const applyAlignment = format.alignment !== '' ? ' applyAlignment="1"' : '';
+    const applyProtection = format.protection !== '' ? ' applyProtection="1"' : '';
+    const quotePrefix = format.quotePrefix ? ' quotePrefix="1"' : '';
+    const xfIdAttr = xfId === null ? '' : ` xfId="${xfId}"`;
+    const open = `<xf numFmtId="${format.numFmtId}" fontId="${format.fontId}" fillId="${format.fillId}" ` +
+        `borderId="${format.borderId}"${xfIdAttr}${quotePrefix}` +
+        `${applyNumberFormat}${applyFont}${applyFill}${applyBorder}${applyAlignment}${applyProtection}`;
+    const body = (format.alignment === '' ? '' : `<alignment ${format.alignment}/>`) +
+        (format.protection === '' ? '' : `<protection ${format.protection}/>`);
+    return body === '' ? `${open}/>` : `${open}>${body}</xf>`;
+}
+export function cellStyleTag(entry) {
+    const builtin = entry.builtinId === undefined ? '' : ` builtinId="${entry.builtinId}"`;
+    return `<cellStyle name="${escapeAttr(entry.name)}" xfId="${entry.xfId}"${builtin}/>`;
+}
+export function alignmentAttrs(alignment) {
+    const parts = [];
+    for (const facet of ALIGNMENT_FACETS) {
+        switch (facet.kind) {
+            case 'token': {
+                const value = alignment[facet.key];
+                if (value === undefined || value === facet.omit)
+                    break;
+                parts.push(`${facet.key}="${checkedToken(value, facet.isValid, facet.label)}"`);
+                break;
+            }
+            case 'number': {
+                const attr = nonDefaultNumAttr(facet.key, alignment[facet.key], 0);
+                if (attr !== '')
+                    parts.push(attr.trimStart());
+                break;
+            }
+            case 'flag':
+                if (alignment[facet.key])
+                    parts.push(`${facet.key}="1"`);
+                break;
+        }
+    }
+    return parts.join(' ');
+}
+export function protectionAttrs(protection) {
+    const parts = [];
+    if (protection.locked === false)
+        parts.push('locked="0"');
+    if (protection.hidden === true)
+        parts.push('hidden="1"');
+    return parts.join(' ');
+}
+export function dxfXml(style) {
+    const parts = [];
+    if (style.font !== undefined) {
+        const font = fontXml(style.font);
+        if (font !== '')
+            parts.push(`<font>${font}</font>`);
+    }
+    if (typeof style.numFmt === 'string' && style.numFmt !== '') {
+        parts.push(`<numFmt numFmtId="${CUSTOM_NUMFMT_BASE}" formatCode="${escapeFormatCode(style.numFmt)}"/>`);
+    }
+    if (style.fill !== undefined)
+        parts.push(patternFillXml(style.fill, { solidBgFallback: false }));
+    if (style.border !== undefined)
+        parts.push(borderXml(style.border));
+    return `<dxf>${parts.join('')}</dxf>`;
+}
+function gradientFillXml(fill) {
+    const attrs = (fill.gradient === 'path' ? ' type="path"' : '') +
+        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>`;
+}
+export function borderXml(border) {
+    const attrs = (border.diagonalUp ? ' diagonalUp="1"' : '') + (border.diagonalDown ? ' diagonalDown="1"' : '');
+    return (`<border${attrs}>` +
+        edgeXml('left', border.left) +
+        edgeXml('right', border.right) +
+        edgeXml('top', border.top) +
+        edgeXml('bottom', border.bottom) +
+        edgeXml('diagonal', border.diagonal) +
+        '</border>');
+}
+function edgeXml(tag, edge) {
+    if (edge === undefined)
+        return `<${tag}/>`;
+    const style = checkedToken(edge.style, isBorderStyle, 'border style');
+    if (edge.color === undefined)
+        return `<${tag} style="${style}"/>`;
+    return `<${tag} style="${style}"><color ${colorAttrs(edge.color)}/></${tag}>`;
+}
+export function patternFillXml(fill, { solidBgFallback }) {
+    if (fill.type === 'gradient')
+        return `<fill>${gradientFillXml(fill)}</fill>`;
+    const fg = fill.fgColor ? `<fgColor ${colorAttrs(fill.fgColor)}/>` : '';
+    const bg = fill.bgColor
+        ? `<bgColor ${colorAttrs(fill.bgColor)}/>`
+        : solidBgFallback && fill.pattern === 'solid'
+            ? '<bgColor indexed="64"/>'
+            : '';
+    const pattern = checkedToken(fill.pattern, isFillPatternType, 'fill pattern');
+    return `<fill><patternFill patternType="${pattern}">${fg}${bg}</patternFill></fill>`;
+}

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

@@ -1,7 +1,9 @@
-import { type DifferentialStyle, type Font, type NamedCellStyle, type TableStyleTable } from '../../core/style.ts';
+import { type Font } from '../../core/style.ts';
 import { type TableStyle } from '../../core/table-style.ts';
+import type { DifferentialStyle, NamedCellStyle, TableStyleTable } from '../../core/workbook-styles.ts';
 import type { XfStyle } from '../style/xf-style.ts';
-/** What a {@link StyleRegistry} needs from its workbook before any style is interned. */
+/** What a {@link StyleRegistry} needs from its workbook before any style is interned.
+ */
 export interface StyleRegistryOptions {
     /**
      * The font every cell naming none of its own renders in, emitted as id 0. Take it from
@@ -22,6 +24,14 @@ export interface StyleRegistryOptions {
      */
     readonly declaredDefaultFont?: Font;
 }
+/**
+ * The interned style table one written package is built against: every distinct fill, number format,
+ * font, border and xf, each handed back as the stable index a cell's `s` attribute names.
+ *
+ * One workbook, one registry. The streaming writer is why that is worth saying: it interns a row's
+ * styles at the moment the row is flushed, long before `xl/styles.xml` is emitted, so the ids already
+ * baked into those rows are only correct if the very same registry emits the part.
+ */
 export declare class StyleRegistry {
     #private;
     constructor(options?: StyleRegistryOptions);
@@ -91,7 +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;
 }
-export declare function fontXml(font: Font, nameTag?: 'name' | 'rFont'): string;

package/dist/io/xlsx/styles.js

@@ -1,25 +1,12 @@
-import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isNamedUnderlineStyle, } from '../../core/style.js';
+import {} from '../../core/style.js';
 import { TABLE_STYLE_ELEMENT_TYPES } from '../../core/table-style.js';
-import { decodeEntities } from '../../xml/xml-scan.js';
-import { assertRepresentable, checkedToken, escapeAttr, numberText, XML_DECLARATION, } from '../../xml/xml.js';
-import { colorAttrs } from './color-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, formatSignature, isDefaultFormat, patternFillXml, protectionAttrs, xfXml, } from './style-elements.js';
 const RESERVED_FILL_COUNT = 2;
 const RESERVED_FONT_COUNT = 1;
-const CUSTOM_NUMFMT_BASE = 164;
 const RESERVED_BORDER_COUNT = 1;
-const DEFAULT_FONT_BODY = '<sz val="11"/><color theme="1"/><name val="Calibri"/><family val="2"/><scheme val="minor"/>';
-const DEFAULT_BORDER = '<border><left/><right/><top/><bottom/><diagonal/></border>';
-const DEFAULT_FORMAT = {
-    fillId: 0,
-    numFmtId: 0,
-    fontId: 0,
-    borderId: 0,
-    alignment: '',
-    protection: '',
-    quotePrefix: false,
-    xfId: 0,
-};
 class InternTable {
     #entries = [];
     #idByKey = new Map();
@@ -137,7 +124,7 @@ export class StyleRegistry {
             const element = style.elements[type];
             if (element === undefined)
                 return [];
-            const size = element.size !== undefined && element.size !== 1 ? ` size="${element.size}"` : '';
+            const size = nonDefaultNumAttr('size', element.size, 1);
             return [
                 `<tableStyleElement type="${type}"${size} dxfId="${this.differentialStyleId(element)}"/>`,
             ];
@@ -150,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);
@@ -206,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 '';
@@ -245,192 +238,3 @@ export class StyleRegistry {
         return `<numFmts count="${this.#numFmts.size}">${entries}</numFmts>`;
     }
 }
-function isDefaultFormat(format) {
-    return (format.fillId === 0 &&
-        format.numFmtId === 0 &&
-        format.fontId === 0 &&
-        format.borderId === 0 &&
-        format.alignment === '' &&
-        format.protection === '' &&
-        !format.quotePrefix &&
-        format.xfId === 0);
-}
-function formatSignature(format) {
-    return (`fill:${format.fillId}|numFmt:${format.numFmtId}|font:${format.fontId}|border:${format.borderId}|` +
-        `align:${format.alignment}|protect:${format.protection}|quote:${format.quotePrefix}|xfId:${format.xfId}`);
-}
-function xfXml(format, xfId) {
-    const applyNumberFormat = format.numFmtId !== 0 ? ' applyNumberFormat="1"' : '';
-    const applyFont = format.fontId !== 0 ? ' applyFont="1"' : '';
-    const applyFill = format.fillId !== 0 ? ' applyFill="1"' : '';
-    const applyBorder = format.borderId !== 0 ? ' applyBorder="1"' : '';
-    const applyAlignment = format.alignment !== '' ? ' applyAlignment="1"' : '';
-    const applyProtection = format.protection !== '' ? ' applyProtection="1"' : '';
-    const quotePrefix = format.quotePrefix ? ' quotePrefix="1"' : '';
-    const xfIdAttr = xfId === null ? '' : ` xfId="${xfId}"`;
-    const open = `<xf numFmtId="${format.numFmtId}" fontId="${format.fontId}" fillId="${format.fillId}" ` +
-        `borderId="${format.borderId}"${xfIdAttr}${quotePrefix}` +
-        `${applyNumberFormat}${applyFont}${applyFill}${applyBorder}${applyAlignment}${applyProtection}`;
-    const body = (format.alignment === '' ? '' : `<alignment ${format.alignment}/>`) +
-        (format.protection === '' ? '' : `<protection ${format.protection}/>`);
-    return body === '' ? `${open}/>` : `${open}>${body}</xf>`;
-}
-function cellStyleTag(entry) {
-    const builtin = entry.builtinId === undefined ? '' : ` builtinId="${entry.builtinId}"`;
-    return `<cellStyle name="${escapeAttr(entry.name)}" xfId="${entry.xfId}"${builtin}/>`;
-}
-function alignmentAttrs(alignment) {
-    const parts = [];
-    for (const facet of ALIGNMENT_FACETS) {
-        switch (facet.kind) {
-            case 'token': {
-                const value = alignment[facet.key];
-                if (value === undefined || value === facet.omit)
-                    break;
-                parts.push(`${facet.key}="${checkedToken(value, facet.isValid, facet.label)}"`);
-                break;
-            }
-            case 'number': {
-                const value = alignment[facet.key];
-                if (value === undefined || value === 0)
-                    break;
-                parts.push(`${facet.key}="${numberText(value)}"`);
-                break;
-            }
-            case 'flag':
-                if (alignment[facet.key])
-                    parts.push(`${facet.key}="1"`);
-                break;
-        }
-    }
-    return parts.join(' ');
-}
-function protectionAttrs(protection) {
-    const parts = [];
-    if (protection.locked === false)
-        parts.push('locked="0"');
-    if (protection.hidden === true)
-        parts.push('hidden="1"');
-    return parts.join(' ');
-}
-function tableStyleName(fragment) {
-    return decodeEntities(/<tableStyle\b[^>]*\bname="([^"]*)"/.exec(fragment)?.[1] ?? '');
-}
-export function fontXml(font, nameTag = 'name') {
-    const parts = [];
-    if (font.bold)
-        parts.push('<b/>');
-    if (font.italic)
-        parts.push('<i/>');
-    if (font.strike)
-        parts.push('<strike/>');
-    if (font.outline)
-        parts.push('<outline/>');
-    const underline = underlineXml(font.underline);
-    if (underline !== '')
-        parts.push(underline);
-    if (font.vertAlign !== undefined) {
-        parts.push(`<vertAlign val="${checkedToken(font.vertAlign, isFontVerticalAlignment, 'font vertical alignment')}"/>`);
-    }
-    if (font.size !== undefined)
-        parts.push(`<sz val="${numberText(font.size)}"/>`);
-    if (font.color !== undefined)
-        parts.push(`<color ${colorAttrs(font.color)}/>`);
-    if (font.name !== undefined)
-        parts.push(`<${nameTag} val="${escapeAttr(font.name)}"/>`);
-    if (font.family !== undefined)
-        parts.push(`<family val="${numberText(font.family)}"/>`);
-    if (font.charset !== undefined)
-        parts.push(`<charset val="${numberText(font.charset)}"/>`);
-    if (font.scheme !== undefined && font.scheme !== 'none')
-        parts.push(`<scheme val="${checkedToken(font.scheme, isFontScheme, 'font scheme')}"/>`);
-    return parts.join('');
-}
-function dxfXml(style) {
-    const parts = [];
-    if (style.font !== undefined) {
-        const font = fontXml(style.font);
-        if (font !== '')
-            parts.push(`<font>${font}</font>`);
-    }
-    if (typeof style.numFmt === 'string' && style.numFmt !== '') {
-        parts.push(`<numFmt numFmtId="${CUSTOM_NUMFMT_BASE}" formatCode="${escapeFormatCode(style.numFmt)}"/>`);
-    }
-    if (style.fill !== undefined)
-        parts.push(patternFillXml(style.fill, { solidBgFallback: false }));
-    if (style.border !== undefined)
-        parts.push(borderXml(style.border));
-    return `<dxf>${parts.join('')}</dxf>`;
-}
-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);
-    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)}"` : '';
-}
-function underlineXml(underline) {
-    if (underline === undefined || underline === false || underline === 'none')
-        return '';
-    if (underline === true || underline === 'single')
-        return '<u/>';
-    return `<u val="${checkedToken(underline, isNamedUnderlineStyle, 'underline style')}"/>`;
-}
-function borderXml(border) {
-    const attrs = (border.diagonalUp ? ' diagonalUp="1"' : '') + (border.diagonalDown ? ' diagonalDown="1"' : '');
-    return (`<border${attrs}>` +
-        edgeXml('left', border.left) +
-        edgeXml('right', border.right) +
-        edgeXml('top', border.top) +
-        edgeXml('bottom', border.bottom) +
-        edgeXml('diagonal', border.diagonal) +
-        '</border>');
-}
-function edgeXml(tag, edge) {
-    if (edge === undefined)
-        return `<${tag}/>`;
-    const style = checkedToken(edge.style, isBorderStyle, 'border style');
-    if (edge.color === undefined)
-        return `<${tag} style="${style}"/>`;
-    return `<${tag} style="${style}"><color ${colorAttrs(edge.color)}/></${tag}>`;
-}
-function escapeFormatCode(code) {
-    assertRepresentable(code);
-    return code
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
-}
-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 ?? ''}`;
-}
-function patternFillXml(fill, { solidBgFallback }) {
-    if (fill.type === 'gradient')
-        return `<fill>${gradientFillXml(fill)}</fill>`;
-    const fg = fill.fgColor ? `<fgColor ${colorAttrs(fill.fgColor)}/>` : '';
-    const bg = fill.bgColor
-        ? `<bgColor ${colorAttrs(fill.bgColor)}/>`
-        : solidBgFallback && fill.pattern === 'solid'
-            ? '<bgColor indexed="64"/>'
-            : '';
-    const pattern = checkedToken(fill.pattern, isFillPatternType, 'fill pattern');
-    return `<fill><patternFill patternType="${pattern}">${fg}${bg}</patternFill></fill>`;
-}

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;