@cj-tech-master/excelts 0.1.0-canary.20251025023400.dff1908

package/dist/types/utils/shared-formula.d.ts

@@ -0,0 +1,2 @@
+declare function slideFormula(formula: string, fromCell: string, toCell: string): string;
+export { slideFormula };

package/dist/types/utils/shared-strings.d.ts

@@ -0,0 +1,12 @@
+declare class SharedStrings {
+    private _values;
+    private _totalRefs;
+    private _hash;
+    constructor();
+    get count(): number;
+    get values(): any[];
+    get totalRefs(): number;
+    getString(index: number): any;
+    add(value: any): number;
+}
+export { SharedStrings };

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

@@ -0,0 +1,2 @@
+declare const StreamBuf: any;
+export { StreamBuf };

package/dist/types/utils/string-buf.d.ts

@@ -0,0 +1,20 @@
+interface StringBufOptions {
+    size?: number;
+    encoding?: BufferEncoding;
+}
+declare class StringBuf {
+    private _buf;
+    private _encoding;
+    private _inPos;
+    private _buffer;
+    constructor(options?: StringBufOptions);
+    get length(): number;
+    get capacity(): number;
+    get buffer(): Buffer;
+    toBuffer(): Buffer;
+    reset(position?: number): void;
+    private _grow;
+    addText(text: string): void;
+    addStringBuf(inBuf: StringBuf): void;
+}
+export { StringBuf };

package/dist/types/utils/under-dash.d.ts

@@ -0,0 +1,7 @@
+export declare function isEqual(a: any, b: any): boolean;
+export declare function escapeHtml(html: string): string;
+export declare function isUndefined(val: any): val is undefined;
+export declare function isObject(val: any): val is Record<string, any>;
+export declare function deepMerge<T = any>(...args: any[]): T;
+export declare function cloneDeep(obj: any, preserveUndefined?: boolean): any;
+export declare function get<T = any>(obj: any, path: string, defaultValue?: T): T;

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

@@ -0,0 +1,45 @@
+export declare function delay(ms: number): Promise<void>;
+export declare function nop(): void;
+export declare function promiseImmediate<T>(value: T): Promise<T>;
+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;
+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>;
+/** @deprecated Import functions directly instead of using the utils object */
+export declare const utils: {
+    nop: typeof nop;
+    promiseImmediate: typeof promiseImmediate;
+    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;
+};
+export {};

package/dist/types/utils/xml-stream.d.ts

@@ -0,0 +1,32 @@
+interface Attributes {
+    [key: string]: any;
+}
+declare class XmlStream {
+    private _xml;
+    private _stack;
+    private _rollbacks;
+    leaf?: boolean;
+    open?: boolean;
+    constructor();
+    get tos(): string | undefined;
+    get cursor(): number;
+    openXml(docAttributes?: Attributes): void;
+    openNode(name: string, attributes?: Attributes): void;
+    addAttribute(name: string, value: any): void;
+    addAttributes(attrs: Attributes): void;
+    writeText(text: any): void;
+    writeXml(xml: string): void;
+    closeNode(): void;
+    leafNode(name: string, attributes?: Attributes, text?: any): void;
+    closeAll(): void;
+    addRollback(): number;
+    commit(): void;
+    rollback(): void;
+    get xml(): string;
+    static StdDocAttributes: {
+        version: string;
+        encoding: string;
+        standalone: string;
+    };
+}
+export { XmlStream };

package/dist/types/utils/zip-stream.d.ts

@@ -0,0 +1,35 @@
+import events from "events";
+import { Zip } from "fflate";
+interface ZipWriterOptions {
+    type?: string;
+    compression?: string;
+}
+interface AppendOptions {
+    name: string;
+    base64?: boolean;
+}
+interface ZipFile {
+    data: Uint8Array;
+    isStream?: boolean;
+}
+declare class ZipWriter extends events.EventEmitter {
+    options: ZipWriterOptions;
+    files: Record<string, ZipFile>;
+    stream: any;
+    zip: Zip;
+    finalized: boolean;
+    constructor(options?: ZipWriterOptions);
+    append(data: any, options: AppendOptions): void;
+    push(chunk: any): boolean;
+    finalize(): Promise<void>;
+    read(size?: number): any;
+    setEncoding(encoding: string): any;
+    pause(): any;
+    resume(): any;
+    isPaused(): boolean;
+    pipe(destination: any, options?: any): any;
+    unpipe(destination?: any): any;
+    unshift(chunk: any): any;
+    wrap(stream: any): any;
+}
+export { ZipWriter };

