@cj-tech-master/excelts 1.4.3 → 1.4.5

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

@@ -0,0 +1,372 @@
+/**
+ * ZIP file format builder
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * ZIP file structure:
+ * ┌──────────────────────────┐
+ * │   Local File Header 1    │
+ * │   File Data 1            │
+ * ├──────────────────────────┤
+ * │   Local File Header 2    │
+ * │   File Data 2            │
+ * ├──────────────────────────┤
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │  Central Directory 1     │
+ * │  Central Directory 2     │
+ * │         ...              │
+ * ├──────────────────────────┤
+ * │ End of Central Directory │
+ * └──────────────────────────┘
+ */
+import { crc32 } from "./crc32.js";
+import { compress, compressSync } from "./compress.js";
+// ZIP signature constants
+const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+// ZIP version constants
+const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+const COMPRESSION_STORE = 0;
+const COMPRESSION_DEFLATE = 8;
+/**
+ * Convert Date to DOS time format
+ * @param date - Date to convert
+ * @returns [dosTime, dosDate]
+ */
+function dateToDos(date) {
+    const dosTime = ((date.getHours() & 0x1f) << 11) |
+        ((date.getMinutes() & 0x3f) << 5) |
+        ((date.getSeconds() >> 1) & 0x1f);
+    const dosDate = (((date.getFullYear() - 1980) & 0x7f) << 9) |
+        (((date.getMonth() + 1) & 0x0f) << 5) |
+        (date.getDate() & 0x1f);
+    return [dosTime, dosDate];
+}
+/**
+ * Encode string to UTF-8 bytes
+ */
+const encoder = new TextEncoder();
+function encodeString(str) {
+    return encoder.encode(str);
+}
+/**
+ * Build Local File Header (30 bytes + filename + extra)
+ */
+function buildLocalFileHeader(entry) {
+    const header = new Uint8Array(30 + entry.name.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, LOCAL_FILE_HEADER_SIG, true); // Signature
+    view.setUint16(4, VERSION_NEEDED, true); // Version needed to extract
+    view.setUint16(6, 0x0800, true); // General purpose bit flag (UTF-8 names)
+    view.setUint16(8, entry.compressionMethod, true); // Compression method
+    view.setUint16(10, entry.modTime, true); // Last mod time
+    view.setUint16(12, entry.modDate, true); // Last mod date
+    view.setUint32(14, entry.crc, true); // CRC-32
+    view.setUint32(18, entry.compressedData.length, true); // Compressed size
+    view.setUint32(22, entry.data.length, true); // Uncompressed size
+    view.setUint16(26, entry.name.length, true); // Filename length
+    view.setUint16(28, 0, true); // Extra field length
+    header.set(entry.name, 30);
+    return header;
+}
+/**
+ * Build Central Directory Header (46 bytes + filename + extra + comment)
+ */
+function buildCentralDirHeader(entry) {
+    const header = new Uint8Array(46 + entry.name.length + entry.comment.length);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CENTRAL_DIR_HEADER_SIG, true); // Signature
+    view.setUint16(4, VERSION_MADE_BY, true); // Version made by
+    view.setUint16(6, VERSION_NEEDED, true); // Version needed to extract
+    view.setUint16(8, 0x0800, true); // General purpose bit flag (UTF-8 names)
+    view.setUint16(10, entry.compressionMethod, true); // Compression method
+    view.setUint16(12, entry.modTime, true); // Last mod time
+    view.setUint16(14, entry.modDate, true); // Last mod date
+    view.setUint32(16, entry.crc, true); // CRC-32
+    view.setUint32(20, entry.compressedData.length, true); // Compressed size
+    view.setUint32(24, entry.data.length, true); // Uncompressed size
+    view.setUint16(28, entry.name.length, true); // Filename length
+    view.setUint16(30, 0, true); // Extra field length
+    view.setUint16(32, entry.comment.length, true); // Comment length
+    view.setUint16(34, 0, true); // Disk number start
+    view.setUint16(36, 0, true); // Internal file attributes
+    view.setUint32(38, 0, true); // External file attributes
+    view.setUint32(42, entry.offset, true); // Relative offset of local header
+    header.set(entry.name, 46);
+    if (entry.comment.length > 0) {
+        header.set(entry.comment, 46 + entry.name.length);
+    }
+    return header;
+}
+/**
+ * Build End of Central Directory Record (22 bytes + comment)
+ */
+function buildEndOfCentralDir(entryCount, centralDirSize, centralDirOffset, comment) {
+    const record = new Uint8Array(22 + comment.length);
+    const view = new DataView(record.buffer);
+    view.setUint32(0, END_OF_CENTRAL_DIR_SIG, true); // Signature
+    view.setUint16(4, 0, true); // Number of this disk
+    view.setUint16(6, 0, true); // Disk where central dir starts
+    view.setUint16(8, entryCount, true); // Number of entries on this disk
+    view.setUint16(10, entryCount, true); // Total number of entries
+    view.setUint32(12, centralDirSize, true); // Size of central directory
+    view.setUint32(16, centralDirOffset, true); // Offset of central directory
+    view.setUint16(20, comment.length, true); // Comment length
+    if (comment.length > 0) {
+        record.set(comment, 22);
+    }
+    return record;
+}
+/**
+ * Create a ZIP file from entries (async)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ *
+ * @example
+ * ```ts
+ * const zip = await createZip([
+ *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
+ *   { name: "folder/file.txt", data: new TextEncoder().encode("Nested!") }
+ * ], { level: 6 });
+ * ```
+ */
+export async function createZip(entries, options = {}) {
+    const level = options.level ?? 6;
+    const zipComment = encodeString(options.comment ?? "");
+    const now = new Date();
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const modDate = entry.modTime ?? now;
+        const [dosTime, dosDate] = dateToDos(modDate);
+        // Compress data
+        const isCompressed = level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed ? await compress(entry.data, { level }) : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: currentOffset
+        };
+        // Calculate offset for next entry
+        currentOffset += 30 + nameBytes.length + compressedData.length;
+        processedEntries.push(processedEntry);
+    }
+    // Build ZIP structure
+    const chunks = [];
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        chunks.push(buildLocalFileHeader(entry));
+        chunks.push(entry.compressedData);
+    }
+    const centralDirOffset = currentOffset;
+    // Central directory
+    const centralDirChunks = [];
+    for (const entry of processedEntries) {
+        centralDirChunks.push(buildCentralDirHeader(entry));
+    }
+    chunks.push(...centralDirChunks);
+    const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+    // End of central directory
+    chunks.push(buildEndOfCentralDir(processedEntries.length, centralDirSize, centralDirOffset, zipComment));
+    // Combine all chunks
+    const totalSize = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+/**
+ * Create a ZIP file from entries (sync, Node.js only)
+ *
+ * @param entries - Files to include in ZIP
+ * @param options - ZIP options
+ * @returns ZIP file as Uint8Array
+ * @throws Error if not in Node.js environment
+ */
+export function createZipSync(entries, options = {}) {
+    const level = options.level ?? 6;
+    const zipComment = encodeString(options.comment ?? "");
+    const now = new Date();
+    // Process entries
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const modDate = entry.modTime ?? now;
+        const [dosTime, dosDate] = dateToDos(modDate);
+        // Compress data
+        const isCompressed = level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed ? compressSync(entry.data, { level }) : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: currentOffset
+        };
+        currentOffset += 30 + nameBytes.length + compressedData.length;
+        processedEntries.push(processedEntry);
+    }
+    // Build ZIP structure
+    const chunks = [];
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        chunks.push(buildLocalFileHeader(entry));
+        chunks.push(entry.compressedData);
+    }
+    const centralDirOffset = currentOffset;
+    // Central directory
+    const centralDirChunks = [];
+    for (const entry of processedEntries) {
+        centralDirChunks.push(buildCentralDirHeader(entry));
+    }
+    chunks.push(...centralDirChunks);
+    const centralDirSize = centralDirChunks.reduce((sum, c) => sum + c.length, 0);
+    // End of central directory
+    chunks.push(buildEndOfCentralDir(processedEntries.length, centralDirSize, centralDirOffset, zipComment));
+    // Combine all chunks
+    const totalSize = chunks.reduce((sum, c) => sum + c.length, 0);
+    const result = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+/**
+ * Streaming ZIP builder for large files
+ * Writes chunks to a callback as they are generated
+ */
+export class ZipBuilder {
+    /**
+     * Create a new ZIP builder
+     * @param options - ZIP options
+     */
+    constructor(options = {}) {
+        this.entries = [];
+        this.currentOffset = 0;
+        this.finalized = false;
+        this.level = options.level ?? 6;
+        this.zipComment = encodeString(options.comment ?? "");
+    }
+    /**
+     * Add a file to the ZIP (async)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    async addFile(entry) {
+        if (this.finalized) {
+            throw new Error("Cannot add files after finalizing");
+        }
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const [dosTime, dosDate] = dateToDos(entry.modTime ?? new Date());
+        // Compress data
+        const isCompressed = this.level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed
+            ? await compress(entry.data, { level: this.level })
+            : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: this.currentOffset
+        };
+        this.entries.push(processedEntry);
+        this.currentOffset += 30 + nameBytes.length + compressedData.length;
+        return [buildLocalFileHeader(processedEntry), compressedData];
+    }
+    /**
+     * Add a file to the ZIP (sync, Node.js only)
+     * @param entry - File entry
+     * @returns Local file header and compressed data chunks
+     */
+    addFileSync(entry) {
+        if (this.finalized) {
+            throw new Error("Cannot add files after finalizing");
+        }
+        const nameBytes = encodeString(entry.name);
+        const commentBytes = encodeString(entry.comment ?? "");
+        const [dosTime, dosDate] = dateToDos(entry.modTime ?? new Date());
+        // Compress data
+        const isCompressed = this.level > 0 && entry.data.length > 0;
+        const compressedData = isCompressed
+            ? compressSync(entry.data, { level: this.level })
+            : entry.data;
+        const processedEntry = {
+            name: nameBytes,
+            data: entry.data,
+            compressedData,
+            crc: crc32(entry.data),
+            compressionMethod: isCompressed ? COMPRESSION_DEFLATE : COMPRESSION_STORE,
+            modTime: dosTime,
+            modDate: dosDate,
+            comment: commentBytes,
+            offset: this.currentOffset
+        };
+        this.entries.push(processedEntry);
+        this.currentOffset += 30 + nameBytes.length + compressedData.length;
+        return [buildLocalFileHeader(processedEntry), compressedData];
+    }
+    /**
+     * Finalize the ZIP and return central directory + end record
+     * @returns Central directory and end of central directory chunks
+     */
+    finalize() {
+        if (this.finalized) {
+            throw new Error("ZIP already finalized");
+        }
+        this.finalized = true;
+        const chunks = [];
+        // Central directory
+        for (const entry of this.entries) {
+            chunks.push(buildCentralDirHeader(entry));
+        }
+        const centralDirSize = chunks.reduce((sum, c) => sum + c.length, 0);
+        // End of central directory
+        chunks.push(buildEndOfCentralDir(this.entries.length, centralDirSize, this.currentOffset, this.zipComment));
+        return chunks;
+    }
+    /**
+     * Get current number of entries
+     */
+    get entryCount() {
+        return this.entries.length;
+    }
+    /**
+     * Get current ZIP data size (without central directory)
+     */
+    get dataSize() {
+        return this.currentOffset;
+    }
+}

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

