@cj-tech-master/excelts 1.6.3 → 2.0.0

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

@@ -0,0 +1,85 @@
+/**
+ * High-performance native date parsing and formatting utilities
+ *
+ * Zero external dependencies. Optimized for CSV batch processing.
+ * Uses character code operations and lookup tables for maximum speed.
+ */
+/** Supported date format strings */
+export type DateFormat = "YYYY-MM-DD[T]HH:mm:ssZ" | "YYYY-MM-DD[T]HH:mm:ss" | "YYYY-MM-DD[T]HH:mm:ss.SSSZ" | "YYYY-MM-DD" | "YYYY-MM-DD HH:mm:ss" | "MM-DD-YYYY" | "MM-DD-YYYY HH:mm:ss" | "MM/DD/YYYY HH:mm:ss" | "DD-MM-YYYY" | "DD-MM-YYYY HH:mm:ss" | "DD/MM/YYYY HH:mm:ss";
+/**
+ * Quick pre-filter to reject non-date strings
+ */
+export declare function mightBeDate(s: string): boolean;
+/**
+ * Parse a date string
+ *
+ * @param value - String to parse
+ * @param formats - Specific formats to try (optional, auto-detects ISO if omitted)
+ * @returns Date object or null
+ *
+ * @example
+ * parseDate("2024-12-26")                    // auto-detect ISO
+ * parseDate("12-26-2024", ["MM-DD-YYYY"])   // explicit US format
+ */
+export declare function parseDate(value: string, formats?: DateFormat[]): Date | null;
+/**
+ * Format a Date to string
+ *
+ * @param date - Date to format
+ * @param format - Format template (optional, defaults to ISO)
+ * @param utc - Use UTC time (default: false)
+ * @returns Formatted string or empty string if invalid
+ *
+ * @example
+ * formatDate(date)                        // "2024-12-26T10:30:00.000+08:00"
+ * formatDate(date, "YYYY-MM-DD", true)   // "2024-12-26"
+ */
+export declare function formatDate(date: Date, format?: string, utc?: boolean): string;
+/**
+ * Optimized date parser for batch processing
+ *
+ * @example
+ * const parser = DateParser.create(["YYYY-MM-DD"]);
+ * const dates = parser.parseAll(csvStrings);
+ */
+export declare class DateParser {
+    private readonly fns;
+    private readonly single;
+    private readonly fn0;
+    private constructor();
+    /** Create parser for specific formats */
+    static create(formats: readonly DateFormat[]): DateParser;
+    /** Create parser for auto-detecting ISO formats */
+    static iso(): DateParser;
+    /** Parse single value */
+    parse: (value: string) => Date | null;
+    /** Parse array of values */
+    parseAll(values: string[]): (Date | null)[];
+    /** Parse and filter valid dates */
+    parseValid(values: string[]): Date[];
+}
+/**
+ * Optimized date formatter for batch processing
+ *
+ * @example
+ * const formatter = DateFormatter.create("YYYY-MM-DD", { utc: true });
+ * const strings = formatter.formatAll(dates);
+ */
+export declare class DateFormatter {
+    private readonly fn;
+    private constructor();
+    /** Create ISO formatter (fastest) */
+    static iso(utc?: boolean): DateFormatter;
+    /** Create custom format formatter */
+    static create(format: string, options?: {
+        utc?: boolean;
+    }): DateFormatter;
+    /** Generic formatter for arbitrary formats */
+    private static createGeneric;
+    /** Format single date */
+    format: (date: Date) => string;
+    /** Format array of dates */
+    formatAll(dates: Date[]): string[];
+}
+/** Get supported format strings */
+export declare function getSupportedFormats(): DateFormat[];

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

