@cj-tech-master/excelts 4.2.0 → 4.2.1-canary.20260112134913.a3cecdd

package/dist/browser/modules/archive/zip/zip-bytes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ZIP file format encoder (single-buffer output)
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * This module focuses on producing a complete ZIP as a single Uint8Array.
+ * For true streaming (push chunks while reading sources), use `zip()` / `ZipArchive.stream()`.
+ */
+import { type CompressOptions } from "@archive/compression/compress";
+import { type ZipTimestampMode } from "@archive/utils/timestamps";
+/**
+ * ZIP file entry
+ */
+export interface ZipEntry {
+    /** File name (can include directory path, use forward slashes) */
+    name: string;
+    /** File data (will be compressed unless level=0) */
+    data: Uint8Array;
+    /** Optional per-entry compression level override */
+    level?: number;
+    /** File modification time (optional, defaults to current time) */
+    modTime?: Date;
+    /** File comment (optional) */
+    comment?: string;
+}
+/**
+ * ZIP encoder options
+ */
+export interface ZipOptions extends CompressOptions {
+    /** ZIP file comment (optional) */
+    comment?: string;
+    /**
+     * Default modification time for entries that don't specify `modTime`.
+     *
+     * If you need stable output across runs, either pass this explicitly or use `reproducible: true`.
+     */
+    modTime?: Date;
+    /**
+     * If true, bias defaults toward reproducible output:
+     * - default `modTime` becomes 1980-01-01 00:00:00 (local time)
+     * - default `timestamps` becomes "dos" (no UTC extra field)
+     */
+    reproducible?: boolean;
+    /**
+     * Max number of entries to compress concurrently in `createZip()`.
+     * This helps avoid zlib threadpool saturation / memory spikes with many files.
+     *
+     * Defaults to 4.
+     */
+    concurrency?: number;
+    /**
+     * If true (default), automatically STORE incompressible data.
+     * If false, always follow `level` (DEFLATE when level > 0).
+     */
+    smartStore?: boolean;
+    /**
+     * Timestamp writing strategy.
+     * - "dos": only write DOS date/time fields (smallest output)
+     * - "dos+utc": also write UTC mtime in 0x5455 extra field
+     */
+    timestamps?: ZipTimestampMode;
+}
+/**
+ * Create a ZIP file from entries (async)
+ */
+export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;

package/dist/browser/modules/archive/zip/zip-bytes.js

