@shbernal/ts-xlsx 3.0.0 → 3.2.0

package/dist/core/worksheet.js

@@ -1,14 +1,16 @@
 import { AuthoringError } from '../errors.js';
 import { tokenSet } from '../token-set.js';
-import { decodeCellRef, decodeRange, encodeAddress, tryDecodeCellRef } from './address.js';
+import { assertAxisInBounds, boundedRect, decodeCellRef, encodeAddress, encodeRange, MAX_ROW, tryDecodeAnchoredRange, tryDecodeCellRef, tryDecodeRange, } from './address.js';
+import { arrayRangeConflicts, formulaPlacement, } from './array-formula-ranges.js';
 import { canonicalizeAutoFilter } from './autofilter.js';
 import { applyCellStyle, Cell, copyCellContent } from './cell.js';
 import { Column } from './column.js';
 import { ConditionalFormattingOverlay } from './conditional-formatting-overlay.js';
 import { DataValidationOverlay } from './data-validation-overlay.js';
+import { translateFormula } from './formula-references.js';
 import { GridEdits } from './grid-edits.js';
+import { HyperlinkOverlay } from './hyperlink.js';
 import { INTERNAL } from './internal.js';
-import { MergeIndex } from './merge-index.js';
 import { clearCoveredValues } from './merge.js';
 import { PivotTable } from './pivot-table.js';
 import { deriveCredential, } from './protection.js';
@@ -17,7 +19,9 @@ import { buildRowCells, positionalPlacements, rowPlacements } from './row-input.
 import { Row } from './row.js';
 import { Table } from './table.js';
 import { UsedExtent } from './used-extent.js';
+import { isArrayFormulaValue, isFormulaValue, isSharedFormulaValue, } from './value.js';
 import { WorksheetComments } from './worksheet-comments.js';
+import { WorksheetMerges } from './worksheet-merges.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 });
@@ -26,6 +30,7 @@ export class Worksheet {
     id;
     state;
     tabColor;
+    codeName;
     properties = {};
     outline = {};
     view = {};
@@ -42,42 +47,47 @@ export class Worksheet {
     #pivotTables = [];
     #loadedPivotTables = [];
     #comments = new WorksheetComments(() => this.name);
-    #merges = [];
+    #merges = new WorksheetMerges();
     #images = new WorksheetPictures({
         columnWidth: (col) => this.#columns.get(col + 1)?.width ?? this.properties.defaultColWidth,
         rowHeight: (row) => this.#rowProperties.get(row + 1)?.height ?? this.properties.defaultRowHeight,
     });
     #preservedReferences = [];
-    #mergeRects = [];
     #dataValidations = new DataValidationOverlay();
     #conditionalFormattings = new ConditionalFormattingOverlay();
+    #hyperlinks = new HyperlinkOverlay();
     #protection;
+    #formulaHost;
     #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,
+            mergeRects: this.#merges.rects,
         });
         this.#edits = new GridEdits({
             rows: this.#rows,
             rowProperties: this.#rowProperties,
             columns: this.#columns,
             merges: this.#merges,
-            mergeRects: this.#mergeRects,
             tables: this.#tables,
+            pivotTables: this.#pivotTables,
+            loadedPivotTables: this.#loadedPivotTables,
             images: this.#images.anchors,
             dataValidations: this.#dataValidations,
             conditionalFormattings: this.#conditionalFormattings,
+            hyperlinks: this.#hyperlinks,
             comments: this.#comments,