@@ -0,0 +1,28 @@
+/**
+ * Browser-compatible Encryptor with pure JS SHA implementations
+ * This provides synchronous hash functions for browser compatibility
+ */
+import { BrowserBuffer } from "./browser-buffer";
+declare const Encryptor: {
+    /**
+     * Calculate a hash of the concatenated buffers with the given algorithm.
+     * @param algorithm - The hash algorithm.
+     * @returns The hash as Uint8Array
+     */
+    hash(algorithm: string, ...buffers: Uint8Array[]): Uint8Array;
+    /**
+     * Convert a password into an encryption key
+     * @param password - The password
+     * @param hashAlgorithm - The hash algorithm
+     * @param saltValue - The salt value (base64 encoded)
+     * @param spinCount - The spin count
+     * @returns The encryption key (base64 encoded)
+     */
+    convertPasswordToHash(password: string, hashAlgorithm: string, saltValue: string, spinCount: number): string;
+    /**
+     * Generates cryptographically strong pseudo-random data.
+     * @param size The size argument is a number indicating the number of bytes to generate.
+     */
+    randomBytes(size: number): BrowserBuffer;
+};
+export { Encryptor };

package/dist/types/utils/parse-sax.d.ts

@@ -1,6 +1,113 @@
-interface SaxEvent {
+/**
+ * High-performance SAX XML parser
+ *
+ * Minimal implementation optimized for Excel XML parsing.
+ * Supports: opentag, text, closetag, error events.
+ * Zero external dependencies.
+ *
+ * Based on XML 1.0 specification with optimizations for common Excel XML patterns.
+ */
+export interface SaxEvent {
     eventType: "opentag" | "text" | "closetag";
     value: any;
 }
+export interface SaxesTagPlain {
+    name: string;
+    attributes: Record<string, string>;
+    isSelfClosing: boolean;
+}
+export interface SaxesOptions {
+    xmlns?: boolean;
+    position?: boolean;
+    fileName?: string;
+    fragment?: boolean;
+}
+type TextHandler = (text: string) => void;
+type OpenTagHandler = (tag: SaxesTagPlain) => void;
+type CloseTagHandler = (tag: SaxesTagPlain) => void;
+type ErrorHandler = (err: Error) => void;
+export declare class SaxesParser {
+    private trackPosition;
+    private fileName?;
+    private fragment;
+    private state;
+    private chunk;
+    private i;
+    private prevI;
+    private text;
+    private name;
+    private q;
+    private tags;
+    private tag;
+    private attribList;
+    private entity;
+    private entityReturnState;
+    private openWakaBang;
+    private sawRoot;
+    private closedRoot;
+    private carriedFromPrevious?;
+    private _closed;
+    private reportedTextBeforeRoot;
+    private reportedTextAfterRoot;
+    line: number;
+    column: number;
+    private positionAtNewLine;
+    private chunkPosition;
+    ENTITIES: Record<string, string>;
+    private textHandler?;
+    private openTagHandler?;
+    private closeTagHandler?;
+    private errorHandler?;
+    constructor(opt?: SaxesOptions);
+    get closed(): boolean;
+    get position(): number;
+    private _init;
+    on(name: "text", handler: TextHandler): void;
+    on(name: "opentag", handler: OpenTagHandler): void;
+    on(name: "closetag", handler: CloseTagHandler): void;
+    on(name: "error", handler: ErrorHandler): void;
+    off(name: string): void;
+    private makeError;
+    fail(message: string): this;
+    write(chunk: string | null): this;
+    close(): this;
+    private getCode;
+    private unget;
+    private processState;
+    private sText;
+    private handleTextInRoot;
+    private handleTextOutsideRoot;
+    private sOpenWaka;
+    private sOpenWakaBang;
+    private sOpenTag;
+    private sOpenTagSlash;
+    private sAttrib;
+    private sAttribName;
+    private sAttribNameSawWhite;
+    private sAttribValue;
+    private sAttribValueQuoted;
+    private sAttribValueClosed;
+    private sCloseTag;
+    private sCloseTagSawWhite;
+    private sComment;
+    private sCommentEnding;
+    private sCommentEnded;
+    private sCData;
+    private sCDataEnding;
+    private sCDataEnding2;
+    private sPI;
+    private sPIEnding;
+    private sDoctype;
+    private sDoctypeQuote;
+    private sDoctypeDTD;
+    private sDoctypeDTDQuoted;
+    private sEntity;
+    private parseEntity;
+    private skipSpaces;
+    private openTag;
+    private openSelfClosingTag;
+    private closeTag;
+    private end;
+}
 declare function parseSax(iterable: any): AsyncGenerator<SaxEvent[]>;
 export { parseSax };

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

@@ -2,9 +2,9 @@
  * Utility functions for ExcelTS
  * Provides convenient helper functions for common spreadsheet operations
  */
-import { Workbook } from "../doc/workbook.js";
-import type { Worksheet } from "../doc/worksheet.js";
-import type { CellValue } from "../types.js";
+import { Workbook } from "../doc/workbook";
+import type { Worksheet } from "../doc/worksheet";
+import type { CellValue } from "../types";
 /**
  * Cell address object (0-indexed)
  */

package/dist/types/utils/stream-buf.browser.d.ts

@@ -0,0 +1,41 @@
+interface StreamBufOptions {
+    bufSize?: number;
+    batch?: boolean;
+}
+type EventCallback = (...args: any[]) => void;
+declare class StreamBuf {
+    private bufSize;
+    private buffers;
+    private batch;
+    private corked;
+    private paused;
+    private encoding;
+    private pipes;
+    private events;
+    constructor(options?: StreamBufOptions);
+    on(event: string, callback: EventCallback): this;
+    once(event: string, callback: EventCallback): this;
+    off(event: string, callback: EventCallback): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeListener(event: string, callback: EventCallback): this;
+    toBuffer(): Uint8Array | null;
+    private _getWritableBuffer;
+    private _pipe;
+    private _writeToBuffers;
+    write(data: any, encoding?: BufferEncoding | Function, callback?: Function): Promise<boolean>;
+    cork(): void;
+    private _flush;
+    uncork(): void;
+    end(chunk?: any, encoding?: BufferEncoding, callback?: Function): void;
+    read(size?: number): Uint8Array;
+    setEncoding(encoding: string): void;
+    pause(): void;
+    resume(): void;
+    isPaused(): boolean;
+    pipe(destination: any): any;
+    unpipe(destination: any): void;
+    unshift(): void;
+    wrap(): void;
+    push(chunk: any): boolean;
+}
+export { StreamBuf };

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

@@ -3,7 +3,7 @@
  * Provides easy-to-use Promise-based API for extracting ZIP files
  * Works in both Node.js and browser environments
  */
-import { type ZipEntryInfo } from "./zip-parser.js";
+import { type ZipEntryInfo } from "./zip-parser";
 /**
  * Extracted file entry
  */
@@ -25,7 +25,7 @@ export interface ExtractedFile {
  *
  * @example
  * ```ts
- * import { extractAll } from "./utils/unzip/extract.js";
+ * import { extractAll } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const files = await extractAll(zipData);
@@ -45,7 +45,7 @@ export declare function extractAll(zipData: Uint8Array | ArrayBuffer): Promise<M
  *
  * @example
  * ```ts
- * import { extractFile } from "./utils/unzip/extract.js";
+ * import { extractFile } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const content = await extractFile(zipData, "readme.txt");
@@ -63,7 +63,7 @@ export declare function extractFile(zipData: Uint8Array | ArrayBuffer, filePath:
  *
  * @example
  * ```ts
- * import { listFiles } from "./utils/unzip/extract.js";
+ * import { listFiles } from "./utils/unzip/extract";
  *
  * const zipData = fs.readFileSync("archive.zip");
  * const paths = await listFiles(zipData);
@@ -79,7 +79,7 @@ export declare function listFiles(zipData: Uint8Array | ArrayBuffer): Promise<st
  *
  * @example
  * ```ts
- * import { forEachEntry } from "./utils/unzip/extract.js";
+ * import { forEachEntry } from "./utils/unzip/extract";
  *
  * await forEachEntry(zipData, async (path, getData) => {
  *   if (path.endsWith(".xml")) {
@@ -91,4 +91,4 @@ export declare function listFiles(zipData: Uint8Array | ArrayBuffer): Promise<st
  * ```
  */
 export declare function forEachEntry(zipData: Uint8Array | ArrayBuffer, callback: (path: string, getData: () => Promise<Uint8Array>, entry: ZipEntryInfo) => Promise<boolean | void>): Promise<void>;
-export { ZipParser, type ZipEntryInfo, type ZipParseOptions } from "./zip-parser.js";
+export { ZipParser, type ZipEntryInfo, type ZipParseOptions } from "./zip-parser";

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

@@ -17,11 +17,11 @@
  * Original source: https://github.com/ZJONSSON/node-unzipper
  * License: MIT
  */
-export { Parse, createParse, type ParseOptions, type ZipEntry } from "./parse.js";
-export { PullStream } from "./pull-stream.js";
-export { NoopStream } from "./noop-stream.js";
-export { bufferStream } from "./buffer-stream.js";
-export { parse as parseBuffer } from "./parse-buffer.js";
-export { parseDateTime } from "./parse-datetime.js";
-export { parseExtraField, type ExtraField, type ZipVars } from "./parse-extra-field.js";
-export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipEntryInfo, type ZipParseOptions } from "./extract.js";
+export { Parse, createParse, type ParseOptions, type ZipEntry } from "./parse";
+export { PullStream } from "./pull-stream";
+export { NoopStream } from "./noop-stream";
+export { bufferStream } from "./buffer-stream";
+export { parse as parseBuffer } from "./parse-buffer";
+export { parseDateTime } from "./parse-datetime";
+export { parseExtraField, type ExtraField, type ZipVars } from "./parse-extra-field";
+export { extractAll, extractFile, listFiles, forEachEntry, ZipParser, type ExtractedFile, type ZipEntryInfo, type ZipParseOptions } from "./extract";

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

@@ -6,9 +6,9 @@
  * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
  */
 import { PassThrough } from "stream";
-import { PullStream } from "./pull-stream.js";
-import { NoopStream } from "./noop-stream.js";
-import { type ExtraField } from "./parse-extra-field.js";
+import { PullStream } from "./pull-stream";
+import { NoopStream } from "./noop-stream";
+import { type ExtraField } from "./parse-extra-field";
 export interface ParseOptions {
     verbose?: boolean;
     forceStream?: boolean;

package/dist/types/utils/unzip/zip-parser.d.ts

@@ -85,6 +85,11 @@ export declare class ZipParser {
      * Extract all files (async)
      */
     extractAll(): Promise<Map<string, Uint8Array>>;
+    /**
+     * Extract all files (sync, Node.js only)
+     * Returns object with file paths as keys and Uint8Array content as values
+     */
+    extractAllSync(): Record<string, Uint8Array>;
     /**
      * Iterate over entries with async callback
      */

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

@@ -0,0 +1,29 @@
+/**
+ * Base utility functions shared between Node.js and Browser
+ * Platform-independent implementations only
+ */
+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;
+export declare function xmlDecode(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 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>;
+/**
+ * Convert a Buffer, ArrayBuffer, or Uint8Array to a UTF-8 string
+ * Works in both Node.js and browser environments
+ */
+export declare function bufferToString(chunk: ArrayBuffer | Uint8Array | string): string;
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * Browser utility functions
+ * Re-exports shared utilities and adds browser-specific implementations
+ */
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base";
+export declare function xmlEncode(text: string): string;
+export declare function fileExists(_path: string): Promise<boolean>;
+import { nop, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base";
+/** @deprecated Import functions directly instead of using the utils object */
+export declare const utils: {
+    nop: typeof nop;
+    inherits: <T extends new (...args: any[]) => any, S extends new (...args: any[]) => any>(cls: T, superCtor: S, statics?: any, prototype?: any) => void;
+    dateToExcel: typeof dateToExcel;
+    excelToDate: typeof excelToDate;
+    parsePath: typeof parsePath;
+    getRelsPath: typeof getRelsPath;
+    xmlEncode: typeof xmlEncode;
+    xmlDecode: typeof xmlDecode;
+    validInt: typeof validInt;
+    isDateFmt: typeof isDateFmt;
+    fs: {
+        exists: typeof fileExists;
+    };
+    toIsoDateString: typeof toIsoDateString;
+    parseBoolean: typeof parseBoolean;
+    range: typeof range;
+    toSortedArray: typeof toSortedArray;
+    objectFromProps: typeof objectFromProps;
+};

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

@@ -1,24 +1,11 @@
-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;
-interface PathInfo {
-    path: string;
-    name: string;
-}
-export declare function dateToExcel(d: Date, date1904?: boolean): number;
-export declare function excelToDate(v: number, date1904?: boolean): Date;
-export declare function parsePath(filepath: string): PathInfo;
-export declare function getRelsPath(filepath: string): string;
+/**
+ * Node.js utility functions
+ * Re-exports shared utilities and adds Node.js-specific implementations
+ */
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base";
 export declare function xmlEncode(text: string): string;
-export declare function xmlDecode(text: string): string;
-export declare function validInt(value: string | number): number;
-export declare function isDateFmt(fmt: string | null | undefined): boolean;
 export declare function fileExists(path: string): Promise<boolean>;
-export declare function toIsoDateString(dt: Date): string;
-export declare function parseBoolean(value: any): 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>;
+import { nop, dateToExcel, excelToDate, parsePath, getRelsPath, xmlDecode, validInt, isDateFmt, toIsoDateString, parseBoolean, range, toSortedArray, objectFromProps } from "./utils.base";
 /** @deprecated Import functions directly instead of using the utils object */
 export declare const utils: {
     nop: typeof nop;
@@ -40,9 +27,3 @@ export declare const utils: {
     toSortedArray: typeof toSortedArray;
     objectFromProps: typeof objectFromProps;
 };
-/**
- * Convert a Buffer or ArrayBuffer to a UTF-8 string
- * Works in both Node.js and browser environments
- */
-export declare function bufferToString(chunk: Buffer | ArrayBuffer | string): string;
-export {};

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

@@ -0,0 +1,45 @@
+/**
+ * Base compression utilities using Web Streams API
+ * Shared between Node.js and Browser implementations
+ *
+ * Uses CompressionStream/DecompressionStream API with "deflate-raw" format
+ * (raw DEFLATE without zlib header/trailer, required for ZIP files)
+ *
+ * Browser fallback: For browsers without deflate-raw support (Firefox < 113, Safari < 16.4),
+ * see deflate-fallback.ts for pure JS implementation
+ */
+/**
+ * Compression options
+ */
+export interface CompressOptions {
+    /**
+     * Compression level (0-9)
+     * - 0: No compression (STORE)
+     * - 1: Fastest compression
+     * - 6: Default compression (good balance)
+     * - 9: Best compression (slowest)
+     *
+     * Note: CompressionStream does not support level configuration,
+     * it uses a fixed level (~6)
+     */
+    level?: number;
+}
+/**
+ * Check if CompressionStream is available
+ */
+export declare function hasCompressionStream(): boolean;
+/**
+ * Compress using CompressionStream API
+ * Uses "deflate-raw" format (required for ZIP files)
+ *
+ * @param data - Data to compress
+ * @returns Compressed data
+ */
+export declare function compressWithStream(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress using DecompressionStream API
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompressWithStream(data: Uint8Array): Promise<Uint8Array>;

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

@@ -0,0 +1,63 @@
+/**
+ * Browser compression utilities
+ *
+ * Primary: CompressionStream API (Chrome 103+, Firefox 113+, Safari 16.4+)
+ * Fallback: Pure JS DEFLATE implementation for older browsers
+ *
+ * Supported browsers with fallback:
+ * - Chrome >= 85
+ * - Firefox >= 79
+ * - Safari >= 14
+ * - Edge >= 85
+ */
+import { type CompressOptions } from "./compress.base";
+export { type CompressOptions };
+/**
+ * Check if CompressionStream with "deflate-raw" is available
+ * Note: Chrome 80-102 has CompressionStream but not deflate-raw support
+ */
+export declare function hasCompressionStream(): boolean;
+/**
+ * Check if native zlib is available (always false in browser)
+ */
+export declare function hasNativeZlib(): boolean;
+/**
+ * Compress data using browser's native CompressionStream or JS fallback
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ *
+ * @example
+ * ```ts
+ * const data = new TextEncoder().encode("Hello, World!");
+ * const compressed = await compress(data, { level: 6 });
+ * ```
+ */
+export declare function compress(data: Uint8Array, options?: {
+    level?: number;
+}): Promise<Uint8Array>;
+/**
+ * Compress data synchronously using pure JS implementation
+ *
+ * @param data - Data to compress
+ * @param options - Compression options
+ * @returns Compressed data
+ */
+export declare function compressSync(data: Uint8Array, options?: {
+    level?: number;
+}): Uint8Array;
+/**
+ * Decompress data using browser's native DecompressionStream or JS fallback
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decompress data synchronously using pure JS implementation
+ *
+ * @param data - Compressed data (deflate-raw format)
+ * @returns Decompressed data
+ */
+export declare function decompressSync(data: Uint8Array): Uint8Array;