@cj-tech-master/excelts 3.1.0 → 4.0.0

package/dist/types/modules/stream/streams.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Native Stream Implementation - Node.js
+ *
+ * Uses Node.js native stream module for maximum performance.
+ * Provides Readable, Writable, Transform, Duplex, and PassThrough streams.
+ */
+import { Readable, Writable as NodeWritable, Transform, Duplex, PassThrough } from "stream";
+import type { TransformStreamOptions, ReadableStreamOptions, WritableStreamOptions, DuplexStreamOptions, PullStreamOptions, BufferedStreamOptions, DataChunk, ICollector, IDuplex, IEventEmitter, IPassThrough, IReadable, ITransform, IWritable, PipelineStreamLike, ReadableLike, WritableLike } from "./types.d.ts";
+import { BufferedStream as StandaloneBufferedStream, StringChunk as StandaloneStringChunk, BufferChunk as StandaloneBufferChunk } from "./buffered-stream.d.ts";
+import { PullStream as StandalonePullStream } from "./pull-stream.d.ts";
+/**
+ * Extended Writable options that match browser API
+ * Supports wrapping an existing Node.js stream
+ */
+export interface WritableOptions<T = Uint8Array> extends WritableStreamOptions {
+    /** Existing Node.js Writable stream to wrap (for API compatibility with browser) */
+    stream?: NodeWritable;
+    autoDestroy?: boolean;
+    emitClose?: boolean;
+    defaultEncoding?: BufferEncoding;
+    write?: (this: Writable<T>, chunk: T, encoding: BufferEncoding, callback: (error?: Error | null) => void) => void;
+    final?: (this: Writable<T>, callback: (error?: Error | null) => void) => void;
+}
+/**
+ * Unified Writable class - wraps Node.js Writable with browser-compatible API
+ *
+ * Supports the same `{ stream }` option as browser version for wrapping existing streams.
+ */
+export declare class Writable<T = Uint8Array> extends NodeWritable {
+    constructor(options?: WritableOptions<T>);
+}
+export { Readable, Transform, Duplex, PassThrough };
+/**
+ * Normalize a user-provided writable into a Node.js-compatible Writable.
+ *
+ * This keeps Web/Node branching at the stream-module boundary.
+ */
+export declare function normalizeWritable<T = Uint8Array>(stream: WritableLike | WritableStream<T> | NodeWritable): WritableLike;
+/**
+ * Pipeline streams together with proper error handling and cleanup
+ * Returns a promise that resolves when the pipeline completes
+ */
+type PipelineStream = PipelineStreamLike;
+type PipelineCallback = (err?: Error | null) => void;
+export interface PipelineOptions {
+    signal?: AbortSignal;
+    end?: boolean;
+}
+/**
+ * Pipeline streams together with proper error handling and cleanup.
+ * Node.js compatible with support for options and callbacks.
+ */
+export declare function pipeline(...args: [...PipelineStream[], PipelineOptions | PipelineCallback] | PipelineStream[]): Promise<void>;
+/**
+ * Wait for a stream to finish
+ */
+export interface FinishedOptions {
+    readable?: boolean;
+    writable?: boolean;
+    error?: boolean;
+    signal?: AbortSignal;
+}
+/**
+ * Wait for a stream to finish, close, or error.
+ * Node.js compatible with support for options and callbacks.
+ */
+export declare function finished(stream: PipelineStream, optionsOrCallback?: FinishedOptions | PipelineCallback, callback?: PipelineCallback): Promise<void>;
+/**
+ * Create a readable stream from various sources
+ */
+export declare function createReadable<_T = Uint8Array>(options?: ReadableStreamOptions & {
+    read?: (size: number) => void;
+    destroy?: (error: Error | null, callback: (error: Error | null) => void) => void;
+}): IReadable<_T>;
+/**
+ * Create a readable stream from an async iterable
+ */
+export declare function createReadableFromAsyncIterable<T>(iterable: AsyncIterable<T>, options?: ReadableStreamOptions): IReadable<T>;
+/**
+ * Create a readable stream from an array
+ */
+export declare function createReadableFromArray<T>(data: T[], options?: ReadableStreamOptions): IReadable<T>;
+/**
+ * Create a writable stream
+ */
+export declare function createWritable<T = Uint8Array>(options?: WritableStreamOptions & {
+    write?: (chunk: T, encoding: string, callback: (error?: Error | null) => void) => void;
+    final?: (callback: (error?: Error | null) => void) => void;
+    destroy?: (error: Error | null, callback: (error: Error | null) => void) => void;
+}): IWritable<T>;
+/**
+ * Create a transform stream from a transform function
+ */
+export declare function createTransform<TInput = Uint8Array, TOutput = Uint8Array>(transformFn: (chunk: TInput, encoding?: string) => TOutput | Promise<TOutput>, options?: TransformStreamOptions & {
+    flush?: () => TOutput | Promise<TOutput> | void;
+}): ITransform<TInput, TOutput>;
+/**
+ * Create a duplex stream
+ */
+export declare function createDuplex<_TRead = Uint8Array, TWrite = Uint8Array>(options?: DuplexStreamOptions & {
+    readable?: unknown;
+    writable?: unknown;
+    allowHalfOpen?: boolean;
+    objectMode?: boolean;
+    read?: (this: any, size: number) => void;
+    write?: (this: any, chunk: TWrite, encoding: string, callback: (error?: Error | null) => void) => void;
+    final?: (this: any, callback: (error?: Error | null) => void) => void;
+    destroy?: (this: any, error: Error | null, callback: (error: Error | null) => void) => void;
+}): IDuplex<_TRead, TWrite>;
+/**
+ * Create a passthrough stream
+ */
+export declare function createPassThrough<_T = any>(options?: TransformStreamOptions): IPassThrough<_T>;
+/**
+ * A writable stream that collects all chunks
+ */
+export declare class Collector<T = Uint8Array> extends Writable {
+    chunks: T[];
+    constructor(options?: WritableStreamOptions);
+    /**
+     * Get all collected data as a single Uint8Array (for binary mode)
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get all collected data as a string
+     */
+    toString(): string;
+}
+/**
+ * Create a collector stream
+ */
+export declare function createCollector<T = Uint8Array>(options?: WritableStreamOptions): ICollector<T>;
+export declare class PullStream extends StandalonePullStream {
+}
+/**
+ * Create a pull stream
+ */
+export declare function createPullStream(options?: PullStreamOptions): PullStream;
+/**
+ * String chunk implementation
+ */
+export declare class StringChunk extends StandaloneStringChunk implements DataChunk {
+}
+/**
+ * Buffer chunk implementation
+ */
+export declare class BufferChunk extends StandaloneBufferChunk implements DataChunk {
+}
+/**
+ * Buffered stream with efficient chunk management
+ */
+export declare class BufferedStream extends StandaloneBufferedStream {
+}
+/**
+ * Create a buffered stream
+ */
+export declare function createBufferedStream(options?: BufferedStreamOptions): BufferedStream;
+/**
+ * Convert a stream to a promise that resolves when finished
+ */
+export declare function streamToPromise(stream: PipelineStream): Promise<void>;
+/**
+ * Collect all data from a readable stream into a Uint8Array
+ * (Node.js equivalent of browser streamToBuffer)
+ */
+export declare function streamToBuffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
+/**
+ * Collect all data from a readable stream into a Uint8Array
+ */
+export declare function streamToUint8Array(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
+/**
+ * Collect all data from a readable stream into a string
+ */
+export declare function streamToString(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, encoding?: string): Promise<string>;
+/**
+ * Drain a stream (consume all data without processing)
+ */
+export declare function drainStream(stream: AsyncIterable<unknown> | ReadableStream<unknown>): Promise<void>;
+/**
+ * Copy from a readable stream to a writable stream
+ */
+export declare function copyStream(source: PipelineStreamLike, destination: PipelineStreamLike): Promise<void>;
+/**
+ * Add abort signal handling to any stream
+ */
+export declare function addAbortSignal<T extends (ReadableLike | WritableLike) & {
+    destroy(error?: Error): any;
+}>(signal: AbortSignal, stream: T): T;
+/**
+ * Create a readable stream from a generator function
+ */
+export declare function createReadableFromGenerator<T>(generator: () => AsyncGenerator<T, void, unknown>, options?: ReadableStreamOptions): IReadable<T>;
+/**
+ * Create a readable stream from a Promise
+ */
+export declare function createReadableFromPromise<T>(promise: Promise<T>, options?: ReadableStreamOptions): IReadable<T>;
+/**
+ * Compose multiple transform streams into one
+ */
+export declare function compose<_T = any, _R = any>(...transforms: Array<ITransform<any, any>>): Transform;
+/**
+ * Wait for multiple streams to finish
+ */
+export declare function finishedAll(streams: ReadonlyArray<PipelineStreamLike>): Promise<void>;
+/**
+ * Create a readable stream that emits nothing and immediately ends
+ */
+export declare function createEmptyReadable<_T = Uint8Array>(options?: ReadableStreamOptions): IReadable<_T>;
+/**
+ * Create a writable stream that discards all data (like /dev/null)
+ */
+export declare function createNullWritable<_T = any>(options?: WritableStreamOptions): IWritable<_T>;
+/**
+ * Promisified version of once for events
+ */
+export declare function once(emitter: IEventEmitter, event: string, options?: {
+    signal?: AbortSignal;
+}): Promise<any[]>;
+/**
+ * Convert a callback-based operation to a promise
+ */
+export declare function promisify<T>(fn: (callback: (error?: Error | null, result?: T) => void) => void): Promise<T>;
+/**
+ * Check if an object is a readable stream
+ */
+export declare function isReadable(obj: unknown): obj is ReadableLike;
+/**
+ * Check if an object is a writable stream
+ */
+export declare function isWritable(obj: unknown): obj is WritableLike;
+/**
+ * Check if an object is a transform stream
+ */
+export declare function isTransform(obj: unknown): obj is ITransform<any, any>;
+/**
+ * Check if an object is a duplex stream
+ */
+export declare function isDuplex(obj: unknown): obj is IDuplex<any, any>;
+/**
+ * Check if an object is any kind of stream
+ */
+export declare function isStream(obj: unknown): obj is ReadableLike | WritableLike;
+/**
+ * Check if a stream has been destroyed
+ */
+export declare function isDestroyed(stream: {
+    destroyed?: boolean;
+} | null | undefined): boolean;
+/**
+ * Check if a readable stream has been disturbed (read from)
+ */
+export declare function isDisturbed(stream: unknown): boolean;
+/**
+ * Check if a stream has an error
+ */
+export declare function isErrored(stream: {
+    errored?: unknown;
+} | null | undefined): boolean;
+/**
+ * Get the default high water mark for streams
+ */
+export declare function getDefaultHighWaterMark(objectMode: boolean): number;
+/**
+ * Set the default high water mark for streams
+ * Note: This is a no-op in this implementation as we use fixed defaults
+ */
+export declare function setDefaultHighWaterMark(_objectMode: boolean, _value: number): void;
+/**
+ * Create a pair of connected Duplex streams
+ */
+export declare function duplexPair<T = Uint8Array>(options?: DuplexStreamOptions): [Duplex, Duplex];
+export declare const consumers: {
+    arrayBuffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+    blob(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, options?: BlobPropertyBag): Promise<Blob>;
+    buffer(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<Uint8Array>;
+    json(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>): Promise<any>;
+    text(stream: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>, encoding?: string): Promise<string>;
+};
+export declare const promises: {
+    pipeline: typeof pipeline;
+    finished: typeof finished;
+};

package/dist/types/modules/stream/types.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Stream Module - Shared Types
+ *
+ * Common type definitions for stream operations across Node.js and Browser.
+ * These types provide a unified interface regardless of the underlying implementation.
+ */
+/**
+ * Options for creating readable streams
+ */
+export interface ReadableStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating writable streams
+ */
+export interface WritableStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating transform streams
+ */
+export interface TransformStreamOptions {
+    /** High water mark for backpressure (bytes) */
+    highWaterMark?: number;
+    /** Enable object mode (non-binary data) */
+    objectMode?: boolean;
+}
+/**
+ * Options for creating duplex streams
+ */
+export interface DuplexStreamOptions {
+    /** Enable object mode for both read and write sides (Node compatibility) */
+    objectMode?: boolean;
+    /** High water mark for both sides (Node compatibility) */
+    highWaterMark?: number;
+    /** Allow half-open (Node compatibility) */
+    allowHalfOpen?: boolean;
+    /** High water mark for read side */
+    readableHighWaterMark?: number;
+    /** High water mark for write side */
+    writableHighWaterMark?: number;
+    /** Enable object mode for read side */
+    readableObjectMode?: boolean;
+    /** Enable object mode for write side */
+    writableObjectMode?: boolean;
+}
+/**
+ * Callback for transform operations
+ */
+export type TransformCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Callback for flush operations
+ */
+export type FlushCallback<T = Uint8Array> = (error?: Error | null, data?: T) => void;
+/**
+ * Callback for write operations
+ */
+export type WriteCallback = (error?: Error | null) => void;
+/**
+ * Callback for destroy operations
+ */
+export type DestroyCallback = (error?: Error | null) => void;
+/**
+ * Event listener type
+ */
+export type EventListener = (...args: any[]) => void;
+/**
+ * Common event emitter interface
+ */
+export interface IEventEmitter {
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string | symbol, listener: EventListener): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): this;
+}
+/**
+ * Minimal readable-like stream shape used by `pipeline`/`finished` signatures.
+ * Kept intentionally permissive so both Node streams and browser wrappers match.
+ */
+export interface ReadableLike extends IEventEmitter {
+    pipe(destination: any): any;
+    destroy?(error?: Error): void;
+    readableEnded?: boolean;
+}
+/**
+ * Minimal writable-like stream shape used by `pipeline`/`finished` signatures.
+ * Kept intentionally permissive so both Node streams and browser wrappers match.
+ */
+export interface WritableLike extends IEventEmitter {
+    write(chunk: any, ...args: any[]): any;
+    end(...args: any[]): any;
+    destroy?(error?: Error): void;
+    writableFinished?: boolean;
+}
+/**
+ * Stream-like union accepted by `pipeline`/`finished` across Node and browser.
+ * Includes Web Streams to support browser-native and Node's WHATWG streams.
+ */
+export type PipelineStreamLike = ReadableLike | WritableLike | (ReadableLike & WritableLike) | ReadableStream<any> | WritableStream<any> | TransformStream<any, any>;
+/**
+ * Common readable stream interface
+ */
+export interface IReadable<T = any> extends ReadableLike, AsyncIterable<T> {
+    read(size?: number): T | null;
+    destroy(error?: Error): any;
+    pipe(destination: any): any;
+    unpipe(destination?: any): this;
+    pause(): this;
+    resume(): this;
+    isPaused(): boolean;
+    readonly readable: boolean;
+    readonly readableEnded: boolean;
+    readonly readableLength: number;
+    readonly readableHighWaterMark?: number;
+    readonly readableObjectMode?: boolean;
+    readonly readableFlowing?: boolean | null;
+    readonly destroyed?: boolean;
+}
+/**
+ * Common writable stream interface
+ */
+export interface IWritable<T = any> extends WritableLike {
+    write(chunk: T, callback?: WriteCallback): boolean;
+    write(chunk: T, encoding?: string, callback?: WriteCallback): boolean;
+    end(callback?: () => void): this;
+    end(chunk: T, callback?: () => void): this;
+    end(chunk: T, encoding?: string, callback?: () => void): this;
+    destroy(error?: Error): any;
+    readonly writable: boolean;
+    readonly writableEnded: boolean;
+    readonly writableFinished: boolean;
+    readonly writableLength: number;
+    readonly writableHighWaterMark?: number;
+    readonly destroyed?: boolean;
+}
+/**
+ * Common transform stream interface
+ */
+export interface ITransform<TInput = any, TOutput = any> extends IReadable<TOutput>, IWritable<TInput> {
+    _transform(chunk: TInput, encoding: string, callback: TransformCallback<TOutput>): void;
+    _flush(callback: FlushCallback<TOutput>): void;
+}
+/**
+ * Common duplex stream interface
+ */
+export interface IDuplex<TRead = any, TWrite = any> extends IReadable<TRead>, IWritable<TWrite> {
+}
+/**
+ * Options for pull stream
+ */
+export interface PullStreamOptions {
+    /** Enable object mode */
+    objectMode?: boolean;
+    /** High water mark for internal buffer */
+    highWaterMark?: number;
+}
+/**
+ * Pull stream interface - allows pulling data on demand
+ */
+export interface IPullStream extends IEventEmitter {
+    write(chunk: Uint8Array): boolean;
+    end(chunk?: Uint8Array): void;
+    destroy(error?: Error): void;
+    /** Pull exactly N bytes from buffer */
+    pull(size: number): Promise<Uint8Array>;
+    /** Pull until pattern is found */
+    pullUntil(pattern: Uint8Array, includePattern?: boolean): Promise<Uint8Array>;
+    /** Stream data until pattern */
+    stream(eof: number | Uint8Array): IReadable<Uint8Array>;
+    readonly length: number;
+    readonly isFinished: boolean;
+    readonly matchPosition: number | undefined;
+}
+/**
+ * Options for buffered stream
+ */
+export interface BufferedStreamOptions {
+    /** Batch size for internal read-write buffers */
+    batchSize?: number;
+}
+/**
+ * Buffered stream interface - manages internal buffering
+ */
+export interface IBufferedStream extends IEventEmitter {
+    write(chunk: Uint8Array | string): boolean;
+    read(size?: number): Uint8Array | null;
+    end(chunk?: Uint8Array | string): void;
+    destroy(error?: Error): void;
+    toUint8Array(): Uint8Array;
+    readonly bufferedLength: number;
+    readonly isFinished: boolean;
+}
+/**
+ * Passthrough stream - passes data through unchanged
+ */
+export type IPassThrough<T = Uint8Array> = ITransform<T, T>;
+/**
+ * Collector interface - collects all chunks
+ */
+export interface ICollector<T = any> extends IWritable<T> {
+    readonly chunks: T[];
+    readonly isFinished?: boolean;
+}
+/**
+ * Pipeline source - can be a readable stream or async iterable
+ */
+export type PipelineSource<T> = IReadable<T> | AsyncIterable<T> | Iterable<T>;
+/**
+ * Pipeline transform - a transform stream or function
+ */
+export type PipelineTransform<TIn, TOut> = ITransform<TIn, TOut> | ((source: AsyncIterable<TIn>) => AsyncIterable<TOut>);
+/**
+ * Pipeline destination - a writable stream or async generator
+ */
+export type PipelineDestination<T, R> = IWritable<T> | ((source: AsyncIterable<T>) => Promise<R>);
+/**
+ * Data chunk interface for flexible chunk handling
+ */
+export interface DataChunk {
+    readonly length: number;
+    copy(target: Uint8Array, targetOffset: number, offset: number, length: number): number;
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Read-write buffer options
+ */
+export interface ReadWriteBufferOptions {
+    /** Initial buffer size */
+    size?: number;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Stream Utilities
+ *
+ * Small, cross-platform helpers built on top of the platform stream
+ * implementation selected by `./streams` (Node.js or browser).
+ */
+import type { IReadable, ITransform } from "./types.d.ts";
+export declare function collect<T>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}): Promise<T[]>;
+export declare function text(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<string>;
+export declare function json<T = unknown>(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<T>;
+export declare function bytes(stream: {
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+}): Promise<Uint8Array>;
+export declare function fromString(str: string): IReadable<Uint8Array>;
+export declare function fromJSON(data: unknown): IReadable<Uint8Array>;
+export declare function fromBytes(data: Uint8Array): IReadable<Uint8Array>;
+export declare function transform<TIn = Uint8Array, TOut = TIn>(fn: (chunk: TIn) => TOut | Promise<TOut>): ITransform<TIn, TOut>;
+export declare function filter<T>(predicate: (chunk: T) => boolean | Promise<boolean>): ITransform<T, T>;

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

@@ -0,0 +1,9 @@
+import type { Plugin } from "vitest/config";
+/**
+ * Prefer sibling `.browser.*` implementation when it exists.
+ *
+ * Example:
+ * - resolved: `/abs/path/to/streams.ts`
+ * - if `/abs/path/to/streams.browser.ts` exists => use it
+ */
+export declare function preferBrowserFilesPlugin(): Plugin;

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

@@ -0,0 +1,14 @@
+/**
+ * Environment detection utilities
+ * Common functions to detect runtime environment (Node.js vs Browser)
+ */
+/**
+ * Check if running in Node.js environment
+ * 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

@@ -1,7 +1,13 @@
 /**
  * Base utility functions shared between Node.js and Browser
- * Platform-independent implementations only
+ * All functions use standard Web APIs that work in both environments
+ * (Node.js 16+ supports atob/btoa/TextEncoder/TextDecoder globally)
  */
+/**
+ * Convert base64 string to Uint8Array
+ * Uses native Buffer in Node.js for better performance
+ */
+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;
@@ -15,6 +21,11 @@ interface PathInfo {
 export declare function parsePath(filepath: string): PathInfo;
 export declare function getRelsPath(filepath: string): string;
 export declare function xmlDecode(text: string): string;
+/**
+ * Encode special characters for XML output
+ * Handles XML entities (< > & " ') and removes invalid control characters
+ */
+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;
@@ -26,4 +37,13 @@ export declare function objectFromProps<T = any>(props: string[], value?: T | nu
  * Works in both Node.js and browser environments
  */
 export declare function bufferToString(chunk: ArrayBuffer | Uint8Array | string): string;
+/**
+ * Convert Uint8Array to base64 string
+ * Uses native Buffer in Node.js, optimized chunked conversion in browser
+ */
+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,28 +2,5 @@
  * 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 { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.d.ts";
 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

@@ -2,28 +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, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString } from "./utils.base";
-export declare function xmlEncode(text: string): string;
+export { delay, nop, inherits, dateToExcel, excelToDate, toIsoDateString, parsePath, getRelsPath, xmlDecode, xmlEncode, validInt, isDateFmt, parseBoolean, range, toSortedArray, objectFromProps, bufferToString, base64ToUint8Array, uint8ArrayToBase64, stringToUtf16Le } from "./utils.base.d.ts";
 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/uuid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generate a UUID v4.
+ *
+ * This exists to avoid a hard dependency on `crypto.randomUUID()` so that
+ * older supported browsers can still generate UUIDs.
+ *
+ * - Prefers `crypto.randomUUID()` when available.
+ * - Falls back to `crypto.getRandomValues()`.
+ * - Last-resort fallback uses `Math.random()` (NOT cryptographically secure).
+ */
+export declare function uuidV4(): string;