sheet-to-schema 1.1.0 → 1.2.0-rc.1

package/README.md

@@ -14,7 +14,7 @@ one record per row, or per group of rows, reporting every cell it could not use.
 - **The same reader on both sides.** `sheet-to-schema/browser` reads a CSV, TSV or `.xlsx`
   file in a browser into exactly the rows the server reads from the same bytes.
 
-> **Status: stable (1.1.0).** It is the import engine of
+> **Status: stable (1.1.0); 1.2.0-rc.1 on `next`.** It is the import engine of
 > [Dynamic Entity](https://github.com/berserker5619/Dynamic-Entity#readme) 3.0, extracted so it can be used without it.
 > Members marked `@internal` are not covered by semver and may change in any release.
 
@@ -29,7 +29,9 @@ npm install express   # for the ready-made router
 ```
 
 Node 20 or later for the main entry; the three packages above are optional peers, loaded the
-first time they are needed. Reading a CSV needs none of them.
+first time they are needed. Reading a CSV needs none of them, through the main entry's
+`readCsvFile`. **`sheet-to-schema/browser` needs `exceljs` installed for a bundled app to
+build**, even one that never reads a workbook: see the browser section.
 
 ## Quick start
 
@@ -174,7 +176,23 @@ For anything else, implement `SchemaAdapter`: `id`, `adapterVersion`, and
 its own cells (`coerce`), finish a record (`finalize`) and check one (`validate`). That is how
 Dynamic Entity's form configs run on this engine.
 
-## In a browser: `sheet-to-schema/browser`
+## In a browser
+
+**CSV only: `readCsvFile`, from the main entry.** It reads a CSV or TSV file exactly as
+`readSheetFile` below does, with nothing in its module graph that asks for `exceljs`, so an app
+that never installed it builds:
+
+```ts
+import { applyMapping, decimalMarkFor, readCsvFile } from 'sheet-to-schema';
+
+const sheet = await readCsvFile(file, { filename: file.name });
+const result = applyMapping(sheet.rows, plan, adapter, undefined, { decimal: decimalMarkFor(sheet.delimiter) });
+```
+
+The format is still decided by the bytes: an `.xlsx` (or any zip), a pre-2007 `.xls` and a
+UTF-16 file are refused with `UNSUPPORTED_FORMAT`, with the server's messages for the last two.
+
+**CSV and `.xlsx`: `sheet-to-schema/browser`.**
 
 ```ts
 import { applyMapping, decimalMarkFor } from 'sheet-to-schema';
@@ -192,9 +210,24 @@ messages. Pass `sheet.delimiter` to `decimalMarkFor`, as the server does, so a s
 reads `1,5` as 1.5 on both sides. `readXlsx` is the same for a caller that already knows the
 file is a workbook.
 
-- **A CSV needs nothing installed.** `exceljs` is loaded with `import()` the first time a
-  workbook is read, so a CSV-only app never downloads it. Without it, a workbook fails with
-  what to install.
+- **Install `exceljs` to build with it.** It is loaded with `import()` the first time a
+  workbook is read, so a CSV-only user never downloads it, but a bundler still resolves that
+  `import()` when it builds. Without `exceljs` installed, checked in October 2026 (Dynamic
+  Entity's 3.1 spec, Step 0):
+
+  | Bundler | Builds? | Reading a workbook |
+  | --- | --- | --- |
+  | Angular 21 `ng build` | No: `Could not resolve "exceljs"` | — |
+  | Angular 21 `ng serve` | Yes | `PEER_MISSING` |
+  | Vite 8 (build and dev) | Yes | `PEER_MISSING` |
+  | webpack 5 | No: `Can't resolve 'exceljs'` | — |
+  | Any of them with `exceljs` marked external | Yes | `PEER_MISSING` (from 1.2.0; the browser's `TypeError` is its `cause`) |
+
+  A CSV read through `/browser` works wherever the app builds. An app that reads only CSV and
+  does not install `exceljs` uses `readCsvFile`.
+- **A missing `exceljs` is `PEER_MISSING`** (an `ImportError`, from 1.2.0), with
+  `details.peer` and what to install. A workbook chunk that failed to download is not: the
+  browser's own error (a `TypeError`, or webpack's `ChunkLoadError`) passes through as it is.
 - **The limits are the server's**, with its defaults: `maxBytes`, `maxRows`, `maxColumns`,
   `maxCellLength` and `maxZipEntries`, through `limits`.
 - **A workbook's zip is checked by what it declares** (entry count, sizes, compression ratio)
@@ -264,7 +297,7 @@ createImportRouter(express.Router(), {
 });
 ```
 
-Four things to know before deploying it:
+Five things to know before deploying it:
 
 1. **An import is not transactional.** A file that fails at row 30,000 has written 29,999
    records. Run `/validate` first, and make your writer idempotent. A grouped import can stop
@@ -279,6 +312,10 @@ Four things to know before deploying it:
    A preview lists `planVersions` and, from 1.1, `features` (`["group"]` on a router created
    with `grouping: true`); a missing `features` means the server will not group. The 1.0 form, `planForServer(plan, preview.planVersions)`,
    still works and checks plan versions only.
+5. **A 500 tells the client nothing, so the server is told instead.** From 1.2, `onError`
+   receives every failure the router answers with a 5xx, with its own code, such as
+   `PEER_MISSING` for a server without `exceljs`, answered `INTERNAL`, and the package. Without
+   `onError`, it is one `console.error` line and the error.
 
 ## Problem codes
 
@@ -288,15 +325,21 @@ Four things to know before deploying it:
 | `CELL_` | One cell could not be read. | `CELL_FORMAT`, `CELL_UNKNOWN_OPTION` |
 | `RECORD_` | The record built from a row is not valid, or needs a warning. | `RECORD_REQUIRED`, `RECORD_GROUP_CONFLICT` |
 
-`PLAN_PROBLEM_CODES`, `CELL_PROBLEM_CODES` and `RECORD_PROBLEM_CODES` list them all.
+`PLAN_PROBLEM_CODES`, `CELL_PROBLEM_CODES` and `RECORD_PROBLEM_CODES` list them all. A
+server's `PLAN_GROUP` refusal of a valid grouped plan also carries a `reason` (from 1.2.0):
+`grouping-disabled` (the router was created without `grouping: true`) or `non-contiguous`
+(`group.contiguous: false`, which the server never streams). Compare `reason`, never the
+message.
 
 A grouped import can also stop as a whole, with an `ImportFailure` (`IMPORT_FAILURE_CODES`).
 `applyMapping` and `runImport` throw it; over HTTP it is the error body's `code`. And the
-browser reader can refuse to read a workbook at all, with an `ImportError`:
+readers can refuse to read a file at all, with an `ImportError` (the main entry exports it from
+1.2.0, for `readCsvFile`):
 
 | Code | HTTP | Raised when |
 | --- | --- | --- |
 | `UNSUPPORTED_RUNTIME` | (browser only) | `sheet-to-schema/browser` is asked to read a workbook where there is no `DecompressionStream` with `deflate-raw` (see the browser section for versions). A CSV is not affected. |
+| `PEER_MISSING` | (answered as `INTERNAL`, 500) | An optional peer the call needs is not installed: `exceljs` for a workbook, `busboy` for an upload. `details.peer` names it. A server's client is told only `INTERNAL`. |
 | `GROUP_NOT_CONTIGUOUS` | 422 | A group's key comes back after its rows ended. `details` has the key and both rows. |
 | `GROUP_TOO_LARGE` | 413 | A group has more than `maxGroupRows` rows. |
 | `TOO_MANY_GROUPS` | 413 | More than `maxGroups` groups, or more than `maxGroupKeyBytes` of group keys. |

package/dist/browser/index.d.mts

@@ -1,6 +1,5 @@
-import { SheetGrid, CsvDelimiter } from 'sheet-to-schema';
-import { I as ImportLimits } from '../import-error-DkGXydP2.mjs';
-export { a as ImportError, b as ImportErrorCode } from '../import-error-DkGXydP2.mjs';
+import { ImportLimits, SheetGrid, CsvDelimiter, SheetFileInput } from 'sheet-to-schema';
+export { ImportError, ImportErrorCode, SheetFileInput } from 'sheet-to-schema';
 
 /** The limits a browser read enforces. Each one left out is the server's default. */
 type BrowserLimits = Pick<ImportLimits, 'maxBytes' | 'maxRows' | 'maxColumns' | 'maxCellLength' | 'maxZipEntries'>;
@@ -18,8 +17,7 @@ interface SheetFile extends SheetGrid {
     /** The separator a CSV turned out to use; pass it to `decimalMarkFor`. Absent for a workbook. */
     delimiter?: CsvDelimiter;
 }
-/** What a file can arrive as: a `File` or other `Blob`, or its bytes. */
-type SheetFileInput = Blob | ArrayBuffer | Uint8Array;
+
 /**
  * Read a CSV, TSV or `.xlsx` file into exactly the grid the server's `readSheet` reads from the
  * same bytes: the same headers, the same rows with the same typed cells, the same separator,
@@ -28,8 +26,8 @@ type SheetFileInput = Blob | ArrayBuffer | Uint8Array;
  * @throws ImportError `TOO_LARGE`, `SHEET_TOO_LARGE`, `UNSUPPORTED_FORMAT`, `MALFORMED_FILE`,
  *   `ARCHIVE_REFUSED`, as the server would; and for a workbook, `UNSUPPORTED_RUNTIME` where the
  *   runtime has no `DecompressionStream` with `deflate-raw` (before Node 20.12, Chrome or Edge
- *   103, Firefox 113, Safari 16.4). A workbook read without `exceljs` installed throws a
- *   plain `Error` saying what to install.
+ *   103, Firefox 113, Safari 16.4). A workbook read without `exceljs` installed throws
+ *   `PEER_MISSING`, saying what to install.
  */
 declare function readSheetFile(input: SheetFileInput, options?: ReadSheetFileOptions): Promise<SheetFile>;
 /**
@@ -40,4 +38,4 @@ declare function readSheetFile(input: SheetFileInput, options?: ReadSheetFileOpt
  */
 declare function readXlsx(input: SheetFileInput, options?: Omit<ReadSheetFileOptions, 'filename'>): Promise<SheetGrid>;
 
-export { type BrowserLimits, type ReadSheetFileOptions, type SheetFile, type SheetFileInput, readSheetFile, readXlsx };
+export { type BrowserLimits, type ReadSheetFileOptions, type SheetFile, readSheetFile, readXlsx };

package/dist/browser/index.d.ts

@@ -1,6 +1,5 @@
-import { SheetGrid, CsvDelimiter } from 'sheet-to-schema';
-import { I as ImportLimits } from '../import-error-DkGXydP2.js';
-export { a as ImportError, b as ImportErrorCode } from '../import-error-DkGXydP2.js';
+import { ImportLimits, SheetGrid, CsvDelimiter, SheetFileInput } from 'sheet-to-schema';
+export { ImportError, ImportErrorCode, SheetFileInput } from 'sheet-to-schema';
 
 /** The limits a browser read enforces. Each one left out is the server's default. */
 type BrowserLimits = Pick<ImportLimits, 'maxBytes' | 'maxRows' | 'maxColumns' | 'maxCellLength' | 'maxZipEntries'>;
@@ -18,8 +17,7 @@ interface SheetFile extends SheetGrid {
     /** The separator a CSV turned out to use; pass it to `decimalMarkFor`. Absent for a workbook. */
     delimiter?: CsvDelimiter;
 }
-/** What a file can arrive as: a `File` or other `Blob`, or its bytes. */
-type SheetFileInput = Blob | ArrayBuffer | Uint8Array;
+
 /**
  * Read a CSV, TSV or `.xlsx` file into exactly the grid the server's `readSheet` reads from the
  * same bytes: the same headers, the same rows with the same typed cells, the same separator,
@@ -28,8 +26,8 @@ type SheetFileInput = Blob | ArrayBuffer | Uint8Array;
  * @throws ImportError `TOO_LARGE`, `SHEET_TOO_LARGE`, `UNSUPPORTED_FORMAT`, `MALFORMED_FILE`,
  *   `ARCHIVE_REFUSED`, as the server would; and for a workbook, `UNSUPPORTED_RUNTIME` where the
  *   runtime has no `DecompressionStream` with `deflate-raw` (before Node 20.12, Chrome or Edge
- *   103, Firefox 113, Safari 16.4). A workbook read without `exceljs` installed throws a
- *   plain `Error` saying what to install.
+ *   103, Firefox 113, Safari 16.4). A workbook read without `exceljs` installed throws
+ *   `PEER_MISSING`, saying what to install.
  */
 declare function readSheetFile(input: SheetFileInput, options?: ReadSheetFileOptions): Promise<SheetFile>;
 /**
@@ -40,4 +38,4 @@ declare function readSheetFile(input: SheetFileInput, options?: ReadSheetFileOpt
  */
 declare function readXlsx(input: SheetFileInput, options?: Omit<ReadSheetFileOptions, 'filename'>): Promise<SheetGrid>;
 
-export { type BrowserLimits, type ReadSheetFileOptions, type SheetFile, type SheetFileInput, readSheetFile, readXlsx };
+export { type BrowserLimits, type ReadSheetFileOptions, type SheetFile, readSheetFile, readXlsx };

package/dist/browser/index.js

@@ -31,127 +31,36 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/shared/import-error.ts
-var STATUS = {
-  NO_FILE: 400,
-  TOO_MANY_FILES: 400,
-  TOO_LARGE: 413,
-  UNSUPPORTED_FORMAT: 415,
-  MALFORMED_FILE: 400,
-  ARCHIVE_REFUSED: 400,
-  SHEET_TOO_LARGE: 413,
-  UNKNOWN_ENTITY: 404,
-  INVALID_PLAN: 400,
-  TIMEOUT: 408,
-  IMPORT_FAILED: 500,
-  // Not an HTTP answer: only the browser reader raises it. 501 if one ever has to be chosen.
-  UNSUPPORTED_RUNTIME: 501,
-  INTERNAL: 500
-};
-var ImportError = class extends Error {
-  code;
-  status;
-  details;
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "ImportError";
-    this.code = code;
-    this.status = STATUS[code] ?? 500;
-    this.details = options.details;
-    if (options.cause !== void 0) this.cause = options.cause;
-  }
-};
-var DEFAULT_LIMITS = {
-  ...sheetToSchema.DEFAULT_GROUP_LIMITS,
-  maxBytes: 10 * 1024 * 1024,
-  maxFields: 16,
-  maxFieldBytes: 1024 * 1024,
-  maxFieldNameBytes: 200,
-  maxFiles: 1,
-  maxRows: 2e5,
-  maxColumns: 512,
-  maxCellLength: 32768,
-  maxUncompressedBytes: 200 * 1024 * 1024,
-  maxCompressionRatio: 200,
-  maxZipEntries: 512,
-  batchSize: 500,
-  maxReportedErrors: 200,
-  sampleRows: 5,
-  idleTimeoutMs: 3e4,
-  totalTimeoutMs: 10 * 6e4
-};
-function resolveLimits(overrides) {
-  const out = { ...DEFAULT_LIMITS };
-  if (!overrides) return out;
-  for (const key of Object.keys(DEFAULT_LIMITS)) {
-    const value = overrides[key];
-    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-      out[key] = Math.floor(value);
-    }
-  }
-  return out;
-}
-
 // src/shared/optional.ts
 var MISSING = /* @__PURE__ */ new Set(["MODULE_NOT_FOUND", "ERR_MODULE_NOT_FOUND"]);
+var quoted = (name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function bundlerMissing(name) {
+  const n = quoted(name);
+  return [
+    new RegExp(`^Could not resolve "${n}" imported by "`),
+    new RegExp(`^Failed to resolve module specifier ['"]${n}['"]`),
+    new RegExp(`^The specifier [\u201C"]${n}[\u201D"] was a bare specifier`),
+    new RegExp(`^Module name, ['"]${n}['"] does not resolve to a valid URL`)
+  ];
+}
 function isMissing(error, name) {
   if (typeof error !== "object" || error === null) return false;
   const { code, message } = error;
-  return MISSING.has(String(code)) && String(message).includes(`'${name}'`);
+  const text = String(message);
+  if (MISSING.has(String(code))) return text.includes(`'${name}'`);
+  return bundlerMissing(name).some((pattern) => pattern.test(text));
 }
 async function loadPeer(entry, name, neededTo, load) {
   try {
     return await load();
   } catch (error) {
     if (!isMissing(error, name)) throw error;
-    throw new Error(
+    throw new sheetToSchema.ImportError(
+      "PEER_MISSING",
       `${entry} needs the "${name}" package to ${neededTo}, and it is not installed. It is an optional peer dependency: run \`npm install ${name}\`.`,
-      { cause: error }
-    );
-  }
-}
-function guardHeaders(headers, limits) {
-  if (headers.length > limits.maxColumns) {
-    throw new ImportError("SHEET_TOO_LARGE", `The sheet has more than ${limits.maxColumns} columns.`);
-  }
-}
-function guardRow(row, seen, width, limits) {
-  if (seen > limits.maxRows) {
-    throw new ImportError("SHEET_TOO_LARGE", `The sheet has more than ${limits.maxRows} rows.`);
-  }
-  if (row.length > limits.maxColumns) {
-    throw new ImportError("SHEET_TOO_LARGE", `Row ${seen + 1} has more than ${limits.maxColumns} columns.`);
-  }
-  for (const cell of row) {
-    if (typeof cell === "string" && cell.length > limits.maxCellLength) {
-      throw new ImportError("SHEET_TOO_LARGE", `A cell in row ${seen + 1} is longer than ${limits.maxCellLength} characters.`);
-    }
-  }
-  return sheetToSchema.padRow(row, width);
-}
-
-// src/shared/sheet-format.ts
-var MAGIC_BYTES = 8;
-var ZIP = [80, 75];
-var OLE2 = [208, 207, 17, 224];
-var UTF16_LE = [255, 254];
-var UTF16_BE = [254, 255];
-var startsWith = (bytes, signature) => signature.every((byte, i) => bytes[i] === byte);
-function detectFormat(head) {
-  if (startsWith(head, ZIP)) return "xlsx";
-  if (startsWith(head, OLE2)) {
-    throw new ImportError(
-      "UNSUPPORTED_FORMAT",
-      "This is a pre-2007 Excel file (.xls). Save it as .xlsx or .csv and try again."
+      { cause: error, details: { peer: name } }
     );
   }
-  if (startsWith(head, UTF16_LE) || startsWith(head, UTF16_BE)) {
-    throw new ImportError(
-      "UNSUPPORTED_FORMAT",
-      "This file is UTF-16 encoded. Save it as UTF-8 CSV and try again."
-    );
-  }
-  return "csv";
 }
 
 // src/shared/xlsx-cells.ts
@@ -273,7 +182,7 @@ function assertDeflateRaw() {
   try {
     new DecompressionStream("deflate-raw");
   } catch (cause) {
-    throw new ImportError("UNSUPPORTED_RUNTIME", UNSUPPORTED_RUNTIME_MESSAGE, { cause });
+    throw new sheetToSchema.ImportError("UNSUPPORTED_RUNTIME", UNSUPPORTED_RUNTIME_MESSAGE, { cause });
   }
 }
 var ignore = () => void 0;
@@ -290,13 +199,13 @@ async function inflate(data, max) {
       size += next.value.length;
       if (size > max) {
         await reader.cancel();
-        throw new ImportError("ARCHIVE_REFUSED", `The workbook inflates to more than the ${max} byte limit.`);
+        throw new sheetToSchema.ImportError("ARCHIVE_REFUSED", `The workbook inflates to more than the ${max} byte limit.`);
       }
       chunks.push(next.value);
     }
   } catch (error) {
-    if (error instanceof ImportError) throw error;
-    throw new ImportError("MALFORMED_FILE", "This is not a readable workbook.", { cause: error });
+    if (error instanceof sheetToSchema.ImportError) throw error;
+    throw new sheetToSchema.ImportError("MALFORMED_FILE", "This is not a readable workbook.", { cause: error });
   }
   return concat(chunks);
 }
