@shbernal/ts-xlsx 2.1.0 → 3.1.0

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

@@ -1,8 +1,11 @@
 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 { stripFormulaEquals } from '../../core/formula.js';
+import { coerceNumericLiteral, enumToken, numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { elementSubtrees, TextCapture, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, localName } from '../../xml/xml-scan.js';
+import { boolAttr, checkedToken, escapeAttr, escapeText, numberText, textAttr, } from '../../xml/xml.js';
 import { colorAttrs, parseColor } from './color-xml.js';
-import { CF_EXT_URI, DATABAR_LINK_EXT_URI, XM_NS } from './namespaces.js';
+import { CF_EXT_URI, DATABAR_LINK_EXT_URI, isExtensionElement, XM_NS } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
 const DEFAULT_DATABAR_CFVO = [{ type: 'min' }, { type: 'max' }];
 const DEFAULT_DATABAR_COLOR = { argb: 'FF638EC6' };
@@ -14,7 +17,7 @@ function needsDataBarExt(rule) {
 function dataBarExtGuid(index) {
     return `{00000000-0000-0000-0000-${String(index + 1).padStart(12, '0')}}`;
 }
-function dataBarExtLinks(formattings) {
+export function dataBarExtLinks(formattings) {
     const links = new Map();
     let index = 0;
     for (const cf of formattings) {
@@ -27,15 +30,13 @@ function dataBarExtLinks(formattings) {
 }
 const SCALE_KINDS = ['dataBar', 'colorScale', 'iconSet'];
 const SCALE_TYPES = new Set(SCALE_KINDS);
-export function conditionalFormattingsXml(formattings, styles) {
+export function conditionalFormattingsXml(formattings, styles, extLinks) {
     if (formattings.length === 0)
         return '';
     const priority = { next: 1 };
-    const extLinks = dataBarExtLinks(formattings);
     return formattings.map((cf) => blockXml(cf, styles, priority, extLinks)).join('');
 }
-export function conditionalFormattingsExtXml(formattings) {
-    const extLinks = dataBarExtLinks(formattings);
+export function conditionalFormattingsExtXml(formattings, extLinks) {
     const items = [];
     for (const cf of formattings) {
         for (const rule of cf.rules) {
@@ -49,8 +50,7 @@ export function conditionalFormattingsExtXml(formattings) {
     return x14Ext(CF_EXT_URI, `<x14:conditionalFormattings>${items.join('')}</x14:conditionalFormattings>`);
 }
 function x14DataBarXml(ref, rule, guid) {
-    const cfvo = rule.cfvo && rule.cfvo.length > 0 ? rule.cfvo : DEFAULT_DATABAR_CFVO;
-    const anchors = cfvo.map(x14CfvoXml).join('');
+    const anchors = dataBarAnchors(rule).map(x14Cfvo).join('');
     const gradient = boolAttr('gradient', rule.gradient);
     const negative = rule.negativeFillColor !== undefined
         ? `<x14:negativeFillColor ${colorAttrs(rule.negativeFillColor)}/>`
@@ -61,12 +61,23 @@ function x14DataBarXml(ref, rule, guid) {
         `<x14:dataBar${gradient}>${anchors}${negative}${axis}</x14:dataBar>` +
         `</x14:cfRule><xm:sqref>${escapeText(ref)}</xm:sqref></x14:conditionalFormatting>`);
 }
-function x14CfvoXml(cfvo) {
-    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>`;
+function dataBarAnchors(rule) {
+    return rule.cfvo && rule.cfvo.length > 0 ? rule.cfvo : DEFAULT_DATABAR_CFVO;
 }
+function cfvoWriter(form) {
+    return (cfvo) => {
+        const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
+        const tag = form === 'classic' ? 'cfvo' : 'x14:cfvo';
+        if (cfvo.value === undefined)
+            return `<${tag} type="${type}"/>`;
+        const value = String(cfvo.value);
+        return form === 'classic'
+            ? `<${tag} type="${type}"${textAttr('val', value)}/>`
+            : `<${tag} type="${type}"><xm:f>${escapeText(value)}</xm:f></${tag}>`;
+    };
+}
+const cfvoXml = cfvoWriter('classic');
+const x14Cfvo = cfvoWriter('x14');
 function cfRuleExtLinkXml(guid) {
     return `<extLst>${x14Ext(DATABAR_LINK_EXT_URI, `<x14:id>${guid}</x14:id>`)}</extLst>`;
 }
@@ -139,9 +150,8 @@ function scaleXml(rule) {
     return iconSetXml(rule);
 }
 function dataBarXml(rule) {
-    const cfvo = rule.cfvo && rule.cfvo.length > 0 ? rule.cfvo : DEFAULT_DATABAR_CFVO;
     const color = rule.color ?? DEFAULT_DATABAR_COLOR;
-    const anchors = cfvo.map(cfvoXml).join('');
+    const anchors = dataBarAnchors(rule).map(cfvoXml).join('');
     return `<dataBar>${anchors}<color ${colorAttrs(color)}/></dataBar>`;
 }
 function colorScaleXml(rule) {
@@ -156,12 +166,7 @@ function iconSetXml(rule) {
     const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
     return `<iconSet${name}>${anchors}</iconSet>`;
 }
-function cfvoXml(cfvo) {
-    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) {
+export function conditionalFormattingPass() {
     const blocks = [];
     let block;
     let draft;
@@ -172,10 +177,10 @@ export function parseConditionalFormattings(xml) {
     let x14Ext;
     let x14ExtId;
     const x14IdCapture = new TextCapture('id');
-    parseXml(xml, {
-        onOpen(name, attrs, selfClosing) {
+    const handlers = {
+        onOpen(name, attrs, selfClosing, scope) {
             const ln = localName(name);
-            if (name.includes(':')) {
+            if (isExtensionElement(scope, name)) {
                 if (ln === 'id' && draft !== undefined) {
                     x14IdCapture.open(ln, selfClosing);
                 }
@@ -232,9 +237,9 @@ export function parseConditionalFormattings(xml) {
             formulaCapture.text(chunk);
             x14IdCapture.text(chunk);
         },
-        onClose(name) {
+        onClose(name, scope) {
             const ln = localName(name);
-            if (name.includes(':')) {
+            if (isExtensionElement(scope, name)) {
                 const id = x14IdCapture.close(ln);
                 if (id !== undefined) {
                     if (draft !== undefined)
@@ -270,29 +275,29 @@ export function parseConditionalFormattings(xml) {
                 block = undefined;
             }
         },
-    });
-    for (const { rule, id } of linked) {
-        const ext = extById.get(id);
-        if (ext === undefined)
-            continue;
-        if (ext.gradient !== undefined)
-            rule.gradient = ext.gradient;
-        if (ext.negativeFillColor !== undefined)
-            rule.negativeFillColor = ext.negativeFillColor;
-        if (ext.axisColor !== undefined)
-            rule.axisColor = ext.axisColor;
-    }
-    return blocks;
+    };
+    const result = () => {
+        for (const { rule, id } of linked) {
+            const ext = extById.get(id);
+            if (ext === undefined)
+                continue;
+            if (ext.gradient !== undefined)
+                rule.gradient = ext.gradient;
+            if (ext.negativeFillColor !== undefined)
+                rule.negativeFillColor = ext.negativeFillColor;
+            if (ext.axisColor !== undefined)
+                rule.axisColor = ext.axisColor;
+        }
+        return blocks;
+    };
+    return { handlers, result };
 }
 function emptyExt() {
     return { gradient: undefined, negativeFillColor: undefined, axisColor: undefined };
 }
 export function parseDxfs(stylesXml) {
-    const block = /<dxfs\b[^>]*>([\s\S]*?)<\/dxfs>/.exec(stylesXml);
-    if (block === null)
-        return [];
-    const inner = block[1] ?? '';
-    return [...inner.matchAll(/<dxf\b[^>]*>[\s\S]*?<\/dxf>|<dxf\b[^>]*\/>/g)].map((m) => m[0] ?? '');
+    const { fragments } = elementSubtrees(stylesXml, new Map([['dxfs', 'dxf']]));
+    return [...(fragments.get('dxfs') ?? [])];
 }
 function newDraft(attrs) {
     return {

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

@@ -1,5 +1,6 @@
 import { type DataValidationEntry } from '../../core/data-validation.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import { type CollectingPass } from '../../xml/xml-read.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.
  * The extended rules are emitted separately by {@link dataValidationsExtXml}. */
@@ -8,13 +9,14 @@ export declare function dataValidationsXml(entries: readonly DataValidationEntry
  * 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. */
 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[];
-/** Parse every extended `<x14:dataValidation>` out of a worksheet's `<extLst>` into range-bound
- * rules tagged `extended`, so a cross-sheet or whole-column list validation Excel stored only in the
- * 2009 extension form is read back rather than dropped. The standard parser ignores these (they are
- * prefixed); this one, symmetrically, handles only the prefixed elements. */
-export declare function parseExtendedDataValidations(xml: string): DataValidationEntry[];
+/** A pass gathering the standard `<dataValidation>` elements of a worksheet part, for a caller
+ * reading the part alongside its other readers in one parse. */
+export declare function dataValidationPass(): CollectingPass<DataValidationEntry[]>;
+/** A pass gathering the extended `<x14:dataValidation>` elements of a worksheet's `<extLst>`, so a
+ * cross-sheet or whole-column list validation Excel stored only in the 2009 extension form is read
+ * back rather than dropped. The standard pass ignores these (they are prefixed); this one,
+ * symmetrically, handles only the prefixed elements. */
+export declare function extendedDataValidationPass(): CollectingPass<DataValidationEntry[]>;
 /** Fold parsed validations onto a sheet, each bound to its original range and carrying its form: an
  * `extended` entry is re-attached as extended so a round-trip writes it back to the x14 block. */
 export declare function applyDataValidations(sheet: Worksheet, entries: readonly DataValidationEntry[]): void;

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

@@ -1,8 +1,12 @@
 import { isDataValidationErrorStyle, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { stripFormulaEquals } from '../../core/formula.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 { coerceNumericLiteral } from '../../xml/xml-attrs.js';
+import { TextCapture } from '../../xml/xml-read.js';
+import { boolStrict, localName } from '../../xml/xml-scan.js';
+import { checkedToken, escapeAttr, escapeText, textAttr } from '../../xml/xml.js';
+import { DATA_VALIDATION_EXT_URI, isExtensionElement, isMainNamespaceElement, XM_NS, } from './namespaces.js';
+import { admitting } from './read-repair.js';
 import { x14Ext } from './x14-ext.js';
 const TYPED = new Set(['whole', 'decimal', 'date', 'time', 'textLength']);
 export function dataValidationsXml(entries) {
@@ -57,34 +61,30 @@ function extendedDataValidationXml(sqref, rule) {
         `<xm:sqref>${escapeText(sqref)}</xm:sqref>`;
     return `<x14:dataValidation${ruleAttrs(rule)}>${body}</x14:dataValidation>`;
 }
-export function parseDataValidations(xml) {
+const FORMULA_ELEMENTS = new Set(['formula1', 'formula2']);
+export function dataValidationPass() {
     const entries = [];
     let current;
-    let slot;
-    parseXml(xml, {
-        onOpen(name, attrs) {
+    const formula = new TextCapture(FORMULA_ELEMENTS);
+    const handlers = {
+        onOpen(name, attrs, selfClosing, scope) {
             const ln = localName(name);
-            if (ln === 'dataValidation' && !name.includes(':')) {
+            if (ln === 'dataValidation' && isMainNamespaceElement(scope, name)) {
                 current = { attrs, formulae: [] };
             }
-            else if (current !== undefined && ln === 'formula1') {
-                slot = 0;
-                current.formulae[0] = '';
-            }
-            else if (current !== undefined && ln === 'formula2') {
-                slot = 1;
-                current.formulae[1] = '';
+            else if (current !== undefined) {
+                formula.open(ln, selfClosing);
             }
         },
         onText(text) {
-            if (current !== undefined && slot !== undefined) {
-                current.formulae[slot] = (current.formulae[slot] ?? '') + text;
-            }
+            formula.text(text);
         },
         onClose(name) {
             const ln = localName(name);
-            if (ln === 'formula1' || ln === 'formula2') {
-                slot = undefined;
+            const text = formula.close(ln);
+            if (text !== undefined) {
+                if (current !== undefined)
+                    current.formulae[ln === 'formula1' ? 0 : 1] = text;
                 return;
             }
             if (ln === 'dataValidation' && current !== undefined) {
@@ -94,8 +94,8 @@ export function parseDataValidations(xml) {
                 current = undefined;
             }
         },
-    });
-    return entries;
+    };
+    return { handlers, result: () => entries };
 }
 function buildEntry(attrs, formulae) {
     const { sqref } = attrs;
@@ -139,22 +139,22 @@ function buildRule(attrs, formulae) {
         rule.formulae = parsed;
     return rule;
 }
-export function parseExtendedDataValidations(xml) {
+export function extendedDataValidationPass() {
     const entries = [];
     let current;
     let slot;
     const capture = new TextCapture(['f', 'sqref']);
-    parseXml(xml, {
-        onOpen(name, attrs, selfClosing) {
+    const handlers = {
+        onOpen(name, attrs, selfClosing, scope) {
             const ln = localName(name);
-            const prefixed = name.includes(':');
-            if (ln === 'dataValidation' && prefixed) {
+            const extension = isExtensionElement(scope, name);
+            if (ln === 'dataValidation' && extension) {
                 current = { attrs, formulae: [], sqref: '' };
             }
-            else if (current !== undefined && prefixed && ln === 'formula1') {
+            else if (current !== undefined && extension && ln === 'formula1') {
                 slot = 0;
             }
-            else if (current !== undefined && prefixed && ln === 'formula2') {
+            else if (current !== undefined && extension && ln === 'formula2') {
                 slot = 1;
             }
             else if (current !== undefined) {
@@ -164,8 +164,9 @@ export function parseExtendedDataValidations(xml) {
         onText(chunk) {
             capture.text(chunk);
         },
-        onClose(name) {
+        onClose(name, scope) {
             const ln = localName(name);
+            const extension = isExtensionElement(scope, name);
             const text = capture.close(ln);
             if (text !== undefined) {
                 if (ln === 'f') {
@@ -176,18 +177,18 @@ export function parseExtendedDataValidations(xml) {
                     current.sqref = text;
                 }
             }
-            else if ((ln === 'formula1' || ln === 'formula2') && name.includes(':')) {
+            else if ((ln === 'formula1' || ln === 'formula2') && extension) {
                 slot = undefined;
             }
-            else if (ln === 'dataValidation' && name.includes(':') && current !== undefined) {
+            else if (ln === 'dataValidation' && extension && current !== undefined) {
                 const built = buildExtendedEntry(current.attrs, current.formulae, current.sqref);
                 if (built !== undefined)
                     entries.push(built);
                 current = undefined;
             }
         },
-    });
-    return entries;
+    };
+    return { handlers, result: () => entries };
 }
 function buildExtendedEntry(attrs, formulae, sqref) {
     if (sqref === '')
@@ -199,6 +200,8 @@ 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 } : {});
+        admitting(() => {
+            sheet.addDataValidation(sqref, rule, extended ? { extended: true } : {});
+        });
     }
 }

package/dist/io/xlsx/edit-vba.d.ts

@@ -1,4 +1,5 @@
 import { type VbaLibraryReference } from '../../vba/project-editor.ts';
+import { type ReadPackageOptions } from '../opc/read-options.ts';
 /**
  * Remove a standard module from an existing macro-enabled package's VBA project, returning new package
  * bytes. Every part but `xl/vbaProject.bin` is preserved byte-for-byte (see {@link removeVbaModule} for
@@ -8,8 +9,10 @@ import { type VbaLibraryReference } from '../../vba/project-editor.ts';
  * @throws {VbaAuthorError} if the package carries no VBA project, `name` is not in the project, or names
  *   a `document`/`designer` module.
  * @throws {VbaParseError} if the attached `vbaProject.bin` is malformed.
+ * @throws {PackageReadError} if the input is not a readable ZIP, or exceeds the inflate bound
+ *   ({@link ReadPackageOptions.maxUncompressedBytes}, defaulting as `readXlsx` does).
  */
-export declare function editXlsxVbaRemoveModule(xlsx: Uint8Array, name: string): Uint8Array;
+export declare function editXlsxVbaRemoveModule(xlsx: Uint8Array, name: string, options?: ReadPackageOptions): Uint8Array;
 /**
  * Add a registered (COM type-library) reference to an existing macro-enabled package's VBA project,
  * returning new package bytes. Every part but `xl/vbaProject.bin` is preserved byte-for-byte (see
@@ -19,5 +22,7 @@ export declare function editXlsxVbaRemoveModule(xlsx: Uint8Array, name: string):
  * @throws {VbaAuthorError} if the package carries no VBA project, or any field of `ref` is invalid (see
  *   {@link VbaLibraryReference}).
  * @throws {VbaParseError} if the attached `vbaProject.bin` is malformed.
+ * @throws {PackageReadError} if the input is not a readable ZIP, or exceeds the inflate bound
+ *   ({@link ReadPackageOptions.maxUncompressedBytes}, defaulting as `readXlsx` does).
  */
-export declare function editXlsxVbaAddReference(xlsx: Uint8Array, ref: VbaLibraryReference): Uint8Array;
+export declare function editXlsxVbaAddReference(xlsx: Uint8Array, ref: VbaLibraryReference, options?: ReadPackageOptions): Uint8Array;

package/dist/io/xlsx/edit-vba.js

@@ -1,20 +1,22 @@
-import { strFromU8, strToU8, unzipSync, zipSync } from 'fflate';
+import { strFromU8, strToU8, zipSync } from 'fflate';
 import { VbaAuthorError } from '../../vba/errors.js';
 import { addVbaReference, removeVbaModule, } from '../../vba/project-editor.js';
-import { relsPathFor } from '../opc/part-paths.js';
-import { parseRelationshipRecords, relationshipTargetByType, resolveRelativePart, resolveWorkbookPart, } from '../opc/read-opc.js';
+import { relsPathFor, resolveRelativePart } from '../opc/part-paths.js';
+import { parseRelationshipRecords, readPartRelationships } from '../opc/read-opc.js';
+import { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
+import { inflateSpreadsheetPackage } from '../opc/sniff-format.js';
 import { FIXED_ENTRY_MTIME } from '../opc/zip-mtime.js';
 const OFFICE_DOCUMENT_REL = 'officeDocument';
 const VBA_PROJECT_REL = 'vbaProject';
 const VBA_SIGNATURE_REL_INFIX = 'vbaProjectSignature';
-export function editXlsxVbaRemoveModule(xlsx, name) {
-    return applyToVbaProjectPart(xlsx, (bin) => removeVbaModule(bin, name));
+export function editXlsxVbaRemoveModule(xlsx, name, options = {}) {
+    return applyToVbaProjectPart(xlsx, options, (bin) => removeVbaModule(bin, name));
 }
-export function editXlsxVbaAddReference(xlsx, ref) {
-    return applyToVbaProjectPart(xlsx, (bin) => addVbaReference(bin, ref));
+export function editXlsxVbaAddReference(xlsx, ref, options = {}) {
+    return applyToVbaProjectPart(xlsx, options, (bin) => addVbaReference(bin, ref));
 }
-function applyToVbaProjectPart(xlsx, apply) {
-    const files = unzipSync(xlsx);
+function applyToVbaProjectPart(xlsx, options, apply) {
+    const files = inflateSpreadsheetPackage(xlsx, options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED);
     const binPath = locateVbaProjectPart(files);
     const bin = binPath === undefined ? undefined : files[binPath];
     if (binPath === undefined || bin === undefined) {
@@ -25,27 +27,11 @@ function applyToVbaProjectPart(xlsx, apply) {
     return zipSync(files, { mtime: FIXED_ENTRY_MTIME });
 }
 function locateVbaProjectPart(files) {
-    const rootRels = textPart(files, '_rels/.rels');
-    if (rootRels === undefined)
+    const partText = (path) => textPart(files, path);
+    const workbookPath = readPartRelationships('', partText).targetPath(OFFICE_DOCUMENT_REL);
+    if (workbookPath === undefined)
         return undefined;
-    const workbookTarget = relationshipTargetByType(rootRels, OFFICE_DOCUMENT_REL);
-    if (workbookTarget === undefined)
-        return undefined;
-    const workbookPath = resolveRelativePart('', workbookTarget);
-    const workbookRels = textPart(files, relsPathFor(workbookPath));
-    if (workbookRels === undefined)
-        return undefined;
-    const vbaTarget = relationshipTargetByType(workbookRels, VBA_PROJECT_REL);
-    if (vbaTarget === undefined)
-        return undefined;
-    return resolveVbaTarget(workbookPath, vbaTarget);
-}
-function resolveVbaTarget(workbookPath, target) {
-    if (target.startsWith('/'))
-        return target.slice(1);
-    if (workbookPath.startsWith('xl/'))
-        return resolveWorkbookPart(target);
-    return resolveRelativePart(workbookPath, target);
+    return readPartRelationships(workbookPath, partText).targetPath(VBA_PROJECT_REL);
 }
 function dropStaleSignature(files, binPath) {
     const binRelsPath = relsPathFor(binPath);

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

@@ -0,0 +1,7 @@
+import { type Font } from '../../core/style.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
+export type FontDraft = {
+    -readonly [K in keyof Font]?: Font[K];
+};
+export declare function applyFontChild(draft: FontDraft, local: string, attrs: XmlAttributes): void;
+export declare function fontXml(font: Font, nameTag?: 'name' | 'rFont'): string;

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

@@ -0,0 +1,104 @@
+import { isFontScheme, isFontVerticalAlignment, isNamedUnderlineStyle, } from '../../core/style.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { boolPresent } from '../../xml/xml-scan.js';
+import { checkedToken, escapeAttr, numberText } from '../../xml/xml.js';
+import { colorAttrs, parseColor } from './color-xml.js';
+export function applyFontChild(draft, local, attrs) {
+    switch (local) {
+        case 'b':
+            draft.bold = boolPresent(attrs.val);
+            break;
+        case 'i':
+            draft.italic = boolPresent(attrs.val);
+            break;
+        case 'strike':
+            draft.strike = boolPresent(attrs.val);
+            break;
+        case 'outline':
+            draft.outline = boolPresent(attrs.val);
+            break;
+        case 'u':
+            draft.underline =
+                attrs.val === undefined
+                    ? true
+                    : attrs.val === 'none'
+                        ? false
+                        : isNamedUnderlineStyle(attrs.val)
+                            ? attrs.val
+                            : true;
+            break;
+        case 'vertAlign':
+            if (attrs.val !== undefined && isFontVerticalAlignment(attrs.val))
+                draft.vertAlign = attrs.val;
+            break;
+        case 'sz': {
+            const size = numFinite(attrs.val);
+            if (size !== undefined)
+                draft.size = size;
+            break;
+        }
+        case 'color':
+            draft.color = parseColor(attrs);
+            break;
+        case 'name':
+        case 'rFont':
+            if (attrs.val !== undefined)
+                draft.name = attrs.val;
+            break;
+        case 'family': {
+            const family = numInteger(attrs.val);
+            if (family !== undefined)
+                draft.family = family;
+            break;
+        }
+        case 'charset': {
+            const charset = numInteger(attrs.val);
+            if (charset !== undefined)
+                draft.charset = charset;
+            break;
+        }
+        case 'scheme':
+            if (attrs.val !== undefined && isFontScheme(attrs.val))
+                draft.scheme = attrs.val;
+            break;
+        default:
+            break;
+    }
+}
+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 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')}"/>`;
+}

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

@@ -1,9 +1,18 @@
+import type { Cell } from '../../core/cell.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
-import type { SheetRelIds } from './package-plan.ts';
+import { type CollectingPass } from '../../xml/xml-read.ts';
+import type { RelIdAllocator } from './package-plan.ts';
 /** A hyperlink gathered from a sheet for serialisation: the cell it sits on, its target, and an
- * optional tooltip. The visible label is the cell's own value and is serialised as that value. */
+ * optional tooltip. The visible label is the cell's own value and is serialised as that value.
+ *
+ * `row`/`col` are the anchor's position, kept so links gathered from separate passes (the sheet's live
+ * rows, and the rows the streaming writer already flushed and evicted) can be merged back into the
+ * row-major order Excel writes them in. They are not serialised; `ref` is.
+ */
 export interface CollectedHyperlink {
     readonly ref: string;
+    readonly row: number;
+    readonly col: number;
     readonly target: string;
     readonly tooltip?: string;
 }
@@ -17,12 +26,36 @@ export interface HyperlinkPlan {
     readonly location?: string;
     readonly tooltip?: string;
 }
-/** Gather every hyperlink cell on a sheet, in row-major order. */
-export declare function collectHyperlinks(sheet: Worksheet): CollectedHyperlink[];
+/**
+ * Gather every hyperlink among a run of cells.
+ *
+ * Takes the cells rather than the sheet, because the streaming writer has to ask this question of a
+ * row at the moment it commits: after that the row's cells are evicted, and a post-hoc walk of
+ * `sheet.rows()` finds nothing. Both writers therefore ask the same function, over whatever cells
+ * they still hold.
+ */
+export declare function collectHyperlinks(cells: Iterable<Cell>): CollectedHyperlink[];
+/** Every cell a sheet still holds, row-major: the live half of what a writer must gather. */
+export declare function liveCells(sheet: Worksheet): Generator<Cell, void, undefined>;
+/** An external hyperlink: the two fields a `TargetMode="External"` relationship needs, both present. */
+export type ExternalHyperlinkPlan = HyperlinkPlan & {
+    readonly relId: string;
+    readonly target: string;
+};
+/**
+ * Whether a planned hyperlink is the external kind, narrowing it so the relationship writer reads
+ * `relId` and `target` as the strings they are.
+ *
+ * A predicate rather than a filter plus two casts: the filter already proved both fields present, and
+ * a cast repeating that proof one line later is a claim the compiler cannot check against the filter
+ * it is supposed to be echoing. `planHyperlinks` sets exactly one of `relId`/`location`, so testing
+ * either field is testing the kind.
+ */
+export declare function isExternalHyperlink(link: HyperlinkPlan): link is ExternalHyperlinkPlan;
 /** Split collected links into internal (location, no rel) and external (relationship) forms, drawing
  * each external link's relationship id from the sheet's allocator so external ids follow every other
  * sheet-local relationship in canonical order. An internal ('#'-prefixed) link consumes no id. */
-export declare function planHyperlinks(links: readonly CollectedHyperlink[], rels: SheetRelIds): HyperlinkPlan[];
+export declare function planHyperlinks(links: readonly CollectedHyperlink[], rels: RelIdAllocator): HyperlinkPlan[];
 /** The `<hyperlinks>` element, or '' when the sheet has none. Attribute order follows CT_Hyperlink:
  * `ref`, `r:id`, `location`, `tooltip`. */
 export declare function hyperlinksXml(links: readonly HyperlinkPlan[]): string;
@@ -34,8 +67,9 @@ interface ParsedHyperlink {
     readonly location?: string;
     readonly tooltip?: string;
 }
-/** Parse every `<hyperlink>` element out of a worksheet part. */
-export declare function parseSheetHyperlinks(xml: string): ParsedHyperlink[];
+/** A pass gathering every `<hyperlink>` element of a worksheet part, for a caller reading the part
+ * alongside its other readers in one parse. */
+export declare function sheetHyperlinkPass(): CollectingPass<ParsedHyperlink[]>;
 /** Fold parsed hyperlinks onto a sheet's cells, wrapping each cell's existing value (its visible
  * 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