package/dist/types/xlsx/defaultnumformats.d.ts

@@ -0,0 +1,12 @@
+interface NumFormat {
+    f?: string;
+    "zh-tw"?: string;
+    "zh-cn"?: string;
+    "ja-jp"?: string;
+    "ko-kr"?: string;
+    "th-th"?: string;
+}
+declare const defaultNumFormats: {
+    [key: number]: NumFormat;
+};
+export { defaultNumFormats };

package/dist/types/xlsx/rel-type.d.ts

@@ -0,0 +1,19 @@
+declare const RelType: {
+    OfficeDocument: string;
+    Worksheet: string;
+    CalcChain: string;
+    SharedStrings: string;
+    Styles: string;
+    Theme: string;
+    Hyperlink: string;
+    Image: string;
+    CoreProperties: string;
+    ExtenderProperties: string;
+    Comments: string;
+    VmlDrawing: string;
+    Table: string;
+    PivotCacheDefinition: string;
+    PivotCacheRecords: string;
+    PivotTable: string;
+};
+export { RelType };

package/dist/types/xlsx/xform/base-xform.d.ts

@@ -0,0 +1,33 @@
+import { XmlStream } from "../../utils/xml-stream.js";
+interface ParseEvent {
+    eventType: string;
+    value: any;
+}
+declare class BaseXform {
+    map?: {
+        [key: string]: any;
+    };
+    model?: any;
+    prepare(_model?: any, _options?: any): void;
+    render(_xmlStream?: XmlStream, _model?: any): void;
+    parseOpen(_node: any): void;
+    parseText(_text: string): void;
+    parseClose(_name: string): boolean;
+    reconcile(_model: any, _options?: any): void;
+    reset(): void;
+    mergeModel(obj: any): void;
+    parse(saxParser: AsyncIterable<ParseEvent[]>): Promise<any>;
+    parseStream(stream: any): Promise<any>;
+    get xml(): string;
+    toXml(model: any): string;
+    static toAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toStringAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toStringValue(attr: any, dflt?: any): any;
+    static toBoolAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toBoolValue(attr: any, dflt?: any): boolean;
+    static toIntAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toIntValue(attr: any, dflt?: any): number;
+    static toFloatAttribute(value: any, dflt?: any, always?: boolean): string | undefined;
+    static toFloatValue(attr: any, dflt?: any): number;
+}
+export { BaseXform };