@@ -0,0 +1,239 @@
+/**
+ * ZIP file format encoder (single-buffer output)
+ *
+ * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
+ * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+ *
+ * This module focuses on producing a complete ZIP as a single Uint8Array.
+ * For true streaming (push chunks while reading sources), use `zip()` / `ZipArchive.stream()`.
+ */
+import { compress, compressSync } from "../compression/compress.browser.js";
+import { crc32 } from "../compression/crc32.browser.js";
+import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../defaults.js";
+import { isProbablyIncompressible } from "../utils/compressibility.js";
+import { encodeUtf8 } from "../utils/text.js";
+import {} from "../utils/timestamps.js";
+import { buildZipEntryMetadata, resolveZipCompressionMethod } from "./zip-entry-metadata.js";
+import { FLAG_UTF8, ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE, ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE, ZIP_LOCAL_FILE_HEADER_FIXED_SIZE, writeCentralDirectoryHeaderInto, writeEndOfCentralDirectoryInto, writeLocalFileHeaderInto } from "../zip-spec/zip-records.js";
+const REPRODUCIBLE_ZIP_MOD_TIME = new Date(1980, 0, 1, 0, 0, 0);
+function encodeZipComment(comment) {
+    // Keep empty comment as empty bytes (no encoding surprises).
+    return comment ? encodeUtf8(comment) : new Uint8Array(0);
+}
+function shouldDeflate(level, data) {
+    return level > 0 && data.length > 0;
+}
+async function compressEntryMaybe(entry, level, compressOptions, smartStore) {
+    if (!shouldDeflate(level, entry.data)) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    if (!smartStore) {
+        const compressed = await compress(entry.data, compressOptions);
+        return { compressedData: compressed, deflate: true };
+    }
+    // Heuristic: skip deflate for high-entropy inputs.
+    if (isProbablyIncompressible(entry.data)) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    const compressed = await compress(entry.data, compressOptions);
+    if (compressed.length >= entry.data.length) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    return { compressedData: compressed, deflate: true };
+}
+function compressEntryMaybeSync(entry, level, compressOptions, smartStore) {
+    if (!shouldDeflate(level, entry.data)) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    if (!smartStore) {
+        const compressed = compressSync(entry.data, compressOptions);
+        return { compressedData: compressed, deflate: true };
+    }
+    if (isProbablyIncompressible(entry.data)) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    const compressed = compressSync(entry.data, compressOptions);
+    if (compressed.length >= entry.data.length) {
+        return { compressedData: entry.data, deflate: false };
+    }
+    return { compressedData: compressed, deflate: true };
+}
+function computeLocalRecordSize(entry) {
+    return (ZIP_LOCAL_FILE_HEADER_FIXED_SIZE +
+        entry.name.length +
+        entry.extraField.length +
+        entry.compressedData.length);
+}
+function computeCentralDirHeaderSize(entry) {
+    return (ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
+        entry.name.length +
+        entry.extraField.length +
+        entry.comment.length);
+}
+function buildProcessedEntry(entry, offset, settings, compressedData, deflate) {
+    const modDate = entry.modTime ?? settings.defaultModTime;
+    const metadata = buildZipEntryMetadata({
+        name: entry.name,
+        comment: entry.comment,
+        modTime: modDate,
+        timestamps: settings.timestamps,
+        useDataDescriptor: false,
+        deflate
+    });
+    return {
+        name: metadata.nameBytes,
+        uncompressedSize: entry.data.length,
+        compressedData,
+        crc: crc32(entry.data),
+        compressionMethod: resolveZipCompressionMethod(deflate),
+        modTime: metadata.dosTime,
+        modDate: metadata.dosDate,
+        extraField: metadata.extraField,
+        comment: metadata.commentBytes,
+        offset
+    };
+}
+function appendProcessedEntry(processedEntries, entry, compressedData, deflate, currentOffset, settings) {
+    const processedEntry = buildProcessedEntry(entry, currentOffset, settings, compressedData, deflate);
+    processedEntries.push(processedEntry);
+    return {
+        processedEntry,
+        nextOffset: currentOffset + computeLocalRecordSize(processedEntry)
+    };
+}
+function finalizeZip(processedEntries, zipComment) {
+    // Assemble ZIP into a single buffer to reduce allocations and copying.
+    let localSectionSize = 0;
+    let centralDirSize = 0;
+    for (const entry of processedEntries) {
+        localSectionSize += computeLocalRecordSize(entry);
+        centralDirSize += computeCentralDirHeaderSize(entry);
+    }
+    // The central directory should start immediately after local section.
+    const centralDirOffset = localSectionSize;
+    const totalSize = localSectionSize + centralDirSize + ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE + zipComment.length;
+    const out = new Uint8Array(totalSize);
+    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+    let offset = 0;
+    // Local file headers and data
+    for (const entry of processedEntries) {
+        offset += writeLocalFileHeaderInto(out, view, offset, {
+            fileName: entry.name,
+            extraField: entry.extraField,
+            flags: FLAG_UTF8,
+            compressionMethod: entry.compressionMethod,
+            dosTime: entry.modTime,
+            dosDate: entry.modDate,
+            crc32: entry.crc,
+            compressedSize: entry.compressedData.length,
+            uncompressedSize: entry.uncompressedSize
+        });
+        out.set(entry.compressedData, offset);
+        offset += entry.compressedData.length;
+    }
+    // Central directory headers
+    for (const entry of processedEntries) {
+        offset += writeCentralDirectoryHeaderInto(out, view, offset, {
+            fileName: entry.name,
+            extraField: entry.extraField,
+            comment: entry.comment,
+            flags: FLAG_UTF8,
+            compressionMethod: entry.compressionMethod,
+            dosTime: entry.modTime,
+            dosDate: entry.modDate,
+            crc32: entry.crc,
+            compressedSize: entry.compressedData.length,
+            uncompressedSize: entry.uncompressedSize,
+            localHeaderOffset: entry.offset
+        });
+    }
+    // End of central directory
+    writeEndOfCentralDirectoryInto(out, view, offset, {
+        entryCount: processedEntries.length,
+        centralDirSize,
+        centralDirOffset,
+        comment: zipComment
+    });
+    return out;
+}
+/**
+ * Create a ZIP file from entries (async)
+ */
+export async function createZip(entries, options = {}) {
+    const reproducible = options.reproducible ?? false;
+    const level = options.level ?? DEFAULT_ZIP_LEVEL;
+    const smartStore = options.smartStore ?? true;
+    const concurrency = options.concurrency ?? 4;
+    const timestamps = options.timestamps ?? (reproducible ? "dos" : DEFAULT_ZIP_TIMESTAMPS);
+    const zipComment = encodeZipComment(options.comment);
+    const defaultModTime = options.modTime ?? (reproducible ? REPRODUCIBLE_ZIP_MOD_TIME : new Date());
+    const settings = {
+        level,
+        timestamps,
+        defaultModTime
+    };
+    const thresholdBytes = options.thresholdBytes;
+    const limit = Math.max(1, Math.floor(concurrency));
+    const processedEntries = new Array(entries.length);
+    if (entries.length > 0) {
+        let nextIndex = 0;
+        const workerCount = Math.min(limit, entries.length);
+        const workers = Array.from({ length: workerCount }, async () => {
+            while (true) {
+                const idx = nextIndex++;
+                if (idx >= entries.length) {
+                    return;
+                }
+                const entry = entries[idx];
+                const entryLevel = entry.level ?? level;
+                const compressOptions = {
+                    level: entryLevel,
+                    thresholdBytes
+                };
+                const { compressedData, deflate } = await compressEntryMaybe(entry, entryLevel, compressOptions, smartStore);
+                processedEntries[idx] = buildProcessedEntry(entry, 0, settings, compressedData, deflate);
+            }
+        });
+        await Promise.all(workers);
+    }
+    // Compute offsets in original order.
+    let currentOffset = 0;
+    for (let i = 0; i < processedEntries.length; i++) {
+        const processedEntry = processedEntries[i];
+        processedEntry.offset = currentOffset;
+        currentOffset += computeLocalRecordSize(processedEntry);
+    }
+    return finalizeZip(processedEntries, zipComment);
+}
+/**
+ * Create a ZIP file from entries (sync)
+ *
+ * This is supported in both Node.js and browser builds.
+ */
+export function createZipSync(entries, options = {}) {
+    const reproducible = options.reproducible ?? false;
+    const level = options.level ?? DEFAULT_ZIP_LEVEL;
+    const smartStore = options.smartStore ?? true;
+    const timestamps = options.timestamps ?? (reproducible ? "dos" : DEFAULT_ZIP_TIMESTAMPS);
+    const zipComment = encodeZipComment(options.comment);
+    const defaultModTime = options.modTime ?? (reproducible ? REPRODUCIBLE_ZIP_MOD_TIME : new Date());
+    const settings = {
+        level,
+        timestamps,
+        defaultModTime
+    };
+    const thresholdBytes = options.thresholdBytes;
+    const processedEntries = [];
+    let currentOffset = 0;
+    for (const entry of entries) {
+        const entryLevel = entry.level ?? level;
+        const compressOptions = {
+            level: entryLevel,
+            thresholdBytes
+        };
+        const { compressedData, deflate } = compressEntryMaybeSync(entry, entryLevel, compressOptions, smartStore);
+        const result = appendProcessedEntry(processedEntries, entry, compressedData, deflate, currentOffset, settings);
+        currentOffset = result.nextOffset;
+    }
+    return finalizeZip(processedEntries, zipComment);
+}

