@shbernal/ts-xlsx 3.0.0 → 3.2.0

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

@@ -3,20 +3,25 @@ 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}. */
-export declare function dataValidationsXml(entries: readonly DataValidationEntry[]): string;
+ * The extended rules are emitted separately by {@link dataValidationsExtXml}.
+ *
+ * An operand is stored with the function prefixes a cell formula takes, as Excel stores it;
+ * `formulaNames` is `formulaNamesInScope` for the sheet. */
+export declare function dataValidationsXml(entries: readonly DataValidationEntry[], formulaNames: ReadonlySet<string>): string;
 /** The `<ext>` carrying the extended (`<x14:dataValidation>`) rules, or '' when the sheet declares
  * none. Emitted bare (no `<extLst>` wrapper) so the worksheet serialiser can gather it into a single
  * `<extLst>` beside the conditional-formatting extension: a worksheet may carry at most one. */
-export declare function dataValidationsExtXml(entries: readonly DataValidationEntry[]): string;
+export declare function dataValidationsExtXml(entries: readonly DataValidationEntry[], formulaNames: ReadonlySet<string>): string;
 /** 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[]>;
+ * reading the part alongside its other readers in one parse. An operand sheds its function prefixes
+ * against `definedNames`, the workbook's names as `definedNameKeys` spells them. */
+export declare function dataValidationPass(definedNames: ReadonlySet<string>): 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[]>;
+ * symmetrically, handles only the prefixed elements. An operand sheds its function prefixes against
+ * `definedNames`, as the standard pass's does. */
+export declare function extendedDataValidationPass(definedNames: ReadonlySet<string>): 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,23 +1,30 @@
-import { isDataValidationErrorStyle, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { isDataValidationErrorStyle, isDataValidationImeMode, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { mangleFormula, stripFormulaEquals, unmangleFunctions } from '../../core/formula.js';
 import { decodeSqrefRects } from '../../core/merge.js';
+import { coerceNumericLiteral, enumToken } from '../../xml/xml-attrs.js';
 import { TextCapture } from '../../xml/xml-read.js';
-import { boolStrict, coerceNumericLiteral, localName } from '../../xml/xml-scan.js';
-import { checkedToken, escapeAttr, escapeText, stripFormulaEquals, textAttr } from '../../xml/xml.js';
-import { DATA_VALIDATION_EXT_URI, XM_NS } from './namespaces.js';
+import { boolStrict, localName } from '../../xml/xml-scan.js';
+import { checkedToken, escapeAttr, escapeText, textAttr } from '../../xml/xml.js';
+import { admitting } from '../read-policy/read-repair.js';
+import { DATA_VALIDATION_EXT_URI, isExtensionElement, isMainNamespaceElement, XM_NS, } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
 const TYPED = new Set(['whole', 'decimal', 'date', 'time', 'textLength']);
-export function dataValidationsXml(entries) {
+export function dataValidationsXml(entries, formulaNames) {
     const standard = entries.filter((entry) => !entry.extended);
     if (standard.length === 0)
         return '';
-    const items = standard.map(({ sqref, rule }) => dataValidationXml(sqref, rule)).join('');
+    const items = standard
+        .map(({ sqref, rule }) => dataValidationXml(sqref, rule, formulaNames))
+        .join('');
     return `<dataValidations count="${standard.length}">${items}</dataValidations>`;
 }
-export function dataValidationsExtXml(entries) {
+export function dataValidationsExtXml(entries, formulaNames) {
     const extended = entries.filter((entry) => entry.extended);
     if (extended.length === 0)
         return '';
-    const items = extended.map(({ sqref, rule }) => extendedDataValidationXml(sqref, rule)).join('');
+    const items = extended
+        .map(({ sqref, rule }) => extendedDataValidationXml(sqref, rule, formulaNames))
+        .join('');
     return x14Ext(DATA_VALIDATION_EXT_URI, `<x14:dataValidations count="${extended.length}" xmlns:xm="${XM_NS}">${items}</x14:dataValidations>`);
 }
 function ruleAttrs(rule) {
@@ -25,10 +32,14 @@ function ruleAttrs(rule) {
         (rule.errorStyle === undefined
             ? ''
             : ` errorStyle="${checkedToken(rule.errorStyle, isDataValidationErrorStyle, 'data validation error style')}"`) +
+        (rule.imeMode === undefined
+            ? ''
+            : ` imeMode="${checkedToken(rule.imeMode, isDataValidationImeMode, 'data validation IME mode')}"`) +
         (rule.operator === undefined
             ? ''
             : ` operator="${checkedToken(rule.operator, isDataValidationOperator, 'data validation operator')}"`) +
         (rule.allowBlank ? ' allowBlank="1"' : '') +
+        (rule.suppressDropDown ? ' showDropDown="1"' : '') +
         (rule.showInputMessage ? ' showInputMessage="1"' : '') +
         (rule.showErrorMessage ? ' showErrorMessage="1"' : '') +
         textAttr('errorTitle', rule.errorTitle) +
@@ -36,60 +47,54 @@ function ruleAttrs(rule) {
         textAttr('promptTitle', rule.promptTitle) +
         textAttr('prompt', rule.prompt));
 }
-function dataValidationXml(sqref, rule) {
-    const [f1, f2] = operands(rule);
-    const body = (f1 !== undefined ? `<formula1>${escapeText(stripFormulaEquals(f1))}</formula1>` : '') +
-        (f2 !== undefined ? `<formula2>${escapeText(stripFormulaEquals(f2))}</formula2>` : '');
+function dataValidationXml(sqref, rule, formulaNames) {
+    const [f1, f2] = rule.formulae ?? [];
+    const body = (f1 !== undefined ? `<formula1>${operandText(f1, formulaNames)}</formula1>` : '') +
+        (f2 !== undefined ? `<formula2>${operandText(f2, formulaNames)}</formula2>` : '');
     return `<dataValidation${ruleAttrs(rule)} sqref="${escapeAttr(sqref)}">${body}</dataValidation>`;
 }
-function operands(rule) {
-    const drop = (v) => typeof v === 'number' && !Number.isFinite(v) ? undefined : v;
+function extendedDataValidationXml(sqref, rule, formulaNames) {
     const [f1, f2] = rule.formulae ?? [];
-    return [drop(f1), drop(f2)];
-}
-function extendedDataValidationXml(sqref, rule) {
-    const [f1, f2] = operands(rule);
     const body = (f1 !== undefined
-        ? `<x14:formula1><xm:f>${escapeText(stripFormulaEquals(f1))}</xm:f></x14:formula1>`
+        ? `<x14:formula1><xm:f>${operandText(f1, formulaNames)}</xm:f></x14:formula1>`
         : '') +
         (f2 !== undefined
-            ? `<x14:formula2><xm:f>${escapeText(stripFormulaEquals(f2))}</xm:f></x14:formula2>`
+            ? `<x14:formula2><xm:f>${operandText(f2, formulaNames)}</xm:f></x14:formula2>`
             : '') +
         `<xm:sqref>${escapeText(sqref)}</xm:sqref>`;
     return `<x14:dataValidation${ruleAttrs(rule)}>${body}</x14:dataValidation>`;
 }
-export function dataValidationPass() {
+function operandText(operand, formulaNames) {
+    return escapeText(mangleFormula(stripFormulaEquals(operand), formulaNames));
+}
+const FORMULA_ELEMENTS = new Set(['formula1', 'formula2']);
+export function dataValidationPass(definedNames) {
     const entries = [];
     let current;
-    let slot;
+    const formula = new TextCapture(FORMULA_ELEMENTS);
     const handlers = {
-        onOpen(name, attrs) {
+        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) {
-                const built = buildEntry(current.attrs, current.formulae);
+                const built = buildEntry(current.attrs, current.formulae, definedNames);
                 if (built !== undefined)
                     entries.push(built);
                 current = undefined;
@@ -98,14 +103,14 @@ export function dataValidationPass() {
     };
     return { handlers, result: () => entries };
 }
-function buildEntry(attrs, formulae) {
+function buildEntry(attrs, formulae, definedNames) {
     const { sqref } = attrs;
     if (sqref === undefined)
         return undefined;
-    const rule = buildRule(attrs, formulae);
+    const rule = buildRule(attrs, formulae, definedNames);
     return rule === undefined ? undefined : { sqref, rule };
 }
-function buildRule(attrs, formulae) {
+function buildRule(attrs, formulae, definedNames) {
     const { type } = attrs;
     if (type === undefined || !isDataValidationType(type))
         return undefined;
@@ -119,12 +124,17 @@ function buildRule(attrs, formulae) {
     }
     if (boolStrict(attrs.allowBlank))
         rule.allowBlank = true;
+    if (boolStrict(attrs.showDropDown))
+        rule.suppressDropDown = true;
     if (boolStrict(attrs.showInputMessage))
         rule.showInputMessage = true;
     if (boolStrict(attrs.showErrorMessage))
         rule.showErrorMessage = true;
     if (attrs.errorStyle !== undefined && isDataValidationErrorStyle(attrs.errorStyle))
         rule.errorStyle = attrs.errorStyle;
+    const imeMode = enumToken(attrs.imeMode, isDataValidationImeMode);
+    if (imeMode !== undefined)
+        rule.imeMode = imeMode;
     if (attrs.error !== undefined)
         rule.error = attrs.error;
     if (attrs.errorTitle !== undefined)
@@ -135,27 +145,28 @@ function buildRule(attrs, formulae) {
         rule.promptTitle = attrs.promptTitle;
     const parsed = formulae
         .filter((f) => f !== undefined)
+        .map((f) => unmangleFunctions(f, definedNames))
         .map((f) => (type === 'list' || type === 'custom' ? f : coerceNumericLiteral(f)));
     if (parsed.length > 0)
         rule.formulae = parsed;
     return rule;
 }
-export function extendedDataValidationPass() {
+export function extendedDataValidationPass(definedNames) {
     const entries = [];
     let current;
     let slot;
     const capture = new TextCapture(['f', 'sqref']);
     const handlers = {
-        onOpen(name, attrs, selfClosing) {
+        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) {
@@ -165,8 +176,9 @@ export function extendedDataValidationPass() {
         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') {
@@ -177,11 +189,11 @@ export function extendedDataValidationPass() {
                     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) {
-                const built = buildExtendedEntry(current.attrs, current.formulae, current.sqref);
+            else if (ln === 'dataValidation' && extension && current !== undefined) {
+                const built = buildExtendedEntry(current.attrs, current.formulae, current.sqref, definedNames);
                 if (built !== undefined)
                     entries.push(built);
                 current = undefined;
@@ -190,16 +202,18 @@ export function extendedDataValidationPass() {
     };
     return { handlers, result: () => entries };
 }
-function buildExtendedEntry(attrs, formulae, sqref) {
+function buildExtendedEntry(attrs, formulae, sqref, definedNames) {
     if (sqref === '')
         return undefined;
-    const rule = buildRule(attrs, formulae);
+    const rule = buildRule(attrs, formulae, definedNames);
     return rule === undefined ? undefined : { sqref, rule, extended: true };
 }
 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,79 +1,79 @@
-import { strFromU8, strToU8, unzipSync, zipSync } from 'fflate';
+import { strToU8, zipSync } from 'fflate';
 import { VbaAuthorError } from '../../vba/errors.js';
 import { addVbaReference, removeVbaModule, } from '../../vba/project-editor.js';
+import { elementRange } from '../../xml/xml-read.js';
 import { relsPathFor, resolveRelativePart } from '../opc/part-paths.js';
-import { parseRelationshipRecords, relationshipTargetByType } from '../opc/read-opc.js';
+import { packageAccessors, 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 = Object.assign(Object.create(null), unzipSync(xlsx));
-    const binPath = locateVbaProjectPart(files);
-    const bin = binPath === undefined ? undefined : files[binPath];
-    if (binPath === undefined || bin === undefined) {
+function applyToVbaProjectPart(xlsx, options, apply) {
+    const files = inflateSpreadsheetPackage(xlsx, options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED);
+    const pkg = packageAccessors(files);
+    const binPath = locateVbaProjectPart(pkg);
+    const binKey = binPath === undefined ? undefined : pkg.partKey(binPath);
+    const bin = binKey === undefined ? undefined : files[binKey];
+    if (binPath === undefined || binKey === undefined || bin === undefined) {
         throw new VbaAuthorError('package has no VBA project to edit');
     }
-    files[binPath] = apply(bin);
-    dropStaleSignature(files, binPath);
+    files[binKey] = apply(bin);
+    dropStaleSignature(files, pkg, binPath);
     return zipSync(files, { mtime: FIXED_ENTRY_MTIME });
 }
-function locateVbaProjectPart(files) {
-    const rootRels = textPart(files, '_rels/.rels');
-    if (rootRels === undefined)
+function locateVbaProjectPart(pkg) {
+    const workbookPath = readPartRelationships('', pkg.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 resolveRelativePart(workbookPath, vbaTarget);
+    return readPartRelationships(workbookPath, pkg.partText).targetPath(VBA_PROJECT_REL);
 }
-function dropStaleSignature(files, binPath) {
-    const binRelsPath = relsPathFor(binPath);
-    const binRels = textPart(files, binRelsPath);
-    if (binRels === undefined)
+function dropStaleSignature(files, pkg, binPath) {
+    const binRelsKey = pkg.partKey(relsPathFor(binPath));
+    const binRels = binRelsKey === undefined ? undefined : pkg.partText(binRelsKey);
+    if (binRelsKey === undefined || binRels === undefined)
         return;
     const signatureRels = parseRelationshipRecords(binRels).filter((rel) => !rel.external && rel.type.includes(VBA_SIGNATURE_REL_INFIX));
     if (signatureRels.length === 0)
         return;
-    let contentTypes = textPart(files, '[Content_Types].xml');
+    const contentTypesKey = pkg.partKey(CONTENT_TYPES_PART);
+    let contentTypes = contentTypesKey === undefined ? undefined : pkg.partText(contentTypesKey);
     let rels = binRels;
     for (const rel of signatureRels) {
         const partPath = resolveRelativePart(binPath, rel.target);
-        delete files[partPath];
-        rels = removeRelationshipById(rels, rel.id);
-        if (contentTypes !== undefined)
-            contentTypes = removeContentTypeOverride(contentTypes, partPath);
+        const partKey = pkg.partKey(partPath);
+        if (partKey !== undefined)
+            delete files[partKey];
+        const partName = `/${partPath}`.toLowerCase();
+        rels = removeElements(rels, 'Relationship', (attrs) => attrs.Id === rel.id);
+        if (contentTypes !== undefined) {
+            contentTypes = removeElements(contentTypes, 'Override', (attrs) => attrs.PartName?.toLowerCase() === partName);
+        }
     }
     if (parseRelationshipRecords(rels).length === 0)
-        delete files[binRelsPath];
+        delete files[binRelsKey];
     else
-        files[binRelsPath] = strToU8(rels);
-    if (contentTypes !== undefined)
-        files['[Content_Types].xml'] = strToU8(contentTypes);
-}
-function textPart(files, path) {
-    const bytes = files[path];
-    return bytes === undefined ? undefined : strFromU8(bytes);
-}
-function removeRelationshipById(xml, id) {
-    return xml.replace(/<Relationship\b[^>]*?\/>|<Relationship\b[\s\S]*?<\/Relationship>/g, (element) => (new RegExp(`\\bId="${escapeRegExp(id)}"`).test(element) ? '' : element));
-}
-function removeContentTypeOverride(xml, partPath) {
-    return xml.replace(/<Override\b[^>]*?\/>/g, (element) => element.includes(`PartName="/${partPath}"`) ? '' : element);
+        files[binRelsKey] = strToU8(rels);
+    if (contentTypesKey !== undefined && contentTypes !== undefined) {
+        files[contentTypesKey] = strToU8(contentTypes);
+    }
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const CONTENT_TYPES_PART = '[Content_Types].xml';
+function removeElements(xml, local, drop) {
+    let kept = '';
+    let rest = xml;
+    let range = elementRange(rest, [local]);
+    while (range !== undefined) {
+        kept += rest.slice(0, drop(range.attrs) ? range.start : range.end);
+        rest = rest.slice(range.end);
+        range = elementRange(rest, [local]);
+    }
+    return kept + rest;
 }

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,29 +1,26 @@
+import type { Hyperlink } from '../../core/hyperlink.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type CollectingPass } from '../../xml/xml-read.ts';
-import type { SheetRelIds } 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. */
-export interface CollectedHyperlink {
-    readonly ref: string;
-    readonly target: string;
-    readonly tooltip?: string;
-}
+import type { RelationshipLedger } from './package-plan.ts';
 /** A hyperlink resolved for serialisation. An external target carries a `relId` (the sheet
- * relationship holding the URL) plus that `target`; an internal target carries a `location` (the
- * in-workbook reference). Exactly one of `relId`/`location` is ever set. */
+ * relationship holding the URL); an internal target carries a `location` (the in-workbook
+ * reference). Exactly one of `relId`/`location` is ever set. */
 export interface HyperlinkPlan {
     readonly ref: string;
     readonly relId?: string;
-    readonly target?: string;
     readonly location?: string;
     readonly tooltip?: string;
 }
-/** Gather every hyperlink cell on a sheet, in row-major order. */
-export declare function collectHyperlinks(sheet: Worksheet): CollectedHyperlink[];
-/** 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[];
+/**
+ * Split a sheet's links into internal (location, no rel) and external (relationship) forms, recording
+ * each external link's URL in the sheet's ledger so its relationship follows every other sheet-local
+ * relationship in canonical order. An internal (`#`-prefixed) link records nothing.
+ *
+ * The links keep the order the sheet holds them in. That order is what decides which of two links over
+ * one cell `Worksheet.hyperlinkAt` reports, and a re-read adds them in document order, so writing them
+ * any other way would change the answer across a save.
+ */
+export declare function planHyperlinks(links: readonly Hyperlink[], rels: RelationshipLedger): 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;
@@ -38,9 +35,10 @@ interface 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
- * package rather than being handed over as a part path. */
+/**
+ * Put parsed hyperlinks on a sheet, in document order, whatever the cells they cover hold. `targetOf`
+ * resolves a relationship id to its raw Target: a URL for the external links hyperlinks almost always
+ * are, so it must stay unresolved against the package rather than being handed over as a part path.
+ */
 export declare function applyHyperlinks(sheet: Worksheet, links: readonly ParsedHyperlink[], targetOf: (relId: string) => string | undefined): void;
 export {};