@cj-tech-master/excelts 1.0.0 → 1.4.0

package/dist/esm/utils/unzip/pull-stream.js

@@ -0,0 +1,141 @@
+/**
+ * Unzipper pull-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import { Duplex, PassThrough, Transform } from "stream";
+const STR_FUNCTION = "function";
+export class PullStream extends Duplex {
+    constructor() {
+        super({ decodeStrings: false, objectMode: true });
+        this.buffer = Buffer.from("");
+        this.finished = false;
+        this.on("finish", () => {
+            this.finished = true;
+            this.emit("chunk", false);
+        });
+    }
+    _write(chunk, _encoding, cb) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        this.cb = cb;
+        this.emit("chunk");
+    }
+    _read() { }
+    /**
+     * The `eof` parameter is interpreted as `file_length` if the type is number
+     * otherwise (i.e. buffer) it is interpreted as a pattern signaling end of stream
+     */
+    stream(eof, includeEof) {
+        const p = new PassThrough();
+        let done = false;
+        const cb = () => {
+            if (typeof this.cb === STR_FUNCTION) {
+                const callback = this.cb;
+                this.cb = undefined;
+                callback();
+            }
+        };
+        const pull = () => {
+            let packet;
+            if (this.buffer && this.buffer.length) {
+                if (typeof eof === "number") {
+                    packet = this.buffer.slice(0, eof);
+                    this.buffer = this.buffer.slice(eof);
+                    eof -= packet.length;
+                    done = done || !eof;
+                }
+                else {
+                    let match = this.buffer.indexOf(eof);
+                    if (match !== -1) {
+                        // store signature match byte offset to allow us to reference
+                        // this for zip64 offset
+                        this.match = match;
+                        if (includeEof) {
+                            match = match + eof.length;
+                        }
+                        packet = this.buffer.slice(0, match);
+                        this.buffer = this.buffer.slice(match);
+                        done = true;
+                    }
+                    else {
+                        const len = this.buffer.length - eof.length;
+                        if (len <= 0) {
+                            cb();
+                        }
+                        else {
+                            packet = this.buffer.slice(0, len);
+                            this.buffer = this.buffer.slice(len);
+                        }
+                    }
+                }
+                if (packet) {
+                    p.write(packet, () => {
+                        if (this.buffer.length === 0 ||
+                            (typeof eof !== "number" && eof.length && this.buffer.length <= eof.length)) {
+                            cb();
+                        }
+                    });
+                }
+            }
+            if (!done) {
+                if (this.finished) {
+                    this.removeListener("chunk", pull);
+                    this.emit("error", new Error("FILE_ENDED"));
+                    return;
+                }
+            }
+            else {
+                this.removeListener("chunk", pull);
+                p.end();
+            }
+        };
+        this.on("chunk", pull);
+        pull();
+        return p;
+    }
+    pull(eof, includeEof) {
+        if (eof === 0) {
+            return Promise.resolve(Buffer.from(""));
+        }
+        // If we already have the required data in buffer
+        // we can resolve the request immediately
+        if (typeof eof === "number" && this.buffer.length > eof) {
+            const data = this.buffer.slice(0, eof);
+            this.buffer = this.buffer.slice(eof);
+            return Promise.resolve(data);
+        }
+        // Otherwise we stream until we have it
+        let buffer = Buffer.from("");
+        const concatStream = new Transform({
+            transform(d, _e, cb) {
+                buffer = Buffer.concat([buffer, d]);
+                cb();
+            }
+        });
+        let rejectHandler;
+        let pullStreamRejectHandler;
+        return new Promise((resolve, reject) => {
+            rejectHandler = reject;
+            pullStreamRejectHandler = (e) => {
+                this.__emittedError = e;
+                reject(e);
+            };
+            if (this.finished) {
+                return reject(new Error("FILE_ENDED"));
+            }
+            this.once("error", pullStreamRejectHandler); // reject any errors from pullstream itself
+            this.stream(eof, includeEof)
+                .on("error", reject)
+                .pipe(concatStream)
+                .on("finish", () => {
+                resolve(buffer);
+            })
+                .on("error", reject);
+        }).finally(() => {
+            this.removeListener("error", rejectHandler);
+            this.removeListener("error", pullStreamRejectHandler);
+        });
+    }
+}