package/dist/types/xlsx/xform/book/defined-name-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform.js";
+interface DefinedNameModel {
+    name: string;
+    ranges: string[];
+    localSheetId?: number;
+}
+declare class DefinedNamesXform extends BaseXform {
+    private _parsedName?;
+    private _parsedLocalSheetId?;
+    private _parsedText;
+    constructor();
+    render(xmlStream: any, model: DefinedNameModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { DefinedNamesXform };

package/dist/types/xlsx/xform/book/sheet-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "../base-xform.js";
+interface SheetModel {
+    id: number;
+    name: string;
+    state?: string;
+    rId: string;
+}
+declare class WorksheetXform extends BaseXform {
+    render(xmlStream: any, model: SheetModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorksheetXform };

package/dist/types/xlsx/xform/book/workbook-calc-properties-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "../base-xform.js";
+interface CalcPropertiesModel {
+    fullCalcOnLoad?: boolean;
+}
+declare class WorkbookCalcPropertiesXform extends BaseXform {
+    render(xmlStream: any, model: CalcPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookCalcPropertiesXform };

package/dist/types/xlsx/xform/book/workbook-pivot-cache-xform.d.ts

@@ -0,0 +1,12 @@
+import { BaseXform } from "../base-xform.js";
+interface PivotCacheModel {
+    cacheId: string;
+    rId: string;
+}
+declare class WorkbookPivotCacheXform extends BaseXform {
+    render(xmlStream: any, model: PivotCacheModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookPivotCacheXform };

package/dist/types/xlsx/xform/book/workbook-properties-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "../base-xform.js";
+interface WorkbookPropertiesModel {
+    date1904?: boolean;
+}
+declare class WorkbookPropertiesXform extends BaseXform {
+    render(xmlStream: any, model: WorkbookPropertiesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookPropertiesXform };

package/dist/types/xlsx/xform/book/workbook-view-xform.d.ts

@@ -0,0 +1,17 @@
+import { BaseXform } from "../base-xform.js";
+interface WorkbookViewModel {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    firstSheet?: number;
+    activeTab?: number;
+    visibility?: string;
+}
+declare class WorkbookViewXform extends BaseXform {
+    render(xmlStream: any, model: WorkbookViewModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { WorkbookViewXform };

package/dist/types/xlsx/xform/book/workbook-xform.d.ts

@@ -0,0 +1,23 @@
+import { BaseXform } from "../base-xform.js";
+import { StaticXform } from "../static-xform.js";
+declare class WorkbookXform extends BaseXform {
+    parser: any;
+    constructor();
+    prepare(model: any): void;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any): void;
+    static WORKBOOK_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:r": string;
+        "xmlns:mc": string;
+        "mc:Ignorable": string;
+        "xmlns:x15": string;
+    };
+    static STATIC_XFORMS: {
+        fileVersion: StaticXform;
+    };
+}
+export { WorkbookXform };

package/dist/types/xlsx/xform/comment/comment-xform.d.ts

@@ -0,0 +1,28 @@
+import { RichTextXform } from "../strings/rich-text-xform.js";
+import { BaseXform } from "../base-xform.js";
+interface NoteText {
+    font?: any;
+    text: string;
+}
+interface CommentNote {
+    texts: NoteText[];
+}
+interface CommentModel {
+    type: string;
+    note: CommentNote;
+    ref: string;
+    authorId?: number;
+}
+declare class CommentXform extends BaseXform {
+    model: CommentModel;
+    parser: any;
+    private _richTextXform?;
+    constructor(model?: CommentModel);
+    get tag(): string;
+    get richTextXform(): RichTextXform;
+    render(xmlStream: any, model?: CommentModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+}
+export { CommentXform };

package/dist/types/xlsx/xform/comment/comments-xform.d.ts

@@ -0,0 +1,21 @@
+import { BaseXform } from "../base-xform.js";
+import { CommentXform } from "./comment-xform.js";
+interface CommentsModel {
+    comments: any[];
+}
+declare class CommentsXform extends BaseXform {
+    map: {
+        [key: string]: CommentXform;
+    };
+    parser: any;
+    model: CommentsModel;
+    constructor();
+    render(xmlStream: any, model?: CommentsModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static COMMENTS_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { CommentsXform };

package/dist/types/xlsx/xform/comment/style/vml-position-xform.d.ts

@@ -0,0 +1,16 @@
+import { BaseXform } from "../../base-xform.js";
+declare class VmlPositionXform extends BaseXform {
+    private _model;
+    model: {
+        [key: string]: boolean;
+    };
+    constructor(model?: {
+        tag?: string;
+    });
+    get tag(): string;
+    render(xmlStream: any, model: string, type?: string[]): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+}
+export { VmlPositionXform };

package/dist/types/xlsx/xform/comment/style/vml-protection-xform.d.ts

@@ -0,0 +1,14 @@
+import { BaseXform } from "../../base-xform.js";
+declare class VmlProtectionXform extends BaseXform {
+    private _model;
+    private text;
+    constructor(model?: {
+        tag?: string;
+    });
+    get tag(): string;
+    render(xmlStream: any, model: any): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { VmlProtectionXform };

package/dist/types/xlsx/xform/comment/vml-anchor-xform.d.ts

@@ -0,0 +1,27 @@
+import { BaseXform } from "../base-xform.js";
+interface AnchorModel {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+interface RefAddress {
+    col: number;
+    row: number;
+}
+interface RenderModel {
+    anchor?: AnchorModel;
+    refAddress?: RefAddress;
+}
+declare class VmlAnchorXform extends BaseXform {
+    private text;
+    constructor();
+    get tag(): string;
+    getAnchorRect(anchor: AnchorModel): number[];
+    getDefaultRect(ref: RefAddress): number[];
+    render(xmlStream: any, model: RenderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(): boolean;
+}
+export { VmlAnchorXform };

package/dist/types/xlsx/xform/comment/vml-client-data-xform.d.ts

@@ -0,0 +1,35 @@
+import { BaseXform } from "../base-xform.js";
+interface Protection {
+    locked?: string;
+    lockText?: string;
+}
+interface ClientDataModel {
+    anchor: any;
+    protection: Protection;
+    editAs: string;
+}
+interface RenderModel {
+    note: {
+        protection: Protection;
+        editAs: string;
+    };
+    refAddress: {
+        row: number;
+        col: number;
+    };
+}
+declare class VmlClientDataXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: ClientDataModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: RenderModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    normalizeModel(): void;
+}
+export { VmlClientDataXform };

package/dist/types/xlsx/xform/comment/vml-notes-xform.d.ts

@@ -0,0 +1,24 @@
+import { BaseXform } from "../base-xform.js";
+interface VmlNotesModel {
+    comments: any[];
+}
+declare class VmlNotesXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: VmlNotesModel;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model?: VmlNotesModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    reconcile(model: any, options: any): void;
+    static DRAWING_ATTRIBUTES: {
+        "xmlns:v": string;
+        "xmlns:o": string;
+        "xmlns:x": string;
+    };
+}
+export { VmlNotesXform };

package/dist/types/xlsx/xform/comment/vml-shape-xform.d.ts

@@ -0,0 +1,25 @@
+import { BaseXform } from "../base-xform.js";
+interface ShapeModel {
+    note: {
+        margins?: {
+            insetmode?: string;
+            inset?: number[];
+        };
+    };
+    refAddress?: any;
+}
+declare class VmlShapeXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    model: any;
+    constructor();
+    get tag(): string;
+    render(xmlStream: any, model: ShapeModel, index?: number): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static V_SHAPE_ATTRIBUTES: (model: ShapeModel, index: number) => any;
+}
+export { VmlShapeXform };

package/dist/types/xlsx/xform/comment/vml-textbox-xform.d.ts

@@ -0,0 +1,23 @@
+import { BaseXform } from "../base-xform.js";
+interface Margins {
+    inset?: number[] | string;
+}
+interface NoteModel {
+    margins?: Margins;
+}
+interface TextboxModel {
+    note?: NoteModel;
+    inset?: number[];
+}
+declare class VmlTextboxXform extends BaseXform {
+    model: TextboxModel;
+    constructor();
+    get tag(): string;
+    conversionUnit(value: string | number, multiple: number, unit: string): string;
+    reverseConversionUnit(inset?: string): number[];
+    render(xmlStream: any, model: TextboxModel): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { VmlTextboxXform };

package/dist/types/xlsx/xform/composite-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "./base-xform.js";
+declare class CompositeXform extends BaseXform {
+    parser?: any;
+    createNewModel(_node?: any): any;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    onParserClose(name: string, parser: any): void;
+    parseClose(name: string): boolean;
+    get tag(): string;
+}
+export { CompositeXform };

package/dist/types/xlsx/xform/core/app-heading-pairs-xform.d.ts

@@ -0,0 +1,8 @@
+import { BaseXform } from "../base-xform.js";
+declare class AppHeadingPairsXform extends BaseXform {
+    render(xmlStream: any, model: any[]): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { AppHeadingPairsXform };

package/dist/types/xlsx/xform/core/app-titles-of-parts-xform.d.ts

@@ -0,0 +1,8 @@
+import { BaseXform } from "../base-xform.js";
+declare class AppTitlesOfPartsXform extends BaseXform {
+    render(xmlStream: any, model: any[]): void;
+    parseOpen(node: any): boolean;
+    parseText(): void;
+    parseClose(name: string): boolean;
+}
+export { AppTitlesOfPartsXform };

package/dist/types/xlsx/xform/core/app-xform.d.ts

@@ -0,0 +1,26 @@
+import { BaseXform } from "../base-xform.js";
+interface AppModel {
+    worksheets: any[];
+    company?: string;
+    manager?: string;
+}
+declare class AppXform extends BaseXform {
+    map: {
+        [key: string]: any;
+    };
+    parser: any;
+    constructor();
+    render(xmlStream: any, model: AppModel): void;
+    parseOpen(node: any): boolean;
+    parseText(text: string): void;
+    parseClose(name: string): boolean;
+    static DateFormat: (dt: Date) => string;
+    static DateAttrs: {
+        "xsi:type": string;
+    };
+    static PROPERTY_ATTRIBUTES: {
+        xmlns: string;
+        "xmlns:vt": string;
+    };
+}
+export { AppXform };

package/dist/types/xlsx/xform/core/content-types-xform.d.ts

@@ -0,0 +1,11 @@
+import { BaseXform } from "../base-xform.js";
+declare class ContentTypesXform extends BaseXform {
+    render(xmlStream: any, model: any): void;
+    parseOpen(): boolean;
+    parseText(): void;
+    parseClose(): boolean;
+    static PROPERTY_ATTRIBUTES: {
+        xmlns: string;
+    };
+}
+export { ContentTypesXform };