@shbernal/ts-xlsx 3.0.0 → 3.2.0

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

@@ -0,0 +1,139 @@
+import type { FormulaPlacement } from '../../core/array-formula-ranges.ts';
+import { type Cell } from '../../core/cell.ts';
+import { type DateEpoch } from '../../core/date.ts';
+import type { ColumnProperties, RowProperties, Worksheet } from '../../core/worksheet.ts';
+import type { WorkbookMetadataTable } from './cell-metadata.ts';
+import type { CommentCell } from './comments.ts';
+import type { SharedFormulaRole } from './shared-formulas.ts';
+import type { SharedStringTable } from './shared-strings.ts';
+import type { StyleRegistry } from './styles.ts';
+/**
+ * The used-cell extent of a sheet: the top-left/bottom-right grid bounds that fold into the
+ * `<dimension>`. Rows carrying only formatting (a row height, an outline level) do not extend the
+ * used range, matching how Excel records `<dimension>`, so {@link add} ignores them. A fresh extent
+ * holds the `Infinity`/`-Infinity` sentinels; {@link isEmpty} reports that no used cell has been seen.
+ */
+export declare class Extent {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    constructor(seed?: Extent);
+    /** Whether no used cell has been folded in yet, in which case the dimension is the lone cell `A1`. */
+    get isEmpty(): boolean;
+    /** Fold a rendered row's used-column span into the extent. `minCol` is `Infinity` when the row
+     * carried no cells (only formatting), which extends nothing. */
+    add(row: number, minCol: number, maxCol: number): void;
+}
+/**
+ * A row the streaming writer already serialised, kept with the attribute string it was built from.
+ *
+ * The attributes are carried rather than re-read out of `xml`, and that is the whole point of the
+ * field. `collapsed="1"` is decided after the row is gone (see {@link FlushedSheet.rowOutline}), so
+ * the summary row has to be patched, and the patcher used to ask `xml.includes(' collapsed="1"')`
+ * whether the attribute was already there. The `<row>` tag's shape is known, but the *cell text*
+ * embedded in it is not: `escapeText` leaves a double quote verbatim, so a cell whose value was the
+ * literal string ` collapsed="1"` answered that question for the row and left the outline group
+ * rendering expanded. A file cannot forge a field.
+ */
+export interface FlushedRow {
+    readonly number: number;
+    readonly xml: string;
+    /** The `<row>` element's own attributes, exactly as {@link renderRow} emitted them. */
+    readonly attrs: string;
+}
+/**
+ * A worksheet's eagerly-serialised rows: each row's `<row>` XML tagged with its number (so it merges
+ * into ascending order with the sheet's remaining live rows, whatever order it was committed in), plus
+ * the used-cell {@link Extent} they span. The buffered pass folds that extent into the sheet's dimension.
+ */
+export interface FlushedSheet {
+    readonly rows: readonly FlushedRow[];
+    readonly extent: Extent;
+    /**
+     * Each flushed row's outline level and hidden flag. Carried across the eviction because both feed
+     * whole-sheet derivations made long after the row is gone from the model: `<sheetFormatPr
+     * outlineLevelRow>` is the deepest level on the sheet, and `collapsed="1"` rides a summary row only
+     * when its whole detail group is hidden, which is a question about *other* rows.
+     *
+     * Carried as the two inputs rather than the derived flag, because the derivation is a look-ahead a
+     * row being finalised cannot do, while its inputs are per-row and known exactly when the row flushes.
+     */
+    readonly rowOutline: ReadonlyMap<number, {
+        readonly outlineLevel: number;
+        readonly hidden: boolean;
+    }>;
+    /**
+     * The notes the flushed rows carried, on the same terms and for the same reason. A note is
+     * serialised outside the `<row>`, into the comments and VML parts, and the buffered pass gathers
+     * notes by walking the sheet's rows at commit time, which finds nothing on a row whose cells have
+     * already been evicted. A hyperlink needs no such record: it lives beside the grid, on the sheet.
+     */
+    readonly notes: readonly CommentCell[];
+    /**
+     * The formulas the flushed rows carried, on the same terms again: whether an array formula's range
+     * holds another formula, or shares a cell with another's, is a question about other rows, and the
+     * writer asks it of the whole sheet at commit.
+     */
+    readonly formulas: readonly FormulaPlacement[];
+}
+/**
+ * A column's style facets are defaults its cells inherit unless they override them; the writer
+ * composes each cell's full style up front (cell over row over column, per facet) so a cell that
+ * overrides one facet still carries the column's others, rather than silently dropping them. Frozen
+ * once by the streaming writer at its first flush so every eagerly-rendered row sees the same defaults.
+ */
+export declare function buildColumnDefaults(sheet: Worksheet): Map<number, ColumnProperties>;
+/** The whole-sheet context a single row needs to serialise: the column defaults it inherits, the
+ * style/string tables it interns into, the shared-formula roles its cells play, and the collapsed
+ * outline summaries whose toggle it must stamp. The streaming writer supplies empty shared-formula
+ * and collapsed-summary sets, since those are whole-sheet derivations a flushed row cannot join. */
+export interface RowRenderContext {
+    readonly columnDefaults: ReadonlyMap<number, ColumnProperties>;
+    readonly styles: StyleRegistry;
+    readonly sharedStrings: SharedStringTable | null;
+    readonly sharedRoles: ReadonlyMap<string, SharedFormulaRole>;
+    readonly collapsedSummaries: ReadonlySet<number>;
+    /** The workbook's date system, which is what a `Date` cell's serial counts from. */
+    readonly dateEpoch: DateEpoch;
+    /** The defined names a bare name in this sheet's formulas resolves to, as `formulaNamesInScope`
+     * gives them: a function passed as a value is written bare where one of them captures its name. */
+    readonly formulaNames: ReadonlySet<string>;
+    /** The workbook's metadata, which a dynamic-array formula's cell and a rich-value error's cell point
+     * into. Shared by every row of every sheet, since the parts it becomes are the workbook's. */
+    readonly cellMetadata: WorkbookMetadataTable;
+}
+/**
+ * Serialise one row to its `<row>` element, or '' when the row has neither data nor its own
+ * formatting. Returns the used-column bounds (`Infinity`/`-Infinity` when nothing was rendered) so a
+ * caller can fold them into the sheet dimension, and the attribute string separately, so a later pass
+ * can ask what this row declared without reading it back out of markup that also holds cell text.
+ * Shared by the buffered sheet pass and the streaming writer's eager flush, so both emit
+ * byte-identical rows.
+ */
+export declare function renderRow(entry: {
+    readonly number: number;
+    readonly cells: readonly Cell[];
+    readonly properties: RowProperties | undefined;
+}, ctx: RowRenderContext): {
+    xml: string;
+    attrs: string;
+    minCol: number;
+    maxCol: number;
+};
+/**
+ * The `<row>` element's opening tag up to its first attribute: the one thing a later pass may rely on
+ * about a rendered row's shape, spelled here so it is the emitter's own string rather than a
+ * re-parse of the emitter's output.
+ */
+export declare function rowOpenTag(number: number): string;
+/**
+ * Refuse an outline depth that is not a non-negative integer, naming what carried it.
+ *
+ * `xsd:unsignedInt` is the attribute's type, so this is what the schema already says. It is asserted
+ * rather than clamped because a negative level is also a hang: the writer finds a group's end by
+ * walking outwards while the neighbouring level exceeds the summary's, and every unmapped row
+ * answers `0`, which exceeds `-1` for as long as there are rows to walk.
+ */
+export declare function assertWritableLevel(name: string, level: number): void;
+export declare function outlineAttr(name: string, level: number | undefined): string;

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

