xlsx-generator

name	xlsx-generator
description	Production-grade XLSX generator that creates valid Microsoft Excel (.xlsx) files from structured table data using a DEFLATE-mode ZIP engine (uses zlib for compression). Supports formulas, merged cells, styles (bold/font/alignment/border/fill/number-format/column-width), panes/freeze-panes, multi-sheet, and auto-sizing.
when_to_use	Use this skill when generating Excel (.xlsx) files from structured data, including creating data tables, reports with styled cells, multi-sheet workbooks, or any data export requiring .xlsx output.
tools	jsexec, read, write, bash
args	[{"name":"data","description":"JSON array of sheet definitions. Each sheet: {name:string, rows:[[value]], formulas:{'R,C':'=...'}, merges:['R1C1:R2C2'], styles:{'R,C':{...}}, colWidths:[N], freeze:{row:N,col:N}}","required":true},{"name":"output","description":"Output file path (default: /generated_spreadsheet.xlsx)","required":false}]

CODE SKILL — VERBATIM REQUIRED This skill targets a formal specification (OOXML). Adaptation is prohibited per C2-A Rule 3. Copy the Runnable Entry Point EXACTLY, replace only template variables.

CRITICAL: Execution Constraints

This skill MUST be used as a single, complete jsexec invocation. The code below is the SOLE IMPLEMENTATION — it MUST NOT be replaced, simplified, or reimplemented.

Prohibited deviations:

• Do NOT write your own crc32() — use ONLY the one in Runnable Entry Point
• Do NOT write your own ZipStream class — use ONLY the one in Runnable Entry Point
• Do NOT skip any OOXML file from the baseline (7-file minimum)
• Do NOT change from DEFLATE compression (method 8) — it is used for smaller file sizes
• Do NOT write your own style/XML generators — use ONLY buildStylesXML(), buildSheetXML(), buildSharedStrings()
• Do NOT write your own buildContentTypes() or buildWorkbookRels()

Correct Invocation Pattern

1. Copy the complete script from ## Runnable Entry Point below
2. Replace ONLY template variables {{data}}, {{output_path}} with actual values
3. Execute as a single jsexec call with NO modifications to the core logic

Argument Details

Arg	Type	Required	Default	Description
data	string (JSON)	yes	—	JSON array of sheet definitions
output_path	string	no	/generated_spreadsheet.xlsx	Output .xlsx file path

Runnable Entry Point (COMPLETE IIFE, DO NOT MODIFY)