@@ -1,35 +1,23 @@
 import events from "events";
-import { Zip, ZipPassThrough, ZipDeflate } from "fflate";
+import { ZipBuilder } from "./zip/index.js";
 import { StreamBuf } from "./stream-buf.js";
 // =============================================================================
 // The ZipWriter class
 // Packs streamed data into an output zip stream
+// Uses native zlib (Node.js) or CompressionStream (browser) for best performance
 class ZipWriter extends events.EventEmitter {
     constructor(options) {
         super();
-        this.options = Object.assign({
-            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;
-        // Create fflate Zip instance for streaming compression
-        this.zip = new Zip((err, data, final) => {
-            if (err) {
-                this.stream.emit("error", err);
-            }
-            else {
-                this.stream.write(Buffer.from(data));
-                if (final) {
-                    this.stream.end();
-                }
-            }
-        });
+        this.pendingWrites = [];
+        // Determine compression level:
+        // - STORE mode = 0 (no compression)
+        // - DEFLATE mode = user level or default 1 (fast compression)
+        const level = options?.compression === "STORE"
+            ? 0
+            : Math.max(0, Math.min(9, options?.compressionOptions?.level ?? 1));
+        this.stream = new StreamBuf();
+        this.zipBuilder = new ZipBuilder({ level });
     }
     append(data, options) {
         let buffer;
@@ -43,7 +31,7 @@ class ZipWriter extends events.EventEmitter {
             buffer = Buffer.from(data, "utf8");
         }
         else if (Buffer.isBuffer(data)) {
-            // Buffer extends Uint8Array, fflate can use it directly - no copy needed
+            // Buffer extends Uint8Array, can use it directly - no copy needed
             buffer = data;
         }
         else if (ArrayBuffer.isView(data)) {
@@ -58,14 +46,16 @@ class ZipWriter extends events.EventEmitter {
             // Assume it's already a Uint8Array or compatible type
             buffer = data;
         }
-        // Add file to zip using streaming API
-        // 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
+        // Add file to zip using native compression
+        // addFile returns chunks that we write to stream immediately
+        const writePromise = this.zipBuilder
+            .addFile({ name: options.name, data: buffer })
+            .then(chunks => {
+            for (const chunk of chunks) {
+                this.stream.write(Buffer.from(chunk));
+            }
+        });
+        this.pendingWrites.push(writePromise);
     }
     push(chunk) {
         return this.stream.push(chunk);
@@ -75,8 +65,14 @@ class ZipWriter extends events.EventEmitter {
             return;
         }
         this.finalized = true;
-        // End the zip stream
-        this.zip.end();
+        // Wait for all pending writes to complete
+        await Promise.all(this.pendingWrites);
+        // Finalize the zip and write central directory
+        const finalChunks = this.zipBuilder.finalize();
+        for (const chunk of finalChunks) {
+            this.stream.write(Buffer.from(chunk));
+        }
+        this.stream.end();
         this.emit("finish");
     }
     // ==========================================================================

package/dist/esm/xlsx/xform/book/defined-name-xform.js

@@ -42,16 +42,50 @@ class DefinedNamesXform extends BaseXform {
         return false;
     }
 }
+// Regex to validate cell range format:
+// - Cell: $A$1 or A1
+// - Range: $A$1:$B$10 or A1:B10
+// - Row range: $1:$2 (for print titles)
+// - Column range: $A:$B (for print titles)
+const cellRangeRegexp = /^[$]?[A-Za-z]{1,3}[$]?\d+(:[$]?[A-Za-z]{1,3}[$]?\d+)?$/;
+const rowRangeRegexp = /^[$]?\d+:[$]?\d+$/;
+const colRangeRegexp = /^[$]?[A-Za-z]{1,3}:[$]?[A-Za-z]{1,3}$/;
 function isValidRange(range) {
+    // Skip array constants wrapped in {} - these are not valid cell ranges
+    // e.g., {"'Sheet1'!$A$1:$B$10"} or {#N/A,#N/A,FALSE,"text"}
+    if (range.startsWith("{") || range.endsWith("}")) {
+        return false;
+    }
+    // Extract the cell reference part (after the sheet name if present)
+    const cellRef = range.split("!").pop() || "";
+    // Must match one of the valid patterns
+    if (!cellRangeRegexp.test(cellRef) &&
+        !rowRangeRegexp.test(cellRef) &&
+        !colRangeRegexp.test(cellRef)) {
+        return false;
+    }
     try {
-        colCache.decodeEx(range);
-        return true;
+        const decoded = colCache.decodeEx(range);
+        // For cell ranges: row/col or top/bottom/left/right should be valid numbers
+        // For row ranges ($1:$2): top/bottom are numbers, left/right are null
+        // For column ranges ($A:$B): left/right are numbers, top/bottom are null
+        if (("row" in decoded && typeof decoded.row === "number") ||
+            ("top" in decoded && typeof decoded.top === "number") ||
+            ("left" in decoded && typeof decoded.left === "number")) {
+            return true;
+        }
+        return false;
     }
     catch {
         return false;
     }
 }
 function extractRanges(parsedText) {
+    // Skip if the entire text is wrapped in {} (array constant)
+    const trimmed = parsedText.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        return [];
+    }
     const ranges = [];
     let quotesOpened = false;
     let last = "";

package/dist/esm/xlsx/xform/list-xform.js

@@ -79,5 +79,11 @@ class ListXform extends BaseXform {
             });
         }
     }