@@ -0,0 +1,222 @@
+import { encodeRange, tryDecodeAnchoredRange } from '../../core/address.js';
+import { cellHasOwnStyle } from '../../core/cell.js';
+import { DEFAULT_DATE_NUMFMT, dateToSerial } from '../../core/date.js';
+import { mangleFormula } from '../../core/formula.js';
+import { NAMED_STYLE_ID } from '../../core/internal.js';
+import { CELL_STYLE_FACETS } from '../../core/style.js';
+import { detectValueType, isArrayFormulaValue, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, isRichTextValue, isSharedFormulaValue, } from '../../core/value.js';
+import { AuthoringError, InternalError, quoted } from '../../errors.js';
+import { boolAttr, checkedToken, escapeAttr, escapeSpreadsheetText, escapeText, numberText, nonDefaultNumAttr, textAttr, textElement, } from '../../xml/xml.js';
+import { richTextRunsXml } from './rich-text.js';
+export class Extent {
+    top = Infinity;
+    left = Infinity;
+    bottom = -Infinity;
+    right = -Infinity;
+    constructor(seed) {
+        if (seed) {
+            this.top = seed.top;
+            this.left = seed.left;
+            this.bottom = seed.bottom;
+            this.right = seed.right;
+        }
+    }
+    get isEmpty() {
+        return this.bottom === -Infinity;
+    }
+    add(row, minCol, maxCol) {
+        if (minCol === Infinity)
+            return;
+        if (row < this.top)
+            this.top = row;
+        if (row > this.bottom)
+            this.bottom = row;
+        if (minCol < this.left)
+            this.left = minCol;
+        if (maxCol > this.right)
+            this.right = maxCol;
+    }
+}
+export function buildColumnDefaults(sheet) {
+    const columnDefaults = new Map();
+    for (const { index, properties } of sheet.columns())
+        columnDefaults.set(index, properties ?? {});
+    return columnDefaults;
+}
+export function renderRow(entry, ctx) {
+    const { number, cells, properties } = entry;
+    const rendered = cells.filter((cell) => cell.value !== null || cellHasOwnStyle(cell));
+    const attrs = rowAttrs(properties, ctx.styles, ctx.collapsedSummaries.has(number));
+    if (rendered.length === 0 && attrs === '') {
+        return { xml: '', attrs: '', minCol: Infinity, maxCol: -Infinity };
+    }
+    const rowFill = properties?.fill;
+    const cellsXml = rendered
+        .map((cell) => {
+        const style = ctx.styles.styleId(composeCellStyle(cell, rowFill, ctx.columnDefaults.get(cell.col)));
+        return cellXml(cell, style, ctx.sharedRoles.get(cell.address), ctx);
+    })
+        .join('');
+    let minCol = Infinity;
+    let maxCol = -Infinity;
+    for (const cell of rendered) {
+        if (cell.col < minCol)
+            minCol = cell.col;
+        if (cell.col > maxCol)
+            maxCol = cell.col;
+    }
+    return { xml: `${rowOpenTag(number)}${attrs}>${cellsXml}</row>`, attrs, minCol, maxCol };
+}
+export function rowOpenTag(number) {
+    return `<row r="${number}"`;
+}
+function composeCellStyle(cell, rowFill, colDef) {
+    const style = {};
+    for (const facet of CELL_STYLE_FACETS)
+        inheritFacet(style, facet, cell, colDef);
+    style.fill = cell.fill ?? rowFill ?? colDef?.fill;
+    style.numFmt = cell.numFmt ?? colDef?.numFmt ?? dateDefaultNumFmt(cell.value);
+    if (cell.quotePrefix !== undefined)
+        style.quotePrefix = cell.quotePrefix;
+    const xfId = cell[NAMED_STYLE_ID];
+    if (xfId !== undefined)
+        style.xfId = xfId;
+    return style;
+}
+function inheritFacet(target, key, cell, colDef) {
+    target[key] = cell[key] ?? colDef?.[key];
+}
+function rowAttrs(properties, styles, collapsedSummary) {
+    if (properties === undefined)
+        return collapsedSummary ? ' collapsed="1"' : '';
+    let attrs = '';
+    if (properties.height !== undefined)
+        attrs += ` ht="${numberText(properties.height)}" customHeight="1"`;
+    if (properties.hidden)
+        attrs += ' hidden="1"';
+    attrs += outlineAttr('outlineLevel', properties.outlineLevel);
+    if (properties.collapsed || collapsedSummary)
+        attrs += ' collapsed="1"';
+    const style = styles.styleId({ fill: properties.fill });
+    if (style !== 0)
+        attrs += ` s="${style}" customFormat="1"`;
+    return attrs;
+}
+function dateDefaultNumFmt(value) {
+    const date = value instanceof Date
+        ? value
+        : (isFormulaValue(value) || isSharedFormulaValue(value) || isArrayFormulaValue(value)) &&
+            value.result instanceof Date
+            ? value.result
+            : undefined;
+    return date !== undefined && !Number.isNaN(date.getTime()) ? DEFAULT_DATE_NUMFMT : undefined;
+}
+function cellElement(ref, s, type, body, cm = '', vm = '') {
+    const attrs = `${s}${type === '' ? '' : ` t="${type}"`}${cm}${vm}`;
+    return body === '' ? `<c r="${ref}"${attrs}/>` : `<c r="${ref}"${attrs}>${body}</c>`;
+}
+const UNWRITABLE = { type: '', v: null };
+const vElement = (v) => (v === null ? '' : `<v>${v}</v>`);
+function valueBody(value, ctx) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? { type: '', v: numberText(value) } : UNWRITABLE;
+    }
+    if (typeof value === 'boolean')
+        return { type: 'b', v: value ? '1' : '0' };
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime())
+            ? UNWRITABLE
+            : { type: '', v: numberText(dateToSerial(value, ctx.dateEpoch)) };
+    }
+    if (isErrorValue(value)) {
+        checkedToken(value.error, isErrorCode, 'cell error value');
+        const vm = ctx.cellMetadata.markRichValueError(value.error);
+        return vm === undefined
+            ? { type: 'e', v: value.error }
+            : { type: 'e', v: '#VALUE!', vm: ` vm="${vm}"` };
+    }
+    return undefined;
+}
+function cellXml(cell, style, shared, ctx) {
+    const { sharedStrings } = ctx;
+    const ref = cell.address;
+    const value = cell.value;
+    const s = style !== 0 ? ` s="${style}"` : '';
+    const formula = cellFormulaXml(cell, s, shared, ctx);
+    if (formula !== undefined)
+        return formula;
+    const body = valueBody(value, ctx);
+    if (body !== undefined)
+        return cellElement(ref, s, body.type, vElement(body.v), '', body.vm);
+    if (typeof value === 'string' || isRichTextValue(value)) {
+        if (sharedStrings !== null) {
+            return cellElement(ref, s, 's', vElement(`${sharedStrings.intern(value)}`));
+        }
+        const inline = typeof value === 'string' ? textElement(value) : richTextRunsXml(value.richText);
+        return cellElement(ref, s, 'inlineStr', `<is>${inline}</is>`);
+    }
+    if (value === null)
+        return cellElement(ref, s, '', '');
+    throw new InternalError(`writing a ${detectValueType(value)} cell value has no arm: every CellValue kind is handled above`);
+}
+function cellFormulaXml(cell, s, shared, ctx) {
+    const { formulaNames } = ctx;
+    const { address: ref, value } = cell;
+    if (shared !== undefined) {
+        if (shared.ref !== undefined && isFormulaValue(value)) {
+            const f = `<f t="shared" ref="${shared.ref}" si="${shared.si}">${escapeText(mangleFormula(value.formula, formulaNames))}</f>`;
+            return formulaBodyXml(ref, s, f, value.result, ctx);
+        }
+        const result = isSharedFormulaValue(value) ? value.result : undefined;
+        return formulaBodyXml(ref, s, `<f t="shared" si="${shared.si}"/>`, result, ctx);
+    }
+    if (isDataTableFormulaValue(value)) {
+        const attrs = `ref="${escapeAttr(value.ref)}"` +
+            boolAttr('dt2D', value.dataTable2D) +
+            boolAttr('dtr', value.dataTableRow) +
+            (value.r1Deleted === true ? ' del1="1"' : '') +
+            (value.r2Deleted === true ? ' del2="1"' : '') +
+            textAttr('r1', value.r1) +
+            textAttr('r2', value.r2);
+        return formulaBodyXml(ref, s, `<f t="dataTable" ${attrs}/>`, value.result, ctx);
+    }
+    if (isArrayFormulaValue(value)) {
+        const cm = value.dynamic === true ? ` cm="${ctx.cellMetadata.markDynamicArray()}"` : '';
+        const f = `<f t="array" ref="${arrayFormulaRange(cell, value.ref)}">${escapeText(mangleFormula(value.formula, formulaNames))}</f>`;
+        return formulaBodyXml(ref, s, f, value.result, ctx, cm);
+    }
+    if (isFormulaValue(value)) {
+        return formulaBodyXml(ref, s, `<f>${escapeText(mangleFormula(value.formula, formulaNames))}</f>`, value.result, ctx);
+    }
+    return undefined;
+}
+function arrayFormulaRange(cell, ref) {
+    const range = tryDecodeAnchoredRange(ref, cell.col, cell.row);
+    if (range === undefined) {
+        throw new AuthoringError(`the array formula in ${cell.address} fills ${quoted(ref)}, which is not a range starting at ${cell.address}`);
+    }
+    return encodeRange(range);
+}
+function formulaBodyXml(ref, s, f, result, ctx, cm = '') {
+    if (result === undefined)
+        return cellElement(ref, s, '', f, cm);
+    const body = valueBody(result, ctx);
+    if (body !== undefined) {
+        return cellElement(ref, s, body.type, f + vElement(body.v), cm, body.vm);
+    }
+    if (typeof result === 'string') {
+        return cellElement(ref, s, 'str', f + vElement(escapeSpreadsheetText(result)), cm);
+    }
+    throw new InternalError('writing a non-primitive formula result has no arm: every FormulaResult kind is handled above');
+}
+export function assertWritableLevel(name, level) {
+    if (Number.isInteger(level) && level >= 0)
+        return;
+    throw new AuthoringError(`${name} must be a non-negative integer, not ${level}`);
+}
+export function outlineAttr(name, level) {
+    if (level === undefined)
+        return '';
+    assertWritableLevel(name, level);
+    return nonDefaultNumAttr(name, level, 0);
+}

