@shbernal/ts-xlsx 3.0.0 → 3.1.0

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

@@ -1,9 +1,12 @@
 import { isDataValidationErrorStyle, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { stripFormulaEquals } from '../../core/formula.js';
 import { decodeSqrefRects } from '../../core/merge.js';
+import { coerceNumericLiteral } 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 { 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) {
@@ -58,34 +61,30 @@ function extendedDataValidationXml(sqref, rule) {
         `<xm:sqref>${escapeText(sqref)}</xm:sqref>`;
     return `<x14:dataValidation${ruleAttrs(rule)}>${body}</x14:dataValidation>`;
 }
+const FORMULA_ELEMENTS = new Set(['formula1', 'formula2']);
 export function dataValidationPass() {
     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) {
@@ -146,16 +145,16 @@ export function extendedDataValidationPass() {
     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 +164,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,10 +177,10 @@ 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) {
+            else if (ln === 'dataValidation' && extension && current !== undefined) {
                 const built = buildExtendedEntry(current.attrs, current.formulae, current.sqref);
                 if (built !== undefined)
                     entries.push(built);
@@ -200,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, resolveRelativePart } from '../opc/part-paths.js';
-import { parseRelationshipRecords, relationshipTargetByType } from '../opc/read-opc.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 = Object.assign(Object.create(null), 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,20 +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 resolveRelativePart(workbookPath, vbaTarget);
+    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,10 +1,18 @@
+import type { Cell } from '../../core/cell.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type CollectingPass } from '../../xml/xml-read.ts';
-import type { SheetRelIds } from './package-plan.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;
 }
@@ -18,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;

package/dist/io/xlsx/hyperlinks.js

@@ -3,22 +3,30 @@ import { isHyperlinkValue, isRichTextValue } from '../../core/value.js';
 import {} from '../../xml/xml-read.js';
 import { localName } from '../../xml/xml-scan.js';
 import { escapeAttr, textAttr } from '../../xml/xml.js';
-export function collectHyperlinks(sheet) {
+import { relAttr } from '../opc/namespaces.js';
+export function collectHyperlinks(cells) {
     const links = [];
-    for (const { cells } of sheet.rows()) {
-        for (const cell of cells) {
-            const value = cell.value;
-            if (isHyperlinkValue(value)) {
-                links.push({
-                    ref: value.range ?? cell.address,
-                    target: value.hyperlink,
-                    ...(value.tooltip !== undefined ? { tooltip: value.tooltip } : {}),
-                });
-            }
+    for (const cell of cells) {
+        const value = cell.value;
+        if (isHyperlinkValue(value)) {
+            links.push({
+                ref: value.range ?? cell.address,
+                row: cell.row,
+                col: cell.col,
+                target: value.hyperlink,
+                ...(value.tooltip !== undefined ? { tooltip: value.tooltip } : {}),
+            });
         }
     }
     return links;
 }
+export function* liveCells(sheet) {
+    for (const { cells } of sheet.rows())
+        yield* cells;
+}
+export function isExternalHyperlink(link) {
+    return link.relId !== undefined && link.target !== undefined;
+}
 export function planHyperlinks(links, rels) {
     return links.map((link) => {
         const tooltip = link.tooltip !== undefined ? { tooltip: link.tooltip } : {};
@@ -45,15 +53,16 @@ export function sheetHyperlinkPass() {
     const links = [];
     return {
         handlers: {
-            onOpen(name, attrs) {
+            onOpen(name, attrs, _selfClosing, scope) {
                 if (localName(name) !== 'hyperlink')
                     return;
                 const ref = attrs.ref;
                 if (ref === undefined)
                     return;
+                const rid = relAttr(scope, attrs, 'id');
                 links.push({
                     ref,
-                    ...(attrs['r:id'] !== undefined ? { rid: attrs['r:id'] } : {}),
+                    ...(rid !== undefined ? { rid } : {}),
                     ...(attrs.location !== undefined ? { location: attrs.location } : {}),
                     ...(attrs.tooltip !== undefined ? { tooltip: attrs.tooltip } : {}),
                 });

package/dist/io/xlsx/images.js

@@ -1,8 +1,9 @@
 import { isImageEditAs, isOneCellAnchor, } from '../../core/image.js';
-import { parseXml, TextCapture } from '../../xml/xml-read.js';
-import { enumToken, localName, numFinite } from '../../xml/xml-scan.js';
+import { enumToken, numFinite } from '../../xml/xml-attrs.js';
+import { openElements, parseXml, TextCapture } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 import { checkedToken, numAttr, numberText, XML_DECLARATION } from '../../xml/xml.js';
-import { RELATIONSHIPS_NS } from '../opc/namespaces.js';
+import { relAttr, RELATIONSHIPS_NS } from '../opc/namespaces.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { DRAWINGML_NS, XDR_NS } from './namespaces.js';
 const IMAGE_REL_TYPE = `${RELATIONSHIPS_NS}/image`;
@@ -85,7 +86,7 @@ export function parseDrawing(xml) {
     let picDepth = 0;
     const coord = new TextCapture(COORDINATES);
     parseXml(xml, {
-        onOpen(name, attrs, selfClosing) {
+        onOpen(name, attrs, selfClosing, scope) {
             const local = localName(name);
             if (local === 'twoCellAnchor' || local === 'oneCellAnchor') {
                 from = blankPoint();
@@ -116,7 +117,7 @@ export function parseDrawing(xml) {
                     ext = { cx, cy };
             }
             else if (local === 'blip') {
-                const value = attrs['r:embed'] ?? attrs.embed;
+                const value = relAttr(scope, attrs, 'embed');
                 if (value !== undefined)
                     embed = value;
             }
@@ -162,14 +163,11 @@ export function parseDrawing(xml) {
 }
 const UNMODELED_DRAWING_CONTENT = new Set(['graphicFrame', 'sp', 'cxnSp', 'grpSp']);
 export function drawingHasUnmodeledContent(xml) {
-    let found = false;
-    parseXml(xml, {
-        onOpen(name) {
-            if (!found && UNMODELED_DRAWING_CONTENT.has(localName(name)))
-                found = true;
-        },
-    });
-    return found;
+    for (const { local } of openElements(xml)) {
+        if (UNMODELED_DRAWING_CONTENT.has(local))
+            return true;
+    }
+    return false;
 }
 const COORDINATES = new Set(['col', 'colOff', 'row', 'rowOff']);
 function setCoordinate(point, coord, value) {

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

@@ -9,6 +9,7 @@
  * The package-level URIs (`.rels`, content types, the relationship vocabulary) describe the
  * container rather than the spreadsheet inside it, and live in `../opc/namespaces.ts`.
  */
+import type { NamespaceScope } from '../../xml/xml-namespaces.ts';
 /**
  * SpreadsheetML main namespace: the default `xmlns` of the workbook,
  * worksheet, styles, sharedStrings, comments, table and pivot parts.
@@ -53,3 +54,18 @@ export declare const DATABAR_LINK_EXT_URI = "{B025F937-C7B1-47D3-B67F-A62EFF666E
 export declare const DATA_VALIDATION_EXT_URI = "{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}";
 export declare const SLICER_LIST_EXT_URI = "{A8765BA9-456A-4dab-B4F3-ACF838C121DE}";
 export declare const SLICER_CACHES_EXT_URI = "{BBE1A952-AA13-448e-AADC-164F8A28A991}";
+/**
+ * Whether an element belongs to the standard SpreadsheetML vocabulary rather than to an extension.
+ *
+ * This used to be spelled `!name.includes(':')`, on the assumption that only extension elements carry
+ * a prefix. A worksheet may bind the *main* namespace to a prefix instead, which is legal and which
+ * real toolchains emit, and then every element has a colon in it: such a file had every one of its
+ * data validations and conditional formats read as an unknown extension and dropped, silently.
+ *
+ * An unprefixed element counts even when the part declares no default namespace. A part with no
+ * `xmlns` at all is not conforming OOXML, but this scanner does not reject it, such parts were read
+ * before, and a fix that gains files by resolving namespaces should not lose files that have none.
+ */
+export declare function isMainNamespaceElement(scope: NamespaceScope, name: string): boolean;
+/** The complement of {@link isMainNamespaceElement}: an element of one of the extension vocabularies. */
+export declare function isExtensionElement(scope: NamespaceScope, name: string): boolean;

package/dist/io/xlsx/namespaces.js

@@ -11,3 +11,10 @@ export const DATABAR_LINK_EXT_URI = '{B025F937-C7B1-47D3-B67F-A62EFF666E3E}';
 export const DATA_VALIDATION_EXT_URI = '{CCE6A557-97BC-4b89-ADB6-D9C93CAAB3DF}';
 export const SLICER_LIST_EXT_URI = '{A8765BA9-456A-4dab-B4F3-ACF838C121DE}';
 export const SLICER_CACHES_EXT_URI = '{BBE1A952-AA13-448e-AADC-164F8A28A991}';
+export function isMainNamespaceElement(scope, name) {
+    const namespace = scope.elementNamespace(name);
+    return namespace === SPREADSHEETML_NS || (namespace === undefined && !name.includes(':'));
+}
+export function isExtensionElement(scope, name) {
+    return !isMainNamespaceElement(scope, name);
+}

package/dist/io/xlsx/package-plan.d.ts

@@ -5,8 +5,9 @@ import type { Table } from '../../core/table.ts';
 import type { Workbook } from '../../core/workbook.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import type { CommentCell } from './comments.ts';
+import type { HyperlinkPlan } from './hyperlinks.ts';
 import type { DrawingImage } from './images.ts';
-export declare class SheetRelIds {
+export declare class RelIdAllocator {
     #private;
     /** The next relationship id (`rId1`, `rId2`, …), advancing the counter. */
     next(): string;
@@ -108,4 +109,15 @@ export interface MediaPlan {
     resolve(id: number): ResolvedMedia;
 }
 export declare function planMedia(workbook: Workbook, sheets: readonly Worksheet[]): MediaPlan;
-export declare function planPreservedParts(workbook: Workbook, generatedDrawingCount: number, generatedMediaCount: number): PreservedPlan;
+export declare function planPreservedParts(workbook: Workbook, generatedDrawingCount: number, generatedMediaCount: number, generatedPivotCount: number): PreservedPlan;
+export interface SheetPlan {
+    readonly tables: TablePlan[];
+    readonly drawing: DrawingPlan | null;
+    readonly comments: CommentPlan | null;
+    readonly threadedComments: ThreadedCommentPlan | null;
+    readonly printerSettings: PrinterSettingsPlan | null;
+    readonly hyperlinks: HyperlinkPlan[];
+    readonly background: BackgroundPlan | null;
+    readonly preservedRefs: PreservedReferencePlan[];
+    readonly pivots: PivotPlan[];
+}