@@ -327,7 +236,7 @@ function sheetNumber(name) {
   return match ? Number(match[1]) : null;
 }
 var refuse = (message) => {
-  throw new ImportError("ARCHIVE_REFUSED", message);
+  throw new sheetToSchema.ImportError("ARCHIVE_REFUSED", message);
 };
 var CRC_TABLE = (() => {
   const table = new Int32Array(256);
@@ -369,12 +278,12 @@ var PartPicker = class {
   ordered() {
     if (!this.sheet) {
       if (!this.kept.has("xl/workbook.xml")) {
-        throw new ImportError(
+        throw new sheetToSchema.ImportError(
           "UNSUPPORTED_FORMAT",
           "This is a zip archive that is not an Excel workbook. Upload an .xlsx or .csv file."
         );
       }
-      throw new ImportError("MALFORMED_FILE", "This workbook has no worksheet.");
+      throw new sheetToSchema.ImportError("MALFORMED_FILE", "This workbook has no worksheet.");
     }
     return [...WANTED, this.sheet.name].map((name) => this.kept.get(name)).filter((entry) => entry !== void 0);
   }
@@ -424,7 +333,7 @@ function repack(entries) {
   return out;
 }
 var malformed = () => {
-  throw new ImportError("MALFORMED_FILE", "The workbook could not be read.");
+  throw new sheetToSchema.ImportError("MALFORMED_FILE", "The workbook could not be read.");
 };
 function pickParts(bytes, limits) {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
@@ -490,69 +399,20 @@ function pickParts(bytes, limits) {
 // src/browser/read-sheet-file.ts
 var loadExcel = () => loadPeer("sheet-to-schema/browser", "exceljs", "read .xlsx files", async () => (await Promise.resolve().then(() => __toESM(__require("exceljs")))).default);
 async function readSheetFile(input, options = {}) {
-  const limits = resolveLimits(options.limits);
-  const bytes = await bytesOf(input, limits.maxBytes);
-  const format = detectFormat(bytes.subarray(0, MAGIC_BYTES));
+  const limits = sheetToSchema.resolveLimits(options.limits);
+  const bytes = await sheetToSchema.bytesOf(input, limits.maxBytes, "readSheetFile");
+  const format = sheetToSchema.detectFormat(bytes.subarray(0, sheetToSchema.MAGIC_BYTES));
   if (format === "xlsx") return { format, ...await xlsxGrid(bytes, limits) };
-  return csvGrid(bytes, limits, /\.tsv$/i.test(options.filename ?? "") ? "	" : void 0);
+  return sheetToSchema.csvGrid(bytes, limits, options.filename);
 }
 async function readXlsx(input, options = {}) {
-  const limits = resolveLimits(options.limits);
-  const bytes = await bytesOf(input, limits.maxBytes);
-  if (detectFormat(bytes.subarray(0, MAGIC_BYTES)) !== "xlsx") {
-    throw new ImportError("UNSUPPORTED_FORMAT", "This is not an .xlsx workbook. Read a CSV with readSheetFile.");
+  const limits = sheetToSchema.resolveLimits(options.limits);
+  const bytes = await sheetToSchema.bytesOf(input, limits.maxBytes, "readSheetFile");
+  if (sheetToSchema.detectFormat(bytes.subarray(0, sheetToSchema.MAGIC_BYTES)) !== "xlsx") {
+    throw new sheetToSchema.ImportError("UNSUPPORTED_FORMAT", "This is not an .xlsx workbook. Read a CSV with readSheetFile.");
   }
   return xlsxGrid(bytes, limits);
 }
-var tooLarge = (maxBytes) => {
-  throw new ImportError("TOO_LARGE", `The file is larger than the ${maxBytes} byte limit.`);
-};
-async function bytesOf(input, maxBytes) {
-  if (ArrayBuffer.isView(input)) {
-    if (input.byteLength > maxBytes) tooLarge(maxBytes);
-    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-  }
-  if (Object.prototype.toString.call(input) === "[object ArrayBuffer]") {
-    const buffer = input;
-    if (buffer.byteLength > maxBytes) tooLarge(maxBytes);
-    return new Uint8Array(buffer);
-  }
-  const blob = input;
-  if (blob !== null && typeof blob === "object" && typeof blob.size === "number" && typeof blob.slice === "function") {
-    if (blob.size > maxBytes) tooLarge(maxBytes);
-    return new Uint8Array(await blobBuffer(blob));
-  }
-  throw new TypeError("readSheetFile reads a Blob (such as a File), an ArrayBuffer or a Uint8Array.");
-}
-function blobBuffer(blob) {
-  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(reader.result);
-    reader.onerror = () => reject(reader.error);
-    reader.readAsArrayBuffer(blob);
-  });
-}
-function csvGrid(bytes, limits, forced) {
-  const text = new TextDecoder("utf-8").decode(bytes);
-  const line = sheetToSchema.completeFirstLine(text);
-  if (line === null && text.length > limits.maxCellLength * limits.maxColumns + limits.maxColumns) {
-    throw new ImportError("SHEET_TOO_LARGE", "The header row is longer than any row may be.");
-  }
-  const delimiter = forced ?? sheetToSchema.detectDelimiter(line ?? text);
-  const reader = sheetToSchema.createCsvReader({ delimiter });
-  const { headers, rows } = guardGrid([...reader.push(text), ...reader.end()], limits);
-  return { format: "csv", headers, rows, delimiter };
-}
-function guardGrid(raw, limits) {
-  const iterator = raw[Symbol.iterator]();
-  const first = iterator.next();
-  const headers = first.done ? [] : first.value.map(sheetToSchema.cellText);
-  guardHeaders(headers, limits);
-  const rows = [];
-  for (let next = iterator.next(); !next.done; next = iterator.next()) rows.push(guardRow(next.value, rows.length + 1, headers.length, limits));
-  return { headers, rows };
-}
 async function xlsxGrid(bytes, limits) {
   assertDeflateRaw();
   const parts = pickParts(bytes, limits);
@@ -563,13 +423,13 @@ async function xlsxGrid(bytes, limits) {
   try {
     await workbook.xlsx.load(archive, { ignoreNodes: IGNORED_NODES });
   } catch (error) {
-    throw new ImportError("MALFORMED_FILE", "This is not a readable workbook.", { cause: error });
+    throw new sheetToSchema.ImportError("MALFORMED_FILE", "This is not a readable workbook.", { cause: error });
   }
   const sheet = workbook.worksheets[0];
   if (!sheet || sheet.rowCount === 0) {
-    throw new ImportError("MALFORMED_FILE", "This workbook has no readable rows.");
+    throw new sheetToSchema.ImportError("MALFORMED_FILE", "This workbook has no readable rows.");
   }
-  return guardGrid(sheetRows(sheet, limits), limits);
+  return sheetToSchema.guardGrid(sheetRows(sheet, limits), limits);
 }
 async function withoutFormulas(sheet, limits) {
   const xml = sheet.method === STORED ? sheet.data : await inflate(sheet.data, limits.maxUncompressedBytes);
@@ -604,7 +464,7 @@ function* sheetRows(sheet, limits) {
     const row = sheet.findRow(number);
     if (!row) continue;
     if (number - 1 > limits.maxRows) {
-      throw new ImportError("SHEET_TOO_LARGE", `The sheet has more than ${limits.maxRows} rows.`);
+      throw new sheetToSchema.ImportError("SHEET_TOO_LARGE", `The sheet has more than ${limits.maxRows} rows.`);
     }
     while (expected < number) {
       yield [];
@@ -619,7 +479,10 @@ function* sheetRows(sheet, limits) {
   }
 }
 
-exports.ImportError = ImportError;
+Object.defineProperty(exports, "ImportError", {
+  enumerable: true,
+  get: function () { return sheetToSchema.ImportError; }
+});
 exports.readSheetFile = readSheetFile;
 exports.readXlsx = readXlsx;
 //# sourceMappingURL=index.js.map