+            rowBreaks: this.rowBreaks,
+            columnBreaks: this.columnBreaks,
+            sheetName: () => this.name,
+            formulaHost: () => this.#formulaHost,
             autoFilter: {
                 get: () => this.#autoFilter,
                 set: (next) => {
@@ -88,8 +98,7 @@ export class Worksheet {
     }
     getCell(reference) {
         const { col, row } = decodeCellRef(reference);
-        const master = this.#mergeIndex.masterOf(row, col);
-        return this.#cellAt(master.row, master.col);
+        return this[INTERNAL].masterAt(row, col);
     }
     hasCell(row, col) {
         return this.#rows.get(row)?.has(col) ?? false;
@@ -103,7 +112,11 @@ export class Worksheet {
     getRange(referenceOrTop, left, bottom, right) {
         if (typeof referenceOrTop === 'string')
             return rangeFrom(this, referenceOrTop);
-        return new Range(this, referenceOrTop, left ?? 0, bottom ?? 0, right ?? 0);
+        const corners = [left, bottom, right].filter((corner) => corner !== undefined).length + 1;
+        if (left === undefined || bottom === undefined || right === undefined) {
+            throw new AuthoringError(`getRange(top, left, bottom, right) needs all four corners; got ${corners}`);
+        }
+        return new Range(this, referenceOrTop, left, bottom, right);
     }
     get rowCount() {
         return this.#extent.lastRow;
@@ -146,7 +159,7 @@ export class Worksheet {
     }
     addTable(options) {
         const table = new Table(options, {
-            holdsValue: (row, col) => this.hasCell(row, col) && this.#cellAt(row, col).value != null,
+            holdsValue: (row, col) => this.#rows.get(row)?.get(col)?.value != null,
             writeCell: (row, col, value, style) => {
                 const cell = this.#cellAt(row, col);
                 cell.value = value;
@@ -184,11 +197,11 @@ export class Worksheet {
     commentThreadAt(reference) {
         return this.#comments.at(reference);
     }
-    addImage(imageId, anchor) {
-        this.#images.add(imageId, anchor);
+    addImage(imageId, anchor, properties) {
+        this.#images.add(imageId, anchor, properties);
     }
-    addImageAnchor(imageId, anchor) {
-        this.#images.addAnchor(imageId, anchor);
+    addImageAnchor(imageId, anchor, properties) {
+        this.#images.addAnchor(imageId, anchor, properties);
     }
     removeImage(imageId) {
         this.#images.remove(imageId);
@@ -209,21 +222,14 @@ export class Worksheet {
         return this.#preservedReferences;
     }
     mergeCells(range) {
-        const { top, left, bottom, right } = decodeRange(range);
-        if (top !== undefined && left !== undefined && bottom !== undefined && right !== undefined) {
-            const rect = { top, left, bottom, right };
-            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);
+        const rect = this.#merges.add(range);
+        if (rect !== undefined) {
             this.#extent.noteMerge(rect);
             clearCoveredValues(this.#rows, rect);
         }
-        this.#merges.push(range);
     }
     get merges() {
-        return this.#merges;
+        return this.#merges.ranges;
     }
     get autoFilter() {
         return this.#autoFilter;
@@ -232,20 +238,10 @@ export class Worksheet {
         this.#autoFilter = filter === undefined ? undefined : canonicalizeAutoFilter(filter);
     }
     unmergeCells(range) {
-        const index = this.#merges.indexOf(range);
-        if (index === -1)
-            return false;
-        this.#merges.splice(index, 1);
-        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) {
-                this.#mergeRects.splice(rectIndex, 1);
-                this.#mergeIndex.invalidate();
-                this.#extent.invalidate();
-            }
-        }
-        return true;
+        const { existed, rectsChanged } = this.#merges.remove(range);
+        if (rectsChanged)
+            this.#extent.invalidate();
+        return existed;
     }
     addDataValidation(sqref, rule, options = {}) {
         this.#dataValidations.add(sqref, rule, options);
@@ -263,12 +259,26 @@ export class Worksheet {
         const cell = tryDecodeCellRef(reference);
         return cell === undefined ? undefined : this.#dataValidations.at(cell.col, cell.row);
     }
+    addHyperlink(link) {
+        this.#hyperlinks.add(link);
+    }
+    removeHyperlink(ref) {
+        return this.#hyperlinks.remove(ref);
+    }
+    get hyperlinks() {
+        return this.#hyperlinks.entries;
+    }
+    hyperlinkAt(reference) {
+        const cell = tryDecodeCellRef(reference);
+        return cell === undefined ? undefined : this.#hyperlinks.at(cell.col, cell.row);
+    }
     spliceRows(start, count, ...inserts) {
         assertStartAndCount('splice', 'row', start, count);
+        assertSpliceFits('row', start, inserts.length);
+        this.#assertArraysSurvive('row', start, count, inserts.length);
         const inserted = inserts.map((values, i) => buildRowCells(start + i, values, this.#columns));
         this.#edits.spliceRows(start, count, inserted);
-        this.#mergeIndex.invalidate();
-        this.#extent.invalidate();
+        this.#afterStructuralEdit();
     }
     insertRow(pos, values) {
         this.spliceRows(pos, 0, values);
@@ -277,15 +287,21 @@ export class Worksheet {
         return this.addRows([values])[0] ?? [];
     }
     addRows(rows) {
-        let number = this.rowCount;
-        return rows.map((values) => {
-            number += 1;
-            return rowPlacements(values, this.#columns).map(([col, value]) => {
-                const cell = this.#cellAt(number, col);
-                cell.value = value;
-                return cell;
-            });
+        const first = this.rowCount + 1;
+        const planned = rows.map((values, i) => {
+            const row = first + i;
+            const placements = rowPlacements(values, this.#columns);
+            for (const [col] of placements) {
+                assertAxisInBounds('row', row);
+                assertAxisInBounds('column', col);
+            }
+            return { row, placements };
         });
+        return planned.map(({ row, placements }) => placements.map(([col, value]) => {
+            const cell = this.#cellAt(row, col);
+            cell.value = value;
+            return cell;
+        }));
     }
     freeze(ySplit = 1, xSplit = 0) {
         if (!Number.isInteger(ySplit) || ySplit < 0 || !Number.isInteger(xSplit) || xSplit < 0) {
@@ -295,10 +311,11 @@ export class Worksheet {
             this.unfreeze();
             return;
         }
+        const topLeftCell = encodeAddress(xSplit + 1, ySplit + 1);
         this.view.state = 'frozen';
         this.view.xSplit = xSplit;
         this.view.ySplit = ySplit;
-        this.view.topLeftCell = encodeAddress(xSplit + 1, ySplit + 1);
+        this.view.topLeftCell = topLeftCell;
     }
     unfreeze() {
         this.view.state = 'normal';
@@ -309,16 +326,19 @@ export class Worksheet {
     duplicateRow(start, options = {}) {
         const { count = 1, insert = true } = options;
         assertStartAndCount('duplicate', 'row', start, count);
-        const source = this.#rows.get(start);
+        assertSpliceFits('row', start + 1, count);
+        if (insert)
+            this.#assertArraysSurvive('row', start + 1, 0, count);
+        else
+            this.#assertArraysSurvive('row', start + 1, count, count);
         const sourceProperties = this.#rowProperties.get(start);
         const snapshot = (destRow) => {
             const row = new Map();
-            if (source) {
-                for (const [col, cell] of source) {
-                    const copy = new Cell(destRow, col);
-                    copyCellContent(cell, copy);
-                    row.set(col, copy);
-                }
+            for (const [col, cell] of this.#rows.get(start) ?? []) {
+                const copy = new Cell(destRow, col);
+                copyCellContent(cell, copy);
+                copy.value = filledDown(cell.value, destRow - start);
+                row.set(col, copy);
             }
             return row;
         };
@@ -329,23 +349,23 @@ export class Worksheet {
                 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));
+            const blanks = Array.from({ length: count }, () => new Map());
+            this.#edits.spliceRows(start + 1, 0, blanks);
         }
+        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();
+        for (let i = 1; i <= count; i++)
+            this.#hyperlinks.copyRow(start, start + i);
+        this.#afterStructuralEdit();
     }
     spliceColumns(start, count, ...inserts) {
         assertStartAndCount('splice', 'column', start, count);
+        assertSpliceFits('column', start, inserts.length);
+        this.#assertArraysSurvive('column', start, count, inserts.length);
         this.#edits.spliceColumns(start, count, inserts);
-        this.#mergeIndex.invalidate();
-        this.#extent.invalidate();
+        this.#afterStructuralEdit();
     }
     insertColumn(pos, values) {
         this.spliceColumns(pos, 0, values);
@@ -354,15 +374,21 @@ export class Worksheet {
         return this.addColumns([values])[0] ?? [];
     }
     addColumns(columns) {
-        let index = this.columnCount;
-        return columns.map((values) => {
-            index += 1;
-            return positionalPlacements(values).map(([row, value]) => {
-                const cell = this.#cellAt(row, index);
-                cell.value = value;
-                return cell;
-            });
+        const first = this.columnCount + 1;
+        const planned = columns.map((values, i) => {
+            const col = first + i;
+            const placements = positionalPlacements(values);
+            for (const [row] of placements) {
+                assertAxisInBounds('column', col);
+                assertAxisInBounds('row', row);
+            }
+            return { col, placements };
         });
+        return planned.map(({ col, placements }) => placements.map(([row, value]) => {
+            const cell = this.#cellAt(row, col);
+            cell.value = value;
+            return cell;
+        }));
     }
     get model() {
         const model = {};
@@ -370,19 +396,71 @@ export class Worksheet {
             model[facet.key] = facet.read(this);
         return model;
     }
+    #afterStructuralEdit() {
+        this.#extent.invalidate();
+        this.#blockObstructedSpills();
+    }
+    #blockObstructedSpills() {
+        const cells = [...this.#rows.values()].flatMap((cols) => [...cols.values()]);
+        if (!cells.some(({ value }) => isArrayFormulaValue(value) && value.dynamic === true))
+            return;
+        const placements = [];
+        for (const cell of cells) {
+            if (typeof cell.value !== 'object' || cell.value === null)
+                continue;
+            const placement = formulaPlacement(cell.address, cell.col, cell.row, cell.value);
+            if (placement !== undefined)
+                placements.push(placement);
+        }
+        for (const { array } of arrayRangeConflicts(placements)) {
+            const cell = this.#rows.get(array.row)?.get(array.col);
+            if (cell === undefined)
+                continue;
+            const value = cell.value;
+            if (!isArrayFormulaValue(value) || value.dynamic !== true)
+                continue;
+            cell.value = { ...value, ref: cell.address, result: { error: '#SPILL!' } };
+        }
+    }
+    #assertArraysSurvive(axis, start, count, insertCount) {
+        if (count === 0 && insertCount === 0)
+            return;
+        const end = start + count - 1;
+        for (const cols of this.#rows.values()) {
+            for (const cell of cols.values()) {
+                const value = cell.value;
+                if (!isArrayFormulaValue(value) || value.dynamic === true)
+                    continue;
+                const range = tryDecodeAnchoredRange(value.ref, cell.col, cell.row);
+                if (range === undefined)
+                    continue;
+                const lo = axis === 'row' ? range.top : range.left;
+                const hi = axis === 'row' ? range.bottom : range.right;
+                const cuts = count > 0
+                    ? start <= hi && end >= lo && !(start <= lo && end >= hi)
+                    : lo < start && start <= hi;
+                if (cuts) {
+                    const verb = count > 0 ? 'deleting' : 'inserting';
+                    throw new AuthoringError(`${verb} at ${axis} ${start} would cut through the array formula in ${cell.address}, which fills ${value.ref}: Excel refuses to change part of an array, so move or delete the whole range`);
+                }
+            }
+        }
+    }
     #resetContent() {
         this.#rows.clear();
         this.#columns.clear();
         this.#rowProperties.clear();
-        this.#merges.length = 0;
-        this.#mergeRects.length = 0;
+        this.#merges.clear();
         this.#dataValidations.clear();
         this.#conditionalFormattings.clear();
+        this.#hyperlinks.clear();
         this.#tables.length = 0;
-        this.#mergeIndex.invalidate();
         this.#extent.reset();
     }
     set model(model) {
+        const rehearsal = new Worksheet(this.name, this.id);
+        for (const facet of WORKSHEET_MODEL_FACETS)
+            facet.write(rehearsal, model);
         this.#resetContent();
         for (const facet of WORKSHEET_MODEL_FACETS)
             facet.write(this, model);
@@ -404,15 +482,14 @@ export class Worksheet {
         return this.#protection;
     }
     #cellAt(row, col) {
-        let cols = this.#rows.get(row);
-        if (cols === undefined) {
-            cols = new Map();
-            this.#rows.set(row, cols);
-        }
-        let cell = cols.get(col);
+        const cols = this.#rows.get(row);
+        let cell = cols?.get(col);
         if (cell === undefined) {
             cell = new Cell(row, col);
-            cols.set(col, cell);
+            if (cols === undefined)
+                this.#rows.set(row, new Map([[col, cell]]));
+            else
+                cols.set(col, cell);
         }
         this.#extent.noteCell(row, col);
         return cell;
@@ -432,10 +509,21 @@ export class Worksheet {
         addPreservedReference: (reference) => {
             this.#preservedReferences.push(reference);
         },
+        setFormulaHost: (host) => {
+            this.#formulaHost = host;
+        },
+        spliceFormulas: (edit) => {
+            this.#edits.spliceFormulas(edit);
+        },
         restoreProtection: (protection) => {
             this.#protection = protection;
         },
         cellAt: (row, col) => this.#cellAt(row, col),
+        masterAt: (row, col) => {
+            const master = this.#merges.masterOf(row, col);
+            return this.#cellAt(master.row, master.col);
+        },
+        peekCell: (row, col) => this.#rows.get(row)?.get(col),
         rowPropertiesOf: (number) => this.#rowProperties.get(number),
         ensureRowProperties: (number) => {
             let properties = this.#rowProperties.get(number);
@@ -446,6 +534,10 @@ export class Worksheet {
             this.#extent.noteDeclaredRow(number);
             return properties;
         },
+        dropRowProperties: (number) => {
+            if (this.#rowProperties.delete(number))
+                this.#extent.invalidate();
+        },
         rowCells: (number) => {
             const cols = this.#rows.get(number);
             return cols ? [...cols].sort(([a], [b]) => a - b).map(([, cell]) => cell) : [];
@@ -460,6 +552,10 @@ export class Worksheet {
             this.#extent.noteDeclaredColumn(index);
             return properties;
         },
+        dropColumnProperties: (index) => {
+            if (this.#columns.delete(index))
+                this.#extent.invalidate();
+        },
         columnCells: (index) => {
             const cells = [];
             for (const number of [...this.#rows.keys()].sort((a, b) => a - b)) {
@@ -471,11 +567,32 @@ export class Worksheet {
         },
     };
 }
+function filledDown(value, offset) {
+    if (isFormulaValue(value))
+        return { formula: translateFormula(value.formula, 0, offset) };
+    if (isArrayFormulaValue(value)) {
+        const formula = translateFormula(value.formula, 0, offset);
+        const decoded = tryDecodeRange(value.ref);
+        const range = decoded === undefined ? undefined : boundedRect(decoded);
+        if (range === undefined || range.bottom + offset > MAX_ROW)
+            return { formula };
+        const ref = encodeRange({ ...range, top: range.top + offset, bottom: range.bottom + offset });
+        return { shareType: 'array', formula, ref, ...(value.dynamic === true ? { dynamic: true } : {}) };
+    }
+    if (isSharedFormulaValue(value)) {
+        return value.formula === undefined
+            ? { sharedFormula: value.sharedFormula }
+            : { sharedFormula: value.sharedFormula, formula: translateFormula(value.formula, 0, offset) };
+    }
+    return value;
+}
 function assertStartAndCount(verb, axis, start, count) {
-    if (!Number.isInteger(start) || start < 1) {
-        throw new RangeError(`${verb} start ${start} is out of bounds: ${axis}s start at 1`);
-    }
+    assertAxisInBounds(axis, start);
     if (!Number.isInteger(count) || count < 0) {
         throw new RangeError(`${verb} count ${count} is invalid: it must be a non-negative integer`);
     }
 }
+function assertSpliceFits(axis, start, insertCount) {
+    if (insertCount > 0)
+        assertAxisInBounds(axis, start + insertCount - 1);
+}

package/dist/customui/ribbon.js

@@ -1,4 +1,5 @@
 import { strFromU8 } from 'fflate';
+import { isRelType } from '../rel-type.js';
 import { tokenSet } from '../token-set.js';
 import { boolStrict, localName, xmlEvents } from '../xml/xml-scan.js';
 import { CustomUiParseError } from './errors.js';
@@ -7,7 +8,7 @@ export const CUSTOMUI_2009_NAMESPACE = 'http://schemas.microsoft.com/office/2009
 export const CUSTOMUI_2007_REL_TYPE = 'http://schemas.microsoft.com/office/2006/relationships/ui/extensibility';
 export const CUSTOMUI_2010_REL_TYPE = 'http://schemas.microsoft.com/office/2007/relationships/ui/extensibility';
 export function isCustomUiRelType(type) {
-    return type.endsWith('/ui/extensibility');
+    return isRelType(type, 'ui/extensibility');
 }
 const MAX_DEPTH = 256;
 const isKnownControlKind = tokenSet({

package/dist/entries/core.d.ts

@@ -1,25 +1,32 @@
-export { type CellAddress, columnToNumber, decodeAddress, decodeRange, encodeAddress, type GridRect, MAX_COLUMN, MAX_ROW, numberToColumn, type RangeAddress, } from '../core/address.ts';
-export type { AutoFilter, CustomFilter, CustomFilterOperator, CustomFilterPredicate, FilterColumn, FilterCriteria, ValuesFilter, } from '../core/autofilter.ts';
+export { type CellAddress, type CellPosition, columnToNumber, decodeAddress, decodeRange, encodeAddress, type GridRect, MAX_COLUMN, MAX_ROW, numberToColumn, type RangeAddress, } from '../core/address.ts';
+export { type AutoFilter, type CustomFilter, type CustomFilterOperator, type CustomFilterPredicate, type FilterColumn, type FilterCriteria, isCustomFilterOperator, type ValuesFilter, } from '../core/autofilter.ts';
 export { Cell } from '../core/cell.ts';
 export { applyTint, type ColorResolutionContext, DEFAULT_INDEXED_COLORS, resolveColor, SYSTEM_INDEXED_COLORS, } from '../core/color-resolution.ts';
+export { AxisHandle } from '../core/axis-handle.ts';
 export { Column } from '../core/column.ts';
+export type { DateEpoch } from '../core/date.ts';
 export type { Comment, CommentThread, Mention, MentionRef, Person } from '../core/comment-thread.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, 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 CfIcon, type CfIconSetType, type CfTimePeriod, type CfValueObject, type CfValueObjectType, type ConditionalFormatting, type ConditionalFormattingOperator, type ConditionalFormattingRule, type ConditionalFormattingType, type DataBarAxisPosition, type DataBarDirection, type IconSetType, isCfIconSetType, isCfTimePeriod, isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isDataBarAxisPosition, isDataBarDirection, isIconSetType, } from '../core/conditional-formatting.ts';
+export { type Hyperlink } from '../core/hyperlink.ts';
+export { type DataValidation, type DataValidationEntry, type DataValidationErrorStyle, type DataValidationImeMode, type DataValidationOperator, type DataValidationType, isDataValidationErrorStyle, isDataValidationImeMode, isDataValidationOperator, isDataValidationType, } from '../core/data-validation.ts';
+export type { AxisSplice } from '../core/grid-shift.ts';
+export { type AnchoredImage, type AnchorPoint, type Extent, type ImageAnchor, type ImageCrop, type ImageEditAs, type ImageHyperlink, isImageEditAs, isOneCellAnchor, type OneCellAnchor, type PictureProperties, type PortableImage, PX_TO_EMU, type TwoCellAnchor, type WorkbookImage, type WorksheetImages, } from '../core/image.ts';
+export type { ReadPackageOptions } from '../io/opc/read-options.ts';
+export type { PixelAnchor } from '../core/worksheet-pictures.ts';
+export { INVALID_SHEET_NAME_CHARS, MAX_COLUMN_WIDTH, MAX_ROW_HEIGHT, MAX_SHEET_NAME_LENGTH, MAX_TABLE_NAME_LENGTH, TABLE_NAME_PATTERN, } from '../core/limits.ts';
+export { type HeaderFooter, isPageOrder, isPageOrientation, type PageBreak, type PageMargins, type PageOrder, type PageOrientation, type PageSetup, type PrintOptions, } from '../core/page-setup.ts';
+export { type ParsedPivotField, type ParsedPivotSource, type ParsedPivotTable, type PivotCacheField, type PivotItem, type PivotMetric, type PivotNumericSummary, isDeclarablePivotSourceKind, 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';
 export { Range } from '../core/range.ts';
 export { Row } from '../core/row.ts';
-export type { Alignment, Border, BorderEdge, BorderStyle, CellStyle, Color, DifferentialStyle, Fill, FillPatternType, Font, FontScheme, FontVerticalAlignment, GradientFill, GradientStop, HorizontalAlignment, NamedCellStyle, PatternFill, Protection, TableStyleNamespace, TableStyleTable, UnderlineStyle, VerticalAlignment, } from '../core/style.ts';
-export { Table, type TableColumn, type TableColumnStyle, type TableOptions, type TableRegion, type TableStyleInfo, } from '../core/table.ts';
+export { type Alignment, type Border, type BorderEdge, type BorderStyle, type CellContent, type CellStyle, type Color, type Fill, type FillPatternType, type Font, type FontScheme, type FontVerticalAlignment, type GradientFill, type GradientStop, type HorizontalAlignment, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, type PatternFill, type Protection, type UnderlineStyle, type VerticalAlignment, } from '../core/style.ts';
+export { Table, type TableColumn, type TableColumnStyle, isTotalsRowFunction, type TableGrid, type TableOptions, type TableRegion, type TableStyleInfo, type TotalsRowFunction, } from '../core/table.ts';
+export type { DifferentialStyle, NamedCellStyle, TableStyleDefinition, TableStyleNamespace, TableStyleTable, } from '../core/workbook-styles.ts';
 export { isTableStyleElementType, STRIPE_ELEMENT_TYPES, TABLE_STYLE_ELEMENT_TYPES, type TableStyle, type TableStyleElement, type TableStyleElementType, } from '../core/table-style.ts';
 export { estimateWrappedLines } from '../core/text-metrics.ts';
-export { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, THEME_COLOR_SLOTS, type ThemeColorScheme, type ThemeColorSlot, type ThemeFontScheme, type ThemeOverrides, } from '../core/theme.ts';
-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 { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, isThemeColorSlot, THEME_COLOR_SLOTS, type ThemeColorScheme, type ThemeColorSlot, type ThemeFontScheme, type ThemeOverrides, } from '../core/theme.ts';
+export { type ArrayFormulaValue, type CellValue, cellValueToText, coerceCellValue, type DataTableFormulaValue, detectValueType, ERROR_CODES, type ErrorCode, type ErrorValue, type FormulaResult, type FormulaValue, isArrayFormulaValue, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, 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 PreservedTheme, 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, type Visibility, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';
+export { type CellModel, type ColumnProperties, type OutlineProperties, type RowInput, type RowProperties, type SheetView, isVisibility, type Visibility, Worksheet, type WorksheetModel, type WorksheetProperties, type WorksheetState, } from '../core/worksheet.ts';

package/dist/entries/core.js

@@ -1,16 +1,23 @@
 export { columnToNumber, decodeAddress, decodeRange, encodeAddress, MAX_COLUMN, MAX_ROW, numberToColumn, } from '../core/address.js';
+export { isCustomFilterOperator, } from '../core/autofilter.js';
 export { Cell } from '../core/cell.js';
 export { applyTint, DEFAULT_INDEXED_COLORS, resolveColor, SYSTEM_INDEXED_COLORS, } from '../core/color-resolution.js';
+export { AxisHandle } from '../core/axis-handle.js';
 export { Column } from '../core/column.js';
-export { isOneCellAnchor, PX_TO_EMU, } from '../core/image.js';
-export { MAX_COLUMN_WIDTH, MAX_ROW_HEIGHT } from '../core/limits.js';
-export { PivotTable, } from '../core/pivot-table.js';
+export { isCfIconSetType, isCfTimePeriod, isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isDataBarAxisPosition, isDataBarDirection, isIconSetType, } from '../core/conditional-formatting.js';
+export {} from '../core/hyperlink.js';
+export { isDataValidationErrorStyle, isDataValidationImeMode, isDataValidationOperator, isDataValidationType, } from '../core/data-validation.js';
+export { isImageEditAs, isOneCellAnchor, PX_TO_EMU, } from '../core/image.js';
+export { INVALID_SHEET_NAME_CHARS, MAX_COLUMN_WIDTH, MAX_ROW_HEIGHT, MAX_SHEET_NAME_LENGTH, MAX_TABLE_NAME_LENGTH, TABLE_NAME_PATTERN, } from '../core/limits.js';
+export { isPageOrder, isPageOrientation, } from '../core/page-setup.js';
+export { isDeclarablePivotSourceKind, PivotTable, } from '../core/pivot-table.js';
 export { Range } from '../core/range.js';
 export { Row } from '../core/row.js';
-export { Table, } from '../core/table.js';
+export { isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../core/style.js';
+export { Table, isTotalsRowFunction, } from '../core/table.js';
 export { isTableStyleElementType, STRIPE_ELEMENT_TYPES, TABLE_STYLE_ELEMENT_TYPES, } from '../core/table-style.js';
 export { estimateWrappedLines } from '../core/text-metrics.js';
-export { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, THEME_COLOR_SLOTS, } from '../core/theme.js';
-export { cellValueToText, coerceCellValue, detectValueType, ERROR_CODES, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, richTextToPlain, ValueType, } from '../core/value.js';
+export { DEFAULT_THEME_COLOR_SCHEME, DEFAULT_THEME_FONTS, isThemeColorSlot, THEME_COLOR_SLOTS, } from '../core/theme.js';
+export { cellValueToText, coerceCellValue, detectValueType, ERROR_CODES, isArrayFormulaValue, isDataTableFormulaValue, isErrorCode, isErrorValue, isFormulaValue, isRichTextValue, isSharedFormulaValue, richTextToPlain, ValueType, } from '../core/value.js';
 export { DEFAULT_WORKBOOK_VIEW, Workbook, } from '../core/workbook.js';
-export { Worksheet, } from '../core/worksheet.js';
+export { isVisibility, Worksheet, } from '../core/worksheet.js';

package/dist/entries/errors.d.ts

@@ -1,5 +1,6 @@
 export { CustomUiParseError } from '../customui/errors.ts';
 export { AuthoringError, InternalError, XlsxError, type XlsxErrorCode } from '../errors.ts';
+export { CsvParseError } from '../io/csv/errors.ts';
 export { PackageReadError, type UnsupportedFormat, UnsupportedFormatError, } from '../io/opc/errors.ts';
 export { XlsbParseError } from '../io/xlsb/errors.ts';
 export { XlsxParseError } from '../io/xlsx/errors.ts';

package/dist/entries/errors.js

@@ -1,5 +1,6 @@
 export { CustomUiParseError } from '../customui/errors.js';
 export { AuthoringError, InternalError, XlsxError } from '../errors.js';
+export { CsvParseError } from '../io/csv/errors.js';
 export { PackageReadError, UnsupportedFormatError, } from '../io/opc/errors.js';
 export { XlsbParseError } from '../io/xlsb/errors.js';
 export { XlsxParseError } from '../io/xlsx/errors.js';

package/dist/entries/xlsx.d.ts

@@ -1,5 +1,5 @@
 export { editXlsxVbaAddReference, editXlsxVbaRemoveModule } from '../io/xlsx/edit-vba.ts';
-export { type ReadXlsxOptions, readXlsx } from '../io/xlsx/read.ts';
+export { 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';