@cj-tech-master/excelts 3.1.0 → 4.0.0-canary.20260103013222.0e5d37f

package/dist/types/modules/archive/parse.base.d.ts

@@ -0,0 +1,198 @@
+import { Duplex, PassThrough, Transform, type Readable } from "../stream/index";
+import { ByteQueue } from "./byte-queue";
+import { parseZipExtraFields, type ZipExtraFields, type ZipVars } from "./utils/zip-extra-fields";
+export declare const CRX_HEADER_FORMAT: [string, number][];
+export declare const LOCAL_FILE_HEADER_FORMAT: [string, number][];
+export declare const DATA_DESCRIPTOR_FORMAT: [string, number][];
+export declare const CENTRAL_DIRECTORY_FILE_HEADER_FORMAT: [string, number][];
+export declare const END_OF_CENTRAL_DIRECTORY_FORMAT: [string, number][];
+export interface ZipEntryVarsMeta {
+    flags: number | null;
+    uncompressedSize: number;
+    lastModifiedDate: number | null;
+    lastModifiedTime: number | null;
+}
+export type { ZipVars, ZipExtraFields };
+export interface ZipEntryPropsMeta {
+    path: string;
+    pathBuffer: Uint8Array;
+    flags: {
+        isUnicode: boolean;
+    };
+}
+export interface CrxHeader {
+    version: number | null;
+    pubKeyLength: number | null;
+    signatureLength: number | null;
+    publicKey?: Uint8Array;
+    signature?: Uint8Array;
+}
+export interface LocalFileHeaderVars {
+    versionsNeededToExtract: number | null;
+    flags: number | null;
+    compressionMethod: number | null;
+    lastModifiedTime: number | null;
+    lastModifiedDate: number | null;
+    crc32: number | null;
+    compressedSize: number | null;
+    uncompressedSize: number | null;
+    fileNameLength: number | null;
+    extraFieldLength: number | null;
+}
+export interface DataDescriptorVars {
+    dataDescriptorSignature: number | null;
+    crc32: number | null;
+    compressedSize: number | null;
+    uncompressedSize: number | null;
+}
+export declare function decodeZipEntryPath(pathBuffer: Uint8Array): string;
+export declare function isZipUnicodeFlag(flags: number | null): boolean;
+export declare function isZipDirectoryPath(path: string): boolean;
+export declare function getZipEntryType(path: string, uncompressedSize: number): "Directory" | "File";
+export declare function buildZipEntryProps(path: string, pathBuffer: Uint8Array, flags: number | null): ZipEntryPropsMeta;
+export declare function resolveZipEntryLastModifiedDateTime(vars: ZipEntryVarsMeta, extraFields: ZipExtraFields): Date;
+export declare const parseExtraField: typeof parseZipExtraFields;
+export declare function hasDataDescriptorFlag(flags: number | null): boolean;
+export declare function isFileSizeKnown(flags: number | null, compressedSize: number | null): boolean;
+export type DrainStream = Transform & {
+    promise: () => Promise<void>;
+};
+export declare function autodrain(stream: {
+    pipe: (dest: Transform) => unknown;
+}): DrainStream;
+/**
+ * Collects all data from a readable stream into a single Uint8Array.
+ */
+export declare function bufferStream(entry: Readable): Promise<Uint8Array>;
+export type PullFn = (length: number) => Promise<Uint8Array>;
+export declare class PullStream extends Duplex {
+    protected readonly _queue: ByteQueue;
+    get buffer(): Uint8Array;
+    set buffer(value: Uint8Array);
+    cb?: () => void;
+    finished: boolean;
+    match?: number;
+    __emittedError?: Error;
+    constructor();
+    _write(chunk: Uint8Array | string, _encoding: string, callback: () => void): void;
+    _read(): void;
+    protected _maybeReleaseWriteCallback(): void;
+    /**
+     * The `eof` parameter is interpreted as `file_length` if the type is number
+     * otherwise (i.e. Uint8Array) it is interpreted as a pattern signaling end of stream
+     */
+    stream(eof: number | Uint8Array, includeEof?: boolean): PassThrough;
+    pull(eof: number | Uint8Array, includeEof?: boolean): Promise<Uint8Array>;
+    pullUntil(pattern: Uint8Array, includeEof?: boolean): Promise<Uint8Array>;
+}
+export type PullStreamPublicApi = {
+    buffer: Uint8Array;
+    cb?: () => void;
+    finished: boolean;
+    match?: number;
+    stream(eof: number | Uint8Array, includeEof?: boolean): PassThrough;
+    pull(eof: number | Uint8Array, includeEof?: boolean): Promise<Uint8Array>;
+    pullUntil(pattern: Uint8Array, includeEof?: boolean): Promise<Uint8Array>;
+};
+export declare function readCrxHeader(pull: PullFn): Promise<CrxHeader>;
+export declare function readLocalFileHeader(pull: PullFn): Promise<{
+    vars: EntryVars;
+    fileNameBuffer: Uint8Array;
+    extraFieldData: Uint8Array;
+}>;
+export declare function readDataDescriptor(pull: PullFn): Promise<DataDescriptorVars>;
+export declare function consumeCentralDirectoryFileHeader(pull: PullFn): Promise<void>;
+export declare function consumeEndOfCentralDirectoryRecord(pull: PullFn): Promise<void>;
+export interface ValidatedDataDescriptorScanResult {
+    /** Start index of the descriptor within `view`, or -1 when not found yet. */
+    foundIndex: number;
+    /** Where the caller should resume searching on the next scan of (a mostly unchanged) view. */
+    nextSearchFrom: number;
+}
+/**
+ * Scan for a validated DATA_DESCRIPTOR record boundary.
+ *
+ * Scanning for the 4-byte signature alone is unsafe because it can appear inside
+ * compressed data. We validate a candidate by requiring:
+ * - the next 4 bytes after the 16-byte descriptor form a known ZIP record signature, and
+ * - the descriptor's compressedSize matches the number of compressed bytes emitted so far.
+ */
+export declare function scanValidatedDataDescriptor(view: Uint8Array, dataDescriptorSignature: Uint8Array, bytesEmitted: number, startIndex?: number, out?: ValidatedDataDescriptorScanResult): ValidatedDataDescriptorScanResult;
+export interface StreamUntilValidatedDataDescriptorSource {
+    getView(): Uint8Array;
+    getLength(): number;
+    read(length: number): Uint8Array;
+    isFinished(): boolean;
+    onDataAvailable(cb: () => void): () => void;
+    maybeReleaseWriteCallback?: () => void;
+}
+export interface StreamUntilValidatedDataDescriptorOptions {
+    source: StreamUntilValidatedDataDescriptorSource;
+    dataDescriptorSignature: Uint8Array;
+    /** Keep enough bytes to validate: descriptor(16) + next record sig(4) = 20. */
+    keepTailBytes?: number;
+    errorMessage?: string;
+}
+/**
+ * Stream compressed file data until we reach a validated DATA_DESCRIPTOR boundary.
+ *
+ * This encapsulates the shared logic used by both Node and browser parsers.
+ */
+export declare function streamUntilValidatedDataDescriptor(options: StreamUntilValidatedDataDescriptorOptions): PassThrough;
+export interface ParseOptions {
+    verbose?: boolean;
+    forceStream?: boolean;
+}
+export interface EntryVars {
+    versionsNeededToExtract: number | null;
+    flags: number | null;
+    compressionMethod: number | null;
+    lastModifiedTime: number | null;
+    lastModifiedDate: number | null;
+    crc32: number | null;
+    compressedSize: number | null;
+    uncompressedSize: number | null;
+    fileNameLength: number | null;
+    extraFieldLength: number | null;
+    lastModifiedDateTime?: Date;
+    crxHeader?: CrxHeader;
+}
+export interface EntryProps {
+    path: string;
+    pathBuffer: Uint8Array;
+    flags: {
+        isUnicode: boolean;
+    };
+}
+export interface ZipEntry extends PassThrough {
+    path: string;
+    props: EntryProps;
+    type: "Directory" | "File";
+    vars: EntryVars;
+    extraFields: ZipExtraFields;
+    size?: number;
+    __autodraining?: boolean;
+    autodrain: () => DrainStream;
+    buffer: () => Promise<Uint8Array>;
+}
+export interface ParseDriverState {
+    crxHeader?: CrxHeader;
+    reachedCD?: boolean;
+}
+export interface ParseIO {
+    pull(length: number): Promise<Uint8Array>;
+    pullUntil(pattern: Uint8Array, includeEof?: boolean): Promise<Uint8Array>;
+    stream(length: number): PassThrough;
+    streamUntilDataDescriptor(): PassThrough;
+    setDone(): void;
+}
+export interface ParseEmitter {
+    emitEntry(entry: ZipEntry): void;
+    pushEntry(entry: ZipEntry): void;
+    pushEntryIfPiped(entry: ZipEntry): void;
+    emitCrxHeader(header: CrxHeader): void;
+    emitError(err: Error): void;
+    emitClose(): void;
+}
+export type InflateFactory = () => Transform | Duplex | PassThrough;
+export declare function runParseLoop(opts: ParseOptions, io: ParseIO, emitter: ParseEmitter, inflateFactory: InflateFactory, state: ParseDriverState): Promise<void>;