// ===== ⛔ Runnable Entry Point (IIFE) — DO NOT MODIFY ANY CODE BELOW ⛔ =====
(function() {
  const fs = require("fs");
  const zlib = require("zlib");

  // ═══════════════════════════════════════════════════════════════════
  // CRC32 (ZIP integrity)
  // ═══════════════════════════════════════════════════════════════════
  const crc32Table = (function() {
    const t = new Uint32Array(256);
    for (let i = 0; i < 256; i++) {
      let c = i;
      for (let k = 0; k < 8; k++)
        c = (c & 1) ? 0xEDB88320 ^ (c >>> 1) : c >>> 1;
      t[i] = c;
    }
    return t;
  })();

  function crc32(buf) {
    let crc = 0xFFFFFFFF;
    for (let i = 0; i < buf.length; i++)
      crc = (crc >>> 8) ^ crc32Table[(crc ^ buf[i]) & 0xFF];
    return (crc ^ 0xFFFFFFFF) >>> 0;
  }

  // ═══════════════════════════════════════════════════════════════════
  
  
   sharedMap =  ();
   shared = [];
   _userStyleBase = ;   

  
   () {
     (cell == )  ;
     ( cell === )  ;
     ( cell === )  ;
     (cell  )  ;
     ( cell === ) {
       (cell.())  ;
       (.(cell))  ;
       cell;
    }
     ( cell ===  && cell. ===  && cell. != ) {
       s = (cell.);
       (.(s))  ;
       s;
    }
     ;
  }

   () {
     ( row  rows) {
       ( cell  row) {
         v = (cell);
         (v !==  && !sharedMap.(v)) {
          sharedMap.(v, shared.);
          shared.(v);
        }
      }
    }
  }

  
  
  
   () {
     s = ;
     (n >= ) {
      s = .((n % ) + ) + s;
      n = .(n / ) - ;
    }
     s;
  }

  
  
  
   () {
    
    
    
    
    
    
    
     (v)
      .(, )
      .(, )
      .(, )
      .(, )
      .(, )
      .(, )
      .(, )
      
      
      .(, );
  }

   () {
    
    
    
    
     (v ===  || v === )  ;
     (v);
  }

  
  
  
   () {
     epoch = .(, , );
     lotusBugFix = .(, , );
     serial = (d.() - epoch) / ;
     (d.() >= lotusBugFix) serial += ;
     serial;
  }

   () {
    
     ( s !== )  ;
     trimmed = s.();

    
    
    
    
    
    
     (!.(trimmed))  ;

     d =  (trimmed);
     ((d.()))  ;

    
    
    
     epoch = .(, , );
     (d.() < epoch)  ;

     d;
  }

  
  
  
   () {
     maxCols = rows.( .(m, r.), );
     (maxCols === )  ;

      = ;
      = ;
      = ;

     contentWidths =  (maxCols).();
     ( c = ; c < maxCols; c++) {
       ( row  rows) {
         v = row[c];
         (v == ) ;
         len = ;
         (v  ) {
          len = ;
        }   ( v ===  && v. != ) {
          len = (v.).;
        }   ( v ===  && v.()) {
          len = v.;
        }  {
          len = (v).;
        }
        contentWidths[c] = .(contentWidths[c], .(len *  + , ));
      }
    }

     xml = ;
     ( c = ; c < maxCols; c++) {
       w = (colConfig && colConfig[c] && colConfig[c]. != )
        ? colConfig[c].
        : .(contentWidths[c] * ) / ;
      xml += ;
    }
    xml += ;
     xml;
  }

  
  
  
   () {
     cfg = st || {};

    
     numFmts = cfg. || [];
     numFmtsXml = ;
     (numFmts. > ) {
      numFmtsXml = ;
       ( nf  numFmts)
        numFmtsXml += ;
      numFmtsXml += ;
    }

    
     fonts = cfg. || [];
     allFonts = [{ : , :  }, ...fonts];
     fontsXml = ;
     ( f  allFonts) {
      fontsXml += ;
       (f.) fontsXml += ;
       (f.) fontsXml += ;
       (f.) fontsXml += ;
       (f.) fontsXml += ;
       (f.) fontsXml += ;
       (f.) fontsXml += ;
      fontsXml += ;
    }
    fontsXml += ;

    
     fills = cfg. || [];
     allFills = [
      { :  },
      { :  },
      ...fills
    ];
     fillsXml = ;
     ( fl  allFills) {
      fillsXml += ;
      fillsXml += ;
       (fl.) fillsXml += ;
       (fl.) fillsXml += ;
      fillsXml += ;
      fillsXml += ;
    }
    fillsXml += ;

    
     borders = cfg. || [];
     allBorders = [{}, ...borders];
     bordersXml = ;
     ( br  allBorders) {
      bordersXml += ;
       ( side  [, , , ]) {
         s = br[side] || br. || ;
         (s) {
          bordersXml += ;
        }  {
          bordersXml += ;
        }
      }
      bordersXml += ;
    }
    bordersXml += ;

    
     cellStyleXfs = ;

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
     hasDate = numFmts. > ;
     userStyleCount = .(fonts., fills., borders.);
    _userStyleBase =  + (hasDate ?  : );

     cellXfsCount =  + (hasDate ?  : ) + userStyleCount;
     cellXfsXml = ;

    
    cellXfsXml += ;

    
     (hasDate) {
      cellXfsXml += ;
    }

    
     ( i = ; i < userStyleCount; i++) {
       fontId = .(i + , allFonts. - );
       fillId = .(i + , allFills. - );
       borderId = .(i + , allBorders. - );
      cellXfsXml += ;
    }

    cellXfsXml += ;

     cellStylesXml = ;
     dxfsXml = ;
     tableStylesXml = ;

     .();
  }

  
  
  
   () {
     .();
  }

  
  
  
   () {
     (v == )  { :  };

    
    
    
    
    
    
    
    
     ( v ===  && v !==  && !(v  )) {
       (v. ===  && v. != ) {
         key = (v.);
         idx = sharedMap.(key);
         { : idx, : , : v. || , : v. !=  ? _userStyleBase + v. : , :  };
      }
       {
        : v.,
        : v. || ( v. ===  ?  : ),
        : v. || ,
        : v. !=  ? _userStyleBase + v. : ,
        : 
      };
    }

    
     (v  ) {
       { : v, : , : , : , :  };
    }

    
     ( v ===  && .(v)) {
       d = (v);
       (d)  { : d, : , : , : , :  };
    }

    
     ( v ===  && v.()) {
       { : v.(), : , : , : , : , : v };
    }

    
     ( v === ) {
       { : v ?  : , : , : , : , :  };
    }

    
     ( v === ) {
       { : v, : , : , : , :  };
    }

    
     key = (v);
     idx = sharedMap.(key);
     { : idx, : , : , : , :  };
  }

   () {
     rows = sheet.;
     merges = sheet. || [];
     frozen = sheet. || { : , :  };
     colConfig = sheet. || ;

     xml = ;

    
     isFirst = (index === );
     hasFrozen = frozen. >  || frozen. > ;
     (hasFrozen || isFirst) {
       paneXml = ;
       (hasFrozen) {
         topLeft = (frozen. >  ? (frozen.) : ) + (frozen. + );
         pane = [];
         (frozen. > ) pane.();
         (frozen. > ) pane.();
         activePane = ;
         (frozen. >  && frozen. === ) activePane = ;
          (frozen. >  && frozen. === ) activePane = ;
          (frozen. >  && frozen. > ) activePane = ;
        paneXml = ;
      }
      xml += ;
    }

    
    xml += ;

    
    xml += ;

     ( r = ; r < rows.; r++) {
      xml += ;

       ( c = ; c < rows[r].; c++) {
         cell = (rows[r][c]);
         (cell.) ;

         ref = (c) + (r + );
         cellXml = ;

        
         (cell. === ) cellXml += ;
          (cell. === ) cellXml += ;
          (cell. === ) cellXml += ;

        
         (cell. > ) cellXml += ;

        cellXml += ;

        
         (cell. ===  && cell.) {
          cellXml += ;
        }   (cell.) {
          cellXml += ;
        }

        
         (cell. === ) {
          cellXml += ;
        }   (cell. ===  && cell.) {
          cellXml += ;
        }   (cell. != ) {
          cellXml += ;
        }

        cellXml += ;
        xml += cellXml;
      }

      xml += ;
    }

    xml += ;

    
     (merges. > ) {
      xml += ;
       ( m  merges) {
        xml += ;
      }
      xml += ;
    }

    xml += ;
     .(xml);
  }

  
  
  
   () {
     xml = ;

     ( v  arr) {
      xml += ;
    }

    xml += ;
     .(xml);
  }

  
  
  
   () {
     xml = ;

     ( i = ; i <= sheetCount; i++) {
      xml += ;
    }

    xml += ;
     .(xml);
  }

  
  
  
   () {
     .();
  }

  
  
  
   () {
     xml = ;

     ( i = ; i < sheets.; i++) {
      xml += ;
    }

    xml += ;
     .(xml);
  }

  
  
  
   () {
     xml = ;

     nextRId = ;

     ( i = ; i < sheetCount; i++) {
      xml += ;
    }

    xml += ;

    xml += ;

    xml += ;

    xml += ;
     .(xml);
  }

  
  
  
    {
    () {
      . = [];
      . = [];
      . = ;
      . = (opts && opts. === ) ?  : ;
    }

    () {
       raw = .(data) ? data : .(data);
       nameBuf = .(name);
       fileCrc = (raw);

       buf = raw;
       method = ;
       (. === ) {
        buf = zlib.(raw);
        method = ;
      }

       header = .();
      header.(, );
      header.(, );
      header.(, );
      header.(method, );
      header.(fileCrc, );
      header.(buf., );
      header.(raw., );
      header.(nameBuf., );

       local = .([header, nameBuf]);
      ..(local, buf);

      ..({
        name,
        : fileCrc,
        : raw.,
        : buf.,
        method,
        : .
      });
      . += local. + buf.;
    }

    () {
       central = [];
       ( e  .) {
         nameBuf = .(e.);
         c = .();
        c.(, );
        c.(, );
        c.(, );
        c.(, );
        c.(e., );
        c.(e., );
        c.(e., );
        c.(e., );
        c.(nameBuf., );
        c.(e., );
        central.(c, nameBuf);
      }

       centralBuf = .(central);
       eocd = .();
      eocd.(, );
      eocd.(.., );
      eocd.(.., );
      eocd.(centralBuf., );
      eocd.(., );

       .([...., centralBuf, eocd]);
    }
  }

  
  
  
   () {
     files = [];

    
    sharedMap.();
    shared. = ;

    
     ( s  sheets) {
      (s.);
    }

    
    files.({ : , : (sheets.) });
    files.({ : , : () });
    files.({ : , : (sheets) });
    files.({ : , : (sheets.) });

    
    files.({ : , : (styles) });

    
    files.({ : , : () });

    
     ( i = ; i < sheets.; i++) {
      files.({
        : ,
        : (sheets[i], i)
      });
    }

    
    files.({
      : ,
      : (shared)
    });

    
     zs =  ({ :  });
     ( f  files) {
      zs.(f., f.);
    }
     zs.();
  }

  
  
  
   data = {{data}};
   outputPath = ;

  
   isArr = .(data);
   sheets = isArr
    ? [{ : , : data }]
    : data.;
   styles = isArr ?  : (data. || );

  
   buf = (sheets, styles);

  
   outputDir = ().(outputPath);
   { fs.(outputDir, { :  }); }  (e) {  }

  
  fs.(outputPath, buf);
  .();
})();

