@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/dist/core/worksheet.d.ts

@@ -15,9 +15,19 @@ import { Row } from './row.ts';
 import type { CellStyle, Color, Fill } from './style.ts';
 import { Table, type TableOptions } from './table.ts';
 import type { CellValue } from './value.ts';
+/**
+ * Whether a thing Excel can hide is showing: a sheet's tab, or the document window itself.
+ *
+ * One type for two schema enumerations. `ST_SheetState` and `ST_Visibility` are declared separately
+ * in ECMA-376 and carry the same three tokens with the same meanings, and `veryHidden` means the same
+ * thing in both: hidden, and not offered in the unhide list.
+ */
+export type Visibility = 'visible' | 'hidden' | 'veryHidden';
+/** Narrow a raw `<sheet state>` or `<workbookView visibility>` token to a known {@link Visibility}. */
+export declare const isVisibility: (value: string) => value is Visibility;
 export interface WorksheetState {
     /** Sheet visibility, as Excel models it. Defaults to `visible`. */
-    readonly state: 'visible' | 'hidden' | 'veryHidden';
+    readonly state: Visibility;
 }
 /** Format defaults applied to every row/column that carries no explicit override. */
 export interface WorksheetProperties {
@@ -266,14 +276,21 @@ export declare class Worksheet {
      * or 0 for an empty sheet. Spans gaps: a value in row 5 makes this 5 even if rows 2–4
      * are empty. This is the used-range extent, not a populated-row tally (see
      * {@link actualRowCount}).
+     *
+     * *Carrying anything* is deliberately wide: a value, a cell's own style facet, quote-prefix flag
+     * or named-style link, a note, a row height or outline level, or a merge reaching down. Styling a
+     * band of empty rows is how a template is laid out, so those rows are used and {@link addRow}
+     * appends past them. A cell merely materialised by {@link getCell} and left untouched carries
+     * nothing, so reading a far address never grows the sheet.
      */
     get rowCount(): number;
     /** The number of rows that hold at least one non-empty cell, ignoring gaps and formatting-only rows. */
     get actualRowCount(): number;
     /**
-     * The 1-based index of the last column carrying anything (a non-empty cell or its own format
+     * The 1-based index of the last column carrying anything (a used cell or the column's own format
      * properties), or 0 for an empty sheet. The used-range width, mirroring {@link rowCount} for the
-     * other axis: a value in column E makes this 5 even if columns B–D are empty.
+     * other axis, down to what *carrying anything* means: a value in column E makes this 5 even if
+     * columns B–D are empty, and a column holding nothing but a styled empty cell is still used.
      */
     get columnCount(): number;
     /**
@@ -538,9 +555,13 @@ export declare class Worksheet {
     /**
      * Copy the row at the 1-based `start`, `options.count` times (default 1). With `options.insert`
      * (the default) the copies are inserted directly after the source, shifting the rows below, and
-     * any merged range there, down by `count`; otherwise the copies overwrite the rows immediately
-     * below without shifting. Each copy is a faithful duplicate of the source's values and per-cell
-     * styles, and carries no merge of its own, so a range can be merged onto a duplicated row afterwards.
+     * any merged range there, down by `count`; otherwise the copies *replace* the rows immediately
+     * below without shifting. A destination row is not overlaid but wholly re-made, so a cell it held
+     * in a column the source leaves empty is dropped, exactly as it would be with a shifting insert.
+     *
+     * Each copy is a faithful duplicate of the source: its cell values, its per-cell styles, and its
+     * row properties (height, hidden, outline level, row fill). It carries no merge of its own, so a
+     * range can be merged onto a duplicated row afterwards.
      *
      * @throws {RangeError} if `start` is not a positive integer or `count` is negative.
      */
@@ -574,7 +595,10 @@ export declare class Worksheet {
      * never disturbs merges or the columns to its left.
      *
      * `values` is an array indexed by row (index 0 → row 1); a hole or an explicit `undefined` leaves
-     * that row untouched, mirroring {@link addRow}'s positional-array shape.
+     * that row untouched, mirroring {@link addRow}'s positional-array shape. That is the only shape a
+     * column takes: the other {@link RowInput} form addresses columns by their
+     * {@link ColumnProperties.key}, and a column's values are indexed by *row*, which carries no key,
+     * so there is nothing on this axis for a keyed object to name.
      */
     addColumn(values: CellValue[]): Cell[];
     /**

package/dist/core/worksheet.js

@@ -1,5 +1,6 @@
 import { AuthoringError } from '../errors.js';
-import { decodeCellRef, decodeRange, encodeAddress, rectsOverlap, tryDecodeCellRef, } from './address.js';
+import { tokenSet } from '../token-set.js';
+import { decodeCellRef, decodeRange, encodeAddress, tryDecodeCellRef } from './address.js';
 import { canonicalizeAutoFilter } from './autofilter.js';
 import { applyCellStyle, Cell, copyCellContent } from './cell.js';
 import { Column } from './column.js';
@@ -7,16 +8,19 @@ import { ConditionalFormattingOverlay } from './conditional-formatting-overlay.j
 import { DataValidationOverlay } from './data-validation-overlay.js';
 import { GridEdits } from './grid-edits.js';
 import { INTERNAL } from './internal.js';
-import { clearCoveredValues, masterOf } from './merge.js';
+import { MergeIndex } from './merge-index.js';
+import { clearCoveredValues } from './merge.js';
 import { PivotTable } from './pivot-table.js';
 import { deriveCredential, } from './protection.js';
 import { Range, rangeFrom } from './range.js';
-import { buildRowCells, rowPlacements } from './row-input.js';
+import { buildRowCells, positionalPlacements, rowPlacements } from './row-input.js';
 import { Row } from './row.js';
-import { Table, TOTALS_ROW_SUBTOTAL_CODE } from './table.js';
+import { Table } from './table.js';
+import { UsedExtent } from './used-extent.js';
 import { WorksheetComments } from './worksheet-comments.js';
 import { WORKSHEET_MODEL_FACETS } from './worksheet-model.js';
 import { WorksheetPictures } from './worksheet-pictures.js';
+export const isVisibility = tokenSet({ visible: true, hidden: true, veryHidden: true });
 export class Worksheet {
     name;
     id;
@@ -50,10 +54,19 @@ export class Worksheet {
     #protection;
     #autoFilter;
     #edits;
+    #extent;
+    #mergeIndex;
     constructor(name, id, state = 'visible') {
         this.name = name;
         this.id = id;
         this.state = state;
+        this.#mergeIndex = new MergeIndex(this.#mergeRects);
+        this.#extent = new UsedExtent({
+            rows: this.#rows,
+            rowProperties: this.#rowProperties,
+            columns: this.#columns,
+            mergeRects: this.#mergeRects,
+        });
         this.#edits = new GridEdits({
             rows: this.#rows,
             rowProperties: this.#rowProperties,
@@ -62,11 +75,20 @@ export class Worksheet {
             mergeRects: this.#mergeRects,
             tables: this.#tables,
             images: this.#images.anchors,
+            dataValidations: this.#dataValidations,
+            conditionalFormattings: this.#conditionalFormattings,
+            comments: this.#comments,
+            autoFilter: {
+                get: () => this.#autoFilter,
+                set: (next) => {
+                    this.#autoFilter = next;
+                },
+            },
         });
     }
     getCell(reference) {
         const { col, row } = decodeCellRef(reference);
-        const master = masterOf(this.#mergeRects, row, col);
+        const master = this.#mergeIndex.masterOf(row, col);
         return this.#cellAt(master.row, master.col);
     }
     hasCell(row, col) {
@@ -84,30 +106,17 @@ export class Worksheet {
         return new Range(this, referenceOrTop, left ?? 0, bottom ?? 0, right ?? 0);
     }
     get rowCount() {
-        let last = 0;
-        for (const [number, cols] of this.#rows) {
-            if (number > last && this.#rowHasContent(cols))
-                last = number;
-        }
-        for (const number of this.#rowProperties.keys()) {
-            if (number > last)
-                last = number;
-        }
-        for (const rect of this.#mergeRects) {
-            if (rect.bottom > last)
-                last = rect.bottom;
-        }
-        return last;
+        return this.#extent.lastRow;
     }
     get actualRowCount() {
         let count = 0;
         for (const cols of this.#rows.values()) {
-            if (this.#rowHasContent(cols))
+            if (this.#rowIsPopulated(cols))
                 count++;
         }
         return count;
     }
-    #rowHasContent(cols) {
+    #rowIsPopulated(cols) {
         for (const cell of cols.values()) {
             if (cell.value !== null)
                 return true;
@@ -115,22 +124,7 @@ export class Worksheet {
         return false;
     }
     get columnCount() {
-        let last = 0;
-        for (const cols of this.#rows.values()) {
-            for (const [col, cell] of cols) {
-                if (cell.value !== null && col > last)
-                    last = col;
-            }
-        }
-        for (const index of this.#columns.keys()) {
-            if (index > last)
-                last = index;
-        }
-        for (const rect of this.#mergeRects) {
-            if (rect.right > last)
-                last = rect.right;
-        }
-        return last;
+        return this.#extent.lastColumn;
     }
     get usedRange() {
         const bottom = this.rowCount;
@@ -151,46 +145,17 @@ export class Worksheet {
         }
     }
     addTable(options) {
-        const table = new Table(options, (row, col, value, style) => {
-            const cell = this.#cellAt(row, col);
-            cell.value = value;
-            if (style !== undefined)
-                applyCellStyle(cell, style);
-        }, (row) => this.spliceRows(row, 0, []));
+        const table = new Table(options, {
+            holdsValue: (row, col) => this.hasCell(row, col) && this.#cellAt(row, col).value != null,
+            writeCell: (row, col, value, style) => {
+                const cell = this.#cellAt(row, col);
+                cell.value = value;
+                if (style !== undefined)
+                    applyCellStyle(cell, style);
+            },
+            insertRow: (row) => this.spliceRows(row, 0, []),
+        });
         this.#tables.push(table);
-        if (table.headerRow) {
-            const { top, left } = table.region;
-            table.columns.forEach((column, index) => {
-                const col = left + index;
-                if (this.hasCell(top, col) && this.#cellAt(top, col).value != null)
-                    return;
-                this.#cellAt(top, col).value = column.name;
-            });
-        }
-        if (table.totalsRow) {
-            const { left, bottom } = table.region;
-            table.columns.forEach((column, index) => {
-                const col = left + index;
-                if (this.hasCell(bottom, col) && this.#cellAt(bottom, col).value != null)
-                    return;
-                if (column.totalsRowLabel !== undefined) {
-                    this.#cellAt(bottom, col).value = column.totalsRowLabel;
-                    return;
-                }
-                if (column.totalsRowFunction !== undefined) {
-                    const code = TOTALS_ROW_SUBTOTAL_CODE[column.totalsRowFunction];
-                    if (code !== undefined) {
-                        this.#cellAt(bottom, col).value = {
-                            formula: `SUBTOTAL(${code},${table.name}[${column.name}])`,
-                        };
-                    }
-                    else if (column.totalsRowFunction === 'custom' &&
-                        column.totalsRowFormula !== undefined) {
-                        this.#cellAt(bottom, col).value = { formula: column.totalsRowFormula };
-                    }
-                }
-            });
-        }
         return table;
     }
     get tables() {
@@ -247,11 +212,12 @@ export class Worksheet {
         const { top, left, bottom, right } = decodeRange(range);
         if (top !== undefined && left !== undefined && bottom !== undefined && right !== undefined) {
             const rect = { top, left, bottom, right };
-            const clash = this.#mergeRects.find((existing) => rectsOverlap(existing, rect));
-            if (clash) {
+            if (this.#mergeIndex.overlapping(rect) !== undefined) {
                 throw new AuthoringError(`merged range "${range}" overlaps an existing merged region`);
             }
             this.#mergeRects.push(rect);
+            this.#mergeIndex.note(rect);
+            this.#extent.noteMerge(rect);
             clearCoveredValues(this.#rows, rect);
         }
         this.#merges.push(range);
@@ -273,8 +239,11 @@ export class Worksheet {
         const { top, left, bottom, right } = decodeRange(range);
         if (top !== undefined && left !== undefined && bottom !== undefined && right !== undefined) {
             const rectIndex = this.#mergeRects.findIndex((r) => r.top === top && r.left === left && r.bottom === bottom && r.right === right);
-            if (rectIndex !== -1)
+            if (rectIndex !== -1) {
                 this.#mergeRects.splice(rectIndex, 1);
+                this.#mergeIndex.invalidate();
+                this.#extent.invalidate();
+            }
         }
         return true;
     }
@@ -298,6 +267,8 @@ export class Worksheet {
         assertStartAndCount('splice', 'row', start, count);
         const inserted = inserts.map((values, i) => buildRowCells(start + i, values, this.#columns));
         this.#edits.spliceRows(start, count, inserted);
+        this.#mergeIndex.invalidate();
+        this.#extent.invalidate();
     }
     insertRow(pos, values) {
         this.spliceRows(pos, 0, values);
@@ -339,6 +310,7 @@ export class Worksheet {
         const { count = 1, insert = true } = options;
         assertStartAndCount('duplicate', 'row', start, count);
         const source = this.#rows.get(start);
+        const sourceProperties = this.#rowProperties.get(start);
         const snapshot = (destRow) => {
             const row = new Map();
             if (source) {
@@ -350,18 +322,30 @@ export class Worksheet {
             }
             return row;
         };
+        const copyProperties = (destRow) => {
+            if (sourceProperties === undefined)
+                this.#rowProperties.delete(destRow);
+            else
+                this.#rowProperties.set(destRow, { ...sourceProperties });
+        };
         if (insert) {
             const copies = Array.from({ length: count }, () => snapshot(start));
             this.#edits.spliceRows(start + 1, 0, copies);
+            this.#mergeIndex.invalidate();
         }
         else {
             for (let i = 1; i <= count; i++)
                 this.#rows.set(start + i, snapshot(start + i));
         }
+        for (let i = 1; i <= count; i++)
+            copyProperties(start + i);
+        this.#extent.invalidate();
     }
     spliceColumns(start, count, ...inserts) {
         assertStartAndCount('splice', 'column', start, count);
         this.#edits.spliceColumns(start, count, inserts);
+        this.#mergeIndex.invalidate();
+        this.#extent.invalidate();
     }
     insertColumn(pos, values) {
         this.spliceColumns(pos, 0, values);
@@ -373,15 +357,11 @@ export class Worksheet {
         let index = this.columnCount;
         return columns.map((values) => {
             index += 1;
-            const cells = [];
-            values.forEach((value, i) => {
-                if (value === undefined)
-                    return;
-                const cell = this.#cellAt(i + 1, index);
+            return positionalPlacements(values).map(([row, value]) => {
+                const cell = this.#cellAt(row, index);
                 cell.value = value;
-                cells.push(cell);
+                return cell;
             });
-            return cells;
         });
     }
     get model() {
@@ -399,6 +379,8 @@ export class Worksheet {
         this.#dataValidations.clear();
         this.#conditionalFormattings.clear();
         this.#tables.length = 0;
+        this.#mergeIndex.invalidate();
+        this.#extent.reset();
     }
     set model(model) {
         this.#resetContent();
@@ -432,12 +414,14 @@ export class Worksheet {
             cell = new Cell(row, col);
             cols.set(col, cell);
         }
+        this.#extent.noteCell(row, col);
         return cell;
     }
     [INTERNAL] = {
         evictRow: (number) => {
             this.#rows.delete(number);
             this.#rowProperties.delete(number);
+            this.#extent.invalidate();
         },
         addLoadedPivotTable: (pivot) => {
             this.#loadedPivotTables.push(pivot);
@@ -459,6 +443,7 @@ export class Worksheet {
                 properties = {};
                 this.#rowProperties.set(number, properties);
             }
+            this.#extent.noteDeclaredRow(number);
             return properties;
         },
         rowCells: (number) => {
@@ -472,6 +457,7 @@ export class Worksheet {
                 properties = {};
                 this.#columns.set(index, properties);
             }
+            this.#extent.noteDeclaredColumn(index);
             return properties;
         },
         columnCells: (index) => {

package/dist/customui/ribbon.js

@@ -1,5 +1,6 @@
 import { strFromU8 } from 'fflate';
-import { boolStrict, localName, xmlEvents } from '../xml/xml-read.js';
+import { tokenSet } from '../token-set.js';
+import { boolStrict, localName, xmlEvents } from '../xml/xml-scan.js';
 import { CustomUiParseError } from './errors.js';
 export const CUSTOMUI_2006_NAMESPACE = 'http://schemas.microsoft.com/office/2006/01/customui';
 export const CUSTOMUI_2009_NAMESPACE = 'http://schemas.microsoft.com/office/2009/07/customui';
@@ -9,26 +10,26 @@ export function isCustomUiRelType(type) {
     return type.endsWith('/ui/extensibility');
 }
 const MAX_DEPTH = 256;
-const KNOWN_KINDS = new Set([
-    'button',
-    'toggleButton',
-    'checkBox',
-    'editBox',
-    'dropDown',
-    'comboBox',
-    'gallery',
-    'menu',
-    'dynamicMenu',
-    'splitButton',
-    'buttonGroup',
-    'box',
-    'labelControl',
-    'separator',
-    'menuSeparator',
-    'dialogBoxLauncher',
-    'control',
-    'item',
-]);
+const isKnownControlKind = tokenSet({
+    button: true,
+    toggleButton: true,
+    checkBox: true,
+    editBox: true,
+    dropDown: true,
+    comboBox: true,
+    gallery: true,
+    menu: true,
+    dynamicMenu: true,
+    splitButton: true,
+    buttonGroup: true,
+    box: true,
+    labelControl: true,
+    separator: true,
+    menuSeparator: true,
+    dialogBoxLauncher: true,
+    control: true,
+    item: true,
+});
 export function parseCustomUi(input) {
     const xml = typeof input === 'string' ? input : strFromU8(input);
     let root;
@@ -79,9 +80,7 @@ function toGroup(groupEl) {
     };
 }
 function toControl(el) {
-    const kind = KNOWN_KINDS.has(el.local)
-        ? el.local
-        : 'unknown';
+    const kind = isKnownControlKind(el.local) ? el.local : 'unknown';
     return {
         kind,
         ...identity(el.attrs),

package/dist/entries/core.d.ts

@@ -4,11 +4,11 @@ export { Cell } from '../core/cell.ts';
 export { applyTint, type ColorResolutionContext, DEFAULT_INDEXED_COLORS, resolveColor, SYSTEM_INDEXED_COLORS, } from '../core/color-resolution.ts';
 export { Column } from '../core/column.ts';
 export type { Comment, CommentThread, Mention, MentionRef, Person } from '../core/comment-thread.ts';
-export type { CfValueObject, ConditionalFormatting, ConditionalFormattingRule, } from '../core/conditional-formatting.ts';
+export type { CfTimePeriod, CfValueObject, CfValueObjectType, ConditionalFormatting, ConditionalFormattingOperator, ConditionalFormattingRule, ConditionalFormattingType, IconSetType, } from '../core/conditional-formatting.ts';
 export type { DataValidation, DataValidationEntry, DataValidationErrorStyle, DataValidationOperator, DataValidationType, } from '../core/data-validation.ts';
 export { type AnchoredImage, type AnchorPoint, type Extent, type ImageAnchor, type ImageEditAs, isOneCellAnchor, type OneCellAnchor, type PortableImage, PX_TO_EMU, type TwoCellAnchor, type WorkbookImage, type WorksheetImages, } from '../core/image.ts';
 export { MAX_COLUMN_WIDTH, MAX_ROW_HEIGHT } from '../core/limits.ts';
-export type { HeaderFooter, PageBreak, PageMargins, PageSetup, PrintOptions, } from '../core/page-setup.ts';
+export type { HeaderFooter, PageBreak, PageMargins, PageOrder, PageOrientation, PageSetup, PrintOptions, } from '../core/page-setup.ts';
 export { type ParsedPivotField, type ParsedPivotSource, type ParsedPivotTable, type PivotCacheField, type PivotItem, type PivotMetric, type PivotNumericSummary, type PivotRecordCell, type PivotSourceKind, PivotTable, type PivotTableOptions, } from '../core/pivot-table.ts';
 export type { PreservedPart, PreservedRelationship, PreservedRootReference, PreservedWorksheetReference, } from '../core/preserved.ts';
 export type { SheetProtection, SheetProtectionCredential, SheetProtectionFlags, SheetProtectionOptions, } from '../core/protection.ts';
@@ -22,4 +22,4 @@ export { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, THEME_COLOR_SLOTS, typ
 export { type CellValue, cellValueToText, coerceCellValue, type DataTableFormulaValue, detectValueType, ERROR_CODES, type ErrorCode, type ErrorValue, type FormulaResult, type FormulaValue, type HyperlinkValue, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, type RichTextRun, type RichTextValue, richTextToPlain, type SharedFormulaValue, ValueType, } from '../core/value.ts';
 export { type AddImageOptions, type AddWorksheetOptions, DEFAULT_WORKBOOK_VIEW, type DefinedName, type PreservedWorkbookReference, Workbook, type WorkbookProperties, type WorkbookView, } from '../core/workbook.ts';
 export type { WorkbookProtection, WorkbookProtectionCredentialAttr, } from '../core/workbook-protection.ts';
-export { type CellModel, type ColumnProperties, type OutlineProperties, type RowInput, type RowProperties, type SheetView, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';
+export { type CellModel, type ColumnProperties, type OutlineProperties, type RowInput, type RowProperties, type SheetView, type Visibility, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';

package/dist/entries/csv.d.ts

@@ -1,2 +1,2 @@
 export { type CsvReadOptions, readCsv } from '../io/csv/read.ts';
-export { type CsvWriteOptions, writeCsv, writeCsvText } from '../io/csv/write.ts';
+export { type CsvEncoding, type CsvWriteOptions, writeCsv, writeCsvText } from '../io/csv/write.ts';

package/dist/entries/node-unavailable.d.ts

@@ -0,0 +1,15 @@
+/** Not available outside Node; see {@link WorkbookStreamWriter}. */
+export declare class StreamedRow {
+    constructor();
+}
+/** Not available outside Node; see {@link WorkbookStreamWriter}. */
+export declare class WorksheetStreamWriter {
+    constructor();
+}
+/**
+ * Not available outside Node. The streaming writer needs `node:fs` and `node:stream`; in a browser,
+ * build the workbook in memory and call `writeXlsx`.
+ */
+export declare class WorkbookStreamWriter {
+    constructor();
+}

package/dist/entries/node-unavailable.js

@@ -0,0 +1,20 @@
+const WHY = 'the streaming writer opens files and pipes Node streams, which a browser has neither of. ' +
+    'Use writeXlsx (or writeXlsxAsync), which produce the same package as bytes.';
+function unavailable(name) {
+    throw new Error(`ts-xlsx: ${name} is not available in this environment: ${WHY}`);
+}
+export class StreamedRow {
+    constructor() {
+        unavailable('StreamedRow');
+    }
+}
+export class WorksheetStreamWriter {
+    constructor() {
+        unavailable('WorksheetStreamWriter');
+    }
+}
+export class WorkbookStreamWriter {
+    constructor() {
+        unavailable('WorkbookStreamWriter');
+    }
+}

package/dist/entries/node.d.ts

@@ -0,0 +1 @@
+export { type CalcProperties, StreamedRow, WorkbookStreamWriter, type WorkbookStreamWriterOptions, WorksheetStreamWriter, } from '../io/xlsx/write-stream.ts';

package/dist/entries/node.js

@@ -0,0 +1 @@
+export { StreamedRow, WorkbookStreamWriter, WorksheetStreamWriter, } from '../io/xlsx/write-stream.js';

package/dist/entries/xlsx.d.ts

@@ -3,4 +3,3 @@ export { type ReadXlsxOptions, readXlsx } from '../io/xlsx/read.ts';
 export { type ReadSheetRowsOptions, readSheetRows, readWorkbookStream, } from '../io/xlsx/read-rows.ts';
 export { DEFAULT_THEME_XML, parseThemeColorScheme, parseThemeFontScheme, } from '../io/xlsx/theme-xml.ts';
 export { type WriteOptions, writeXlsx, writeXlsxAsync } from '../io/xlsx/write.ts';
-export { type CalcProperties, StreamedRow, WorkbookStreamWriter, type WorkbookStreamWriterOptions, WorksheetStreamWriter, } from '../io/xlsx/write-stream.ts';

package/dist/entries/xlsx.js

@@ -3,4 +3,3 @@ export { readXlsx } from '../io/xlsx/read.js';
 export { readSheetRows, readWorkbookStream, } from '../io/xlsx/read-rows.js';
 export { DEFAULT_THEME_XML, parseThemeColorScheme, parseThemeFontScheme, } from '../io/xlsx/theme-xml.js';
 export { writeXlsx, writeXlsxAsync } from '../io/xlsx/write.js';
-export { StreamedRow, WorkbookStreamWriter, WorksheetStreamWriter, } from '../io/xlsx/write-stream.js';

package/dist/io/csv/read.js

@@ -1,6 +1,6 @@
 import { Workbook } from '../../core/workbook.js';
 export function readCsv(input, options = {}) {
-    const text = stripBom(typeof input === 'string' ? input : Buffer.from(input).toString('utf8'));
+    const text = stripBom(typeof input === 'string' ? input : new TextDecoder('utf-8', { ignoreBOM: true }).decode(input));
     const delimiter = options.delimiter ?? ',';
     if (delimiter.length !== 1) {
         throw new RangeError(`CSV delimiter must be a single character, got ${JSON.stringify(delimiter)}`);

package/dist/io/csv/write.d.ts

@@ -1,5 +1,15 @@
 import { type CellValue } from '../../core/value.ts';
 import type { Workbook } from '../../core/workbook.ts';
+/**
+ * A byte encoding {@link writeCsv} can produce, spelled the way Node's `Buffer` spells it and
+ * meaning the same bytes.
+ *
+ * Named here rather than taken from Node's `BufferEncoding`, which is what this option used to be:
+ * that type is part of `@types/node`, so it made a browser consumer's public API surface depend on
+ * Node's types, and it offered `base64` and `hex` as if they were output encodings for a text
+ * format. The list is what a CSV consumer actually asks for.
+ */
+export type CsvEncoding = 'ascii' | 'latin1' | 'ucs-2' | 'ucs2' | 'utf-8' | 'utf-16le' | 'utf16le' | 'utf8';
 export interface CsvWriteOptions {
     /** Which worksheet to write; defaults to the first. A name matching no sheet throws rather than
      * silently emitting an empty file. */
@@ -14,7 +24,7 @@ export interface CsvWriteOptions {
     /** Render Date cells in UTC rather than the runner's local time. */
     readonly dateUTC?: boolean;
     /** Byte encoding for {@link writeCsv}; defaults to `"utf8"`. */
-    readonly encoding?: BufferEncoding;
+    readonly encoding?: CsvEncoding;
     /** Prepend a UTF-8 byte-order mark (applies only to UTF-8); defaults to `true` for UTF-8. */
     readonly bom?: boolean;
     /** Per-field transform replacing the default value rendering; receives the cell's value (`null`
@@ -28,6 +38,6 @@ export declare function writeCsvText(workbook: Workbook, options?: CsvWriteOptio
  * The CSV bytes of one worksheet in the requested encoding, with a UTF-8 BOM by default.
  *
  * @throws {AuthoringError} if a field holds an unpaired surrogate and the encoding is UTF-8, which
- * cannot represent one. The alternative is `Buffer.from`'s silent U+FFFD substitution.
+ * cannot represent one. The alternative is a silent U+FFFD substitution.
  */
 export declare function writeCsv(workbook: Workbook, options?: CsvWriteOptions): Uint8Array;

package/dist/io/csv/write.js

@@ -30,10 +30,10 @@ export function writeCsv(workbook, options = {}) {
     const utf8 = isUtf8(encoding);
     if (utf8)
         assertEncodable(text);
-    const body = Buffer.from(text, encoding);
+    const body = encode(text, encoding);
     const wantBom = options.bom ?? utf8;
     if (!wantBom || !utf8)
-        return Uint8Array.from(body);
+        return body;
     const out = new Uint8Array(UTF8_BOM.length + body.length);
     out.set(UTF8_BOM, 0);
     out.set(body, UTF8_BOM.length);
@@ -42,6 +42,21 @@ export function writeCsv(workbook, options = {}) {
 function isUtf8(encoding) {
     return encoding === 'utf8' || encoding === 'utf-8';
 }
+function encode(text, encoding) {
+    if (isUtf8(encoding))
+        return new TextEncoder().encode(text);
+    if (encoding === 'ascii' || encoding === 'latin1') {
+        const bytes = new Uint8Array(text.length);
+        for (let i = 0; i < text.length; i++)
+            bytes[i] = text.charCodeAt(i) & 0xff;
+        return bytes;
+    }
+    const bytes = new Uint8Array(text.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < text.length; i++)
+        view.setUint16(i * 2, text.charCodeAt(i), true);
+    return bytes;
+}
 function assertEncodable(text) {
     const found = LONE_SURROGATE.exec(text);
     if (found === null)

package/dist/io/opc/inflate.js

@@ -1,8 +1,9 @@
 import { Unzip, UnzipInflate } from 'fflate';
+import { concat } from '../../bytes.js';
 import { PackageReadError } from './errors.js';
 const INPUT_SLICE = 1 << 14;
 export function inflatePackage(data, cap) {
-    const files = {};
+    const files = Object.create(null);
     let total = 0;
     let failure;
     const unzip = new Unzip((file) => {
@@ -23,7 +24,7 @@ export function inflatePackage(data, cap) {
             chunks.push(chunk);
             size += chunk.length;
             if (final)
-                files[file.name] = join(chunks, size);
+                files[file.name] = concat(chunks, size);
         };
         try {
             file.start();
@@ -43,14 +44,3 @@ export function inflatePackage(data, cap) {
         throw failure;
     return files;
 }
-function join(chunks, size) {
-    if (chunks.length === 1)
-        return chunks[0];
-    const out = new Uint8Array(size);
-    let at = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, at);
-        at += chunk.length;
-    }
-    return out;
-}