+    reset() {
+        super.reset();
+        if (this.childXform) {
+            this.childXform.reset();
+        }
+    }
 }
 export { ListXform };

package/dist/esm/xlsx/xform/sheet/cell-xform.js

@@ -407,7 +407,12 @@ class CellXform extends BaseXform {
                 }
                 break;
             case Enums.ValueType.Formula:
-                if (model.result !== undefined && style && isDateFmt(style.numFmt)) {
+                // Only convert formula result to date if the result is a number
+                // String results (t="str") should not be converted even if the cell has a date format
+                if (model.result !== undefined &&
+                    typeof model.result === "number" &&
+                    style &&
+                    isDateFmt(style.numFmt)) {
                     model.result = excelToDate(model.result, options.date1904);
                 }
                 if (model.shareType === "shared") {

package/dist/esm/xlsx/xform/sheet/row-xform.js

@@ -1,6 +1,7 @@
 import { BaseXform } from "../base-xform.js";
 import { CellXform } from "./cell-xform.js";
 import { parseBoolean } from "../../../utils/utils.js";
+import { colCache } from "../../../utils/col-cache.js";
 class RowXform extends BaseXform {
     constructor(options) {
         super();
@@ -12,6 +13,11 @@ class RowXform extends BaseXform {
     get tag() {
         return "row";
     }
+    reset() {
+        super.reset();
+        this.numRowsSeen = 0;
+        this.lastCellCol = 0;
+    }
     prepare(model, options) {
         const styleId = options.styles.addStyleModel(model.style);
         if (styleId) {
@@ -62,11 +68,15 @@ class RowXform extends BaseXform {
         }
         if (node.name === "row") {
             this.numRowsSeen += 1;
+            // Reset lastCellCol for each new row
+            this.lastCellCol = 0;
             const spans = node.attributes.spans
                 ? node.attributes.spans.split(":").map((span) => parseInt(span, 10))
                 : [undefined, undefined];
+            // If r attribute is missing, use numRowsSeen as the row number
+            const rowNumber = node.attributes.r ? parseInt(node.attributes.r, 10) : this.numRowsSeen;
             const model = (this.model = {
-                number: parseInt(node.attributes.r, 10),
+                number: rowNumber,
                 min: spans[0],
                 max: spans[1],
                 cells: []
@@ -106,7 +116,19 @@ class RowXform extends BaseXform {
     parseClose(name) {
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
-                this.model.cells.push(this.parser.model);
+                const cellModel = this.parser.model;
+                // If cell has address, extract column number from it
+                // Otherwise, calculate address based on position
+                if (cellModel.address) {
+                    const decoded = colCache.decodeAddress(cellModel.address);
+                    this.lastCellCol = decoded.col;
+                }
+                else {
+                    // No r attribute, calculate address from position
+                    this.lastCellCol += 1;
+                    cellModel.address = colCache.encodeAddress(this.model.number, this.lastCellCol);
+                }
+                this.model.cells.push(cellModel);
                 if (this.maxItems && this.model.cells.length > this.maxItems) {
                     throw new Error(`Max column count (${this.maxItems}) exceeded`);
                 }

package/dist/esm/xlsx/xform/table/filter-column-xform.js

@@ -54,6 +54,10 @@ class FilterColumnXform extends BaseXform {
                     filterButton: attributes.hiddenButton === "0"
                 };
                 return true;
+            case "dynamicFilter":
+                // Ignore dynamicFilter nodes - we don't need to preserve them for reading
+                // See: https://github.com/exceljs/exceljs/issues/2972
+                return true;
             default:
                 this.parser = this.map[node.name];
                 if (this.parser) {

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

@@ -1,3 +1,7 @@
+import type { Row } from "./row.js";
+import type { Column } from "./column.js";
+import type { Worksheet } from "./worksheet.js";
+import type { Workbook } from "./workbook.js";
 interface FullAddress {
     sheetName: string;
     address: string;
@@ -26,16 +30,16 @@ interface CellModel {
 }
 declare class Cell {
     static Types: typeof import("./enums.js").ValueType;
-    _row: any;
-    _column: any;
+    _row: Row;
+    _column: Column;
     _address: string;
     _value: any;
-    style: any;
+    style: Record<string, unknown>;
     _mergeCount: number;
     _comment?: any;
-    constructor(row: any, column: any, address: string);
-    get worksheet(): any;
-    get workbook(): any;
+    constructor(row: Row, column: Column, address: string);
+    get worksheet(): Worksheet;
+    get workbook(): Workbook;
     destroy(): void;
     get numFmt(): any;
     set numFmt(value: any);