Usage Notes

Cell Value Formats

Type	Format	Example	Auto-detected?
Number	123 or 45.67	Salary, counts	✅ Yes
String	"text"	Names, labels	✅ Yes
Boolean	true / false	Status flags	✅ Yes
Date	"YYYY-MM-DD"	Hire dates	✅ Yes (regex)
Formula	"=SUM(A1:A10)"	Calculations	✅ Yes (starts with =)
Empty	null or skipped	Blank cells	✅ Yes

Cell Objects (for explicit styling)

When a cell needs a non-default style, use an object with t, v, and s fields:

// ⚠️ CRITICAL for styled string cells: must include t:"s"
{ "t": "s", "v": "Header Text", "s": 0 }   // ✅ Correct — string goes to shared pool
{ "v": "Header Text", "s": 0 }             // ❌ WRONG  — string NOT in shared pool → invalid OOXML
{ "t": "s", "v": "Title", "s": 1 }         // ✅ Correct — title style
{ "v": 42, "s": 0 }                        // ✅ OK for numbers (no t needed)
{ "v": "2026-07-18", "s": 0 }              // ✅ OK for dates (auto-detected)

Why t:"s" matters: cellDisplayValue() only adds strings to the shared string pool when t === "s". Without it, the raw string value is written directly to <c t="s"><v>text</v></c>, which is invalid OOXML — the <v> element expects a numeric index into the shared strings table.

