@cj-tech-master/excelts 5.0.6 → 5.1.0

package/dist/types/modules/excel/xlsx/xform/pivot-table/pivot-cache-definition-xform.d.ts

@@ -1,46 +1,30 @@
 import { BaseXform } from "../base-xform.js";
-import { type CacheFieldModel } from "./cache-field-xform.js";
-import type { PivotTableSource } from "../../../pivot-table.js";
-/**
- * Model for parsed pivot cache definition
- */
-interface ParsedCacheDefinitionModel {
-    sourceRef?: string;
-    sourceSheet?: string;
-    sourceTableName?: string;
-    cacheFields: CacheFieldModel[];
-    recordCount?: number;
-    rId?: string;
-    refreshOnLoad?: string;
-    createdVersion?: string;
-    refreshedVersion?: string;
-    minRefreshableVersion?: string;
-    isLoaded?: boolean;
-}
+import type { CacheField as CacheFieldType, ParsedCacheDefinition, PivotTableSource } from "../../../pivot-table.js";
+import { XmlStream } from "../../../utils/xml-stream.js";
 /**
  * Model for generating pivot cache definition (with live source)
  */
 interface CacheDefinitionModel {
     source: PivotTableSource;
-    cacheFields: any[];
+    cacheFields: CacheFieldType[];
 }