package/dist/{esm/modules/archive → browser/modules/archive/zip}/zip-entry-metadata.js

@@ -1,6 +1,6 @@
-import { encodeUtf8 } from "./utils/text.js";
-import { buildZipTimestampExtraField, dateToZipDos } from "./utils/timestamps.js";
-import { COMPRESSION_DEFLATE, COMPRESSION_STORE, FLAG_DATA_DESCRIPTOR, FLAG_UTF8 } from "./zip-constants.js";
+import { encodeUtf8 } from "../utils/text.js";
+import { buildZipTimestampExtraField, dateToZipDos } from "../utils/timestamps.js";
+import { COMPRESSION_DEFLATE, COMPRESSION_STORE, FLAG_DATA_DESCRIPTOR, FLAG_UTF8 } from "../zip-spec/zip-records.js";
 export function resolveZipCompressionMethod(deflate) {
     return deflate ? COMPRESSION_DEFLATE : COMPRESSION_STORE;
 }

package/dist/browser/modules/archive/{zip-records.d.ts → zip-spec/zip-records.d.ts}

@@ -3,6 +3,23 @@
  *
  * Shared by streaming zip writer and buffer zip builder.
  */
+export declare const LOCAL_FILE_HEADER_SIG = 67324752;
+export declare const CENTRAL_DIR_HEADER_SIG = 33639248;
+export declare const END_OF_CENTRAL_DIR_SIG = 101010256;
+export declare const DATA_DESCRIPTOR_SIG = 134695760;
+export declare const ZIP64_END_OF_CENTRAL_DIR_SIG = 101075792;
+export declare const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 117853008;
+export declare const VERSION_NEEDED = 20;
+export declare const VERSION_MADE_BY = 20;
+export declare const COMPRESSION_STORE = 0;
+export declare const COMPRESSION_DEFLATE = 8;
+export declare const FLAG_UTF8 = 2048;
+export declare const FLAG_DATA_DESCRIPTOR = 8;
+export declare const UINT16_MAX = 65535;
+export declare const UINT32_MAX = 4294967295;
+export declare const ZIP_LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+export declare const ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE = 46;
+export declare const ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE = 22;
 export interface ZipLocalFileHeaderInput {
     fileName: Uint8Array;
     extraField: Uint8Array;
@@ -15,6 +32,7 @@ export interface ZipLocalFileHeaderInput {
     uncompressedSize: number;
     versionNeeded?: number;
 }
+export declare function writeLocalFileHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipLocalFileHeaderInput): number;
 export declare function buildLocalFileHeader(input: ZipLocalFileHeaderInput): Uint8Array;
 export interface ZipCentralDirectoryHeaderInput {
     fileName: Uint8Array;
@@ -32,6 +50,7 @@ export interface ZipCentralDirectoryHeaderInput {
     versionNeeded?: number;
     externalAttributes?: number;
 }
+export declare function writeCentralDirectoryHeaderInto(out: Uint8Array, view: DataView, offset: number, input: ZipCentralDirectoryHeaderInput): number;
 export declare function buildCentralDirectoryHeader(input: ZipCentralDirectoryHeaderInput): Uint8Array;
 export interface ZipEndOfCentralDirectoryInput {
     entryCount: number;
@@ -39,5 +58,6 @@ export interface ZipEndOfCentralDirectoryInput {
     centralDirOffset: number;
     comment: Uint8Array;
 }
+export declare function writeEndOfCentralDirectoryInto(out: Uint8Array, view: DataView, offset: number, input: ZipEndOfCentralDirectoryInput): number;
 export declare function buildEndOfCentralDirectory(input: ZipEndOfCentralDirectoryInput): Uint8Array;
 export declare function buildDataDescriptor(crc32: number, compressedSize: number, uncompressedSize: number): Uint8Array<ArrayBuffer>;

package/dist/browser/modules/archive/zip-spec/zip-records.js

@@ -0,0 +1,126 @@
+/**
+ * ZIP record builders (PKWARE APPNOTE)
+ *
+ * Shared by streaming zip writer and buffer zip builder.
+ */
+// =============================================================================
+// ZIP format constants (PKWARE APPNOTE)
+// =============================================================================
+// Signatures
+export const LOCAL_FILE_HEADER_SIG = 0x04034b50;
+export const CENTRAL_DIR_HEADER_SIG = 0x02014b50;
+export const END_OF_CENTRAL_DIR_SIG = 0x06054b50;
+export const DATA_DESCRIPTOR_SIG = 0x08074b50;
+export const ZIP64_END_OF_CENTRAL_DIR_SIG = 0x06064b50;
+export const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50;
+// Versions
+export const VERSION_NEEDED = 20; // 2.0 - supports DEFLATE
+export const VERSION_MADE_BY = 20; // 2.0
+// Compression methods
+export const COMPRESSION_STORE = 0;
+export const COMPRESSION_DEFLATE = 8;
+// General purpose bit flags
+export const FLAG_UTF8 = 0x0800;
+export const FLAG_DATA_DESCRIPTOR = 0x0008;
+// ZIP64 / sentinel sizes
+export const UINT16_MAX = 0xffff;
+export const UINT32_MAX = 0xffffffff;
+export const ZIP_LOCAL_FILE_HEADER_FIXED_SIZE = 30;
+export const ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE = 46;
+export const ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE = 22;
+export function writeLocalFileHeaderInto(out, view, offset, input) {
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    view.setUint32(offset + 0, LOCAL_FILE_HEADER_SIG, true);
+    view.setUint16(offset + 4, versionNeeded, true);
+    view.setUint16(offset + 6, input.flags, true);
+    view.setUint16(offset + 8, input.compressionMethod, true);
+    view.setUint16(offset + 10, input.dosTime, true);
+    view.setUint16(offset + 12, input.dosDate, true);
+    view.setUint32(offset + 14, input.crc32, true);
+    view.setUint32(offset + 18, input.compressedSize, true);
+    view.setUint32(offset + 22, input.uncompressedSize, true);
+    view.setUint16(offset + 26, input.fileName.length, true);
+    view.setUint16(offset + 28, input.extraField.length, true);
+    out.set(input.fileName, offset + ZIP_LOCAL_FILE_HEADER_FIXED_SIZE);
+    if (input.extraField.length > 0) {
+        out.set(input.extraField, offset + ZIP_LOCAL_FILE_HEADER_FIXED_SIZE + input.fileName.length);
+    }
+    return ZIP_LOCAL_FILE_HEADER_FIXED_SIZE + input.fileName.length + input.extraField.length;
+}
+export function buildLocalFileHeader(input) {
+    const header = new Uint8Array(ZIP_LOCAL_FILE_HEADER_FIXED_SIZE + input.fileName.length + input.extraField.length);
+    const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+    writeLocalFileHeaderInto(header, view, 0, input);
+    return header;
+}
+export function writeCentralDirectoryHeaderInto(out, view, offset, input) {
+    const versionMadeBy = input.versionMadeBy ?? VERSION_MADE_BY;
+    const versionNeeded = input.versionNeeded ?? VERSION_NEEDED;
+    const externalAttributes = input.externalAttributes ?? 0;
+    view.setUint32(offset + 0, CENTRAL_DIR_HEADER_SIG, true);
+    view.setUint16(offset + 4, versionMadeBy, true);
+    view.setUint16(offset + 6, versionNeeded, true);
+    view.setUint16(offset + 8, input.flags, true);
+    view.setUint16(offset + 10, input.compressionMethod, true);
+    view.setUint16(offset + 12, input.dosTime, true);
+    view.setUint16(offset + 14, input.dosDate, true);
+    view.setUint32(offset + 16, input.crc32, true);
+    view.setUint32(offset + 20, input.compressedSize, true);
+    view.setUint32(offset + 24, input.uncompressedSize, true);
+    view.setUint16(offset + 28, input.fileName.length, true);
+    view.setUint16(offset + 30, input.extraField.length, true);
+    view.setUint16(offset + 32, input.comment.length, true);
+    view.setUint16(offset + 34, 0, true); // disk number start
+    view.setUint16(offset + 36, 0, true); // internal file attributes
+    view.setUint32(offset + 38, externalAttributes, true);
+    view.setUint32(offset + 42, input.localHeaderOffset, true);
+    out.set(input.fileName, offset + ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE);
+    if (input.extraField.length > 0) {
+        out.set(input.extraField, offset + ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE + input.fileName.length);
+    }
+    if (input.comment.length > 0) {
+        out.set(input.comment, offset + ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE + input.fileName.length + input.extraField.length);
+    }
+    return (ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
+        input.fileName.length +
+        input.extraField.length +
+        input.comment.length);
+}
+export function buildCentralDirectoryHeader(input) {
+    const header = new Uint8Array(ZIP_CENTRAL_DIR_HEADER_FIXED_SIZE +
+        input.fileName.length +
+        input.extraField.length +
+        input.comment.length);
+    const view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+    writeCentralDirectoryHeaderInto(header, view, 0, input);
+    return header;
+}
+export function writeEndOfCentralDirectoryInto(out, view, offset, input) {
+    view.setUint32(offset + 0, END_OF_CENTRAL_DIR_SIG, true);
+    view.setUint16(offset + 4, 0, true);
+    view.setUint16(offset + 6, 0, true);
+    view.setUint16(offset + 8, input.entryCount, true);
+    view.setUint16(offset + 10, input.entryCount, true);
+    view.setUint32(offset + 12, input.centralDirSize, true);
+    view.setUint32(offset + 16, input.centralDirOffset, true);
+    view.setUint16(offset + 20, input.comment.length, true);
+    if (input.comment.length > 0) {
+        out.set(input.comment, offset + ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE);
+    }
+    return ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE + input.comment.length;
+}
+export function buildEndOfCentralDirectory(input) {
+    const record = new Uint8Array(ZIP_END_OF_CENTRAL_DIR_FIXED_SIZE + input.comment.length);
+    const view = new DataView(record.buffer, record.byteOffset, record.byteLength);
+    writeEndOfCentralDirectoryInto(record, view, 0, input);
+    return record;
+}
+export function buildDataDescriptor(crc32, compressedSize, uncompressedSize) {
+    const descriptor = new Uint8Array(16);
+    const view = new DataView(descriptor.buffer);
+    view.setUint32(0, DATA_DESCRIPTOR_SIG, true);
+    view.setUint32(4, crc32, true);
+    view.setUint32(8, compressedSize, true);
+    view.setUint32(12, uncompressedSize, true);
+    return descriptor;
+}

package/dist/browser/modules/excel/form-control.d.ts

@@ -42,6 +42,8 @@ export interface FormCheckboxModel {
     shapeId: number;
     /** Control property ID (rId in relationships) */
     ctrlPropId: number;
+    /** Relationship id (e.g., rId5) in sheet rels for ctrlProp (set during XLSX prepare) */
+    ctrlPropRelId?: string;
     /** Top-left anchor */
     tl: FormControlAnchor;
     /** Bottom-right anchor */

package/dist/browser/modules/excel/form-control.js

@@ -106,25 +106,63 @@ class FormCheckbox {
         let tl;
         let br;
         if (typeof range === "string") {
-            // Parse cell reference like "B2" or "B2:D3"
-            const decoded = colCache.decode(range);
-            if ("top" in decoded) {
-                // It's a range like "B2:D3"
-                tl = {
-                    col: decoded.left - 1, // Convert to 0-based
-                    colOff: DEFAULT_COL_OFF,
-                    row: decoded.top - 1,
-                    rowOff: DEFAULT_ROW_OFF
-                };
-                br = {
-                    col: decoded.right - 1,
-                    colOff: DEFAULT_END_COL_OFF,
-                    row: decoded.bottom - 1,
-                    rowOff: DEFAULT_END_ROW_OFF
-                };
+            // Parse cell reference like "B2" or range like "B2:D3"
+            const isRange = range.includes(":");
+            if (isRange) {
+                const decoded = colCache.decode(range);
+                if ("top" in decoded) {
+                    // Treat 1-cell ranges (e.g., "J4:J4") as a single cell with default checkbox size.
+                    if (decoded.left === decoded.right && decoded.top === decoded.bottom) {
+                        const col = decoded.left - 1;
+                        const row = decoded.top - 1;
+                        tl = {
+                            col,
+                            colOff: DEFAULT_COL_OFF,
+                            row,
+                            rowOff: DEFAULT_ROW_OFF
+                        };
+                        br = {
+                            col: col + 2,
+                            colOff: DEFAULT_END_COL_OFF,
+                            row: row + 1,
+                            rowOff: DEFAULT_END_ROW_OFF
+                        };
+                    }
+                    else {
+                        // Regular range
+                        tl = {
+                            col: decoded.left - 1, // Convert to 0-based
+                            colOff: DEFAULT_COL_OFF,
+                            row: decoded.top - 1,
+                            rowOff: DEFAULT_ROW_OFF
+                        };
+                        br = {
+                            col: decoded.right - 1,
+                            colOff: DEFAULT_END_COL_OFF,
+                            row: decoded.bottom - 1,
+                            rowOff: DEFAULT_END_ROW_OFF
+                        };
+                    }
+                }
+                else {
+                    // Defensive fallback: if the cache returns an address, treat it like a single-cell ref.
+                    tl = {
+                        col: decoded.col - 1,
+                        colOff: DEFAULT_COL_OFF,
+                        row: decoded.row - 1,
+                        rowOff: DEFAULT_ROW_OFF
+                    };
+                    br = {
+                        col: decoded.col + 1,
+                        colOff: DEFAULT_END_COL_OFF,
+                        row: decoded.row,
+                        rowOff: DEFAULT_END_ROW_OFF
+                    };
+                }
             }
             else {
                 // Single cell reference - create default size checkbox
+                const decoded = colCache.decodeAddress(range);
                 tl = {
                     col: decoded.col - 1,
                     colOff: DEFAULT_COL_OFF,

package/dist/browser/modules/excel/stream/workbook-reader.browser.js

@@ -9,7 +9,7 @@
  * with filesystem-specific features (filename input + temp-file buffering).
  */
 import { EventEmitter, Readable } from "../../stream/index.browser.js";
-import { createParse } from "../../archive/parse.browser.js";
+import { createParse } from "../../archive/unzip/stream.browser.js";
 import { iterateStream } from "../utils/iterate-stream.js";
 import { getWorksheetNoFromWorksheetPath, getWorksheetNoFromWorksheetRelsPath, normalizeZipPath, OOXML_PATHS, worksheetRelTarget } from "../utils/ooxml-paths.js";
 import { parseSax } from "../utils/parse-sax.js";

package/dist/browser/modules/excel/stream/workbook-writer.browser.d.ts

@@ -7,7 +7,7 @@
  * Node.js uses `workbook-writer.ts`, which extends the same base implementation
  * with filesystem-specific features (filename output + image loading).
  */
-import { Zip } from "@archive/streaming-zip";
+import { Zip } from "@archive/zip/stream";
 import { StreamBuf } from "@excel/utils/stream-buf";
 import { StylesXform } from "@excel/xlsx/xform/style/styles-xform";
 import { SharedStrings } from "@excel/utils/shared-strings";

package/dist/browser/modules/excel/stream/workbook-writer.browser.js

@@ -7,7 +7,7 @@
  * Node.js uses `workbook-writer.ts`, which extends the same base implementation
  * with filesystem-specific features (filename output + image loading).
  */
-import { Zip, ZipDeflate } from "../../archive/streaming-zip.js";
+import { Zip, ZipDeflate } from "../../archive/zip/stream.js";
 import { StreamBuf } from "../utils/stream-buf.js";
 import { base64ToUint8Array } from "../../../utils/utils.browser.js";
 import { RelType } from "../xlsx/rel-type.js";

package/dist/browser/modules/excel/utils/ooxml-validator.d.ts

@@ -0,0 +1,48 @@
+export type OoxmlProblemKind = "missing-part" | "xml-malformed" | "content-types-missing" | "content-types-malformed" | "content-types-missing-default" | "content-types-missing-for-part" | "content-types-duplicate-override" | "root-rels-missing-officeDocument" | "rels-malformed" | "rels-missing-target" | "rels-duplicate-id" | "rels-empty-target" | "rels-invalid-target-path" | "rels-source-missing" | "workbook-sheet-missing-rel" | "workbook-sheet-wrong-rel-type" | "workbook-duplicate-sheetId" | "workbook-duplicate-sheet-rid" | "sheet-missing-rels" | "sheet-controls-missing-drawing" | "sheet-control-missing-rel" | "sheet-control-wrong-rel-type" | "sheet-legacyDrawing-missing-rel" | "sheet-legacyDrawing-wrong-rel-type" | "sheet-drawing-missing-rel" | "sheet-drawing-wrong-rel-type" | "sheet-comments-missing-rel" | "sheet-comments-wrong-rel-type" | "sheet-hyperlink-missing-rel" | "sheet-hyperlink-wrong-rel-type" | "sheet-tablePart-missing-rel" | "sheet-tablePart-wrong-rel-type";
+export type OoxmlOrderingProblemKind = "sheet-legacyDrawing-after-controls";
+export interface OoxmlValidationProblem {
+    kind: OoxmlProblemKind;
+    file?: string;
+    message: string;
+}
+export interface OoxmlOrderingValidationProblem {
+    kind: OoxmlOrderingProblemKind;
+    file?: string;
+    message: string;
+}
+export interface OoxmlValidationReport {
+    ok: boolean;
+    problems: Array<OoxmlValidationProblem | OoxmlOrderingValidationProblem>;
+    stats: {
+        entryCount: number;
+        xmlLikeCount: number;
+        relsCount: number;
+    };
+}
+export interface OoxmlValidateOptions {
+    /**
+     * Whether to check every XML-like entry (.xml, .rels, .vml) for well-formedness.
+     * Default: true.
+     */
+    checkXmlWellFormed?: boolean;
+    /**
+     * Whether to validate relationship targets exist (TargetMode=External ignored).
+     * Default: true.
+     */
+    checkRelationshipTargets?: boolean;
+    /**
+     * Whether to validate that every ContentTypes Override PartName exists.
+     * Default: true.
+     */
+    checkContentTypesOverrides?: boolean;
+    /**
+     * Whether to validate worksheet <controls>/<legacyDrawing> r:id wiring.
+     * Default: true.
+     */
+    checkWorksheetControlWiring?: boolean;
+    /**
+     * If provided, stops after this many problems.
+     */
+    maxProblems?: number;
+}
+export declare function validateXlsxBuffer(xlsxBuffer: Uint8Array, options?: OoxmlValidateOptions): Promise<OoxmlValidationReport>;