@cj-tech-master/excelts 1.6.3 → 2.0.0

package/dist/types/csv/csv-core.d.ts

@@ -0,0 +1,207 @@
+/**
+ * CSV Parser and Formatter - RFC 4180 compliant
+ *
+ * A lightweight, cross-platform CSV implementation that works in both
+ * Node.js and Browser environments with zero dependencies.
+ *
+ * High-performance RFC 4180 compliant CSV parser and formatter.
+ *
+ * @see https://tools.ietf.org/html/rfc4180
+ */
+/** Header array type (can include undefined to skip columns) */
+export type HeaderArray = (string | undefined | null)[];
+/** Header transform function */
+export type HeaderTransformFunction = (headers: string[]) => HeaderArray;
+/** Row types */
+export type RowArray = string[];
+export type RowMap = Record<string, string>;
+export type Row = RowArray | RowMap;
+/** Row transform callback */
+export type RowTransformCallback<T> = (error?: Error | null, row?: T | null) => void;
+/** Row transform function - sync or async */
+export type RowTransformFunction<I = Row, O = Row> = ((row: I) => O | null) | ((row: I, callback: RowTransformCallback<O>) => void);
+/** Row validate callback */
+export type RowValidateCallback = (error?: Error | null, isValid?: boolean, reason?: string) => void;
+/** Row validate function - sync or async */
+export type RowValidateFunction<T = Row> = ((row: T) => boolean) | ((row: T, callback: RowValidateCallback) => void);
+/** Validation result */
+export interface RowValidationResult<T = Row> {
+    row: T | null;
+    isValid: boolean;
+    reason?: string;
+}
+/**
+ * CSV parsing options
+ */
+export interface CsvParseOptions {
+    /** Field delimiter (default: ",") */
+    delimiter?: string;
+    /** Quote character (default: '"'), set to false or null to disable quoting */
+    quote?: string | false | null;
+    /** Escape character for quotes (default: '"'), set to false or null to disable */
+    escape?: string | false | null;
+    /** Skip empty lines (default: false) */
+    skipEmptyLines?: boolean;
+    /** Alias for skipEmptyLines */
+    ignoreEmpty?: boolean;
+    /** Trim whitespace from both sides of fields (default: false) */
+    trim?: boolean;
+    /** Left trim whitespace from fields (default: false) */
+    ltrim?: boolean;
+    /** Right trim whitespace from fields (default: false) */
+    rtrim?: boolean;
+    /**
+     * Header handling:
+     * - true: first row is headers, return objects
+     * - false: no headers, return arrays
+     * - string[]: use these as headers
+     * - function: transform first row headers
+     */
+    headers?: boolean | HeaderArray | HeaderTransformFunction;
+    /**
+     * If true and headers is string[], discard first row and use provided headers
+     */
+    renameHeaders?: boolean;
+    /** Comment character - lines starting with this are ignored */
+    comment?: string;
+    /** Maximum number of data rows to parse (excluding header) */
+    maxRows?: number;
+    /** Number of lines to skip at the beginning (before header detection) */
+    skipLines?: number;
+    /** Number of data rows to skip (after header detection) */
+    skipRows?: number;
+    /**
+     * Strict column handling:
+     * - If true, rows with column count mismatch emit 'data-invalid' event
+     * - If false (default), throws error on mismatch (unless discardUnmappedColumns)
+     */
+    strictColumnHandling?: boolean;
+    /**
+     * If true, discard columns that exceed header count
+     * Only valid when headers are specified
+     */
+    discardUnmappedColumns?: boolean;
+    /**
+     * Enable object mode (default: true for Node.js streams)
+     * - true: push row objects/arrays
+     * - false: push JSON strings
+     */
+    objectMode?: boolean;
+    /**
+     * Character encoding for input (default: "utf8")
+     * Only used in Node.js streaming context
+     */
+    encoding?: BufferEncoding;
+    /**
+     * Synchronous transform function to apply to each row after parsing
+     * Return null/undefined to skip the row
+     * Works in both Node.js and Browser environments
+     *
+     * @example
+     * // With headers (row is Record<string, string>)
+     * transform: (row) => ({ ...row, name: row.name.toUpperCase() })
+     *
+     * // Without headers (row is string[])
+     * transform: (row) => [row[0].toUpperCase(), row[1]]
+     */
+    transform?: (row: Row) => Row | null | undefined;
+    /**
+     * Synchronous validate function to check each row
+     * Return false to mark row as invalid (will be in invalidRows)
+     * Can also return { isValid: boolean, reason?: string }
+     * Works in both Node.js and Browser environments
+     *
+     * @example
+     * // With headers
+     * validate: (row) => row.name !== ''
+     *
+     * // With custom reason
+     * validate: (row) => ({ isValid: row.age >= 18, reason: 'Must be adult' })
+     */
+    validate?: (row: Row) => boolean | {
+        isValid: boolean;
+        reason?: string;
+    };
+}
+/**
+ * CSV formatting options
+ */
+export interface CsvFormatOptions {
+    /** Field delimiter (default: ",") */
+    delimiter?: string;
+    /** Quote character (default: '"'), set to false or null to disable quoting */
+    quote?: string | false | null;
+    /** Escape character (default: same as quote) */
+    escape?: string | false | null;
+    /** Row delimiter (default: "\n") */
+    rowDelimiter?: string;
+    /** Always quote all fields (default: false, only quote when necessary) */
+    alwaysQuote?: boolean;
+    /** Quote specific columns by name or index */
+    quoteColumns?: boolean | boolean[] | Record<string, boolean>;
+    /** Quote header fields */
+    quoteHeaders?: boolean | boolean[] | Record<string, boolean>;
+    /**
+     * Header handling:
+     * - true: auto-detect headers from first object
+     * - false/null: no headers
+     * - string[]: use these as headers
+     */
+    headers?: string[] | boolean | null;
+    /**
+     * Whether to write headers (default: true when headers is provided)
+     * Set to false to suppress header row output
+     */
+    writeHeaders?: boolean;
+    /** Include BOM for UTF-8 (default: false) */
+    writeBOM?: boolean;
+    /** Include final row delimiter (default: true) */
+    includeEndRowDelimiter?: boolean;
+    /** Write headers even when there's no data (default: false) */
+    alwaysWriteHeaders?: boolean;
+    /**
+     * Transform function to apply to each row before formatting
+     * Can be sync (returns row) or async (calls callback)
+     */
+    transform?: RowTransformFunction<Row, Row>;
+    /**
+     * Enable object mode (default: true for Node.js streams)
+     * - true: accept row objects/arrays directly
+     * - false: accept JSON strings
+     */
+    objectMode?: boolean;
+}
+/**
+ * Parsed CSV result with headers
+ */
+export interface CsvParseResult<T = string[]> {
+    /** Header row (if headers option was true) */
+    headers?: string[];
+    /** Data rows */
+    rows: T[];
+    /** Invalid rows (when strictColumnHandling is true) */
+    invalidRows?: {
+        row: string[];
+        reason: string;
+    }[];
+}
+/**
+ * Check if a transform function is synchronous (1 argument) vs async (2 arguments)
+ */
+export declare function isSyncTransform<I, O>(transform: RowTransformFunction<I, O>): transform is (row: I) => O | null;
+/**
+ * Check if a validate function is synchronous (1 argument) vs async (2 arguments)
+ */
+export declare function isSyncValidate<T>(validate: RowValidateFunction<T>): validate is (row: T) => boolean;
+/**
+ * Parse a CSV string into rows of fields
+ */
+export declare function parseCsv(input: string, options?: CsvParseOptions): string[][] | CsvParseResult<Record<string, string>>;
+/**
+ * Format data as a CSV string
+ */
+export declare function formatCsv(data: (string | number | boolean | null | undefined)[][] | Record<string, any>[], options?: CsvFormatOptions): string;
+/**
+ * Async CSV parser that yields rows one at a time
+ */
+export declare function parseCsvStream(input: string | AsyncIterable<string>, options?: CsvParseOptions): AsyncGenerator<string[] | Record<string, string>, void, unknown>;