-declare class PivotCacheDefinitionXform extends BaseXform {
-    map: {
-        [key: string]: any;
-    };
-    model: ParsedCacheDefinitionModel | null;
+declare class PivotCacheDefinitionXform extends BaseXform<ParsedCacheDefinition | null> {
     private currentCacheField;
     private inCacheFields;
     private inCacheSource;
+    private extLstCollector;
+    private unknownCollector;
+    private unknownElementsXmlParts;
+    private cacheSourceChildCollector;
+    private cacheSourceXmlParts;
     constructor();
-    prepare(_model: any): void;
     get tag(): string;
     reset(): void;
     /**
      * Render pivot cache definition XML.
      * Supports both newly created models (with PivotTableSource) and loaded models.
      */
-    render(xmlStream: any, model: CacheDefinitionModel | ParsedCacheDefinitionModel): void;
+    render(xmlStream: XmlStream, model: CacheDefinitionModel | ParsedCacheDefinition): void;
     /**
      * Render newly created pivot cache definition
      */
@@ -52,10 +36,10 @@ declare class PivotCacheDefinitionXform extends BaseXform {
     parseOpen(node: any): boolean;
     parseText(text: string): void;
     parseClose(name: string): boolean;
-    reconcile(_model: any, _options: any): void;
-    static PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
+    static renderCacheFieldsXml(cacheFields: CacheFieldType[]): string;
+    static readonly PIVOT_CACHE_DEFINITION_ATTRIBUTES: {
         xmlns: string;
         "xmlns:r": string;
     };
 }
-export { PivotCacheDefinitionXform, type ParsedCacheDefinitionModel };
+export { PivotCacheDefinitionXform };

package/dist/types/modules/excel/xlsx/xform/pivot-table/pivot-cache-records-xform.d.ts

@@ -1,49 +1,23 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
 import { BaseXform } from "../base-xform.js";
-import type { PivotTableSource } from "../../../pivot-table.js";
+import type { PivotTableSource, ParsedCacheRecords, CacheField } from "../../../pivot-table.js";
 /**
  * Model for generating pivot cache records (with live source)
  */
 interface CacheRecordsModel {
     source: PivotTableSource;
-    cacheFields: any[];
+    cacheFields: CacheField[];
 }
-/**
- * Parsed record value - can be:
- * - { type: 'x', value: number } - Shared item index
- * - { type: 'n', value: number } - Numeric value
- * - { type: 's', value: string } - String value
- * - { type: 'b', value: boolean } - Boolean value
- * - { type: 'm' } - Missing/null value
- * - { type: 'd', value: Date } - Date value
- * - { type: 'e', value: string } - Error value
- */
-interface RecordValue {
-    type: "x" | "n" | "s" | "b" | "m" | "d" | "e";
-    value?: any;
-}
-/**
- * Parsed cache records model
- */
-interface ParsedCacheRecordsModel {
-    records: RecordValue[][];
-    count: number;
-    isLoaded?: boolean;
-}
-declare class PivotCacheRecordsXform extends BaseXform {
-    map: {
-        [key: string]: any;
-    };
-    model: ParsedCacheRecordsModel | null;
+declare class PivotCacheRecordsXform extends BaseXform<ParsedCacheRecords | null> {
     private currentRecord;
     constructor();
-    prepare(_model: any): void;
     get tag(): string;
     reset(): void;
     /**
      * Render pivot cache records XML.
      * Supports both newly created models (with PivotTableSource) and loaded models.
      */
-    render(xmlStream: any, model: CacheRecordsModel | ParsedCacheRecordsModel): void;
+    render(xmlStream: XmlStream, model: CacheRecordsModel | ParsedCacheRecords): void;
     /**
      * Render newly created pivot cache records
      */
@@ -61,8 +35,7 @@ declare class PivotCacheRecordsXform extends BaseXform {
     parseOpen(node: any): boolean;
     parseText(_text: string): void;
     parseClose(name: string): boolean;
-    reconcile(_model: any, _options: any): void;
-    static PIVOT_CACHE_RECORDS_ATTRIBUTES: {
+    static readonly PIVOT_CACHE_RECORDS_ATTRIBUTES: {
         xmlns: string;
         "xmlns:r": string;
         "xmlns:mc": string;
@@ -70,4 +43,4 @@ declare class PivotCacheRecordsXform extends BaseXform {
         "xmlns:xr": string;
     };
 }
-export { PivotCacheRecordsXform, type ParsedCacheRecordsModel };
+export { PivotCacheRecordsXform };

package/dist/types/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.d.ts

@@ -1,37 +1,72 @@
+import { XmlStream } from "../../../utils/xml-stream.js";
 import { BaseXform } from "../base-xform.js";
+import type { CacheField, DataField, PivotTableSubtotal } from "../../../pivot-table.js";
 /**
  * Model for generating pivot table (with live source)
  */
-interface PivotTableModel {
+interface PivotTableRenderModel {
     rows: number[];
     columns: number[];
     values: number[];
-    metric: "sum" | "count";
-    cacheFields: any[];
-    cacheId: number;
+    pages?: number[];
+    metric: PivotTableSubtotal;
+    /** Per-value metric overrides (parallel to `values` array). Falls back to `metric`. */
+    valueMetrics: PivotTableSubtotal[];
+    cacheFields: CacheField[];
+    cacheId: string | number;
+    tableNumber: number;
     applyWidthHeightFormats: "0" | "1";
 }
+/**
+ * A single <item> element inside a pivotField's <items> collection.
+ * Items can reference a shared item index (x attribute) or indicate a subtotal type (t attribute).
+ */
+interface PivotFieldItem {
+    /** Shared item index (maps to cacheField sharedItems) */
+    x?: number;
+    /** Item type: "default" for subtotals, "sum", "count", "avg", "max", "min", "grand", etc. */
+    t?: string;
+    /** Hidden flag — "1" means item is filtered out */
+    h?: string;
+    /** Show details (hide details when "0") */
+    sd?: string;
+    /** Calculated item flag */
+    f?: string;
+    /** Missing flag */
+    m?: string;
+    /** Child items flag */
+    c?: string;
+    /** Drill across flag */
+    d?: string;
+}
 /**
  * Parsed pivot field
  */
 interface ParsedPivotField {
     axis?: "axisRow" | "axisCol" | "axisPage" | "axisValues";
     dataField?: boolean;
-    items?: number[];
+    items?: PivotFieldItem[];
     compact?: boolean;
     outline?: boolean;
     showAll?: boolean;
     defaultSubtotal?: boolean;
+    numFmtId?: number;
+    sortType?: string;
+    autoSortScopeXml?: string;
+    subtotalTop?: boolean;
+    insertBlankRow?: boolean;
+    multipleItemSelectionAllowed?: boolean;
+    /** Bag of additional attributes not individually modeled (for roundtrip preservation) */
+    extraAttrs?: Record<string, string>;
 }
 /**
- * Parsed data field
+ * Parsed page field (report filter)
  */
-interface ParsedDataField {
-    name: string;
+interface ParsedPageField {
     fld: number;
-    baseField?: number;
-    baseItem?: number;
-    subtotal?: "sum" | "count" | "average" | "max" | "min" | "product" | "countNums" | "stdDev" | "stdDevP" | "var" | "varP";
+    item?: number;
+    hier?: number;
+    name?: string;
 }
 /**
  * Parsed pivot table model (loaded from file)
@@ -45,11 +80,14 @@ interface ParsedPivotTableModel {
         firstHeaderRow?: number;
         firstDataRow?: number;
         firstDataCol?: number;
+        rowPageCount?: number;
+        colPageCount?: number;
     };
     pivotFields: ParsedPivotField[];
     rowFields: number[];
     colFields: number[];
-    dataFields: ParsedDataField[];
+    pageFields: ParsedPageField[];
+    dataFields: DataField[];
     applyNumberFormats?: string;
     applyBorderFormats?: string;
     applyFontFormats?: string;
@@ -58,30 +96,54 @@ interface ParsedPivotTableModel {
     applyWidthHeightFormats?: string;
     dataCaption?: string;
     styleName?: string;
+    /** Full pivotTableStyleInfo attributes (preserved on roundtrip) */
+    styleInfo?: {
+        name?: string;
+        showRowHeaders?: string;
+        showColHeaders?: string;
+        showRowStripes?: string;
+        showColStripes?: string;
+        showLastColumn?: string;
+    };
     updatedVersion?: string;
     minRefreshableVersion?: string;
     createdVersion?: string;
-    useAutoFormatting?: boolean;
-    itemPrintTitles?: boolean;
+    useAutoFormatting?: string;
+    itemPrintTitles?: string;
     indent?: number;
     compact?: boolean;
     compactData?: boolean;
-    multipleFieldFilters?: boolean;
+    multipleFieldFilters?: string;
     outline?: boolean;
     outlineData?: boolean;
     chartFormat?: number;
+    colGrandTotals?: string;
+    rowGrandTotals?: string;
+    showError?: string;
+    errorCaption?: string;
+    showMissing?: string;
+    missingCaption?: string;
+    grandTotalCaption?: string;
     rowItems?: RowColItem[];
     colItems?: RowColItem[];
     hasColFields?: boolean;
+    hasRowItems?: boolean;
+    hasColItems?: boolean;
     chartFormats?: ChartFormatItem[];
+    extLstXml?: string;
+    formatsXml?: string;
+    conditionalFormatsXml?: string;
+    filtersXml?: string;
+    unknownElementsXml?: string;
     isLoaded?: boolean;
-    extensions?: any[];
 }
 /**
  * Row or column item in pivot table
  */
 interface RowColItem {
     t?: string;
+    r?: number;
+    i?: number;
     x: Array<{
         v: number;
     }>;
@@ -95,27 +157,28 @@ interface ChartFormatItem {
     series?: boolean;
     pivotAreaXml?: string;
 }
-declare class PivotTableXform extends BaseXform {
-    map: {
-        [key: string]: any;
-    };
-    model: ParsedPivotTableModel | null;
+declare class PivotTableXform extends BaseXform<ParsedPivotTableModel | null> {
     private state;
     private currentPivotField;
     private currentRowItem;
     private currentColItem;
     private currentChartFormat;
     private pivotAreaXmlBuffer;
-    private pivotAreaDepth;
+    private autoSortScopeXmlBuffer;
+    private extLstCollector;
+    private formatsCollector;
+    private conditionalFormatsCollector;
+    private filtersCollector;
+    private unknownCollector;
+    private unknownElementsXmlParts;
     constructor();
-    prepare(_model: any): void;
     get tag(): string;
     reset(): void;
     /**
      * Render pivot table XML.
      * Supports both newly created models and loaded models.
      */
-    render(xmlStream: any, model: PivotTableModel | ParsedPivotTableModel): void;
+    render(xmlStream: XmlStream, model: PivotTableRenderModel | ParsedPivotTableModel): void;
     /**
      * Render newly created pivot table
      */
@@ -124,6 +187,15 @@ declare class PivotTableXform extends BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     private renderLoaded;
+    /**
+     * Build the root `<pivotTableDefinition>` attributes for a loaded (roundtrip) model.
+     * Extracted from renderLoaded to keep the render method focused on element structure.
+     */
+    private buildLoadedRootAttributes;
+    /**
+     * Render `<chartFormats>` with preserved pivotArea XML for pivot chart roundtrip.
+     */
+    private renderChartFormats;
     /**
      * Render a row or column item element
      */
@@ -133,11 +205,13 @@ declare class PivotTableXform extends BaseXform {
      */
     private renderPivotFieldLoaded;
     parseOpen(node: any): boolean;
-    parseText(_text: string): void;
+    parseText(text: string): void;
+    /** Feed a close-tag to a collector; if it completes, store the result on the model. */
+    private tryCloseCollector;
     parseClose(name: string): boolean;
-    reconcile(_model: any, _options: any): void;
-    static PIVOT_TABLE_ATTRIBUTES: {
+    static readonly PIVOT_TABLE_ATTRIBUTES: {
         xmlns: string;
     };
+    static readonly EXTLST_XML: string;
 }
 export { PivotTableXform, type ParsedPivotTableModel };

package/dist/types/modules/excel/xlsx/xform/pivot-table/raw-xml-collector.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Reusable utility for collecting raw XML fragments during SAX parsing.
+ *
+ * Many pivot-table xforms need to capture entire sub-trees (extLst, formats,
+ * conditionalFormats, filters, fieldGroup, unknown elements, …) as raw strings
+ * for roundtrip preservation.  The pattern — `active` flag, `depth` counter,
+ * `buffer` of string fragments, plus identical `feedOpen` / `feedClose` /
+ * `feedText` logic — was previously copy-pasted across multiple files.
+ *
+ * Usage:
+ * ```ts
+ * const collector = new RawXmlCollector("extLst");
+ * // In parseOpen, when you see <extLst>:
+ * collector.start();                      // opens with <extLst>
+ * // For every child open tag while active:
+ * collector.feedOpen(name, attributes);
+ * // For every text node while active:
+ * collector.feedText(text);
+ * // For every close tag while active:
+ * if (collector.feedClose(name)) { ... }  // returns true when root tag closed
+ * // Retrieve result:
+ * collector.result;                       // joined XML string
+ * ```
+ */
+declare class RawXmlCollector {
+    /** Tag name that this collector captures (e.g. "extLst", "formats"). */
+    rootTag: string;
+    /** Whether the collector is currently capturing. */
+    active: boolean;
+    /** Nesting depth *within* the root element (0 = direct children). */
+    private depth;
+    /** String fragments being accumulated. */
+    private buffer;
+    /** Index of the last open-tag entry in the buffer (for self-closing collapse). */
+    private lastOpenIndex;
+    constructor(rootTag: string);
+    /**
+     * Begin collecting.  Pushes the opening root tag (with optional attributes)
+     * and resets depth.
+     *
+     * @param attributes - Attributes on the root element (may be undefined/null).
+     */
+    start(attributes?: Record<string, unknown> | null): void;
+    /**
+     * Begin collecting with a dynamically determined root tag.
+     * Used for catch-all unknown element collectors where the tag name
+     * is not known at construction time.
+     */
+    startAs(rootTag: string, attributes?: Record<string, unknown> | null): void;
+    /**
+     * Reset the collector to its initial idle state.
+     */
+    reset(): void;
+    /**
+     * Feed an open-tag event.  Must only be called while `active` is true.
+     */
+    feedOpen(name: string, attributes?: Record<string, unknown> | null): void;
+    /**
+     * Feed a text-node event.  Must only be called while `active` is true.
+     */
+    feedText(text: string): void;
+    /**
+     * Feed a close-tag event.
+     *
+     * @returns `true` when the **root** close tag has been received (collector
+     *          deactivates itself and the result is ready).  `false` for any
+     *          nested close tag.
+     */
+    feedClose(name: string): boolean;
+    /** The collected XML string.  Only meaningful after `feedClose` returns true. */
+    get result(): string;
+}
+/**
+ * Serialize an attributes object to an XML attribute string.
+ * `null`, `undefined`, and empty objects produce an empty string.
+ */
+declare function serializeAttributes(attributes?: Record<string, unknown> | null): string;
+export { RawXmlCollector, serializeAttributes };

package/dist/types/modules/excel/xlsx/xform/sheet/row-xform.d.ts

@@ -16,12 +16,11 @@ interface RowModel {
     style?: any;
     dyDescent?: number;
 }
-declare class RowXform extends BaseXform {
+declare class RowXform extends BaseXform<RowModel> {
     private maxItems?;
     map: {
         [key: string]: any;
     };
-    model: RowModel;
     parser: any;
     private numRowsSeen;
     private lastCellCol;

package/dist/types/modules/excel/xlsx/xform/sheet/sheet-view-xform.d.ts

@@ -16,8 +16,7 @@ interface SheetViewModel {
     activePane?: string;
     activeCell?: string;
 }
-declare class SheetViewXform extends BaseXform {
-    model: SheetViewModel;
+declare class SheetViewXform extends BaseXform<SheetViewModel> {
     private sheetView;
     private pane;
     private selections;

package/dist/types/modules/excel/xlsx/xform/table/auto-filter-xform.d.ts

@@ -4,12 +4,11 @@ interface AutoFilterModel {
     autoFilterRef: string;
     columns: any[];
 }
-declare class AutoFilterXform extends BaseXform {
+declare class AutoFilterXform extends BaseXform<AutoFilterModel> {
     map: {
         [key: string]: FilterColumnXform;
     };
     parser: any;
-    model: AutoFilterModel;
     constructor();
     get tag(): string;
     prepare(model: any): void;

package/dist/types/modules/excel/xlsx/xform/table/custom-filter-xform.d.ts

@@ -3,8 +3,7 @@ interface CustomFilterModel {
     val: string;
     operator?: string;
 }
-declare class CustomFilterXform extends BaseXform {
-    model: CustomFilterModel;
+declare class CustomFilterXform extends BaseXform<CustomFilterModel> {
     constructor();
     get tag(): string;
     render(xmlStream: any, model: CustomFilterModel): void;

package/dist/types/modules/excel/xlsx/xform/table/filter-column-xform.d.ts

@@ -5,12 +5,11 @@ interface FilterColumnModel {
     filterButton: boolean;
     customFilters?: any[];
 }
-declare class FilterColumnXform extends BaseXform {
+declare class FilterColumnXform extends BaseXform<FilterColumnModel> {
     map: {
         [key: string]: ListXform;
     };
     parser: any;
-    model: FilterColumnModel;
     constructor();
     get tag(): string;
     prepare(model: FilterColumnModel, options: {

package/dist/types/modules/excel/xlsx/xform/table/filter-xform.d.ts

@@ -2,8 +2,7 @@ import { BaseXform } from "../base-xform.js";
 interface FilterModel {
     val: string;
 }
-declare class FilterXform extends BaseXform {
-    model: FilterModel;
+declare class FilterXform extends BaseXform<FilterModel> {
     constructor();
     get tag(): string;
     render(xmlStream: any, model: FilterModel): void;

package/dist/types/modules/excel/xlsx/xform/table/table-column-xform.d.ts

@@ -6,8 +6,7 @@ interface TableColumnModel {
     totalsRowFunction?: string;
     dxfId?: string;
 }
-declare class TableColumnXform extends BaseXform {
-    model: TableColumnModel;
+declare class TableColumnXform extends BaseXform<TableColumnModel> {
     constructor();
     get tag(): string;
     prepare(model: TableColumnModel, options: {

package/dist/types/modules/excel/xlsx/xform/table/table-style-info-xform.d.ts

@@ -6,8 +6,7 @@ interface TableStyleModel {
     showRowStripes: boolean;
     showColumnStripes: boolean;
 }
-declare class TableStyleInfoXform extends BaseXform {
-    model: TableStyleModel;
+declare class TableStyleInfoXform extends BaseXform<TableStyleModel> {
     constructor();
     get tag(): string;
     render(xmlStream: any, model: TableStyleModel): void;

package/dist/types/modules/excel/xlsx/xform/table/table-xform.d.ts

@@ -12,12 +12,11 @@ interface TableModel {
     autoFilterRef?: string;
     style?: any;
 }
-declare class TableXform extends BaseXform {
+declare class TableXform extends BaseXform<TableModel> {
     map: {
         [key: string]: any;
     };
     parser: any;
-    model: TableModel;
     constructor();
     prepare(model: TableModel, options: any): void;
     get tag(): string;

package/dist/types/modules/excel/xlsx/xlsx.browser.d.ts

@@ -8,6 +8,7 @@
  * - prepareModel: Prepare model for writing
  * - loadFromFiles: Load from pre-extracted ZIP data
  */
+import type { PivotTableSubtotal } from "../pivot-table.js";
 import { type IEventEmitter } from "../../stream/index.js";
 import type { Workbook } from "../workbook.js";
 import type { ZipTimestampMode } from "../../archive/utils/timestamps.js";
@@ -195,7 +196,10 @@ declare class XLSX {
     protected _buildDefinitionToCacheIdMap(model: any): Map<string, number>;
     protected _determineMetric(dataFields: Array<{
         subtotal?: string;
-    }>): "sum" | "count";
+    }>): PivotTableSubtotal;
+    protected _determineValueMetrics(dataFields: Array<{
+        subtotal?: string;
+    }>, defaultMetric: PivotTableSubtotal): PivotTableSubtotal[];
     _processWorksheetEntry(stream: IParseStream, model: any, sheetNo: number, options: XlsxOptions | undefined, path: string): Promise<void>;
     _processCommentEntry(stream: IParseStream, model: any, name: string): Promise<void>;
     _processTableEntry(stream: IParseStream, model: any, name: string): Promise<void>;
@@ -216,7 +220,6 @@ declare class XLSX {
     _processPivotTableEntry(stream: IParseStream, model: any, name: string): Promise<void>;
     _processPivotTableRelsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
     _processPivotCacheDefinitionEntry(stream: IParseStream, model: any, name: string): Promise<void>;
-    _processPivotCacheDefinitionRelsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
     _processPivotCacheRecordsEntry(stream: IParseStream, model: any, name: string): Promise<void>;
     loadFromFiles(zipData: Record<string, Uint8Array>, options?: any): Promise<any>;
     /**

package/dist/types/utils/env.d.ts

@@ -7,8 +7,3 @@
  * Returns true if process.versions.node exists
  */
 export declare function isNode(): boolean;
-/**
- * Check if running in browser environment
- * Returns true if window and document are defined
- */
-export declare function isBrowser(): boolean;

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

@@ -9,17 +9,14 @@
  */
 export declare function base64ToUint8Array(base64: string): Uint8Array;
 export declare function delay(ms: number): Promise<void>;
-export declare function nop(): void;
-export declare const inherits: <T extends new (...args: any[]) => any, S extends new (...args: any[]) => any>(cls: T, superCtor: S, statics?: any, prototype?: any) => void;
 export declare function dateToExcel(d: Date, date1904?: boolean): number;
 export declare function excelToDate(v: number, date1904?: boolean): Date;
-export declare function toIsoDateString(dt: Date): string;
-interface PathInfo {
-    path: string;
-    name: string;
-}
-export declare function parsePath(filepath: string): PathInfo;
-export declare function getRelsPath(filepath: string): string;
+/**
+ * Parse an OOXML date string into a Date object.
+ * OOXML dates like "2024-01-15T00:00:00" lack a timezone suffix,
+ * which some JS engines parse as local time. Appending "Z" forces UTC.
+ */
+export declare function parseOoxmlDate(raw: string): Date;
 export declare function xmlDecode(text: string): string;
 /**
  * Encode special characters for XML output
@@ -28,10 +25,9 @@ export declare function xmlDecode(text: string): string;
 export declare function xmlEncode(text: string): string;
 export declare function validInt(value: string | number): number;
 export declare function isDateFmt(fmt: string | null | undefined): boolean;
-export declare function parseBoolean(value: any): boolean;
+export declare function parseBoolean(value: unknown): boolean;
 export declare function range(start: number, stop: number, step?: number): Generator<number>;
-export declare function toSortedArray(values: Iterable<any>): any[];
-export declare function objectFromProps<T = any>(props: string[], value?: T | null): Record<string, T | null>;
+export declare function toSortedArray<T>(values: Iterable<T>): T[];
 /**
  * Convert a Buffer, ArrayBuffer, or Uint8Array to a UTF-8 string
  * Works in both Node.js and browser environments
@@ -46,4 +42,3 @@ export declare function uint8ArrayToBase64(bytes: Uint8Array): string;
  * Convert string to UTF-16LE Uint8Array (used for Excel password hashing)
  */
 export declare function stringToUtf16Le(str: string): Uint8Array;
-export {};

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

@@ -2,5 +2,5 @@
  * Browser utility functions
  * Re-exports shared utilities and adds browser-specific implementations
  */
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
+export { delay, dateToExcel, excelToDate, parseOoxmlDate, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
 export declare function fileExists(_path: string): Promise<boolean>;

package/dist/types/utils/utils.d.ts

@@ -2,5 +2,5 @@
  * Node.js utility functions
  * Re-exports shared utilities and adds Node.js-specific implementations
  */
-export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
+export { delay, dateToExcel, excelToDate, parseOoxmlDate, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.js";
 export declare function fileExists(path: string): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cj-tech-master/excelts",
-  "version": "5.0.6",
+  "version": "5.1.0",
   "description": "TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.",
   "type": "module",
   "publishConfig": {