package/dist/io/xlsx/shared-formulas.js

@@ -1,4 +1,4 @@
-import { encodeAddress } from '../../core/address.js';
+import { encodeRect } from '../../core/address.js';
 import { isFormulaValue, isSharedFormulaValue } from '../../core/value.js';
 import { AuthoringError } from '../../errors.js';
 export function planSharedFormulas(sheet) {
@@ -35,7 +35,7 @@ export function planSharedFormulas(sheet) {
         }
         roles.set(masterAddress, {
             si,
-            ref: `${encodeAddress(master.col, master.row)}:${encodeAddress(maxCol, maxRow)}`,
+            ref: encodeRect({ top: master.row, left: master.col, bottom: maxRow, right: maxCol }),
         });
         for (const clone of clones)
             roles.set(clone.address, { si });

package/dist/io/xlsx/sheet-properties.d.ts

@@ -1,7 +1,8 @@
-import type { AutoFilter } from '../../core/autofilter.ts';
+import { type AutoFilter } from '../../core/autofilter.ts';
 import { type HeaderFooter, type PageBreak, type PageMargins, type PageSetup, type PrintOptions } from '../../core/page-setup.ts';
 import { type SheetProtection } from '../../core/protection.ts';
 import type { SheetView, Worksheet } from '../../core/worksheet.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 export declare function sheetViewsXml(view: SheetView, active: boolean): string;
 export declare function sheetPrXml(sheet: Worksheet): string;
 export declare function sheetProtectionXml(protection: SheetProtection | undefined): string;
@@ -11,3 +12,11 @@ export declare function printOptionsXml(printOptions: PrintOptions): string;
 export declare function pageMarginsXml(margins: PageMargins): string;
 export declare function pageSetupXml(pageSetup: PageSetup, printerSettingsRelId: string | null): string;
 export declare function pageBreaksXml(breaks: readonly PageBreak[], element: 'rowBreaks' | 'colBreaks'): string;
+export declare function parseSheetProtection(attrs: XmlAttributes): SheetProtection | undefined;
+export declare class PageBreakAccumulator {
+    #private;
+    begin(target: PageBreak[]): void;
+    end(): void;
+    add(attrs: XmlAttributes): void;
+}
+export declare function applySheetProperties(local: string, attrs: XmlAttributes, sheet: Worksheet): void;

package/dist/io/xlsx/sheet-properties.js

@@ -1,16 +1,22 @@
-import { encodeAddress } from '../../core/address.js';
+import { encodeAddress, MAX_COLUMN, MAX_ROW } from '../../core/address.js';
+import { isCustomFilterOperator, } from '../../core/autofilter.js';
 import { HEADER_FOOTER_ELEMENTS, MARGIN_SIDES, PAGE_SETUP_FACETS, PRINT_OPTION_FLAGS, } from '../../core/page-setup.js';
-import { SHEET_PROTECTION_FLAGS } from '../../core/protection.js';
+import { isLegacyPasswordHash, SHEET_PROTECTION_FLAGS, } from '../../core/protection.js';
+import { assertWritableNumber, AuthoringError } from '../../errors.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { boolStrict, boolTristate } from '../../xml/xml-scan.js';
 import { boolAttr, checkedToken, escapeAttr, escapeSpreadsheetText, numAttr, numberText, } from '../../xml/xml.js';
-import { colorAttrs } from './color-xml.js';
+import { colorAttrs, parseColor } from './color-xml.js';
 export function sheetViewsXml(view, active) {
     const selected = active ? ' tabSelected="1"' : '';
     const gridLines = view.showGridLines === false ? ' showGridLines="0"' : '';
-    const xSplit = view.xSplit ?? 0;
-    const ySplit = view.ySplit ?? 0;
-    if (view.state !== 'frozen' || (xSplit === 0 && ySplit === 0)) {
-        return `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0"/></sheetViews>`;
-    }
+    const normal = `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0"/></sheetViews>`;
+    if (view.state !== 'frozen')
+        return normal;
+    const xSplit = frozenSplit('xSplit', view.xSplit, MAX_COLUMN);
+    const ySplit = frozenSplit('ySplit', view.ySplit, MAX_ROW);
+    if (xSplit === 0 && ySplit === 0)
+        return normal;
     const topLeftCell = view.topLeftCell ?? encodeAddress(xSplit + 1, ySplit + 1);
     const activePane = xSplit > 0 && ySplit > 0 ? 'bottomRight' : xSplit > 0 ? 'topRight' : 'bottomLeft';
     const pane = '<pane' +
@@ -20,11 +26,23 @@ export function sheetViewsXml(view, active) {
     const selection = `<selection pane="${activePane}" activeCell="${escapeAttr(topLeftCell)}" sqref="${escapeAttr(topLeftCell)}"/>`;
     return `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0">${pane}${selection}</sheetView></sheetViews>`;
 }
+function frozenSplit(name, value, lines) {
+    if (value === undefined)
+        return 0;
+    assertWritableNumber(value);
+    if (!Number.isInteger(value) || value < 0 || value >= lines) {
+        throw new AuthoringError(`cannot write ${name}="${value}": a frozen split is a whole count from 0 to ${lines - 1}`);
+    }
+    return value;
+}
 export function sheetPrXml(sheet) {
+    const attrs = sheet.codeName === undefined ? '' : ` codeName="${escapeAttr(sheet.codeName)}"`;
     const children = (sheet.tabColor !== undefined ? `<tabColor ${colorAttrs(sheet.tabColor)}/>` : '') +
         outlinePrXml(sheet.outline) +
         pageSetUpPrXml(sheet.pageSetup);
-    return children === '' ? '' : `<sheetPr>${children}</sheetPr>`;
+    if (attrs === '' && children === '')
+        return '';
+    return children === '' ? `<sheetPr${attrs}/>` : `<sheetPr${attrs}>${children}</sheetPr>`;
 }
 function pageSetUpPrXml(pageSetup) {
     return pageSetup.fitToPage ? '<pageSetUpPr fitToPage="1"/>' : '';
@@ -36,14 +54,17 @@ function outlinePrXml(outline) {
 export function sheetProtectionXml(protection) {
     if (protection === undefined)
         return '';
-    const { flags, credential } = protection;
+    const { flags, credential, legacyPasswordHash } = protection;
     let attrs = '';
+    if (legacyPasswordHash !== undefined) {
+        attrs += ` password="${checkedToken(legacyPasswordHash, isLegacyPasswordHash, 'legacy sheet password hash')}"`;
+    }
     if (credential !== undefined) {
         attrs +=
-            ` algorithmName="${credential.algorithmName}"` +
-                ` hashValue="${credential.hashValue}"` +
-                ` saltValue="${credential.saltValue}"` +
-                ` spinCount="${credential.spinCount}"`;
+            ` algorithmName="${escapeAttr(credential.algorithmName)}"` +
+                ` hashValue="${escapeAttr(credential.hashValue)}"` +
+                ` saltValue="${escapeAttr(credential.saltValue)}"` +
+                numAttr('spinCount', credential.spinCount);
     }
     attrs += ' sheet="1"';
     for (const { key, defaultForbidden } of SHEET_PROTECTION_FLAGS) {
@@ -66,7 +87,7 @@ export function autoFilterXml(filter) {
     return `<autoFilter ref="${ref}">${filter.columns.map(filterColumnXml).join('')}</autoFilter>`;
 }
 function filterColumnXml(column) {
-    return `<filterColumn colId="${column.colId}">${filterCriteriaXml(column.criteria)}</filterColumn>`;
+    return `<filterColumn colId="${numberText(column.colId)}">${filterCriteriaXml(column.criteria)}</filterColumn>`;
 }
 function filterCriteriaXml(criteria) {
     if (criteria.kind === 'values') {
@@ -76,7 +97,7 @@ function filterCriteriaXml(criteria) {
     }
     const andAttr = criteria.and ? ' and="1"' : '';
     const predicates = criteria.predicates
-        .map((p) => `<customFilter operator="${p.operator}" val="${escapeAttr(p.val)}"/>`)
+        .map((p) => `<customFilter operator="${checkedToken(p.operator, isCustomFilterOperator, 'custom filter operator')}" val="${escapeAttr(p.val)}"/>`)
         .join('');
     return `<customFilters${andAttr}>${predicates}</customFilters>`;
 }
@@ -137,10 +158,151 @@ export function pageSetupXml(pageSetup, printerSettingsRelId) {
 export function pageBreaksXml(breaks, element) {
     if (breaks.length === 0)
         return '';
+    const manual = breaks.filter((brk) => brk.man !== false).length;
     const brks = breaks
-        .map((brk) => {
-        return `<brk${numAttr('id', brk.id)}${numAttr('max', brk.max)} man="1"/>`;
-    })
+        .map((brk) => `<brk${numAttr('id', brk.id)}${numAttr('min', brk.min)}${numAttr('max', brk.max)}` +
+        `${brk.man === false ? '' : ' man="1"'}/>`)
         .join('');
-    return `<${element} count="${breaks.length}" manualBreakCount="${breaks.length}">${brks}</${element}>`;
+    return `<${element} count="${breaks.length}" manualBreakCount="${manual}">${brks}</${element}>`;
+}
+export function parseSheetProtection(attrs) {
+    if (!boolStrict(attrs.sheet))
+        return undefined;
+    const flags = {};
+    for (const { key } of SHEET_PROTECTION_FLAGS) {
+        const raw = attrs[key];
+        if (raw !== undefined)
+            flags[key] = !boolStrict(raw);
+    }
+    const { algorithmName, hashValue, saltValue, spinCount } = attrs;
+    const spin = numInteger(spinCount, 0);
+    if (algorithmName !== undefined &&
+        hashValue !== undefined &&
+        saltValue !== undefined &&
+        spin !== undefined) {
+        const credential = {
+            algorithmName,
+            hashValue,
+            saltValue,
+            spinCount: spin,
+        };
+        return { flags, credential, ...legacyHash(attrs.password) };
+    }
+    return { flags, ...legacyHash(attrs.password) };
+}
+function legacyHash(password) {
+    return password !== undefined && isLegacyPasswordHash(password)
+        ? { legacyPasswordHash: password }
+        : {};
+}
+export class PageBreakAccumulator {
+    #target = null;
+    begin(target) {
+        this.#target = target;
+    }
+    end() {
+        this.#target = null;
+    }
+    add(attrs) {
+        if (this.#target === null)
+            return;
+        const id = numInteger(attrs.id, 1);
+        if (id === undefined)
+            return;
+        const brk = {
+            id,
+            man: boolStrict(attrs.man),
+        };
+        const min = numInteger(attrs.min, 0);
+        if (min !== undefined)
+            brk.min = min;
+        const max = numInteger(attrs.max, 0);
+        if (max !== undefined)
+            brk.max = max;
+        this.#target.push(brk);
+    }
+}
+export function applySheetProperties(local, attrs, sheet) {
+    switch (local) {
+        case 'sheetPr':
+            if (attrs.codeName !== undefined)
+                sheet.codeName = attrs.codeName;
+            break;
+        case 'tabColor':
+            sheet.tabColor = parseColor(attrs);
+            break;
+        case 'outlinePr':
+            for (const flag of ['summaryBelow', 'summaryRight']) {
+                const value = boolTristate(attrs[flag]);
+                if (value !== undefined)
+                    sheet.outline[flag] = value;
+            }
+            break;
+        case 'sheetView':
+            if (boolTristate(attrs.showGridLines) === false) {
+                sheet.view.showGridLines = false;
+            }
+            break;
+        case 'pane':
+            if (attrs.state === 'frozen' || attrs.state === 'frozenSplit') {
+                sheet.view.state = 'frozen';
+                const xSplit = numInteger(attrs.xSplit, 0);
+                const ySplit = numInteger(attrs.ySplit, 0);
+                if (xSplit !== undefined && xSplit < MAX_COLUMN)
+                    sheet.view.xSplit = xSplit;
+                if (ySplit !== undefined && ySplit < MAX_ROW)
+                    sheet.view.ySplit = ySplit;
+                if (attrs.topLeftCell !== undefined)
+                    sheet.view.topLeftCell = attrs.topLeftCell;
+            }
+            break;
+        case 'pageSetUpPr':
+            if (boolTristate(attrs.fitToPage) !== undefined) {
+                sheet.pageSetup.fitToPage = boolStrict(attrs.fitToPage);
+            }
+            break;
+        case 'printOptions':
+            applyPrintOptions(sheet.printOptions, attrs);
+            break;
+        case 'pageMargins':
+            applyMargins(sheet.pageMargins, attrs);
+            break;
+        case 'pageSetup':
+            applyPageSetup(sheet.pageSetup, attrs);
+            break;
+    }
+}
+function applyPrintOptions(printOptions, attrs) {
+    for (const flag of PRINT_OPTION_FLAGS) {
+        const value = boolTristate(attrs[flag]);
+        if (value !== undefined)
+            printOptions[flag] = value;
+    }
+}
+function applyMargins(margins, attrs) {
+    for (const side of MARGIN_SIDES) {
+        const value = numFinite(attrs[side]);
+        if (value !== undefined)
+            margins[side] = value;
+    }
+}
+function applyPageSetup(pageSetup, attrs) {
+    for (const facet of PAGE_SETUP_FACETS) {
+        const raw = attrs[facet.key];
+        if (facet.kind === 'count') {
+            const value = numInteger(raw, 0);
+            if (value !== undefined)
+                pageSetup[facet.key] = value;
+        }
+        else if (raw === undefined) {
+            continue;
+        }
+        else if (facet.key === 'pageOrder') {
+            if (facet.isValid(raw))
+                pageSetup.pageOrder = raw;
+        }
+        else if (facet.isValid(raw)) {
+            pageSetup.orientation = raw;
+        }
+    }
 }

package/dist/io/xlsx/strict-parts.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A package part's bytes in Transitional: an XML part declaring a Strict namespace has its
+ * declarations and its percentages translated, and any other part is handed back as the same bytes.
+ * Only the opening tags that change are re-rendered, so everything else in the part rides through byte
+ * for byte. A part the scanner cannot read is left as it came, as it would have been carried.
+ */
+export declare function transitionalPart(bytes: Uint8Array, contentType: string): Uint8Array;