package/dist/types/modules/archive/parse.browser.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ZIP Stream Parser - Browser Version
+ *
+ * A streaming ZIP parser for browsers using native DecompressionStream.
+ * Falls back to pure JavaScript implementation for older browsers.
+ * Uses the browser Duplex stream implementation for compatibility.
+ */
+import { Duplex } from "../stream/index";
+import { type CrxHeader, type PullStreamPublicApi, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base";
+export type { CrxHeader, EntryProps, EntryVars, ParseOptions, ZipEntry };
+export type ParseStream = Duplex & {
+    promise(): Promise<void>;
+} & PullStreamPublicApi & {
+    crxHeader?: CrxHeader;
+};
+export declare function createParseClass(createInflateRawFn: InflateFactory): {
+    new (opts?: ParseOptions): ParseStream;
+};
+declare const BaseParse: new (opts?: ParseOptions) => ParseStream;
+export declare class Parse extends BaseParse {
+}
+export declare function createParse(opts?: ParseOptions): ParseStream;

package/dist/types/modules/archive/parse.d.ts

@@ -0,0 +1,16 @@
+import type { Duplex } from "../stream/index";
+import { type PullStreamPublicApi, type CrxHeader, type EntryProps, type EntryVars, type InflateFactory, type ParseOptions, type ZipEntry } from "./parse.base";
+export type { CrxHeader } from "./parse.base";
+export type { EntryProps, EntryVars, ParseOptions, ZipEntry };
+export type ParseStream = Duplex & {
+    promise(): Promise<void>;
+} & PullStreamPublicApi & {
+    crxHeader?: CrxHeader;
+};
+export declare function createParseClass(createInflateRawFn: InflateFactory): {
+    new (opts?: ParseOptions): ParseStream;
+};
+declare const BaseParse: new (opts?: ParseOptions) => ParseStream;
+export declare class Parse extends BaseParse {
+}
+export declare function createParse(opts?: ParseOptions): ParseStream;

package/dist/types/modules/archive/streaming-compress.base.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared types for true streaming compression.
+ *
+ * Kept in a dedicated base module so Node.js and browser implementations
+ * don't depend on each other.
+ */
+export interface StreamCompressOptions {
+    level?: number;
+}
+export type StreamCallback = (err?: Error | null) => void;
+/**
+ * Minimal cross-platform streaming codec surface.
+ *
+ * Both Node.js (zlib / stream.Transform) and browser implementations
+ * support this subset.
+ */
+export interface StreamingCodec {
+    on(event: "data", listener: (chunk: Uint8Array) => void): this;
+    on(event: "end", listener: () => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: "data", listener: (chunk: Uint8Array) => void): this;
+    once(event: "end", listener: () => void): this;
+    once(event: "error", listener: (err: Error) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    off(event: "data", listener: (chunk: Uint8Array) => void): this;
+    off(event: "end", listener: () => void): this;
+    off(event: "error", listener: (err: Error) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    write(chunk: Uint8Array, callback?: StreamCallback): boolean;
+    end(callback?: StreamCallback): unknown;
+    destroy(err?: Error): unknown;
+}
+export type DeflateStream = StreamingCodec;
+export type InflateStream = StreamingCodec;
+export declare function asError(err: unknown): Error;

package/dist/types/modules/archive/streaming-compress.browser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Browser True Streaming Compression
+ *
+ * Uses native CompressionStream("deflate-raw") for real chunk-by-chunk streaming.
+ * Falls back to buffered compression if not supported.
+ *
+ * API compatible with Node.js version - supports .on("data"), .on("end"), .write(callback), .end()
+ */
+export type { StreamCompressOptions } from "./streaming-compress.base";
+import { type DeflateStream, type InflateStream, type StreamCompressOptions } from "./streaming-compress.base";
+/**
+ * Check if deflate-raw streaming compression is supported by this library.
+ *
+ * In browsers, the library always supports deflate-raw via the JS fallback.
+ * Native deflate-raw Web Streams support (CompressionStream/DecompressionStream)
+ * is used when available, but is not required.
+ */
+export declare function hasDeflateRaw(): boolean;
+/**
+ * Create a streaming DEFLATE compressor
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;

package/dist/types/modules/archive/streaming-compress.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Node.js True Streaming Compression
+ *
+ * Uses zlib.createDeflateRaw() with explicit flush() calls for real chunk-by-chunk streaming.
+ * Each write() immediately produces compressed output without waiting for end().
+ */
+export type { DeflateStream, InflateStream, StreamCompressOptions, StreamingCodec } from "./streaming-compress.base";
+import type { DeflateStream, InflateStream, StreamCompressOptions } from "./streaming-compress.base";
+/**
+ * Create a true streaming DEFLATE compressor
+ * Returns a Transform stream that emits compressed data immediately after each write
+ */
+export declare function createDeflateStream(options?: StreamCompressOptions): DeflateStream;
+/**
+ * Create a true streaming INFLATE decompressor
+ */
+export declare function createInflateStream(): InflateStream;
+/**
+ * Check if true streaming deflate-raw is available
+ * In Node.js, zlib is always available, so this always returns true
+ */
+export declare function hasDeflateRaw(): boolean;

package/dist/types/modules/archive/streaming-zip.d.ts

@@ -0,0 +1,120 @@
+/**
+ * True Streaming ZIP creator - shared implementation.
+ *
+ * This module is intentionally platform-agnostic.
+ * - In Node builds it uses `./crc32` + `./streaming-compress` (zlib-backed).
+ * - In browser builds the bundler aliases those imports to their browser variants.
+ */
+import type { ZipTimestampMode } from "./utils/timestamps";
+import type { ZipEntryInfo as UnzipZipEntryInfo } from "./zip-entry-info";
+/**
+ * Internal entry info for central directory
+ */
+interface ZipEntryInfo {
+    name: Uint8Array;
+    extraField: Uint8Array;
+    flags: number;
+    crc: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    compressionMethod: number;
+    dosTime: number;
+    dosDate: number;
+    offset: number;
+}
+type CentralDirectoryEntryInfo = ZipEntryInfo;
+/**
+ * True Streaming ZIP File - compresses chunk by chunk
+ */
+export declare class ZipDeflateFile {
+    private _deflate;
+    private _crc;
+    private _uncompressedSize;
+    private _compressedSize;
+    private _finalized;
+    private _headerEmitted;
+    private _ondata;
+    private _centralDirEntryInfo;
+    private _pendingEnd;
+    private _emittedDataDescriptor;
+    private _localHeader;
+    private _completeResolve;
+    private _completeReject;
+    private _completePromise;
+    private _completeError;
+    private _dataQueue;
+    private _finalQueued;
+    readonly name: string;
+    readonly level: number;
+    readonly nameBytes: Uint8Array;
+    readonly dosTime: number;
+    readonly dosDate: number;
+    readonly extraField: Uint8Array;
+    private readonly _flags;
+    private readonly _compressionMethod;
+    private readonly _modTime;
+    constructor(name: string, options?: {
+        level?: number;
+        modTime?: Date;
+        timestamps?: ZipTimestampMode;
+    });
+    private _buildLocalHeader;
+    private _enqueueData;
+    private _flushQueue;
+    get ondata(): ((data: Uint8Array, final: boolean) => void) | undefined;
+    set ondata(cb: (data: Uint8Array, final: boolean) => void);
+    private _resolveComplete;
+    private _rejectComplete;
+    private _ensureCompletePromise;
+    private _tapCallback;
+    private _emitHeaderIfNeeded;
+    private _writeData;
+    private _endDeflateAndWait;
+    private _finalizeAfterWrite;
+    /**
+     * Push data - immediately compresses and outputs
+     * Returns a Promise that resolves when the write is complete.
+     * If final=true, it resolves after the data descriptor is emitted.
+     */
+    push(data: Uint8Array, final?: boolean, callback?: (err?: Error | null) => void): Promise<void>;
+    /**
+     * Emit local file header with Data Descriptor flag
+     */
+    private _emitHeader;
+    /**
+     * Emit Data Descriptor with CRC and sizes
+     */
+    private _emitDataDescriptor;
+    /**
+     * Returns a promise that resolves when the file is completely written
+     * (including data descriptor)
+     */
+    complete(): Promise<void>;
+    /**
+     * Get entry metadata in the same shape as unzip parser outputs.
+     * This is best-effort: writer-only fields like encryption are always false.
+     */
+    getEntryInfo(): UnzipZipEntryInfo | null;
+    /** Writer-only metadata for building the Central Directory. */
+    getCentralDirectoryEntryInfo(): CentralDirectoryEntryInfo | null;
+    isComplete(): boolean;
+}
+/**
+ * Streaming ZIP Creator - processes files sequentially
+ */
+export declare class StreamingZip {
+    private callback;
+    private entries;
+    private currentOffset;
+    private ended;
+    private endPending;
+    private fileQueue;
+    private fileQueueIndex;
+    private activeFile;
+    constructor(callback: (err: Error | null, data: Uint8Array, final: boolean) => void);
+    add(file: ZipDeflateFile): void;
+    private _processNextFile;
+    private _finalize;
+    end(): void;
+}
+export { StreamingZip as Zip, ZipDeflateFile as ZipDeflate };

package/dist/types/modules/archive/utils/binary.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Tiny binary reader for Uint8Array-backed DataView.
+ * Shared by ZIP parsers.
+ */
+export declare function writeUint32LE(value: number): Uint8Array;
+export declare function readUint32LE(data: Uint8Array, offset: number): number;
+export declare class BinaryReader {
+    private view;
+    private offset;
+    private data;
+    constructor(data: Uint8Array, offset?: number);
+    get position(): number;
+    set position(value: number);
+    get remaining(): number;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readBigUint64(): bigint;
+    readBytes(length: number): Uint8Array;
+    readString(length: number, utf8?: boolean): string;
+    skip(length: number): void;
+    slice(start: number, end: number): Uint8Array;
+    peekUint32(offset: number): number;
+}

package/dist/types/modules/archive/utils/bytes.d.ts

@@ -0,0 +1,7 @@
+export declare function sumUint8ArrayLengths(arrays: readonly Uint8Array[]): number;
+export declare function concatUint8Arrays(arrays: readonly Uint8Array[]): Uint8Array;
+/**
+ * Find the first index of `pattern` within `buffer`.
+ * Returns -1 when not found.
+ */
+export declare function indexOfUint8ArrayPattern(buffer: Uint8Array, pattern: Uint8Array, startIndex?: number): number;

package/dist/types/modules/archive/utils/parse-buffer.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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: Uint8Array, format: [string, number][]): Record<string, number | null>;
+export declare function parseTyped<T>(buffer: Uint8Array, format: [string, number][]): T;

package/dist/types/modules/archive/utils/text.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared text encoding/decoding utilities.
+ *
+ * Caches encoder/decoder instances for performance.
+ */
+export declare const utf8Encoder: TextEncoder;
+export declare const utf8Decoder: TextDecoder;
+/**
+ * Encode a string as UTF-8.
+ */
+export declare function encodeUtf8(value: string): Uint8Array;
+/**
+ * Decode bytes as UTF-8.
+ */
+export declare function decodeUtf8(bytes: Uint8Array): string;
+/**
+ * Decode bytes as Latin-1/byte-to-char.
+ * Used as a fallback when UTF-8 flag is not set.
+ */
+export declare function decodeLatin1(bytes: Uint8Array): string;

package/dist/types/modules/archive/utils/timestamps.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DOS date/time helpers for ZIP files.
+ */
+/**
+ * Convert Date to DOS time/date fields.
+ *
+ * Note: uses local time fields (getHours/getMinutes/getSeconds),
+ * which matches common ZIP writer behavior.
+ */
+export declare function dateToDos(date: Date): [number, number];
+/**
+ * Parse DOS date/time to JS Date.
+ */
+export declare function parseDosDateTimeUTC(date: number, time?: number): Date;
+/**
+ * How to write timestamps in ZIP headers.
+ *
+ * ZIP always has DOS date/time fields; `dos+utc` additionally writes the Info-ZIP
+ * extended timestamp extra field (0x5455) for a UTC mtime.
+ */
+export type ZipTimestampMode = "dos" | "dos+utc";
+export declare function resolveZipLastModifiedDateFromUnixSeconds(dosDate: number, dosTime: number, mtimeUnixSeconds?: number): Date;
+export declare function resolveZipLastModifiedDateFromExtraField(dosDate: number, dosTime: number, extraField: Uint8Array): Date;
+export declare function buildZipTimestampExtraField(modTime: Date, mode: ZipTimestampMode): Uint8Array;
+export declare function dateToZipDos(modTime: Date): {
+    dosTime: number;
+    dosDate: number;
+};

package/dist/types/modules/archive/utils/zip-extra-fields.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ZIP extra field parsing helpers.
+ *
+ * Kept standalone so both streaming parser (`parse.base.ts`) and buffer parser
+ * (`zip-parser.ts`) can share ZIP64 + Info-ZIP timestamp handling.
+ */
+export interface ZipVars {
+    uncompressedSize: number;
+    compressedSize: number;
+    offsetToLocalFileHeader?: number;
+}
+export interface ZipExtraFields {
+    uncompressedSize?: number;
+    compressedSize?: number;
+    offsetToLocalFileHeader?: number;
+    /** Info-ZIP extended timestamp (0x5455) mtime, Unix seconds (UTC). */
+    mtimeUnixSeconds?: number;
+}
+export declare function parseZipExtraFields(extraField: Uint8Array, vars: ZipVars): ZipExtraFields;

package/dist/types/modules/archive/utils/zip-extra.d.ts

@@ -0,0 +1,18 @@
+export declare function unixSecondsFromDate(date: Date): number;
+/**
+ * Build Info-ZIP "Extended Timestamp" extra field (0x5455).
+ * We write only mtime (UTC, Unix seconds) to minimize size.
+ *
+ * Layout:
+ * - Header ID: 2 bytes (0x5455)
+ * - Data size: 2 bytes
+ * - Flags: 1 byte (bit0 = mtime)
+ * - mtime: 4 bytes (Unix seconds)
+ */
+export declare function buildExtendedTimestampExtraFieldFromUnixSeconds(unixSeconds: number): Uint8Array;
+export declare function buildExtendedTimestampExtraFieldFromDate(date: Date): Uint8Array;
+/**
+ * Parse Info-ZIP "Extended Timestamp" extra field (0x5455) and return mtime.
+ * Returns Unix seconds (UTC) if present.
+ */
+export declare function parseExtendedTimestampMtimeUnixSeconds(extraField: Uint8Array): number | undefined;