Style Index Mapping

User-supplied s values are 0-based and map to cellXfs entries:

Internal cellXfs layout:
  [0] = Default (numFmtId=0, font[0], fill[0], border[0])
  [1] = Date format (only present if numFmts defined)
  [_userStyleBase+N] = User style N

_userStyleBase = 1 + (numFmts.length > 0 ? 1 : 0)

User s	font	fill	border	Typical Use
0	fonts[0]	fills[0]	borders[0]	Header row
1	fonts[1]	fills[1]	borders[1]	Title / emphasis
N	fonts[N]	fills[N]	borders[N]	Custom style N

Style Configuration (Multi-Sheet Format)

const data = {
  sheets: [
    {
      name: "Sheet1",
      rows: [ /* 2D array of cells */ ],
      merges: ["A1:E1"],               // optional: "A1:B2" format
      frozen: { row: 1, col: 0 },      // optional: freeze panes
      columns: [{ width: 20 }, ...]    // optional: override auto-fit
    }
    // ... more sheets
  ],
  styles: {
    fonts: [
      { b: true, sz: 12, color: "FFFFFF" },  // user font 0
      { b: true, sz: 14, color: "1F3864" }   // user font 1
    ],
    fills: [
      { patternType: "solid", fgColor: "4472C4" },  // user fill 0
      { patternType: "solid", fgColor: "D9E2F3" }   // user fill 1
    ],
    borders: [
      { left: "thin", right: "thin", top: , :  }  
    ]
    
  }
};