package/dist/esm/utils/utils.js

@@ -3,21 +3,6 @@ export function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 export function nop() { }
-export function promiseImmediate(value) {
-    return new Promise(resolve => {
-        if (global.setImmediate) {
-            setImmediate(() => {
-                resolve(value);
-            });
-        }
-        else {
-            // poorman's setImmediate - must wait at least 1ms
-            setTimeout(() => {
-                resolve(value);
-            }, 1);
-        }
-    });
-}
 // useful stuff
 export const inherits = function (cls, superCtor, statics, prototype) {
     cls.super_ = superCtor;
@@ -189,7 +174,6 @@ export function objectFromProps(props, value = null) {
 /** @deprecated Import functions directly instead of using the utils object */
 export const utils = {
     nop,
-    promiseImmediate,
     inherits,
     dateToExcel,
     excelToDate,
@@ -208,3 +192,15 @@ export const utils = {
     toSortedArray,
     objectFromProps
 };
+// TextDecoder is available in ES2020+ and all modern browsers/Node.js
+const textDecoder = new TextDecoder("utf-8");
+/**
+ * Convert a Buffer or ArrayBuffer to a UTF-8 string
+ * Works in both Node.js and browser environments
+ */
+export function bufferToString(chunk) {
+    if (typeof chunk === "string") {
+        return chunk;
+    }
+    return textDecoder.decode(chunk);
+}

package/dist/esm/utils/zip-stream.js

@@ -1,8 +1,6 @@
 import events from "events";
-import { Zip, ZipPassThrough } from "fflate";
+import { Zip, ZipPassThrough, ZipDeflate } from "fflate";
 import { StreamBuf } from "./stream-buf.js";
-import { stringToBuffer } from "./browser-buffer-encode.js";
-import { isBrowser } from "./browser.js";
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
@@ -13,6 +11,10 @@ class ZipWriter extends events.EventEmitter {
             type: "nodebuffer",
             compression: "DEFLATE"
         }, options);
+        // Default compression level is 6 (good balance of speed and size)
+        // 0 = no compression, 9 = best compression
+        const level = this.options.compressionOptions?.level ?? 6;
+        this.compressionLevel = Math.max(0, Math.min(9, level));
         this.files = {};
         this.stream = new StreamBuf();
         this.finalized = false;
@@ -32,42 +34,36 @@ class ZipWriter extends events.EventEmitter {
     append(data, options) {
         let buffer;
         if (Object.prototype.hasOwnProperty.call(options, "base64") && options.base64) {
-            // Use Buffer.from for efficient base64 decoding
+            // Decode base64 data - Buffer.from works in both Node.js and browser (via polyfill)
             const base64Data = typeof data === "string" ? data : data.toString();
-            if (isBrowser) {
-                // Browser: use atob with optimized Uint8Array conversion
-                const binaryString = atob(base64Data);
-                const len = binaryString.length;
-                buffer = new Uint8Array(len);
-                // Use a single loop with cached length for better performance
-                for (let i = 0; i < len; i++) {
-                    buffer[i] = binaryString.charCodeAt(i);
-                }
-            }
-            else {
-                // Node.js: use efficient Buffer.from
-                buffer = Buffer.from(base64Data, "base64");
-            }
+            buffer = Buffer.from(base64Data, "base64");
+        }
+        else if (typeof data === "string") {
+            // Convert string to Buffer - works in both environments
+            buffer = Buffer.from(data, "utf8");
+        }
+        else if (Buffer.isBuffer(data)) {
+            // Buffer extends Uint8Array, fflate can use it directly - no copy needed
+            buffer = data;
+        }
+        else if (ArrayBuffer.isView(data)) {
+            // Handle typed arrays - create view without copy
+            buffer = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else if (data instanceof ArrayBuffer) {
+            // Handle ArrayBuffer directly
+            buffer = new Uint8Array(data);
         }
         else {
-            if (typeof data === "string") {
-                // Convert string to Uint8Array
-                if (isBrowser) {
-                    buffer = stringToBuffer(data);
-                }
-                else {
-                    buffer = Buffer.from(data, "utf8");
-                }
-            }
-            else if (Buffer.isBuffer(data)) {
-                buffer = new Uint8Array(data);
-            }
-            else {
-                buffer = data;
-            }
+            // Assume it's already a Uint8Array or compatible type
+            buffer = data;
         }
         // Add file to zip using streaming API
-        const zipFile = new ZipPassThrough(options.name);
+        // Use ZipDeflate for compression or ZipPassThrough for no compression
+        const useCompression = this.options.compression !== "STORE";
+        const zipFile = useCompression
+            ? new ZipDeflate(options.name, { level: this.compressionLevel })
+            : new ZipPassThrough(options.name);
         this.zip.add(zipFile);
         zipFile.push(buffer, true); // true = final chunk
     }

package/dist/esm/xlsx/xlsx.js

@@ -3,9 +3,8 @@ import { Unzip, UnzipInflate } from "fflate";
 import { PassThrough } from "stream";
 import { ZipWriter } from "../utils/zip-stream.js";
 import { StreamBuf } from "../utils/stream-buf.js";
-import { fileExists } from "../utils/utils.js";
+import { fileExists, bufferToString } from "../utils/utils.js";
 import { XmlStream } from "../utils/xml-stream.js";
-import { bufferToString } from "../utils/browser-buffer-decode.js";
 import { StylesXform } from "./xform/style/styles-xform.js";
 import { CoreXform } from "./xform/core/core-xform.js";
 import { SharedStringsXform } from "./xform/strings/shared-strings-xform.js";

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

@@ -21,7 +21,7 @@ declare class Column {
     _number: number;
     _header: any;
     _key: string | undefined;
-    width: number | undefined;
+    width?: number;
     _hidden: boolean | undefined;
     _outlineLevel: number | undefined;
     style: any;

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

@@ -90,7 +90,7 @@ declare class Worksheet {
     _name: string;
     state: string;
     _rows: any[];
-    _columns: any[] | null;
+    _columns: any[];
     _keys: {
         [key: string]: any;
     };
@@ -118,7 +118,7 @@ declare class Worksheet {
     get workbook(): any;
     destroy(): void;
     get dimensions(): Range;
-    get columns(): any[] | null;
+    get columns(): any[];
     set columns(value: any[]);
     getColumnKey(key: string): any;
     setColumnKey(key: string, value: any): void;

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

@@ -1,4 +1,5 @@
 export { Workbook } from "./doc/workbook.js";
 export * from "./doc/enums.js";
 export * from "./types.js";
+export * from "./utils/sheet-utils.js";
 export type { FastCsvParserOptionsArgs, FastCsvFormatterOptionsArgs, CsvReadOptions, CsvWriteOptions } from "./csv/csv.js";

package/dist/types/index.d.ts

@@ -15,4 +15,5 @@ export { Table } from "./doc/table.js";
 export { DataValidations } from "./doc/data-validations.js";
 export * from "./doc/enums.js";
 export * from "./types.js";
+export * from "./utils/sheet-utils.js";
 export type { FastCsvParserOptionsArgs, FastCsvFormatterOptionsArgs, CsvReadOptions, CsvWriteOptions } from "./csv/csv.js";

package/dist/types/stream/xlsx/workbook-writer.d.ts

@@ -24,6 +24,7 @@ declare class WorkbookWriter {
     _worksheets: any[];
     views: any[];
     zipOptions?: any;
+    compressionLevel: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
     media: any[];
     commentRefs: any[];
     zip: any;

package/dist/types/utils/cell-format.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Excel Cell Format Parser
+ * A simplified implementation for formatting cell values according to Excel numFmt patterns
+ * Supports: General, percentages, decimals, thousands separators, dates, currencies,
+ * scientific notation, fractions, elapsed time, and more
+ */
+/**
+ * Get format string from numFmtId
+ * Handles default mappings for certain format IDs
+ */
+export declare function getFormat(numFmtId: number): string;
+/**
+ * Check if format is "General"
+ */
+declare function isGeneral(fmt: string): boolean;
+/**
+ * Check if format is a date format
+ */
+declare function isDateFormat(fmt: string): boolean;
+/**
+ * Main format function - formats a value according to Excel numFmt
+ * @param fmt The Excel number format string (e.g., "0.00%", "#,##0", "yyyy-mm-dd")
+ * @param val The value to format
+ */
+export declare function format(fmt: string, val: number | string | boolean): string;
+export declare const cellFormat: {
+    format: typeof format;
+    getFormat: typeof getFormat;
+    isDateFormat: typeof isDateFormat;
+    isGeneral: typeof isGeneral;
+};
+export {};

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

@@ -0,0 +1,203 @@
+/**
+ * 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";
+/**
+ * Cell address object (0-indexed)
+ */
+export interface CellAddress {
+    /** 0-indexed column number */
+    c: number;
+    /** 0-indexed row number */
+    r: number;
+}
+/**
+ * Range object with start and end addresses
+ */
+export interface Range {
+    /** Start cell (top-left) */
+    s: CellAddress;
+    /** End cell (bottom-right) */
+    e: CellAddress;
+}
+/**
+ * Row data for JSON conversion
+ */
+export type JSONRow = Record<string, CellValue>;
+/**
+ * Decode column string to 0-indexed number
+ * @example decodeCol("A") => 0, decodeCol("Z") => 25, decodeCol("AA") => 26
+ */
+export declare function decodeCol(colstr: string): number;
+/**
+ * Encode 0-indexed column number to string
+ * @example encodeCol(0) => "A", encodeCol(25) => "Z", encodeCol(26) => "AA"
+ */
+export declare function encodeCol(col: number): string;
+/**
+ * Decode row string to 0-indexed number
+ * @example decodeRow("1") => 0, decodeRow("10") => 9
+ */
+export declare function decodeRow(rowstr: string): number;
+/**
+ * Encode 0-indexed row number to string
+ * @example encodeRow(0) => "1", encodeRow(9) => "10"
+ */
+export declare function encodeRow(row: number): string;
+/**
+ * Decode cell address string to CellAddress object
+ * @example decodeCell("A1") => {c: 0, r: 0}, decodeCell("B2") => {c: 1, r: 1}
+ */
+export declare function decodeCell(cstr: string): CellAddress;
+/**
+ * Encode CellAddress object to cell address string
+ * @example encodeCell({c: 0, r: 0}) => "A1", encodeCell({c: 1, r: 1}) => "B2"
+ */
+export declare function encodeCell(cell: CellAddress): string;
+/**
+ * Decode range string to Range object
+ * @example decodeRange("A1:B2") => {s: {c: 0, r: 0}, e: {c: 1, r: 1}}
+ */
+export declare function decodeRange(range: string): Range;
+/**
+ * Encode Range object to range string
+ */
+export declare function encodeRange(range: Range): string;
+export declare function encodeRange(start: CellAddress, end: CellAddress): string;
+/** Origin can be cell address string, cell object, row number, or -1 to append */
+export type Origin = string | CellAddress | number;
+export interface JSON2SheetOpts {
+    /** Use specified field order (default Object.keys) */
+    header?: string[];
+    /** Use specified date format in string output */
+    dateNF?: string;
+    /** Store dates as type d (default is n) */
+    cellDates?: boolean;
+    /** If true, do not include header row in output */
+    skipHeader?: boolean;
+    /** If true, emit #NULL! error cells for null values */
+    nullError?: boolean;
+}
+export interface SheetAddJSONOpts extends JSON2SheetOpts {
+    /** Use specified cell as starting point */
+    origin?: Origin;
+}
+/**
+ * Create a worksheet from an array of objects (xlsx compatible)
+ * @example
+ * const ws = jsonToSheet([{name: "Alice", age: 30}, {name: "Bob", age: 25}])
+ */
+export declare function jsonToSheet(data: JSONRow[], opts?: JSON2SheetOpts): Worksheet;
+/**
+ * Add data from an array of objects to an existing worksheet (xlsx compatible)
+ */
+export declare function sheetAddJson(worksheet: Worksheet, data: JSONRow[], opts?: SheetAddJSONOpts): Worksheet;
+export interface Sheet2JSONOpts {
+    /**
+     * Control output format:
+     * - 1: Generate an array of arrays
+     * - "A": Row object keys are literal column labels (A, B, C, ...)
+     * - string[]: Use specified strings as keys in row objects
+     * - undefined: Read and disambiguate first row as keys
+     */
+    header?: 1 | "A" | string[];
+    /**
+     * Override Range:
+     * - number: Use worksheet range but set starting row to the value
+     * - string: Use specified range (A1-Style bounded range string)
+     * - undefined: Use worksheet range
+     */
+    range?: number | string;
+    /** Use raw values (true, default) or formatted text strings with trim (false) */
+    raw?: boolean;
+    /** Default value for empty cells */
+    defval?: CellValue;
+    /** Include blank lines in the output */
+    blankrows?: boolean;
+}
+/**
+ * Convert worksheet to JSON array (xlsx compatible)
+ * @example
+ * // Default: array of objects with first row as headers
+ * const data = sheetToJson(worksheet)
+ * // => [{name: "Alice", age: 30}, {name: "Bob", age: 25}]
+ *
+ * // Array of arrays
+ * const aoa = sheetToJson(worksheet, { header: 1 })
+ * // => [["name", "age"], ["Alice", 30], ["Bob", 25]]
+ *
+ * // Column letters as keys
+ * const cols = sheetToJson(worksheet, { header: "A" })
+ * // => [{A: "name", B: "age"}, {A: "Alice", B: 30}]
+ */
+export declare function sheetToJson<T = JSONRow>(worksheet: Worksheet, opts?: Sheet2JSONOpts): T[];
+export interface Sheet2CSVOpts {
+    /** Field separator (default: ",") */
+    FS?: string;
+    /** Record separator (default: "\n") */
+    RS?: string;
+    /** Skip blank rows */
+    blankrows?: boolean;
+    /** Force quote all fields */
+    forceQuotes?: boolean;
+}
+/**
+ * Convert worksheet to CSV string
+ */
+export declare function sheetToCsv(worksheet: Worksheet, opts?: Sheet2CSVOpts): string;
+/**
+ * Create a new workbook
+ */
+export declare function bookNew(): Workbook;
+/**
+ * Append worksheet to workbook (xlsx compatible)
+ * @example
+ * const wb = bookNew();
+ * const ws = jsonToSheet([{a: 1, b: 2}]);
+ * bookAppendSheet(wb, ws, "Sheet1");
+ */
+export declare function bookAppendSheet(workbook: Workbook, worksheet: Worksheet, name?: string): void;
+export interface AOA2SheetOpts {
+    /** Use specified cell as starting point */
+    origin?: Origin;
+    /** Use specified date format in string output */
+    dateNF?: string;
+    /** Store dates as type d (default is n) */
+    cellDates?: boolean;
+}
+/**
+ * Create a worksheet from an array of arrays (xlsx compatible)
+ * @example
+ * const ws = aoaToSheet([["Name", "Age"], ["Alice", 30], ["Bob", 25]])
+ */
+export declare function aoaToSheet(data: CellValue[][], opts?: AOA2SheetOpts): Worksheet;
+/**
+ * Add data from an array of arrays to an existing worksheet (xlsx compatible)
+ */
+export declare function sheetAddAoa(worksheet: Worksheet, data: CellValue[][], opts?: AOA2SheetOpts): Worksheet;
+/**
+ * Convert worksheet to array of arrays
+ */
+export declare function sheetToAoa(worksheet: Worksheet): CellValue[][];
+export declare const utils: {
+    decodeCol: typeof decodeCol;
+    encodeCol: typeof encodeCol;
+    decodeRow: typeof decodeRow;
+    encodeRow: typeof encodeRow;
+    decodeCell: typeof decodeCell;
+    encodeCell: typeof encodeCell;
+    decodeRange: typeof decodeRange;
+    encodeRange: typeof encodeRange;
+    jsonToSheet: typeof jsonToSheet;
+    sheetAddJson: typeof sheetAddJson;
+    sheetToJson: typeof sheetToJson;
+    sheetToCsv: typeof sheetToCsv;
+    aoaToSheet: typeof aoaToSheet;
+    sheetAddAoa: typeof sheetAddAoa;
+    sheetToAoa: typeof sheetToAoa;
+    bookNew: typeof bookNew;
+    bookAppendSheet: typeof bookAppendSheet;
+};

package/dist/types/utils/unzip/buffer-stream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unzipper buffer-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import type { Readable } from "stream";
+export declare function bufferStream(entry: Readable): Promise<Buffer>;

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

@@ -0,0 +1,12 @@
+/**
+ * Unzip utilities for parsing ZIP archives
+ * 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";

package/dist/types/utils/unzip/noop-stream.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unzipper noop-stream module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+import { Transform } from "stream";
+import type { TransformCallback } from "stream";
+export declare class NoopStream extends Transform {
+    constructor();
+    _transform(_chunk: any, _encoding: BufferEncoding, cb: TransformCallback): void;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Unzipper parse-buffer module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+/**
+ * Parses sequential unsigned little endian numbers from the head of the passed buffer according to
+ * the specified format passed. If the buffer is not large enough to satisfy the full format,
+ * null values will be assigned to the remaining keys.
+ * @param buffer The buffer to sequentially extract numbers from.
+ * @param format Expected format to follow when extracting values from the buffer. A list of list entries
+ * with the following structure:
+ * [
+ *   [
+ *     <key>,  // Name of the key to assign the extracted number to.
+ *     <size>  // The size in bytes of the number to extract. possible values are 1, 2, 4, 8.
+ *   ],
+ *   ...
+ * ]
+ * @returns An object with keys set to their associated extracted values.
+ */
+export declare function parse(buffer: Buffer, format: [string, number][]): Record<string, number | null>;

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

@@ -0,0 +1,12 @@
+/**
+ * Unzipper parse-datetime module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+/**
+ * Dates in zip file entries are stored as DosDateTime
+ * Spec is here: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+ */
+export declare function parseDateTime(date: number, time?: number): Date;

package/dist/types/utils/unzip/parse-extra-field.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unzipper parse-extra-field module
+ * Original source: https://github.com/ZJONSSON/node-unzipper
+ * License: MIT
+ * Copyright (c) 2012 - 2013 Near Infinity Corporation
+ * Commits in this fork are (c) Ziggy Jonsson (ziggy.jonsson.nyc@gmail.com)
+ */
+export interface ZipVars {
+    uncompressedSize: number;
+    compressedSize: number;
+    offsetToLocalFileHeader?: number;
+}
+export interface ExtraField {
+    uncompressedSize?: number;
+    compressedSize?: number;
+    offsetToLocalFileHeader?: number;
+}
+export declare function parseExtraField(extraField: Buffer, vars: ZipVars): ExtraField;