xlsx-mini 0.0.0 → 0.0.1

package/README.md

@@ -1,5 +1,421 @@
 # xlsx-mini
 
-Zero-dependency `.xlsx` writer for TypeScript. This version only reserves the package name.
+[![npm](https://img.shields.io/npm/v/xlsx-mini)](https://www.npmjs.com/package/xlsx-mini)
+[![ci](https://github.com/ANicholasson/xlsx-mini/actions/workflows/ci.yml/badge.svg)](https://github.com/ANicholasson/xlsx-mini/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/xlsx-mini)](./LICENSE)
 
-Development happens at https://github.com/ANicholasson/xlsx-mini. The first usable release will be 0.1.0.
+Writes `.xlsx` files from TypeScript with no dependencies, on every JavaScript runtime. You describe sheets, rows and cells; it returns the bytes. The files open without a repair dialog in Excel, Numbers, Google Sheets and LibreOffice, and the writer is measured on every change. Every TypeScript snippet in this README is run by the test suite.
+
+## Install
+
+```sh
+pnpm add xlsx-mini
+```
+
+ESM only. Node 20.12 or later (22 or later for `require`), Bun, Deno, Cloudflare Workers, Vercel's edge runtime and evergreen browsers: the core uses only web-standard APIs, and the runtime matrix in CI proves each host on every change.
+
+## Quick start
+
+<!-- snippet: quick-start -->
+
+```ts
+import { writeFile } from "node:fs/promises";
+import { writeXlsx } from "xlsx-mini";
+
+export default async function quickStart(path = "orders.xlsx"): Promise<void> {
+  const bytes = await writeXlsx({
+    sheets: [
+      {
+        name: "Orders",
+        rows: [
+          ["Order", "Customer", "Total", "Paid"],
+          ["A-1001", "Kari Nordmann", 1234.5, true],
+          ["A-1002", "Ola Nordmann", 99, false],
+        ],
+      },
+    ],
+  });
+  await writeFile(path, bytes);
+}
+```
+
+A row is an array of cells. A cell is a string, a number, a boolean, a `Date`, a Temporal value, or `null` for an empty cell; wrap a value in `{ value, style }` to style it. The result is an ArrayBuffer-backed `Uint8Array`, ready for a file, a `Response` or a `Blob`.
+
+## Where it runs
+
+### Any web framework, through a Response
+
+<!-- snippet: response -->
+
+```ts
+import { XLSX_MIME_TYPE, writeXlsx } from "xlsx-mini";
+
+export default async function report(): Promise<Response> {
+  const bytes = await writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+  return new Response(bytes, {
+    headers: {
+      "Content-Type": XLSX_MIME_TYPE,
+      "Content-Disposition": 'attachment; filename="report.xlsx"',
+    },
+  });
+}
+```
+
+### Express and friends
+
+<!-- snippet: express -->
+
+```ts
+import { XLSX_MIME_TYPE, writeXlsx } from "xlsx-mini";
+
+/** Any response with setHeader and end: Express, Node's http, Fastify's raw reply. */
+interface Reply {
+  setHeader(name: string, value: string): void;
+  end(body: Uint8Array): void;
+}
+
+export default async function handler(reply: Reply): Promise<void> {
+  const bytes = await writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+  reply.setHeader("Content-Type", XLSX_MIME_TYPE);
+  reply.setHeader("Content-Disposition", 'attachment; filename="report.xlsx"');
+  reply.end(bytes);
+}
+```
+
+### Browser
+
+The `xlsx-mini/browser` entry adds `downloadXlsx`, which saves the bytes through a download. It throws `NO_DOM` anywhere without a document, so a server never downloads by accident.
+
+<!-- snippet: browser -->
+
+```ts
+import { writeXlsx } from "xlsx-mini";
+import { downloadXlsx } from "xlsx-mini/browser";
+
+export default async function exportInBrowser(): Promise<void> {
+  const bytes = await writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+  downloadXlsx(bytes, "report.xlsx");
+}
+```
+
+### Next.js route handler
+
+<!-- snippet: next-route -->
+
+```ts
+// app/api/report/route.ts
+import { XLSX_MIME_TYPE, writeXlsx } from "xlsx-mini";
+
+export async function GET(): Promise<Response> {
+  const bytes = await writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+  return new Response(bytes, {
+    headers: {
+      "Content-Type": XLSX_MIME_TYPE,
+      "Content-Disposition": 'attachment; filename="report.xlsx"',
+    },
+  });
+}
+```
+
+The same handler on the edge runtime:
+
+<!-- snippet: next-edge -->
+
+```ts
+// app/api/report/route.ts on the edge runtime: the same handler, one line more
+import { XLSX_MIME_TYPE, writeXlsx } from "xlsx-mini";
+
+export const runtime = "edge";
+
+export async function GET(): Promise<Response> {
+  const bytes = await writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+  return new Response(bytes, { headers: { "Content-Type": XLSX_MIME_TYPE } });
+}
+```
+
+### Next.js server action and client component
+
+The action builds the workbook on the server; the client receives the bytes and downloads them.
+
+<!-- snippet: actions -->
+
+```ts
+// app/actions.ts
+"use server";
+
+import { writeXlsx } from "xlsx-mini";
+
+export async function exportReport(): Promise<Uint8Array> {
+  return writeXlsx({ sheets: [{ name: "Report", rows: [["Total", 42]] }] });
+}
+```
+
+<!-- snippet: next-client -->
+
+```ts
+// app/export-button.tsx: wire this to a button's onClick
+"use client";
+
+import { downloadXlsx } from "xlsx-mini/browser";
+import { exportReport } from "./actions";
+
+export async function onExportClick(): Promise<void> {
+  downloadXlsx(await exportReport(), "report.xlsx");
+}
+```
+
+## From an array of objects
+
+`sheetFromObjects` turns objects into a sheet: a bold header row, a frozen header and an autofilter by default, each switchable. A column names a key, and the types reject a key whose values a cell cannot hold; a `value` function computes a cell from the whole object.
+
+<!-- snippet: objects -->
+
+```ts
+import { sheetFromObjects, writeXlsx } from "xlsx-mini";
+
+interface Order {
+  id: string;
+  customer: string;
+  total: number;
+  placed: Date;
+}
+
+export default function fromObjects(orders: Order[]): Promise<Uint8Array> {
+  const sheet = sheetFromObjects(orders, {
+    name: "Orders",
+    columns: [
+      { key: "id", header: "Order", width: 12 },
+      { key: "customer", header: "Customer", width: 24 },
+      { key: "total", header: "Total", width: 14, style: { numberFormat: '#,##0.00 "kr"' } },
+      { key: "placed", header: "Placed", width: 18, style: { numberFormat: "yyyy-mm-dd hh:mm" } },
+    ],
+  });
+  return writeXlsx({ sheets: [sheet] });
+}
+```
+
+## Number formats
+
+A style sets `bold` and a `numberFormat`: an Excel format string, or a built-in format id from 0 to 49. Column styles apply to every cell in the column; a cell's own style wins.
+
+<!-- snippet: formats -->
+
+```ts
+import { type CellStyle, writeXlsx } from "xlsx-mini";
+
+const header: CellStyle = { bold: true };
+const money: CellStyle = { numberFormat: '#,##0.00 "kr"' };
+const percent: CellStyle = { numberFormat: "0.0%" };
+const isoDate: CellStyle = { numberFormat: "yyyy-mm-dd" };
+
+export default function formats(): Promise<Uint8Array> {
+  return writeXlsx({
+    sheets: [
+      {
+        name: "Invoice",
+        // A column style applies to every cell in the column; a cell's own style wins.
+        columns: [undefined, { style: money }, { style: percent }, { style: isoDate }],
+        rows: [
+          [
+            { value: "Item", style: header },
+            { value: "Price", style: header },
+            { value: "VAT", style: header },
+            { value: "Due", style: header },
+          ],
+          ["Desk", 4999, 0.25, new Date(Date.UTC(2026, 11, 1))],
+          [
+            "Chair",
+            { value: 1299.5, style: { numberFormat: "0" } },
+            0.25,
+            new Date(Date.UTC(2026, 11, 15)),
+          ],
+        ],
+      },
+    ],
+  });
+}
+```
+
+| Want                  | Format string      |
+| --------------------- | ------------------ |
+| Thousands, 2 decimals | `#,##0.00`         |
+| Currency after        | `#,##0.00 "kr"`    |
+| Currency before       | `"$"#,##0.00`      |
+| Percent               | `0.0%`             |
+| Whole number          | `0`                |
+| ISO date              | `yyyy-mm-dd`       |
+| Date and time         | `yyyy-mm-dd hh:mm` |
+| Text as typed         | `@`                |
+
+## Dates and Temporal
+
+A `Date` is written as its UTC instant; what the reader shows follows the cell's format, or the built-in date-time format when the cell has none. Temporal values need no polyfill: `Temporal.PlainDate`, `PlainDateTime`, `ZonedDateTime` and `Instant` are recognised by their `Symbol.toStringTag`, and a `PlainDate` gets the built-in date format. Dates run from 1900-01-01 to 9999-12-31, in Excel's 1900 date system.
+
+<!-- snippet: dates -->
+
+```ts
+import { writeXlsx } from "xlsx-mini";
+
+export default function dates(): Promise<Uint8Array> {
+  return writeXlsx({
+    sheets: [
+      {
+        name: "Dates",
+        rows: [
+          // A Date is written as its UTC instant and shown with the built-in date-time format.
+          ["Shipped", new Date("2026-11-05T14:30:00Z")],
+          // A Temporal.PlainDate shows as a date; PlainDateTime, ZonedDateTime and Instant as
+          // date-times. They are recognised by their Symbol.toStringTag, so no polyfill is needed.
+          ["Due", { [Symbol.toStringTag]: "Temporal.PlainDate", year: 2026, month: 12, day: 1 }],
+        ],
+      },
+    ],
+  });
+}
+```
+
+## Extending accepted value types
+
+Augment the `Register` interface with your own types, and the `coerce` option converts each such value once, with its path, into something a cell can hold. `coerce` also sees every `Date` and Temporal value, so it can override how those are written.
+
+<!-- snippet: register -->
+
+```ts
+import { type Coerce, writeXlsx } from "xlsx-mini";
+
+export class Money {
+  constructor(readonly cents: number) {}
+}
+
+// Let your own types into cells; the types then accept them everywhere a cell value goes.
+declare module "xlsx-mini" {
+  interface Register {
+    cellValue: Money | bigint;
+  }
+}
+
+// Then say how they become something a cell can hold.
+const coerce: Coerce = (value) => {
+  if (value instanceof Money) return value.cents / 100;
+  if (typeof value === "bigint") return Number(value);
+  return value;
+};
+
+export default function extended(): Promise<Uint8Array> {
+  return writeXlsx(
+    {
+      sheets: [
+        {
+          name: "Ledger",
+          rows: [
+            ["Rent", new Money(1_250_000)],
+            ["Views", 1234567890123n],
+          ],
+        },
+      ],
+    },
+    { coerce },
+  );
+}
+```
+
+## Errors and limits
+
+The writer throws one error class, `XlsxMiniError`, with a `code` to switch on and a `path` into your input such as `sheets[1].rows[40][2]`. It throws before writing anything a reader would refuse.
+
+<!-- snippet: errors -->
+
+```ts
+import { XlsxMiniError, writeXlsx } from "xlsx-mini";
+
+export default async function safely(): Promise<string> {
+  try {
+    await writeXlsx({ sheets: [{ name: "Bad/Name", rows: [] }] });
+    return "written";
+  } catch (error) {
+    // code says what, path says where: "INVALID_SHEET_NAME at sheets[0].name"
+    if (error instanceof XlsxMiniError) return `${error.code} at ${error.path}`;
+    throw error;
+  }
+}
+```
+
+| Code                    | When                                                                                           |
+| ----------------------- | ---------------------------------------------------------------------------------------------- |
+| `NO_SHEETS`             | The workbook has no sheet.                                                                     |
+| `INVALID_SHEET_NAME`    | Empty, over 31 characters, contains `[ ] : * ? / \`, starts or ends with `'`, or is `History`. |
+| `DUPLICATE_SHEET_NAME`  | Two sheets share a name, ignoring case.                                                        |
+| `INVALID_NUMBER`        | `NaN` or an infinity.                                                                          |
+| `INVALID_DATE`          | An invalid `Date`.                                                                             |
+| `DATE_OUT_OF_RANGE`     | Before 1900-01-01 or after 9999-12-31.                                                         |
+| `UNSUPPORTED_VALUE`     | A value no cell can hold and `coerce` did not convert.                                         |
+| `INVALID_NUMBER_FORMAT` | A format string outside 1 to 255 characters, or a built-in id outside 0 to 49.                 |
+| `INVALID_COLUMN_WIDTH`  | A width outside 0 to 255.                                                                      |
+| `INVALID_FREEZE`        | Frozen rows or columns outside the sheet.                                                      |
+| `CELL_TEXT_TOO_LONG`    | Text over 32 767 characters.                                                                   |
+| `TOO_MANY_COLUMNS`      | More than 16 384 cells in a row.                                                               |
+| `TOO_MANY_ROWS`         | More than 1 048 576 rows.                                                                      |
+| `PACKAGE_TOO_LARGE`     | The file would pass 4 GiB.                                                                     |
+| `NO_DOM`                | `downloadXlsx` called where there is no document.                                              |
+
+Empty cells cost nothing: `null`, `undefined` and rows without cells are skipped, and positions stay where you put them.
+
+## API
+
+| Export                             | Shape                                                                                                                         |
+| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `writeXlsx(workbook, options?)`    | `Promise<Uint8Array<ArrayBuffer>>`                                                                                            |
+| `WriteOptions`                     | `{ coerce?: Coerce; compression?: "deflate" \| "none" }`; `"none"` writes STORE entries, byte-identical on every platform     |
+| `Workbook`                         | `{ sheets: readonly Sheet[] }`                                                                                                |
+| `Sheet`                            | `{ name; rows: Iterable<Row>; columns?: (Column \| undefined)[]; freeze?: Freeze; autoFilter?: boolean }`                     |
+| `Row`, `Cell`                      | `readonly Cell[]`; `CellValue \| { value: CellValue; style?: CellStyle }`                                                     |
+| `CellValue`                        | `string \| number \| boolean \| Date \| TemporalLike \| null \| undefined \| Registered`                                      |
+| `CellStyle`                        | `{ bold?: boolean; numberFormat?: string \| number }`                                                                         |
+| `Column`, `Freeze`                 | `{ width?: number; style?: CellStyle }`; `{ rows?: number; columns?: number }`                                                |
+| `Coerce`, `Register`, `Registered` | `(value: Date \| TemporalLike \| Registered, path: string) => CellValue`; the augmentation point and what it holds            |
+| `sheetFromObjects(data, options)`  | `Sheet`; options `{ name; columns?: ObjectColumn<T>[]; header?: CellStyle \| false; freeze?: boolean; autoFilter?: boolean }` |
+| `XlsxMiniError`, `ErrorCode`       | `{ code: ErrorCode; path: string; message }`                                                                                  |
+| `XLSX_MIME_TYPE`                   | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`                                                           |
+| `downloadXlsx(bytes, filename)`    | from `xlsx-mini/browser`; adds `.xlsx` when the name lacks it                                                                 |
+
+Rows are read once: pass a generator or a database cursor and the writer streams through it, encoding each row as it comes.
+
+## Security
+
+No runtime dependencies and no install scripts. The writer touches no file, network or global state; it reads what you give it and returns bytes. Text is escaped for XML and characters XML cannot carry are dropped, so cell content cannot break the file. Releases are published through npm trusted publishing with provenance, so every version on npm traces to a commit and a workflow run in this repository. To report a vulnerability, see `SECURITY.md`.
+
+## Benchmarks
+
+Every pull request gets one comment: the pull request and `main` built and timed on the same runner, in turns, on Node, Bun and Deno, for three suites. `pnpm bench` runs them here. On an Apple M5 Pro with Node 24, the minimum of seven runs:
+
+| Suite                                        | Deflate |  STORE |
+| -------------------------------------------- | ------: | -----: |
+| Wide table, 100 000 rows by 10 mixed columns |  495 ms | 177 ms |
+| Many sheets, 40 sheets of 2 500 rows by 6    |  238 ms |  74 ms |
+| String-heavy, 200 000 rows by 5 text columns |  367 ms |  90 ms |
+
+STORE is the writer's own path; deflate adds the runtime's zlib and is the default. Budgets and the method are in `docs/adr/0021-performance-baseline-and-budgets.md`.
+
+## Compatibility
+
+Each golden fixture is opened by hand in four applications before a release; `docs/compatibility.md` records how. For the current fixtures:
+
+| Fixture                          | Excel 16.114 (macOS) | Numbers 14.4 | Google Sheets | LibreOffice 26.8 |
+| -------------------------------- | :------------------: | :----------: | :-----------: | :--------------: |
+| Strings and numbers              |        clean         |    clean     |     clean     |      clean       |
+| Every kind of cell value         |        clean         |    clean     |    pending    |      clean       |
+| Deflated entries                 |        clean         |    clean     |    pending    |      clean       |
+| Several sheets, escaped names    |        clean         |    clean     |    pending    |      clean       |
+| Styles and number formats        |        clean         |    clean     |    pending    |      clean       |
+| Widths, frozen panes, autofilter |        clean         |    clean     |    pending    |      clean       |
+| Built from objects               |        clean         |    clean     |    pending    |      clean       |
+
+LibreOffice also reads every fixture back cell for cell in CI, on every change.
+
+## Contributing
+
+Issues and pull requests are welcome; `CONTRIBUTING.md` is short. The design decisions live in `docs/adr/`.
+
+## License
+
+MIT

package/dist/browser.d.ts

@@ -0,0 +1,16 @@
+import { XLSX_MIME_TYPE } from "./workbook/index.js";
+export { XLSX_MIME_TYPE };
+/**
+ * Saves `bytes` as a file through the browser's download mechanism: a `Blob` with the .xlsx media
+ * type behind an object URL, clicked through an anchor with a `download` attribute. The `.xlsx`
+ * extension is added when `filename` lacks it. Throws `NO_DOM` outside a browser; on a server,
+ * return the bytes in a `Response` with `XLSX_MIME_TYPE` instead.
+ *
+ * @example
+ * import { writeXlsx } from "xlsx-mini";
+ * import { downloadXlsx } from "xlsx-mini/browser";
+ *
+ * downloadXlsx(await writeXlsx(workbook), "orders.xlsx");
+ */
+export declare function downloadXlsx(bytes: Uint8Array, filename: string): void;
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,CAAC;AAQ1B;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAkBtE"}

package/dist/browser.js

@@ -0,0 +1,36 @@
+import { XlsxMiniError } from "./errors/index.js";
+import { XLSX_MIME_TYPE } from "./workbook/index.js";
+export { XLSX_MIME_TYPE };
+/**
+ * How long the object URL outlives the click. Revoking it at once cancels the download in some
+ * browsers; forty seconds is the delay FileSaver.js settled on after years of bug reports.
+ */
+const REVOKE_DELAY_MS = 40_000;
+/**
+ * Saves `bytes` as a file through the browser's download mechanism: a `Blob` with the .xlsx media
+ * type behind an object URL, clicked through an anchor with a `download` attribute. The `.xlsx`
+ * extension is added when `filename` lacks it. Throws `NO_DOM` outside a browser; on a server,
+ * return the bytes in a `Response` with `XLSX_MIME_TYPE` instead.
+ *
+ * @example
+ * import { writeXlsx } from "xlsx-mini";
+ * import { downloadXlsx } from "xlsx-mini/browser";
+ *
+ * downloadXlsx(await writeXlsx(workbook), "orders.xlsx");
+ */
+export function downloadXlsx(bytes, filename) {
+    if (typeof document === "undefined") {
+        throw new XlsxMiniError("NO_DOM", "downloadXlsx", "downloadXlsx needs a browser document; on a server send the bytes in a Response");
+    }
+    // The writer's output is ArrayBuffer-backed; the Blob constructor insists on that in its types.
+    const blob = new Blob([bytes], { type: XLSX_MIME_TYPE });
+    const url = URL.createObjectURL(blob);
+    const anchor = document.createElement("a");
+    anchor.href = url;
+    anchor.download = filename.toLowerCase().endsWith(".xlsx") ? filename : `${filename}.xlsx`;
+    document.body.append(anchor);
+    anchor.click();
+    anchor.remove();
+    setTimeout(() => URL.revokeObjectURL(url), REVOKE_DELAY_MS);
+}
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B;;;GAGG;AACH,MAAM,eAAe,GAAG,MAAM,CAAC;AAE/B;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,KAAiB,EAAE,QAAgB;IAC9D,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;QACpC,MAAM,IAAI,aAAa,CACrB,QAAQ,EACR,cAAc,EACd,iFAAiF,CAClF,CAAC;IACJ,CAAC;IACD,gGAAgG;IAChG,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,KAAgC,CAAC,EAAE,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;IACpF,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC3C,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC;IAClB,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,OAAO,CAAC;IAC3F,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7B,MAAM,CAAC,KAAK,EAAE,CAAC;IACf,MAAM,CAAC,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC,CAAC;AAC9D,CAAC"}

package/dist/errors/index.d.ts

@@ -0,0 +1,21 @@
+/** Every failure the writer reports, as a string literal so callers can switch on it. */
+export type ErrorCode = "NO_SHEETS" | "INVALID_SHEET_NAME" | "DUPLICATE_SHEET_NAME" | "INVALID_NUMBER" | "INVALID_DATE" | "DATE_OUT_OF_RANGE" | "UNSUPPORTED_VALUE" | "INVALID_NUMBER_FORMAT" | "INVALID_COLUMN_WIDTH" | "INVALID_FREEZE" | "CELL_TEXT_TOO_LONG" | "TOO_MANY_COLUMNS" | "TOO_MANY_ROWS" | "PACKAGE_TOO_LARGE" | "NO_DOM";
+/**
+ * The one error class the writer throws. `code` says what went wrong, `path` says where in the
+ * input, as the caller wrote it: `sheets[1].rows[40][2]` is the third cell of the 41st row of the
+ * second sheet.
+ *
+ * @example
+ * try {
+ *   await writeXlsx(workbook);
+ * } catch (error) {
+ *   if (error instanceof XlsxMiniError && error.code === "INVALID_NUMBER") console.log(error.path);
+ * }
+ */
+export declare class XlsxMiniError extends Error {
+    readonly name = "XlsxMiniError";
+    readonly code: ErrorCode;
+    readonly path: string;
+    constructor(code: ErrorCode, path: string, message: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,MAAM,MAAM,SAAS,GACjB,WAAW,GACX,oBAAoB,GACpB,sBAAsB,GACtB,gBAAgB,GAChB,cAAc,GACd,mBAAmB,GACnB,mBAAmB,GACnB,uBAAuB,GACvB,sBAAsB,GACtB,gBAAgB,GAChB,oBAAoB,GACpB,kBAAkB,GAClB,eAAe,GACf,mBAAmB,GACnB,QAAQ,CAAC;AAEb;;;;;;;;;;;GAWG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,SAAkB,IAAI,mBAAmB;IACzC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,YAAY,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAIzD;CACF"}

package/dist/errors/index.js

@@ -0,0 +1,23 @@
+/**
+ * The one error class the writer throws. `code` says what went wrong, `path` says where in the
+ * input, as the caller wrote it: `sheets[1].rows[40][2]` is the third cell of the 41st row of the
+ * second sheet.
+ *
+ * @example
+ * try {
+ *   await writeXlsx(workbook);
+ * } catch (error) {
+ *   if (error instanceof XlsxMiniError && error.code === "INVALID_NUMBER") console.log(error.path);
+ * }
+ */
+export class XlsxMiniError extends Error {
+    name = "XlsxMiniError";
+    code;
+    path;
+    constructor(code, path, message) {
+        super(`${message} at ${path}`);
+        this.code = code;
+        this.path = path;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACpB,IAAI,GAAG,eAAe,CAAC;IAChC,IAAI,CAAY;IAChB,IAAI,CAAS;IAEtB,YAAY,IAAe,EAAE,IAAY,EAAE,OAAe;QACxD,KAAK,CAAC,GAAG,OAAO,OAAO,IAAI,EAAE,CAAC,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { type ErrorCode, XlsxMiniError } from "./errors/index.js";
+export type { CompressionMode } from "./opc/index.js";
+export { type ObjectColumn, type SheetFromObjectsOptions, sheetFromObjects, } from "./worksheet/index.js";
+export { type WriteOptions, writeXlsx } from "./write-xlsx.js";
+export type { CellStyle } from "./styles/index.js";
+export { type Workbook, XLSX_MIME_TYPE } from "./workbook/index.js";
+export type { Cell, CellObject, CellValue, Coerce, Column, Freeze, Register, Registered, Row, Sheet, TemporalInstantLike, TemporalLike, TemporalPlainDateLike, TemporalPlainDateTimeLike, TemporalZonedDateTimeLike, } from "./worksheet/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC5B,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC/D,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,QAAQ,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACpE,YAAY,EACV,IAAI,EACJ,UAAU,EACV,SAAS,EACT,MAAM,EACN,MAAM,EACN,MAAM,EACN,QAAQ,EACR,UAAU,EACV,GAAG,EACH,KAAK,EACL,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { XlsxMiniError } from "./errors/index.js";
+export { sheetFromObjects, } from "./worksheet/index.js";
+export { writeXlsx } from "./write-xlsx.js";
+export { XLSX_MIME_TYPE } from "./workbook/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAGL,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAqB,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE/D,OAAO,EAAiB,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/opc/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Open Packaging Conventions container: the zip archive an .xlsx file is.
+ * Knows nothing about spreadsheets.
+ */
+export { type CompressionMode, selectCompression, store } from "./lib/compression.js";
+export { crc32 } from "./lib/crc32.js";
+export { createPackage, type PackagePart } from "./lib/zip.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/opc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/opc/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,eAAe,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/opc/index.js

@@ -0,0 +1,8 @@
+/**
+ * Open Packaging Conventions container: the zip archive an .xlsx file is.
+ * Knows nothing about spreadsheets.
+ */
+export { selectCompression, store } from "./lib/compression.js";
+export { crc32 } from "./lib/crc32.js";
+export { createPackage } from "./lib/zip.js";
+//# sourceMappingURL=index.js.map

package/dist/opc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/opc/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAwB,iBAAiB,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAE,aAAa,EAAoB,MAAM,cAAc,CAAC"}

package/dist/opc/lib/compression.d.ts

@@ -0,0 +1,17 @@
+/** How entries are stored in the package: the zip method id and the transform that produces them. */
+export interface Compression {
+    /** Zip method: 0 for STORE, 8 for DEFLATE. */
+    readonly method: 0 | 8;
+    compress(data: Uint8Array): Promise<Uint8Array>;
+}
+/** What a caller may ask for. The runtime may still force STORE when it cannot deflate. */
+export type CompressionMode = "deflate" | "none";
+/** STORE: bytes go in as they are. Byte-deterministic on every platform. */
+export declare const store: Compression;
+/**
+ * Picks the strategy for a requested mode. Deflate is confirmed by constructing the stream, not by
+ * checking that the class exists: some runtimes list `deflate-raw` without implementing it. Where
+ * it is unavailable the package is written with STORE entries instead.
+ */
+export declare function selectCompression(mode: CompressionMode): Compression;
+//# sourceMappingURL=compression.d.ts.map

package/dist/opc/lib/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../../src/opc/lib/compression.ts"],"names":[],"mappings":"AAAA,qGAAqG;AACrG,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACjD;AAED,2FAA2F;AAC3F,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjD,4EAA4E;AAC5E,eAAO,MAAM,KAAK,EAAE,WAGnB,CAAC;AAQF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,WAAW,CAQpE"}