Note: There are always baseline fonts[0] (Calibri 11pt), fills[0] (none) + fills[1] (gray125), and borders[0] (none) that users do not need to define.

Built-in Features

Feature	How to use
Auto-fit columns	Automatic — computed from all cell content widths
Custom column widths	columns: [{ width: 20 }, { width: 15 }] per sheet
Freeze panes	frozen: { row: N, col: M }
Merged cells	merges: ["A1:F1", "B2:C3"]
First sheet selected	Default — first tab visible on open

Common Pitfalls

⚠️ Styled string cells without t:"s": The most common error. Use { "t": "s", "v": "text", "s": 0 } not { "v": "text", "s": 0 } for styled header cells. See Cell Objects above.

⚠️ Style arrays must be equal length: If fonts has 2 entries, fills should also have 2 entries (for consistent style indices). Mismatched lengths may cause unexpected style assignments.

⚠️ Formulas are not validated: Strings starting with = are written as raw <f> elements. Excel will evaluate them on open, but the generator does not validate formula syntax.

⚠️ Dates before 1900-01-01 are rejected: tryParseDateString() returns null for dates before the Excel epoch (1899-12-30), preventing negative serial numbers.

C3 Verification

Check Item	Constraint	Common Omission	Method
ZIP Integrity	EOCD + CD signatures valid	Corrupted ZIP	unzip -t <file>
[Content_Types].xml	All sheet parts declared	Missing sheet Override	Verify sheet count matches
_rels/.rels	rId1 → workbook	Missing relationship	Check Target path
xl/workbook.xml	All sheets listed	Missing sheet entry	Verify sheet count
xl/_rels/workbook.xml.rels	One rId per sheet + styles	Wrong relationship count	Count Relationship elements
xl/styles.xml	fonts/fills/borders/cellXfs	Malformed or empty style	XML well-formed check
xl/sharedStrings.xml	Present when string cells exist	Missing SS file	Cross-check cell types
Compression	Method 8 (DEFLATE)	Accidental STORE	Verify ZIP entry method
Formulas	<f> elements present	Formulas lost	Check formula cells
Merged cells	<mergeCells> present when specified	Merges omitted	Check merge XML