package/dist/types/csv/csv-stream.d.ts

@@ -0,0 +1,114 @@
+/**
+ * CSV Streaming Support for Node.js
+ *
+ * Provides true streaming CSV parsing and formatting using Node.js streams.
+ * This enables processing of large CSV files without loading them entirely into memory.
+ */
+import { Transform, type Readable, type TransformCallback } from "stream";
+import type { CsvParseOptions, CsvFormatOptions, RowTransformFunction, RowValidateFunction, Row } from "./csv-core";
+/**
+ * Transform stream that parses CSV data row by row
+ *
+ * @example
+ * ```ts
+ * const parser = new CsvParserStream({ headers: true });
+ * fs.createReadStream('data.csv')
+ *   .pipe(parser)
+ *   .on('data', (row) => console.log(row));
+ * ```
+ */
+export declare class CsvParserStream extends Transform {
+    private options;
+    private buffer;
+    private currentRow;
+    private currentField;
+    private inQuotes;
+    private lineNumber;
+    private rowCount;
+    private skippedDataRows;
+    private headerRow;
+    private headersEmitted;
+    private delimiter;
+    private quote;
+    private escape;
+    private quoteEnabled;
+    private _rowTransform;
+    private _rowValidator;
+    private encoding;
+    constructor(options?: CsvParseOptions);
+    /**
+     * Set a transform function to modify rows before emitting
+     * Supports both sync and async transforms
+     */
+    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
+    /**
+     * Set a validate function to filter rows
+     * Invalid rows emit 'data-invalid' event
+     */
+    validate<T extends Row = Row>(validateFunction: RowValidateFunction<T>): this;
+    _transform(chunk: Buffer | string, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private applyTrim;
+    private processBuffer;
+    private buildRow;
+    private processPendingRows;
+    private transformAndValidateRow;
+    private validateRow;
+    private emitRow;
+}
+/**
+ * Options for CSV formatter stream
+ */
+export interface CsvFormatterStreamOptions extends CsvFormatOptions {
+    /** Whether input is objects (vs arrays) */
+    objectMode?: boolean;
+}
+/**
+ * Transform stream that formats rows to CSV
+ *
+ * @example
+ * ```ts
+ * const formatter = new CsvFormatterStream({ headers: ['name', 'age'] });
+ * formatter.pipe(fs.createWriteStream('output.csv'));
+ * formatter.write(['Alice', 30]);
+ * formatter.write(['Bob', 25]);
+ * formatter.end();
+ * ```
+ */
+export declare class CsvFormatterStream extends Transform {
+    private options;
+    private delimiter;
+    private quote;
+    private escape;
+    private rowDelimiter;
+    private quoteEnabled;
+    private alwaysQuote;
+    private headerWritten;
+    private headers;
+    private shouldWriteHeaders;
+    private rowCount;
+    private _rowTransform;
+    constructor(options?: CsvFormatterStreamOptions);
+    /**
+     * Set a transform function to modify rows before formatting
+     */
+    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private formatAndPush;
+    private formatRow;
+    private shouldQuoteField;
+    private formatField;
+}
+/**
+ * Create a readable stream from an array of rows
+ */
+export declare function createCsvReadableStream(rows: any[][], options?: CsvFormatOptions): Readable;
+/**
+ * Create parser stream factory
+ */
+export declare function createCsvParserStream(options?: CsvParseOptions): CsvParserStream;
+/**
+ * Create formatter stream factory
+ */
+export declare function createCsvFormatterStream(options?: CsvFormatterStreamOptions): CsvFormatterStream;

package/dist/types/csv/csv.base.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CSV Base class - Shared functionality for Node.js and Browser
+ *
+ * Uses native CSV parser (RFC 4180 compliant) with zero external dependencies.
+ * Date parsing uses native high-performance datetime utilities.
+ */
+import { type DateFormat } from "../utils/datetime";
+import { type CsvParseOptions, type CsvFormatOptions } from "./csv-core";
+import type { Workbook } from "../doc/workbook";
+import type { Worksheet } from "../doc/worksheet";
+/**
+ * CSV read options
+ */
+export interface CsvReadOptions {
+    /** Date format strings to try when parsing (default: ISO formats) */
+    dateFormats?: readonly DateFormat[];
+    /** Custom value mapper function */
+    map?(value: any, index: number): any;
+    /** Worksheet name to create (default: "Sheet1") */
+    sheetName?: string;
+    /** CSV parsing options */
+    parserOptions?: Partial<CsvParseOptions>;
+}
+/**
+ * CSV write options
+ */
+export interface CsvWriteOptions {
+    /** Date format for output (default: ISO format) */
+    dateFormat?: string;
+    /** Use UTC for dates (default: false) */
+    dateUTC?: boolean;
+    /** Worksheet name or ID to export */
+    sheetName?: string;
+    /** Worksheet ID to export */
+    sheetId?: number;
+    /** Output encoding (default: "utf8") */
+    encoding?: string;
+    /** Custom value mapper function */
+    map?(value: any, index: number): any;
+    /** Include empty rows (default: true) */
+    includeEmptyRows?: boolean;
+    /** CSV formatting options */
+    formatterOptions?: Partial<CsvFormatOptions>;
+}
+/**
+ * Create the default value mapper for CSV parsing
+ */
+export declare function createDefaultValueMapper(dateFormats: readonly DateFormat[]): (datum: any) => any;
+/**
+ * Create the default value mapper for CSV writing
+ */
+export declare function createDefaultWriteMapper(dateFormat?: string, dateUTC?: boolean): (value: any) => any;
+/**
+ * Parse CSV content into a worksheet
+ */
+export declare function parseCsvToWorksheet(content: string, workbook: Workbook, options?: CsvReadOptions): Worksheet;
+/**
+ * Format worksheet as CSV string
+ */
+export declare function formatWorksheetToCsv(worksheet: Worksheet | undefined, options?: CsvWriteOptions): string;
+export { parseCsv, formatCsv, parseCsvStream } from "./csv-core";
+export type { CsvParseOptions, CsvFormatOptions, CsvParseResult } from "./csv-core";

package/dist/types/csv/csv.browser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * CSV class for Browser - No file system dependencies
+ *
+ * Provides:
+ * - load: Load from string or ArrayBuffer
+ * - writeString: Write to string
+ * - writeBuffer: Write to Uint8Array
+ */
+import { type CsvReadOptions, type CsvWriteOptions } from "./csv.base";
+import type { Workbook } from "../doc/workbook.browser";
+import type { Worksheet } from "../doc/worksheet";
+declare class CSV {
+    workbook: Workbook;
+    constructor(workbook: Workbook);
+    /**
+     * Load CSV from string or ArrayBuffer
+     */
+    load(data: string | ArrayBuffer | Uint8Array, options?: CsvReadOptions): Worksheet;
+    /**
+     * Write CSV to string
+     */
+    writeString(options?: CsvWriteOptions): string;
+    /**
+     * Write CSV to Uint8Array buffer
+     */
+    writeBuffer(options?: CsvWriteOptions): Uint8Array;
+    readFile(_filename: string, _options?: CsvReadOptions): Promise<never>;
+    read(_stream: any, _options?: CsvReadOptions): Promise<never>;
+    writeFile(_filename: string, _options?: CsvWriteOptions): Promise<never>;
+    write(_stream: any, _options?: CsvWriteOptions): Promise<never>;
+}
+export { CSV };
+export type { CsvReadOptions, CsvWriteOptions } from "./csv.base";

package/dist/types/csv/csv.d.ts

@@ -1,79 +1,105 @@
-import type { Workbook } from "../doc/workbook.js";
-import type { Worksheet } from "../doc/worksheet.js";
-type HeaderArray = (string | undefined | null)[];
-type HeaderTransformFunction = (headers: HeaderArray) => HeaderArray;
-export interface FastCsvParserOptionsArgs {
-    objectMode?: boolean;
-    delimiter?: string;
-    quote?: string | null;
-    escape?: string;
-    headers?: boolean | HeaderTransformFunction | HeaderArray;
-    renameHeaders?: boolean;
-    ignoreEmpty?: boolean;
-    comment?: string;
-    strictColumnHandling?: boolean;
-    discardUnmappedColumns?: boolean;
-    trim?: boolean;
-    ltrim?: boolean;
-    rtrim?: boolean;
-    encoding?: string;
-    maxRows?: number;
-    skipLines?: number;
-    skipRows?: number;
+/**
+ * CSV class for Node.js - Full streaming and file system support
+ *
+ * Features:
+ * - readFile: Read from file path (streaming)
+ * - writeFile: Write to file path (streaming)
+ * - read: Read from Node.js stream
+ * - write: Write to Node.js stream
+ * - createReadStream: Create a readable stream from worksheet
+ * - createWriteStream: Create a writable stream that writes to worksheet
+ */
+import { type Readable, type Writable } from "stream";
+import { type CsvReadOptions, type CsvWriteOptions } from "./csv.base";
+import type { Workbook } from "../doc/workbook";
+import type { Worksheet } from "../doc/worksheet";
+/**
+ * Extended read options for streaming
+ */
+export interface CsvStreamReadOptions extends CsvReadOptions {
+    /** High water mark for stream (default: 64KB) */
+    highWaterMark?: number;
 }
-interface QuoteColumnMap {
-    [s: string]: boolean;
-}
-type QuoteColumns = boolean | boolean[] | QuoteColumnMap;
-interface RowMap {
-    [key: string]: any;
-}
-type RowHashArray = [string, any][];
-type RowArray = string[];
-type Rows = RowArray | RowMap | RowHashArray;
-type RowTransformCallback = (error?: Error | null, row?: Rows) => void;
-interface RowTransformFunction {
-    (row: Rows, callback: RowTransformCallback): void;
-    (row: Rows): Rows;
-}
-export interface FastCsvFormatterOptionsArgs {
-    objectMode?: boolean;
-    delimiter?: string;
-    rowDelimiter?: string;
-    quote?: string | boolean;
-    escape?: string;
-    quoteColumns?: QuoteColumns;
-    quoteHeaders?: QuoteColumns;
-    headers?: null | boolean | string[];
-    includeEndRowDelimiter?: boolean;
-    writeBOM?: boolean;
-    transform?: RowTransformFunction;
-    alwaysWriteHeaders?: boolean;
-}
-export interface CsvReadOptions {
-    dateFormats?: string[];
-    map?(value: any, index: number): any;
-    sheetName?: string;
-    parserOptions?: Partial<FastCsvParserOptionsArgs>;
-}
-export interface CsvWriteOptions {
-    dateFormat?: string;
-    dateUTC?: boolean;
-    sheetName?: string;
-    sheetId?: number;
-    encoding?: string;
-    map?(value: any, index: number): any;
-    includeEmptyRows?: boolean;
-    formatterOptions?: Partial<FastCsvFormatterOptionsArgs>;
+/**
+ * Extended write options for streaming
+ */
+export interface CsvStreamWriteOptions extends CsvWriteOptions {
+    /** High water mark for stream (default: 64KB) */
+    highWaterMark?: number;
 }
 declare class CSV {
     workbook: Workbook;
-    worksheet: Worksheet;
     constructor(workbook: Workbook);
-    readFile(filename: string, options?: CsvReadOptions): Promise<Worksheet>;
-    read(stream: any, options?: CsvReadOptions): Promise<Worksheet>;
-    write(stream: any, options?: CsvWriteOptions): Promise<void>;
-    writeFile(filename: string, options?: CsvWriteOptions): Promise<void>;
+    /**
+     * Read CSV from file using streaming
+     *
+     * @example
+     * ```ts
+     * const worksheet = await workbook.csv.readFile('data.csv');
+     * ```
+     */
+    readFile(filename: string, options?: CsvStreamReadOptions): Promise<Worksheet>;
+    /**
+     * Read CSV from Node.js readable stream
+     *
+     * Uses true streaming - processes data row by row without loading entire file into memory.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createReadStream('data.csv');
+     * const worksheet = await workbook.csv.read(stream);
+     * ```
+     */
+    read(stream: Readable, options?: CsvReadOptions): Promise<Worksheet>;
+    /**
+     * Write CSV to file using streaming
+     *
+     * @example
+     * ```ts
+     * await workbook.csv.writeFile('output.csv');
+     * ```
+     */
+    writeFile(filename: string, options?: CsvStreamWriteOptions): Promise<void>;
+    /**
+     * Write CSV to Node.js writable stream
+     *
+     * Uses true streaming - writes data row by row.
+     *
+     * @example
+     * ```ts
+     * const stream = fs.createWriteStream('output.csv');
+     * await workbook.csv.write(stream);
+     * ```
+     */
+    write(stream: Writable, options?: CsvWriteOptions): Promise<void>;
+    /**
+     * Write CSV to buffer
+     *
+     * Note: This loads the entire CSV into memory. For large files, use write() with a stream.
+     */
     writeBuffer(options?: CsvWriteOptions): Promise<Buffer>;
+    /**
+     * Create a readable stream that outputs CSV rows from the worksheet
+     *
+     * @example
+     * ```ts
+     * const csvStream = workbook.csv.createReadStream();
+     * csvStream.pipe(fs.createWriteStream('output.csv'));
+     * ```
+     */
+    createReadStream(options?: CsvWriteOptions): Readable;
+    /**
+     * Create a writable stream that parses CSV and adds rows to a worksheet
+     *
+     * @example
+     * ```ts
+     * const csvWriter = workbook.csv.createWriteStream({ sheetName: 'Data' });
+     * fs.createReadStream('input.csv').pipe(csvWriter);
+     * await new Promise(resolve => csvWriter.on('finish', resolve));
+     * ```
+     */
+    createWriteStream(options?: CsvReadOptions): Writable;
 }
 export { CSV };
+export type { CsvReadOptions, CsvWriteOptions } from "./csv.base";
+export { CsvParserStream, CsvFormatterStream } from "./csv-stream";

package/dist/types/doc/anchor.d.ts

@@ -1,4 +1,4 @@
-import type { Worksheet } from "./worksheet.js";
+import type { Worksheet } from "./worksheet";
 interface AnchorModel {
     nativeCol: number;
     nativeRow: number;

package/dist/types/doc/cell.d.ts

@@ -1,9 +1,9 @@
-import { Note } from "./note.js";
-import type { Row } from "./row.js";
-import type { Column } from "./column.js";
-import type { Worksheet } from "./worksheet.js";
-import type { Workbook } from "./workbook.js";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellHyperlinkValue } from "../types.js";
+import { Note } from "./note";
+import type { Row } from "./row";
+import type { Column } from "./column";
+import type { Worksheet } from "./worksheet";
+import type { Workbook } from "./workbook";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellRichTextValue, CellErrorValue, DataValidation, CellValue, CellHyperlinkValue } from "../types";
 export type HyperlinkValueData = CellHyperlinkValue;
 export type FormulaResult = string | number | boolean | Date | CellErrorValue;
 export interface FormulaValueData {
@@ -68,7 +68,7 @@ export interface CellModel {
 }
 export type CellValueType = CellValue;
 declare class Cell {
-    static Types: typeof import("./enums.js").ValueType;
+    static Types: typeof import("./enums").ValueType;
     private _row;
     private _column;
     private _address;

package/dist/types/doc/column.d.ts

@@ -1,6 +1,6 @@
-import type { Cell, CellValueType } from "./cell.js";
-import type { Worksheet } from "./worksheet.js";
-import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue } from "../types.js";
+import type { Cell, CellValueType } from "./cell";
+import type { Worksheet } from "./worksheet";
+import type { Style, NumFmt, Font, Alignment, Protection, Borders, Fill, CellValue } from "../types";
 /** Header value type - can be a single value or array for multi-row headers */
 export type ColumnHeaderValue = CellValue | CellValue[];
 export interface ColumnDefn {
@@ -97,6 +97,12 @@ declare class Column {
      */
     get values(): CellValueType[];
     set values(v: CellValueType[]);
+    /**
+     * Add a page break after this column.
+     * @param top - Optional top row limit for the page break (1-indexed)
+     * @param bottom - Optional bottom row limit for the page break (1-indexed)
+     */
+    addPageBreak(top?: number, bottom?: number): void;
     get numFmt(): string | NumFmt | undefined;
     set numFmt(value: string | undefined);
     get font(): Partial<Font> | undefined;

package/dist/types/doc/defined-names.d.ts

@@ -1,7 +1,7 @@
-import { type DecodedRange } from "../utils/col-cache.js";
-import { CellMatrix } from "../utils/cell-matrix.js";
-import { Range } from "./range.js";
-import type { Address } from "../types.js";
+import { type DecodedRange } from "../utils/col-cache";
+import { CellMatrix } from "../utils/cell-matrix";
+import { Range } from "./range";
+import type { Address } from "../types";
 interface DefinedNameCell {
     sheetName?: string;
     address: string;

package/dist/types/doc/image.d.ts

@@ -1,5 +1,5 @@
-import { Anchor, type AnchorModel } from "./anchor.js";
-import type { Worksheet } from "./worksheet.js";
+import { Anchor, type AnchorModel } from "./anchor";
+import type { Worksheet } from "./worksheet";
 interface ImageHyperlinks {
     hyperlink?: string;
     tooltip?: string;

package/dist/types/doc/modelcontainer.d.ts

@@ -1,4 +1,4 @@
-import { XLSX } from "../xlsx/xlsx.js";
+import { XLSX } from "../xlsx/xlsx";
 declare class ModelContainer {
     model: any;
     private _xlsx?;