@nexterajs/ui 0.0.1

package/fesm2022/nexterajs-ui-excel.mjs

@@ -0,0 +1,779 @@
+/**
+ * Public value types for the in-repo .xlsx writer. These mirror the narrow slice of the exceljs
+ * `Cell` shape the app actually uses (verified across every call site), so existing code migrates by
+ * import path only — see {@link NxeWorkbook} (aliased as `Workbook`).
+ */
+
+/**
+ * Minimal, zero-dependency ZIP support for the in-repo .xlsx writer/reader — replacing the
+ * `jszip`/`pako` machinery that used to arrive transitively via `exceljs`.
+ *
+ * The WRITE half ({@link writeZip}) emits a STORE-only (uncompressed) archive — valid for `.xlsx`,
+ * which Excel reads happily — so no DEFLATE compressor is needed. CRC-32 is still required per entry
+ * even under STORE, so it is computed here.
+ *
+ * The READ half ({@link readCentralDirectory} / {@link readZipEntryBytes}) parses a real-world
+ * archive via its central directory (the authoritative size source — local headers may carry zeroed
+ * sizes when a data descriptor is used) and inflates DEFLATE entries with the browser-native
+ * {@link DecompressionStream} (`deflate-raw`); STORE entries are copied. No external lib.
+ */
+const SIG_LOCAL = 0x04034b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_EOCD = 0x06054b50;
+/** A fixed DOS date/time (1980-01-01 00:00:00) so writer output is byte-reproducible. */
+const DOS_DATE = 0x0021;
+const DOS_TIME = 0x0000;
+// ────────────────────────────────────────────────────────────────────────────
+// CRC-32 (lazy 256-entry table, standard 0xEDB88320 polynomial)
+// ────────────────────────────────────────────────────────────────────────────
+let CRC_TABLE = null;
+function crcTable() {
+    if (CRC_TABLE) {
+        return CRC_TABLE;
+    }
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+        t[n] = c >>> 0;
+    }
+    return (CRC_TABLE = t);
+}
+/** CRC-32 of a byte array (as required by the ZIP format, including STORE entries). */
+function crc32(bytes) {
+    const t = crcTable();
+    let c = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++) {
+        c = t[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+/**
+ * Build a STORE (uncompressed) ZIP archive from the given parts. Layout: every local file header +
+ * data, then the central directory, then the End-Of-Central-Directory record. The first two bytes
+ * are `PK` (0x50 0x4B). Returns the whole archive as one {@link Uint8Array}.
+ */
+function writeZip(parts) {
+    const enc = new TextEncoder();
+    const entries = parts.map((p) => {
+        const nameBytes = enc.encode(p.name);
+        return { nameBytes, data: p.bytes, crc: crc32(p.bytes) };
+    });
+    let localSize = 0;
+    let centralSize = 0;
+    for (const e of entries) {
+        localSize += 30 + e.nameBytes.length + e.data.length;
+        centralSize += 46 + e.nameBytes.length;
+    }
+    const total = localSize + centralSize + 22;
+    const out = new Uint8Array(total);
+    const view = new DataView(out.buffer);
+    let offset = 0;
+    const localOffsets = [];
+    // Local file headers + data.
+    for (const e of entries) {
+        localOffsets.push(offset);
+        view.setUint32(offset, SIG_LOCAL, true);
+        view.setUint16(offset + 4, 20, true); // version needed
+        view.setUint16(offset + 6, 0, true); // general-purpose flag
+        view.setUint16(offset + 8, 0, true); // method 0 = STORE
+        view.setUint16(offset + 10, DOS_TIME, true);
+        view.setUint16(offset + 12, DOS_DATE, true);
+        view.setUint32(offset + 14, e.crc, true);
+        view.setUint32(offset + 18, e.data.length, true); // compressed size
+        view.setUint32(offset + 22, e.data.length, true); // uncompressed size
+        view.setUint16(offset + 26, e.nameBytes.length, true);
+        view.setUint16(offset + 28, 0, true); // extra length
+        offset += 30;
+        out.set(e.nameBytes, offset);
+        offset += e.nameBytes.length;
+        out.set(e.data, offset);
+        offset += e.data.length;
+    }
+    // Central directory.
+    const centralStart = offset;
+    entries.forEach((e, i) => {
+        view.setUint32(offset, SIG_CENTRAL, true);
+        view.setUint16(offset + 4, 20, true); // version made by
+        view.setUint16(offset + 6, 20, true); // version needed
+        view.setUint16(offset + 8, 0, true); // flag
+        view.setUint16(offset + 10, 0, true); // method STORE
+        view.setUint16(offset + 12, DOS_TIME, true);
+        view.setUint16(offset + 14, DOS_DATE, true);
+        view.setUint32(offset + 16, e.crc, true);
+        view.setUint32(offset + 20, e.data.length, true); // compressed size
+        view.setUint32(offset + 24, e.data.length, true); // uncompressed size
+        view.setUint16(offset + 28, e.nameBytes.length, true);
+        view.setUint16(offset + 30, 0, true); // extra length
+        view.setUint16(offset + 32, 0, true); // comment length
+        view.setUint16(offset + 34, 0, true); // disk number start
+        view.setUint16(offset + 36, 0, true); // internal attrs
+        view.setUint32(offset + 38, 0, true); // external attrs
+        view.setUint32(offset + 42, localOffsets[i], true); // local header offset
+        offset += 46;
+        out.set(e.nameBytes, offset);
+        offset += e.nameBytes.length;
+    });
+    // End of central directory.
+    view.setUint32(offset, SIG_EOCD, true);
+    view.setUint16(offset + 4, 0, true); // disk number
+    view.setUint16(offset + 6, 0, true); // disk with central dir
+    view.setUint16(offset + 8, entries.length, true); // entries this disk
+    view.setUint16(offset + 10, entries.length, true); // total entries
+    view.setUint32(offset + 12, centralSize, true);
+    view.setUint32(offset + 16, centralStart, true);
+    view.setUint16(offset + 20, 0, true); // comment length
+    return out;
+}
+/**
+ * Parse the central directory of a ZIP buffer into a name → {@link ZipEntry} map. Scans backwards
+ * for the EOCD record, then walks each central-directory header. Throws on a ZIP64 archive (never
+ * produced by Excel for the small workbooks this app handles).
+ */
+function readCentralDirectory(buf) {
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const dec = new TextDecoder('utf-8');
+    // Locate EOCD (signature within the last 22 + up to 65535 comment bytes).
+    let eocd = -1;
+    const minPos = Math.max(0, buf.length - 22 - 65535);
+    for (let i = buf.length - 22; i >= minPos; i--) {
+        if (view.getUint32(i, true) === SIG_EOCD) {
+            eocd = i;
+            break;
+        }
+    }
+    if (eocd < 0) {
+        throw new Error('Not a valid .xlsx file (no ZIP end-of-central-directory record).');
+    }
+    const entryCount = view.getUint16(eocd + 10, true);
+    const cdOffset = view.getUint32(eocd + 16, true);
+    if (entryCount === 0xffff || cdOffset === 0xffffffff) {
+        throw new Error('Unsupported ZIP (ZIP64 archives are not supported).');
+    }
+    const map = new Map();
+    let p = cdOffset;
+    for (let i = 0; i < entryCount; i++) {
+        if (view.getUint32(p, true) !== SIG_CENTRAL) {
+            break;
+        }
+        const method = view.getUint16(p + 10, true);
+        const compSize = view.getUint32(p + 20, true);
+        const uncompSize = view.getUint32(p + 24, true);
+        const nameLen = view.getUint16(p + 28, true);
+        const extraLen = view.getUint16(p + 30, true);
+        const commentLen = view.getUint16(p + 32, true);
+        const localOffset = view.getUint32(p + 42, true);
+        const name = dec.decode(buf.subarray(p + 46, p + 46 + nameLen));
+        map.set(name, { name, method, compSize, uncompSize, localOffset });
+        p += 46 + nameLen + extraLen + commentLen;
+    }
+    return map;
+}
+/** Inflate a raw-DEFLATE byte array using the browser-native DecompressionStream. */
+async function inflateRaw(bytes) {
+    // Copy into a fresh ArrayBuffer-backed view so it satisfies BlobPart (a subarray may be SAB-typed).
+    const part = new Uint8Array(bytes);
+    const stream = new Blob([part]).stream().pipeThrough(new DecompressionStream('deflate-raw'));
+    const buf = await new Response(stream).arrayBuffer();
+    return new Uint8Array(buf);
+}
+/** Resolve where an entry's file data begins, reading the LOCAL header's own name/extra lengths. */
+function localDataOffset(buf, view, localOffset) {
+    if (view.getUint32(localOffset, true) !== SIG_LOCAL) {
+        throw new Error('Corrupt ZIP (bad local file header).');
+    }
+    const nameLen = view.getUint16(localOffset + 26, true);
+    const extraLen = view.getUint16(localOffset + 28, true);
+    return localOffset + 30 + nameLen + extraLen;
+}
+/** Read (and inflate, if DEFLATE) one archive member's raw bytes. */
+async function readZipEntryBytes(buf, entry) {
+    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const start = localDataOffset(buf, view, entry.localOffset);
+    const comp = buf.subarray(start, start + entry.compSize);
+    if (entry.method === 0) {
+        return comp.slice();
+    }
+    if (entry.method === 8) {
+        return inflateRaw(comp);
+    }
+    throw new Error(`Unsupported ZIP compression method ${entry.method}.`);
+}
+/** Read one archive member and decode it as UTF-8 text (for the OOXML parts). */
+async function readZipEntryText(buf, entry) {
+    return new TextDecoder('utf-8').decode(await readZipEntryBytes(buf, entry));
+}
+
+const MAIN_NS = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+const REL_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const PKG_REL_NS = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const CT_NS = 'http://schemas.openxmlformats.org/package/2006/content-types';
+// ────────────────────────────────────────────────────────────────────────────
+// Small helpers (column letters, escaping, Excel serial dates)
+// ────────────────────────────────────────────────────────────────────────────
+/** 1 → A, 27 → AA. */
+function colLetter(n) {
+    let s = '';
+    while (n > 0) {
+        const r = (n - 1) % 26;
+        s = String.fromCharCode(65 + r) + s;
+        n = Math.floor((n - 1) / 26);
+    }
+    return s;
+}
+/** 1-based (row, col) → A1 reference. */
+function cellRef(row, col) {
+    return colLetter(col) + row;
+}
+/** Strip XML-1.0-forbidden control chars, then escape `& < >` for element text. */
+function escapeText(s) {
+    return s
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/** Escape for attribute values (adds `"`). */
+function escapeAttr(s) {
+    return escapeText(s).replace(/"/g, '&quot;');
+}
+/** `xml:space="preserve"` when leading/trailing whitespace would otherwise be collapsed. */
+function preserve(s) {
+    return /^\s|\s$/.test(s) ? ' xml:space="preserve"' : '';
+}
+/**
+ * Excel serial date — days since 1899-12-30 (epoch absorbs the 1900 leap-year bug for all dates
+ * ≥ 1900-03-01, the only range these reports produce). Built from LOCAL calendar components so the
+ * printed `dd mmm yyyy` matches the day the grid showed, regardless of timezone.
+ */
+function excelSerial(d) {
+    const epoch = Date.UTC(1899, 11, 30);
+    const ms = Date.UTC(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+    return (ms - epoch) / 86400000;
+}
+function alignmentXml(a) {
+    const h = a.horizontal ? ` horizontal="${a.horizontal}"` : '';
+    const vMap = { top: 'top', middle: 'center', bottom: 'bottom' };
+    const v = a.vertical ? ` vertical="${vMap[a.vertical]}"` : '';
+    const i = a.indent != null && a.indent > 0 ? ` indent="${a.indent}"` : '';
+    return h || v || i ? `<alignment${h}${v}${i}/>` : '';
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Style registry — de-duped numFmts / fonts / fills / cellXfs
+// ────────────────────────────────────────────────────────────────────────────
+class StyleRegistry {
+    numFmts = [];
+    numFmtIndex = new Map();
+    fonts = ['<font><sz val="11"/><name val="Calibri Light"/></font>'];
+    fontIndex = new Map([['Calibri Light|false|11', 0]]);
+    fills = [
+        '<fill><patternFill patternType="none"/></fill>',
+        '<fill><patternFill patternType="gray125"/></fill>',
+    ];
+    fillIndex = new Map();
+    xfs = ['<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>'];
+    xfIndex = new Map();
+    numFmtId(code) {
+        let id = this.numFmtIndex.get(code);
+        if (id === undefined) {
+            id = 164 + this.numFmts.length;
+            this.numFmts.push(code);
+            this.numFmtIndex.set(code, id);
+        }
+        return id;
+    }
+    fontId(font) {
+        const name = font.name || 'Calibri Light';
+        const bold = !!font.bold;
+        const size = font.size || 11;
+        const key = `${name}|${bold}|${size}`;
+        let id = this.fontIndex.get(key);
+        if (id === undefined) {
+            id = this.fonts.length;
+            this.fonts.push(`<font>${bold ? '<b/>' : ''}<sz val="${size}"/><name val="${escapeAttr(name)}"/></font>`);
+            this.fontIndex.set(key, id);
+        }
+        return id;
+    }
+    fillId(fill) {
+        const argb = fill.fgColor.argb;
+        let id = this.fillIndex.get(argb);
+        if (id === undefined) {
+            id = this.fills.length;
+            this.fills.push(`<fill><patternFill patternType="solid"><fgColor rgb="${escapeAttr(argb)}"/></patternFill></fill>`);
+            this.fillIndex.set(argb, id);
+        }
+        return id;
+    }
+    /** Resolve the 0-based cellXfs index for a cell's facets; 0 means "all default" (omit `s`). */
+    cellStyle(cell) {
+        const numFmtId = cell.numFmt ? this.numFmtId(cell.numFmt) : 0;
+        const fontId = cell.font ? this.fontId(cell.font) : 0;
+        const fillId = cell.fill ? this.fillId(cell.fill) : 0;
+        const align = cell.alignment ? alignmentXml(cell.alignment) : '';
+        if (numFmtId === 0 && fontId === 0 && fillId === 0 && align === '') {
+            return 0;
+        }
+        const key = `${numFmtId}|${fontId}|${fillId}|${align}`;
+        let s = this.xfIndex.get(key);
+        if (s === undefined) {
+            s = this.xfs.length;
+            const flags = (numFmtId !== 0 ? ' applyNumberFormat="1"' : '') +
+                (fontId !== 0 ? ' applyFont="1"' : '') +
+                (fillId !== 0 ? ' applyFill="1"' : '') +
+                (align !== '' ? ' applyAlignment="1"' : '');
+            this.xfs.push(`<xf numFmtId="${numFmtId}" fontId="${fontId}" fillId="${fillId}" borderId="0" xfId="0"${flags}>${align}</xf>`);
+            this.xfIndex.set(key, s);
+        }
+        return s;
+    }
+    toXml() {
+        const numFmtsXml = this.numFmts.length
+            ? `<numFmts count="${this.numFmts.length}">${this.numFmts
+                .map((code, i) => `<numFmt numFmtId="${164 + i}" formatCode="${escapeAttr(code)}"/>`)
+                .join('')}</numFmts>`
+            : '';
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<styleSheet xmlns="${MAIN_NS}">` +
+            numFmtsXml +
+            `<fonts count="${this.fonts.length}">${this.fonts.join('')}</fonts>` +
+            `<fills count="${this.fills.length}">${this.fills.join('')}</fills>` +
+            '<borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>' +
+            '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>' +
+            `<cellXfs count="${this.xfs.length}">${this.xfs.join('')}</cellXfs>` +
+            '</styleSheet>');
+    }
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Object model
+// ────────────────────────────────────────────────────────────────────────────
+class NxeCell {
+    value = null;
+    numFmt;
+    /** Default MUST be undefined (never a shared `{}`) — `formatExcel` reads `cell.font?.name`. */
+    font;
+    fill;
+    alignment;
+}
+class NxeRow {
+    /** 1-based column → cell (only accessed columns exist). */
+    cells = new Map();
+    _font;
+    /**
+     * exceljs parity: setting `row.font` overwrites every existing cell's font and seeds cells
+     * created later in this row. Each cell gets its own copy — `formatExcel`-style passes mutate
+     * `cell.font` in place, so cells must not alias one object.
+     */
+    get font() {
+        return this._font;
+    }
+    set font(f) {
+        this._font = f;
+        this.cells.forEach((cell) => {
+            cell.font = f ? { ...f } : undefined;
+        });
+    }
+    getCell(col) {
+        let c = this.cells.get(col);
+        if (!c) {
+            c = new NxeCell();
+            if (this._font) {
+                c.font = { ...this._font };
+            }
+            this.cells.set(col, c);
+        }
+        return c;
+    }
+    eachCell(cb) {
+        for (const col of [...this.cells.keys()].sort((a, b) => a - b)) {
+            cb(this.cells.get(col), col);
+        }
+    }
+}
+/** Column facet (exceljs `Column` slice) — only `width` (Excel character units) is supported. */
+class NxeColumn {
+    number;
+    width;
+    constructor(number) {
+        this.number = number;
+    }
+}
+class NxeWorksheet {
+    name;
+    autoFilter;
+    rows = new Map();
+    maxRow = 0;
+    merges = [];
+    /** 1-based column → column facet (only accessed columns exist). */
+    colMap = new Map();
+    constructor(name) {
+        this.name = name;
+    }
+    /** Highest populated row (0 when empty) — `getCell` auto-extends past the `addRow` cursor. */
+    get rowCount() {
+        return this.maxRow;
+    }
+    rowAt(r) {
+        let row = this.rows.get(r);
+        if (!row) {
+            row = new NxeRow();
+            this.rows.set(r, row);
+        }
+        if (r > this.maxRow) {
+            this.maxRow = r;
+        }
+        return row;
+    }
+    addRow(values) {
+        const row = this.rowAt(this.maxRow + 1);
+        values.forEach((v, i) => {
+            row.getCell(i + 1).value = v;
+        });
+        return row;
+    }
+    /** 1-based (row, col); auto-extends the sheet (the pivot exporter writes past the cursor). */
+    getCell(row, col) {
+        return this.rowAt(row).getCell(col);
+    }
+    /** Lazily-created column facet, 1-based (exceljs `getColumn`); may point past the used range. */
+    getColumn(n) {
+        let c = this.colMap.get(n);
+        if (!c) {
+            c = new NxeColumn(n);
+            this.colMap.set(n, c);
+        }
+        return c;
+    }
+    /** exceljs parity: one entry per column touched so far (via `addRow`/`getCell`/`getColumn`). */
+    get columns() {
+        let max = 0;
+        this.eachRow((row) => row.eachCell((_c, col) => (max = Math.max(max, col))));
+        for (const n of this.colMap.keys()) {
+            max = Math.max(max, n);
+        }
+        const out = [];
+        for (let n = 1; n <= max; n++) {
+            out.push(this.getColumn(n));
+        }
+        return out;
+    }
+    mergeCells(r1, c1, r2, c2) {
+        this.merges.push(`${cellRef(r1, c1)}:${cellRef(r2, c2)}`);
+        this.getCell(r1, c1); // ensure the anchor cell renders
+    }
+    eachRow(cb) {
+        for (const r of [...this.rows.keys()].sort((a, b) => a - b)) {
+            cb(this.rows.get(r), r);
+        }
+    }
+    /** @internal Serialize this sheet to its worksheet XML, registering styles as it goes. */
+    toXml(styles) {
+        const rowsXml = [];
+        this.eachRow((row, r) => {
+            const cellsXml = [];
+            row.eachCell((cell, c) => {
+                const xml = buildCellXml(cell, r, c, styles);
+                if (xml) {
+                    cellsXml.push(xml);
+                }
+            });
+            if (cellsXml.length) {
+                rowsXml.push(`<row r="${r}">${cellsXml.join('')}</row>`);
+            }
+        });
+        const sheetData = rowsXml.length ? `<sheetData>${rowsXml.join('')}</sheetData>` : '<sheetData/>';
+        const af = this.autoFilter;
+        const autoFilterXml = af
+            ? `<autoFilter ref="${cellRef(af.from.row, af.from.column)}:${cellRef(af.to.row, af.to.column)}"/>`
+            : '';
+        const mergeXml = this.merges.length
+            ? `<mergeCells count="${this.merges.length}">${this.merges.map((m) => `<mergeCell ref="${m}"/>`).join('')}</mergeCells>`
+            : '';
+        const widthCols = [...this.colMap.values()]
+            .filter((c) => c.width != null)
+            .sort((a, b) => a.number - b.number);
+        // Schema requires ≥1 <col> child — never emit an empty <cols/>.
+        const colsXml = widthCols.length
+            ? `<cols>${widthCols.map((c) => `<col min="${c.number}" max="${c.number}" width="${c.width}" customWidth="1"/>`).join('')}</cols>`
+            : '';
+        // Schema order: cols → sheetData → autoFilter → mergeCells (regardless of call order).
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<worksheet xmlns="${MAIN_NS}" xmlns:r="${REL_NS}">` +
+            colsXml +
+            sheetData +
+            autoFilterXml +
+            mergeXml +
+            '</worksheet>');
+    }
+}
+function buildCellXml(cell, r, c, styles) {
+    const ref = cellRef(r, c);
+    const s = styles.cellStyle(cell);
+    const sAttr = s !== 0 ? ` s="${s}"` : '';
+    const v = cell.value;
+    if (typeof v === 'number' && isFinite(v)) {
+        return `<c r="${ref}"${sAttr}><v>${v}</v></c>`;
+    }
+    if (v instanceof Date && !isNaN(v.getTime())) {
+        return `<c r="${ref}"${sAttr}><v>${excelSerial(v)}</v></c>`;
+    }
+    if (v !== null && v !== undefined && v !== '') {
+        const text = String(v);
+        return `<c r="${ref}"${sAttr} t="inlineStr"><is><t${preserve(text)}>${escapeText(text)}</t></is></c>`;
+    }
+    // Empty value: emit only if it carries a non-default style; otherwise omit entirely.
+    return s !== 0 ? `<c r="${ref}"${sAttr}/>` : '';
+}
+class NxeWorkbook {
+    worksheets = [];
+    /** Mirrors `workbook.xlsx.writeBuffer()` — resolves to the packed `.xlsx` bytes. */
+    xlsx = { writeBuffer: () => Promise.resolve(this.serialize()) };
+    addWorksheet(name) {
+        const ws = new NxeWorksheet(name || `Sheet${this.worksheets.length + 1}`);
+        this.worksheets.push(ws);
+        return ws;
+    }
+    eachSheet(cb) {
+        this.worksheets.forEach((ws, i) => cb(ws, i + 1));
+    }
+    /** Build the full OOXML package and pack it as a STORE ZIP. */
+    serialize() {
+        const styles = new StyleRegistry();
+        const sheetXmls = this.worksheets.map((ws) => ws.toXml(styles)); // registers styles
+        const stylesXml = styles.toXml();
+        const n = this.worksheets.length;
+        const overrides = this.worksheets
+            .map((_, i) => `<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`)
+            .join('');
+        const contentTypes = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<Types xmlns="${CT_NS}">` +
+            '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>' +
+            '<Default Extension="xml" ContentType="application/xml"/>' +
+            '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>' +
+            '<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>' +
+            overrides +
+            '</Types>';
+        const rootRels = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<Relationships xmlns="${PKG_REL_NS}">` +
+            `<Relationship Id="rId1" Type="${REL_NS}/officeDocument" Target="xl/workbook.xml"/>` +
+            '</Relationships>';
+        const sheetsXml = this.worksheets
+            .map((ws, i) => `<sheet name="${escapeAttr(ws.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`)
+            .join('');
+        const workbookXml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<workbook xmlns="${MAIN_NS}" xmlns:r="${REL_NS}"><sheets>${sheetsXml}</sheets></workbook>`;
+        const wsRels = this.worksheets
+            .map((_, i) => `<Relationship Id="rId${i + 1}" Type="${REL_NS}/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`)
+            .join('');
+        const workbookRels = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
+            `<Relationships xmlns="${PKG_REL_NS}">` +
+            wsRels +
+            `<Relationship Id="rId${n + 1}" Type="${REL_NS}/styles" Target="styles.xml"/>` +
+            '</Relationships>';
+        const enc = new TextEncoder();
+        const part = (name, xml) => ({ name, bytes: enc.encode(xml) });
+        const parts = [
+            part('[Content_Types].xml', contentTypes),
+            part('_rels/.rels', rootRels),
+            part('xl/workbook.xml', workbookXml),
+            part('xl/_rels/workbook.xml.rels', workbookRels),
+            part('xl/styles.xml', stylesXml),
+            ...sheetXmls.map((xml, i) => part(`xl/worksheets/sheet${i + 1}.xml`, xml)),
+        ];
+        return writeZip(parts);
+    }
+}
+
+/**
+ * Zero-dependency, in-repo `.xlsx` reader — replaces SheetJS (`xlsx`), which was used in exactly one
+ * place to read an uploaded workbook into a positional array-of-arrays. Modern `.xlsx` only (legacy
+ * binary `.xls` is intentionally unsupported — guard with {@link isXlsxBytes} and reject upstream).
+ *
+ * Pipeline: {@link readCentralDirectory}/{@link readZipEntryText} (from {@link './nxe-zip'}) unzip the
+ * needed OOXML parts, then the browser-native `DOMParser` reads `xl/workbook.xml` → first sheet,
+ * `xl/_rels/workbook.xml.rels` → its path, optional `xl/sharedStrings.xml` → the string table, and
+ * the sheet XML → cells. Output mirrors SheetJS `sheet_to_json(ws, { header: 1 })`: one array per
+ * row, values placed at their column index (gaps filled with `''`), numbers kept as real numbers.
+ */
+/** True when the bytes begin with the ZIP local-file-header magic (`PK\x03\x04`) — i.e. an `.xlsx`. */
+function isXlsxBytes(buf) {
+    return buf.length >= 4 && buf[0] === 0x50 && buf[1] === 0x4b && buf[2] === 0x03 && buf[3] === 0x04;
+}
+function parseXml(text) {
+    const doc = new DOMParser().parseFromString(text, 'application/xml');
+    if (doc.getElementsByTagName('parsererror').length) {
+        throw new Error('Malformed .xlsx (could not parse XML).');
+    }
+    return doc;
+}
+/** Read a namespaced attribute by its local name (e.g. the `r:id` on a `<sheet>`). */
+function attrByLocalName(el, local) {
+    const direct = el.getAttribute(local) ?? el.getAttribute('r:' + local);
+    if (direct != null) {
+        return direct;
+    }
+    for (let i = 0; i < el.attributes.length; i++) {
+        if (el.attributes[i].localName === local) {
+            return el.attributes[i].value;
+        }
+    }
+    return null;
+}
+/** A1 reference → 0-based { col, row }. */
+function refToColRow(ref) {
+    const m = /^([A-Z]+)(\d+)$/.exec(ref);
+    if (!m) {
+        return { col: 0, row: 0 };
+    }
+    let col = 0;
+    for (const ch of m[1]) {
+        col = col * 26 + (ch.charCodeAt(0) - 64);
+    }
+    return { col: col - 1, row: Number(m[2]) - 1 };
+}
+/** Concatenate every descendant `<t>` text of a node (covers rich-text runs in shared strings). */
+function collectText(node) {
+    const ts = node.getElementsByTagName('t');
+    if (!ts.length) {
+        return '';
+    }
+    let out = '';
+    for (let i = 0; i < ts.length; i++) {
+        out += ts[i].textContent ?? '';
+    }
+    return out;
+}
+function resolveFirstSheetPath(dir, workbookXml, relsXml) {
+    const wb = parseXml(workbookXml);
+    const sheets = wb.getElementsByTagName('sheet');
+    const fallback = 'xl/worksheets/sheet1.xml';
+    if (!sheets.length) {
+        return fallback;
+    }
+    const rid = attrByLocalName(sheets[0], 'id');
+    if (rid && relsXml) {
+        const rels = parseXml(relsXml);
+        const relationships = rels.getElementsByTagName('Relationship');
+        for (let i = 0; i < relationships.length; i++) {
+            if (relationships[i].getAttribute('Id') === rid) {
+                let target = relationships[i].getAttribute('Target') || '';
+                target = target.replace(/^\//, '').replace(/^xl\//, '');
+                const full = 'xl/' + target.replace(/^\.\.\//, '');
+                return dir.has(full) ? full : fallback;
+            }
+        }
+    }
+    return dir.has(fallback) ? fallback : [...dir.keys()].find((k) => /^xl\/worksheets\/.+\.xml$/.test(k)) || fallback;
+}
+/**
+ * Read the FIRST worksheet of an `.xlsx` into a dense, positional array-of-arrays (matching SheetJS
+ * `sheet_to_json(ws, { header: 1 })`). Numeric cells are returned as numbers; string cells as
+ * strings; missing leading/intermediate cells as `''`.
+ */
+async function readXlsxFirstSheet(input) {
+    const buf = input instanceof Uint8Array ? input : new Uint8Array(input);
+    if (!isXlsxBytes(buf)) {
+        throw new Error('Not an .xlsx file.');
+    }
+    const dir = readCentralDirectory(buf);
+    const get = async (name) => {
+        const entry = dir.get(name);
+        return entry ? readZipEntryText(buf, entry) : null;
+    };
+    const workbookXml = await get('xl/workbook.xml');
+    if (!workbookXml) {
+        throw new Error('Invalid .xlsx (missing xl/workbook.xml).');
+    }
+    const relsXml = await get('xl/_rels/workbook.xml.rels');
+    const sheetPath = resolveFirstSheetPath(dir, workbookXml, relsXml);
+    // Shared strings (optional).
+    const sharedStrings = [];
+    const sharedXml = await get('xl/sharedStrings.xml');
+    if (sharedXml) {
+        const si = parseXml(sharedXml).getElementsByTagName('si');
+        for (let i = 0; i < si.length; i++) {
+            sharedStrings.push(collectText(si[i]));
+        }
+    }
+    const sheetXml = await get(sheetPath);
+    if (!sheetXml) {
+        throw new Error('Invalid .xlsx (missing worksheet part).');
+    }
+    const result = [];
+    const rows = parseXml(sheetXml).getElementsByTagName('row');
+    let runningRow = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const rowEl = rows[i];
+        const rAttr = rowEl.getAttribute('r');
+        const rowIdx = rAttr ? Number(rAttr) - 1 : runningRow;
+        runningRow = rowIdx + 1;
+        const out = [];
+        const cells = rowEl.getElementsByTagName('c');
+        let runningCol = 0;
+        for (let j = 0; j < cells.length; j++) {
+            const cell = cells[j];
+            const ref = cell.getAttribute('r');
+            const colIdx = ref ? refToColRow(ref).col : runningCol;
+            runningCol = colIdx + 1;
+            const t = cell.getAttribute('t');
+            let value = '';
+            if (t === 's') {
+                const v = cell.getElementsByTagName('v')[0];
+                value = v ? sharedStrings[Number(v.textContent)] ?? '' : '';
+            }
+            else if (t === 'inlineStr') {
+                const is = cell.getElementsByTagName('is')[0];
+                value = is ? collectText(is) : '';
+            }
+            else if (t === 'str') {
+                const v = cell.getElementsByTagName('v')[0];
+                value = v ? v.textContent ?? '' : '';
+            }
+            else {
+                // number / boolean / default
+                const v = cell.getElementsByTagName('v')[0];
+                value = v && v.textContent !== '' ? Number(v.textContent) : '';
+            }
+            for (let k = out.length; k < colIdx; k++) {
+                out[k] = '';
+            }
+            out[colIdx] = value;
+        }
+        result[rowIdx] = out;
+    }
+    // Fill any skipped rows so the array is dense (positional), like SheetJS header:1.
+    for (let i = 0; i < result.length; i++) {
+        if (!result[i]) {
+            result[i] = [];
+        }
+    }
+    return result;
+}
+
+/**
+ * Tiny in-repo replacement for `file-saver-es`'s `saveAs`. Triggers a browser download of a Blob by
+ * clicking a synthetic anchor with an object URL, then revoking it. Callers keep building their own
+ * Blob (so the MIME type is preserved).
+ */
+function nxeSaveAs(blob, fileName) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fileName;
+    a.style.display = 'none';
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+
+// @nexterajs/ui/excel — public API.
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { NxeCell, NxeColumn, NxeRow, NxeWorkbook, NxeWorksheet, NxeWorkbook as Workbook, colLetter, isXlsxBytes, nxeSaveAs, readXlsxFirstSheet };
+//# sourceMappingURL=nexterajs-ui-excel.mjs.map