keepset 0.37.1 → 0.38.0

package/dist/node/fetch-dataset.js

@@ -1,4 +1,4 @@
-import { $ as ArchiveError, H as getCollectionTarget, L as getOwn, U as getTarget, at as RecipeError, it as NativeParseError, rt as KeepsetError, t as getDataset, z as countTarget } from "../bundled-CRr7GPD3.js";
+import { $ as ArchiveError, H as getCollectionTarget, L as getOwn, U as getTarget, at as RecipeError, it as NativeParseError, rt as KeepsetError, t as getDataset, z as countTarget } from "../bundled-U2l4WT5T.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "crossmap";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -136,34 +136,74 @@ function detect(dataLine) {
 	return dataLine.includes(",") ? "comma" : "whitespace";
 }
 /**
-* Parses a delimited edge list: one edge per line, source and target in the configured columns, after `skipLines` header lines, with blank lines and lines whose first non-blank characters are a comment prefix skipped. A `detect` delimiter is fixed from the first data line. Nodes are the endpoints, in order of first appearance.
+* Reads a line's multiplicity.
+* @param fields - The line's fields.
+* @param column - The multiplicity column.
+* @param lineNumber - The 1-based line, for the error.
+* @returns How many edges the line stands for.
+* @throws NativeParseError when the field is not a whole number.
+*/
+function multiplicity(fields, column, lineNumber) {
+	const value = fields[column]?.trim() ?? "";
+	if (!/^(?:0|[1-9]\d*)$/.test(value)) throw new NativeParseError("edge-list", lineNumber, `column ${String(column)} holds ${JSON.stringify(value)}, which is not a whole number of edges`);
+	return Number(value);
+}
+/**
+* Parses a delimited edge list: one edge per line, source and target in the configured columns, after `skipLines` header lines, with blank lines and lines whose first non-blank characters are a comment prefix skipped. A `detect` delimiter is fixed from the first data line. A recipe that names a `keep` column reads only the lines whose field there is one of its values; one that names a `multiplicityColumn` emits as many edges for a line as the field says, none for a zero; one that says `mirrored` emits each pair of mirror-image lines once. Nodes are the endpoints of the lines read, in order of first appearance.
 * @param text - The file text.
 * @param options - The recipe's edge-list parser.
 * @returns The native graph.
-* @throws NativeParseError naming the line when a data line has too few fields or an empty endpoint, or when the file holds no edges.
+* @throws NativeParseError naming the line when a data line has too few fields, an empty endpoint or a multiplicity that is not a whole number, when a mirrored table has a line without its mirror, or when the file holds no edges.
 */
 function parseEdgeList(text, options) {
 	let split = options.delimiter === "detect" ? void 0 : splitters[options.delimiter];
-	const needed = Math.max(options.sourceColumn, options.targetColumn) + 1;
+	const needed = Math.max(options.sourceColumn, options.targetColumn, options.keep?.column ?? 0, options.multiplicityColumn ?? 0) + 1;
 	const order = new NodeOrder();
 	const edges = [];
-	for (const [index, line] of lines(text).entries()) {
+	const awaiting = /* @__PURE__ */ new Map();
+	const all = lines(text);
+	for (const [index, line] of all.entries()) {
 		const lineNumber = index + 1;
 		const content = line.trimStart();
 		if (index < options.skipLines || content === "" || options.commentPrefixes.some((prefix) => content.startsWith(prefix))) continue;
 		split ??= splitters[detect(line)];
 		const fields = split(line);
 		if (fields.length < needed) throw new NativeParseError("edge-list", lineNumber, `expected at least ${String(needed)} fields, found ${String(fields.length)}`);
+		if (options.keep !== void 0 && !options.keep.values.includes(fields[options.keep.column]?.trim() ?? "")) continue;
 		const source = endpoint$1(fields, options.sourceColumn, lineNumber);
 		const target = endpoint$1(fields, options.targetColumn, lineNumber);
+		const count = options.multiplicityColumn === void 0 ? 1 : multiplicity(fields, options.multiplicityColumn, lineNumber);
+		if (count === 0) continue;
 		order.add(source);
 		order.add(target);
-		edges.push({
+		if (options.mirrored === true && source !== target) {
+			const key = JSON.stringify([
+				source,
+				target,
+				count
+			]);
+			const waiting = awaiting.get(key);
+			if (waiting !== void 0 && waiting.length > 0) {
+				waiting.shift();
+				continue;
+			}
+			const mirror = JSON.stringify([
+				target,
+				source,
+				count
+			]);
+			awaiting.set(mirror, [...awaiting.get(mirror) ?? [], lineNumber]);
+		}
+		for (let copy = 0; copy < count; copy += 1) edges.push({
 			source,
 			target
 		});
 	}
-	if (edges.length === 0) throw new NativeParseError("edge-list", lines(text).length, "the file holds no edges");
+	for (const [key, waiting] of awaiting) {
+		const [first] = waiting;
+		if (first !== void 0) throw new NativeParseError("edge-list", first, `the table is mirrored but this line has no mirror image (${key} is never listed)`);
+	}
+	if (edges.length === 0) throw new NativeParseError("edge-list", all.length, "the file holds no edges");
 	return {
 		nodes: order.nodes(),
 		edges
@@ -384,7 +424,7 @@ const FORMAT$13 = "hgb";
 /** A type code or node id as the HGB files write them: a non-negative decimal integer with no sign or leading zero. */
 const CODE = /^(?:0|[1-9]\d*)$/;
 /** A number as a decimal literal with an optional sign and exponent, so `Number` cannot read hex, an empty string or infinity. */
-const DECIMAL$4 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const DECIMAL$5 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** `node.dat` lines are the id, the name and the type, then the attributes on node types that have them. */
 const NODE_FIELDS = 3;
 const NODE_FIELDS_WITH_ATTRIBUTES = 4;
@@ -456,7 +496,7 @@ function parseHgb(parts, options) {
 			if (actual === void 0) throw new NativeParseError(FORMAT$13, number, `link.dat: the ${end} ${JSON.stringify(id)} is not a node of node.dat`);
 			if (actual !== expected) throw new NativeParseError(FORMAT$13, number, `link.dat: a ${linkType.name} link's ${end} must be a ${expected} node, and ${id} is a ${actual} node`);
 		}
-		if (!DECIMAL$4.test(weight) || Number(weight) !== 1) throw new NativeParseError(FORMAT$13, number, `link.dat: the weight ${JSON.stringify(weight)} is not 1; a weighted HGB file would lose its weights`);
+		if (!DECIMAL$5.test(weight) || Number(weight) !== 1) throw new NativeParseError(FORMAT$13, number, `link.dat: the weight ${JSON.stringify(weight)} is not 1; a weighted HGB file would lose its weights`);
 		edges.push({
 			source,
 			target,
@@ -588,7 +628,7 @@ const COUNT_LINE = /^%\s+(\d+)\s+(\d+)\s+(\d+)\s*$/;
 /** A node id: KONECT numbers nodes from 1. */
 const NODE_ID = /^[1-9]\d*$/;
 /** A number as a decimal literal with an optional sign and exponent, so `Number` cannot read hex, an empty string or infinity. */
-const DECIMAL$3 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const DECIMAL$4 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** The columns of an edge line (handbook section 9.1): the two nodes, then optionally the weight, and the time only when the weight is also given. */
 const ENDPOINT_COLUMNS = 2;
 const WEIGHTED_COLUMNS = 3;
@@ -686,9 +726,9 @@ function readEdge(content, number, context) {
 	const target = endpoint(to, bipartite ? RIGHT_PREFIX : "", header.counts?.right, number);
 	order.add(source);
 	order.add(target);
-	if (third !== void 0 && !options.weighted && (!DECIMAL$3.test(third) || Number(third) !== 1)) throw new NativeParseError(FORMAT$11, number, `the third column ${JSON.stringify(third)} is not 1; an edge that stands for several would be read as one`);
-	if (third !== void 0 && options.weighted && !DECIMAL$3.test(third)) throw new NativeParseError(FORMAT$11, number, `the weight ${JSON.stringify(third)} is not a number`);
-	if (time !== void 0 && !DECIMAL$3.test(time)) throw new NativeParseError(FORMAT$11, number, `the time ${JSON.stringify(time)} is not a number`);
+	if (third !== void 0 && !options.weighted && (!DECIMAL$4.test(third) || Number(third) !== 1)) throw new NativeParseError(FORMAT$11, number, `the third column ${JSON.stringify(third)} is not 1; an edge that stands for several would be read as one`);
+	if (third !== void 0 && options.weighted && !DECIMAL$4.test(third)) throw new NativeParseError(FORMAT$11, number, `the weight ${JSON.stringify(third)} is not a number`);
+	if (time !== void 0 && !DECIMAL$4.test(time)) throw new NativeParseError(FORMAT$11, number, `the time ${JSON.stringify(time)} is not a number`);
 	const edge = {
 		source,
 		target
@@ -808,7 +848,7 @@ const DELIMITERS = {
 	semicolon: ";"
 };
 /** A number as a decimal literal, with an optional sign and exponent. `Number` alone would also accept hex, binary, `Infinity` and the empty string. */
-const DECIMAL$2 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const DECIMAL$3 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** The byte order mark some exporters put before the first header. */
 const BYTE_ORDER_MARK = "";
 /**
@@ -952,7 +992,7 @@ var RecordScanner = class {
 * @returns The records in order, blank lines included as a record of one empty field.
 * @throws NativeParseError when a quoted field is never closed or a quote opens inside an unquoted field.
 */
-function* records(pieces, delimiter, firstLine) {
+function* records$1(pieces, delimiter, firstLine) {
 	const scanner = new RecordScanner(delimiter.charCodeAt(0), firstLine);
 	let carry = "";
 	for (const piece of pieces) {
@@ -971,7 +1011,7 @@ function* records(pieces, delimiter, firstLine) {
 * @throws NativeParseError when a quoted field is never closed or a quote opens inside an unquoted field.
 */
 function csvGrid(text) {
-	return [...records([text], ",", 1)].map((record) => record.fields);
+	return [...records$1([text], ",", 1)].map((record) => record.fields);
 }
 /**
 * Drops the first physical lines of a file given in pieces.
@@ -1020,7 +1060,7 @@ function* withoutByteOrderMark(text) {
 */
 function numeric$1(cell, factor, column, line) {
 	if (cell === "") return null;
-	if (!DECIMAL$2.test(cell)) throw new NativeParseError("csv-table", line, `column ${column} is declared numeric but holds ${JSON.stringify(cell)}`);
+	if (!DECIMAL$3.test(cell)) throw new NativeParseError("csv-table", line, `column ${column} is declared numeric but holds ${JSON.stringify(cell)}`);
 	return Number(cell) * factor;
 }
 /**
@@ -1032,7 +1072,7 @@ function numeric$1(cell, factor, column, line) {
 */
 function* tableRecords(text, options) {
 	const body = afterLines(withoutByteOrderMark(text), options.skipLines);
-	for (const record of records(body, DELIMITERS[options.delimiter], options.skipLines + 1)) if (record.fields.length > 1 || record.fields[0]?.trim() !== "") yield record;
+	for (const record of records$1(body, DELIMITERS[options.delimiter], options.skipLines + 1)) if (record.fields.length > 1 || record.fields[0]?.trim() !== "") yield record;
 }
 /**
 * Parses a delimited table into rows (a cell whose text is one of the recipe's `nullValues` is empty, so null): the first record after `skipLines` lines is the header, each later record is a row, and every row carries every column but the id column (or, when the recipe lists `columns`, exactly those, so a wide table is not held cell for cell), an empty cell being null. Cells are trimmed. A column the recipe declares numeric is read as a decimal number times its factor and any other column stays a string. `id` is the row's id, so a column of that name which is not the id column is named by its position. A row's id is the cell of the recipe's id column, which is then not also a column, or its 1-based row number when the recipe names none. Blank lines are skipped; a row with a different number of fields than the header, two columns with the same name, and an id cell that is empty are errors.
@@ -2543,8 +2583,8 @@ const PREDEFINED = {
 	apos: "'"
 };
 const CODE_POINT = /^#(?:x([0-9A-Fa-f]+)|(\d+))$/;
-const HEXADECIMAL$1 = 16;
-const DECIMAL$1 = 10;
+const HEXADECIMAL$2 = 16;
+const DECIMAL$2 = 10;
 /** The markup that runs from an opening marker to a closing one and holds no elements: comments, CDATA sections and processing instructions. */
 const COMMENT = {
 	open: "<!--",
@@ -2591,7 +2631,7 @@ var XmlReader = class {
 			if (predefined !== void 0) return predefined;
 			const code = CODE_POINT.exec(reference);
 			if (code === null) return this.#fail(index, `the entity ${whole} is not one of the five predefined ones`);
-			return String.fromCodePoint(code[1] === void 0 ? Number.parseInt(code[2] ?? "", DECIMAL$1) : Number.parseInt(code[1], HEXADECIMAL$1));
+			return String.fromCodePoint(code[1] === void 0 ? Number.parseInt(code[2] ?? "", DECIMAL$2) : Number.parseInt(code[1], HEXADECIMAL$2));
 		});
 	}
 	/**
@@ -2839,6 +2879,47 @@ function parseVrpRep(text) {
 	};
 }
 //#endregion
+//#region src/parsers/witvliet-synapses.ts
+/** One chemical synapse of the file: the presynaptic neuron and every neuron it contacts. The file's other fields (CATMAID and VAST ids, the synapse's size and its partners' shares of it) are not read. */
+const SynapseSchema = z.object({
+	pre: z.string().min(1),
+	post: z.array(z.string().min(1)).min(1)
+});
+/**
+* Parses a Witvliet synapse file: a JSON array of chemical synapses, each a `pre` neuron and its `post` partners. A synapse is polyadic, one presynaptic site facing several partners, and each partner is one edge from `pre` to it, so a synapse with three partners is three edges and a partner listed twice is two. Nodes are the neurons in order of first appearance, `pre` before its partners.
+* @param text - The file text.
+* @returns The native graph.
+* @throws NativeParseError, numbering the synapse (from 1) in place of a line, when the text is not JSON, not an array, a synapse lacks its `pre` or `post` or names an empty neuron, or the file holds no synapse.
+*/
+function parseWitvlietSynapses(text) {
+	let document;
+	try {
+		document = JSON.parse(text);
+	} catch (error) {
+		throw new NativeParseError("witvliet-synapses", 1, `the file is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!Array.isArray(document)) throw new NativeParseError("witvliet-synapses", 1, "the file is not a JSON array of synapses");
+	const order = new NodeOrder();
+	const edges = [];
+	for (const [index, item] of document.entries()) {
+		const synapse = SynapseSchema.safeParse(item);
+		if (!synapse.success) throw new NativeParseError("witvliet-synapses", index + 1, `synapse ${String(index + 1)} is not a pre neuron with a non-empty list of post neurons: ${synapse.error.issues.map((issue) => `${issue.path.join(".")} ${issue.message}`).join("; ")}`);
+		order.add(synapse.data.pre);
+		for (const post of synapse.data.post) {
+			order.add(post);
+			edges.push({
+				source: synapse.data.pre,
+				target: post
+			});
+		}
+	}
+	if (edges.length === 0) throw new NativeParseError("witvliet-synapses", 1, "the file holds no synapses");
+	return {
+		nodes: order.nodes(),
+		edges
+	};
+}
+//#endregion
 //#region src/parsers/parse-native.ts
 /** Bytes converted per String.fromCharCode call: spreading a whole file would exceed the engine's argument-count limit, and this many stays well inside every engine's. */
 const LATIN1_CHUNK = 32768;
@@ -2904,6 +2985,7 @@ function parseNative(bytes, parser) {
 	if (parser.format === "gml") return parseGml(text);
 	if (parser.format === "ucinet-dl") return parseUcinetDl(text, parser);
 	if (parser.format === "gd-contest") return parseGdContest(text);
+	if (parser.format === "witvliet-synapses") return parseWitvlietSynapses(text);
 	if (parser.format === "customer-points") return parseCustomerPoints(text);
 	if (parser.format === "solomon") return parseSolomon(text);
 	if (parser.format === "top") return parseTop(text);
@@ -3564,23 +3646,10 @@ function readTar(bytes) {
 	return members;
 }
 //#endregion
-//#region src/node/xlsx.ts
-const HEXADECIMAL = 16;
-const DECIMAL = 10;
-const LETTERS = 26;
-const FIRST_LETTER = "A".charCodeAt(0);
-const SECONDS_PER_DAY = 86400;
-const MILLISECONDS = 1e3;
-/** The serial number Excel gives its 29th of February 1900, a day that never existed: serials above it count from 30 December 1899 and serials below it from 31 December 1899. */
-const LEAP_BUG_SERIAL = 60;
-/** The day a serial number counts from: 1 January 1904 in a workbook that says so, otherwise 31 December 1899 for the serials before Excel's false 29th of February 1900 and 30 December 1899 for those after it. */
-const EPOCH_1904 = "1904-01-01T00:00:00Z";
-const EPOCH_BEFORE_LEAP_BUG = "1899-12-31T00:00:00Z";
-const EPOCH_AFTER_LEAP_BUG = "1899-12-30T00:00:00Z";
-const DATE_LENGTH = 10;
-const DATE_TIME_LENGTH = 19;
-const SECONDS_PER_MINUTE = 60;
-const MINUTES_PER_HOUR = 60;
+//#region src/node/xml-part.ts
+/** Helpers shared by the readers of spreadsheet formats that store their parts as XML (xlsx and OpenDocument): they read the flat, namespace-prefixed markup those parts are written in, without building a tree. */
+const HEXADECIMAL$1 = 16;
+const DECIMAL$1 = 10;
 /**
 * Replaces the XML entities and character references of a text.
 * @param text - Escaped text.
@@ -3588,8 +3657,8 @@ const MINUTES_PER_HOUR = 60;
 */
 function unescape(text) {
 	return text.replaceAll(/&(#x[0-9A-Fa-f]+|#[0-9]+|amp|lt|gt|quot|apos);/g, (_whole, entity) => {
-		if (entity.startsWith("#x")) return String.fromCodePoint(Number.parseInt(entity.slice(2), HEXADECIMAL));
-		if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), DECIMAL));
+		if (entity.startsWith("#x")) return String.fromCodePoint(Number.parseInt(entity.slice(2), HEXADECIMAL$1));
+		if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), DECIMAL$1));
 		return {
 			amp: "&",
 			lt: "<",
@@ -3618,16 +3687,156 @@ function attributesOf(tag) {
 function elements(xml, name) {
 	return [...xml.matchAll(new RegExp(`<${name}(?=[\\s/>])([^>]*)>`, "g"))].map((match) => attributesOf(match[1] ?? ""));
 }
+//#endregion
+//#region src/node/ods.ts
+/** The part of an OpenDocument spreadsheet that holds its tables ([ODF 1.3] part 2, 3.1.3). */
+const CONTENT_PART = "content.xml";
+const DECIMAL = 10;
+const SECONDS_PER_MINUTE$1 = 60;
+const MINUTES_PER_HOUR$1 = 60;
+/** An `office:time-value`, an ISO 8601 duration of hours, minutes and seconds such as `PT13H05M00S` (the form spreadsheet applications write for a time of day, [ODF 1.3] part 3, 19.389). */
+const TIME_VALUE = /^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?$/;
+/** The value types whose value is the number in `office:value` ([ODF 1.3] part 3, 19.387). */
+const NUMERIC_TYPES = /* @__PURE__ */ new Set([
+	"float",
+	"percentage",
+	"currency"
+]);
 /**
-* The strings of a workbook's shared string table, in index order: each item's text runs joined, the phonetic runs of East Asian text left out.
-* @param xml - The `sharedStrings.xml` text.
-* @returns The strings.
+* The text of a cell's paragraphs, as a spreadsheet shows it: paragraphs joined by line breaks, `text:s` as its count of spaces, `text:tab` as a tab and `text:line-break` as a line break, the text of spans and links kept and annotations left out.
+* @param body - The XML between the cell's start and end tags.
+* @param row - The 1-based row, for the error.
+* @returns The text.
+* @throws ArchiveError when a run of spaces states a count that is not a positive whole number.
 */
-function sharedStrings(xml) {
-	return [...xml.matchAll(/<si(?:\s[^>]*)?>([\s\S]*?)<\/si>/g)].map((item) => {
-		return [...(item[1] ?? "").replaceAll(/<rPh[\s\S]*?<\/rPh>/g, "").matchAll(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g)].map((text) => unescape(text[1] ?? "")).join("");
-	});
+function cellText(body, row) {
+	const paragraphs = [];
+	for (const paragraph of body.replaceAll(/<office:annotation[\s>][\s\S]*?<\/office:annotation>/g, "").matchAll(/<text:(?:p|h)(?=[\s/>])[^>]*?(?:\/>|>([\s\S]*?)<\/text:(?:p|h)>)/g)) {
+		const inner = (paragraph[1] ?? "").replaceAll(/<text:s(?=[\s/>])([^>]*?)\/?>/g, (_whole, attributes) => " ".repeat(repeats(attributesOf(attributes), "text:c", row))).replaceAll(/<text:tab(?=[\s/>])[^>]*?\/?>/g, "	").replaceAll(/<text:line-break(?=[\s/>])[^>]*?\/?>/g, "\n").replaceAll(/<[^>]*>/g, "");
+		paragraphs.push(unescape(inner));
+	}
+	return paragraphs.join("\n");
 }
+/**
+* A time value as the clock text the xlsx reader gives a time alone, `hh:mm:ss`, with the seconds rounded to whole seconds and an hour count past a day kept as it stands.
+* @param duration - The `office:time-value`.
+* @param row - The 1-based row, for the error.
+* @returns The text.
+* @throws ArchiveError when the value is not an hours, minutes and seconds duration.
+*/
+function timeText(duration, row) {
+	const match = TIME_VALUE.exec(duration);
+	if (match === null) throw new ArchiveError(`row ${String(row)} has a time cell holding ${duration}, which is not a duration of hours, minutes and seconds`);
+	const total = Math.round(Number.parseInt(match[1] ?? "0", DECIMAL) * MINUTES_PER_HOUR$1 * SECONDS_PER_MINUTE$1 + Number.parseInt(match[2] ?? "0", DECIMAL) * SECONDS_PER_MINUTE$1 + Number(match[3] ?? "0"));
+	return [
+		Math.floor(total / 3600),
+		Math.floor(total / SECONDS_PER_MINUTE$1) % MINUTES_PER_HOUR$1,
+		total % SECONDS_PER_MINUTE$1
+	].map((part) => String(part).padStart(2, "0")).join(":");
+}
+/**
+* The text a cell gives the CSV, by its value type: the stored number for a number, percentage or currency, the stored ISO 8601 date (or date and time) for a date, `hh:mm:ss` for a time, TRUE or FALSE for a boolean, the shown text for a string or an error, and nothing for a cell with no value.
+* @param attributes - The cell's attributes.
+* @param body - The XML between its tags.
+* @param row - The 1-based row, for errors.
+* @returns The text, empty for no value.
+* @throws ArchiveError when a typed cell lacks the attribute its type stores its value in.
+*/
+function valueText(attributes, body, row) {
+	const type = attributes["office:value-type"];
+	const stored = (name) => {
+		const value = attributes[name];
+		if (value === void 0) throw new ArchiveError(`row ${String(row)} has a ${type ?? ""} cell with no ${name}`);
+		return value;
+	};
+	if (type === void 0 || type === "string" || attributes["calcext:value-type"] === "error") return cellText(body, row);
+	if (NUMERIC_TYPES.has(type)) return stored("office:value");
+	if (type === "date") return stored("office:date-value");
+	if (type === "time") return timeText(stored("office:time-value"), row);
+	if (type === "boolean") return stored("office:boolean-value") === "true" ? "TRUE" : "FALSE";
+	throw new ArchiveError(`row ${String(row)} has a cell of value type ${type}, which OpenDocument does not define`);
+}
+/**
+* How many times a row or cell repeats.
+* @param attributes - Its attributes.
+* @param name - The repeat attribute, which is absent for an element that appears once.
+* @param row - The 1-based row, for the error.
+* @returns The count, at least one.
+* @throws ArchiveError when the attribute is not a positive whole number.
+*/
+function repeats(attributes, name, row) {
+	const stated = attributes[name];
+	if (stated === void 0) return 1;
+	if (!/^[1-9]\d*$/.test(stated)) throw new ArchiveError(`row ${String(row)} states ${name} as ${stated}, which is not a positive whole number`);
+	return Number(stated);
+}
+/**
+* Reads one table of an OpenDocument spreadsheet (`.ods`, a zip of XML parts) as the same text the xlsx reader gives (see `valueText`). A cell or row repeated by `table:number-columns-repeated` or `table:number-rows-repeated` is written as often as it repeats when it holds a value; an empty one only moves the position on, so the filler an application writes to the end of the sheet costs nothing. A covered cell (the hidden part of a merged range) is an empty cell.
+* @param bytes - The spreadsheet.
+* @param sheet - The table's name.
+* @returns The table's cells.
+* @throws ArchiveError when the bytes are not an OpenDocument spreadsheet, the table is missing, or a cell is malformed.
+*/
+function odsGrid(bytes, sheet) {
+	let content;
+	try {
+		content = getOwn(unzipSync(bytes, { filter: (file) => file.name === CONTENT_PART }), CONTENT_PART);
+	} catch (error) {
+		throw new ArchiveError(`not a valid OpenDocument spreadsheet: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	if (content === void 0) throw new ArchiveError(`the file is not an OpenDocument spreadsheet: it has no ${CONTENT_PART}`);
+	const xml = new TextDecoder("utf-8", { fatal: true }).decode(content);
+	const names = [];
+	let table;
+	for (const match of xml.matchAll(/<table:table(?=[\s>])([^>]*)>([\s\S]*?)<\/table:table>/g)) {
+		const name = attributesOf(match[1] ?? "")["table:name"] ?? "";
+		names.push(name);
+		if (name === sheet) {
+			table = match[2] ?? "";
+			break;
+		}
+	}
+	if (table === void 0) throw new ArchiveError(`the spreadsheet has no table ${sheet}; it has ${names.join(", ")}`);
+	const rows = /* @__PURE__ */ new Map();
+	let width = 0;
+	let next = 1;
+	for (const row of table.matchAll(/<table:table-row(?=[\s/>])([^>]*?)(?:\/>|>([\s\S]*?)<\/table:table-row>)/g)) {
+		const repeated = repeats(attributesOf(row[1] ?? ""), "table:number-rows-repeated", next);
+		const cells = [];
+		let column = 0;
+		for (const cell of (row[2] ?? "").matchAll(/<table:(?:covered-)?table-cell(?=[\s/>])([^>]*?)(?:\/>|>([\s\S]*?)<\/table:(?:covered-)?table-cell>)/g)) {
+			const attributes = attributesOf(cell[1] ?? "");
+			const span = repeats(attributes, "table:number-columns-repeated", next);
+			const text = valueText(attributes, cell[2] ?? "", next);
+			if (text !== "") {
+				for (let copy = 0; copy < span; copy += 1) cells[column + copy] = text;
+				width = Math.max(width, column + span);
+			}
+			column += span;
+		}
+		if (cells.length > 0) for (let copy = 0; copy < repeated; copy += 1) rows.set(next + copy, cells);
+		next += repeated;
+	}
+	return {
+		rows,
+		width
+	};
+}
+//#endregion
+//#region src/node/sheet.ts
+/** What the spreadsheet readers (`xlsx`, `xls` and `ods`) share: the date arithmetic of the Excel serial number, the test for a number format that shows a date, and the CSV a sheet is written as, so the three formats give the table parser the same text for the same cells. */
+const SECONDS_PER_DAY = 86400;
+const MILLISECONDS = 1e3;
+/** The serial number Excel gives its 29th of February 1900, a day that never existed: serials above it count from 30 December 1899 and serials below it from 31 December 1899. */
+const LEAP_BUG_SERIAL = 60;
+/** The day a serial number counts from: 1 January 1904 in a workbook that says so, otherwise 31 December 1899 for the serials before Excel's false 29th of February 1900 and 30 December 1899 for those after it. */
+const EPOCH_1904 = "1904-01-01T00:00:00Z";
+const EPOCH_BEFORE_LEAP_BUG = "1899-12-31T00:00:00Z";
+const EPOCH_AFTER_LEAP_BUG = "1899-12-30T00:00:00Z";
+const DATE_LENGTH = 10;
+const DATE_TIME_LENGTH = 19;
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_HOUR = 60;
 /** The built-in number format ids that show a date or a time, as inclusive ranges (ECMA-376, 18.8.30): the short and long dates and times, the locale dates, and the elapsed and minute times. */
 const BUILT_IN_DATE_FORMATS = [
 	{
@@ -3656,24 +3865,6 @@ function isDateFormat(code) {
 	return /[ymdhs]/i.test(code.replaceAll(/"[^"]*"|\\.|\[[^\]]*\]/g, ""));
 }
 /**
-* Which cell styles show dates, by the style's index.
-* @param xml - The `styles.xml` text, or undefined when the workbook has none.
-* @returns The style indexes whose number format is a date or a time.
-*/
-function dateStyles(xml) {
-	if (xml === void 0) return /* @__PURE__ */ new Set();
-	const custom = /* @__PURE__ */ new Map();
-	for (const format of elements(xml, "numFmt")) if (format["numFmtId"] !== void 0 && format["formatCode"] !== void 0) custom.set(Number(format["numFmtId"]), format["formatCode"]);
-	const cellFormats = /<cellXfs(?:\s[^>]*)?>([\s\S]*?)<\/cellXfs>/.exec(xml)?.[1] ?? "";
-	const styles = /* @__PURE__ */ new Set();
-	for (const [index, format] of elements(cellFormats, "xf").entries()) {
-		const id = Number(format["numFmtId"] ?? "0");
-		const code = custom.get(id);
-		if (code === void 0 ? BUILT_IN_DATE_FORMATS.some((range) => id >= range.first && id <= range.last) : isDateFormat(code)) styles.add(index);
-	}
-	return styles;
-}
-/**
 * A date serial number as ISO 8601 text: a date when it has no time of day, a date and time when it has, and a time alone for a serial below one day in a 1900 workbook.
 * @param serial - The serial number, with the time of day as its fraction.
 * @param date1904 - Whether the workbook counts days from 1 January 1904.
@@ -3692,6 +3883,630 @@ function isoOf(serial, date1904) {
 	return new Date(Date.parse(date1904 ? EPOCH_1904 : whole < LEAP_BUG_SERIAL ? EPOCH_BEFORE_LEAP_BUG : EPOCH_AFTER_LEAP_BUG) + (whole * SECONDS_PER_DAY + seconds) * MILLISECONDS).toISOString().slice(0, seconds === 0 ? DATE_LENGTH : DATE_TIME_LENGTH);
 }
 /**
+* Writes a sheet's cells as CSV text, so a recipe reads every spreadsheet format with the table parser: one line for every row number from the first to the last row that holds a value (a row with no value before it is an empty line, so the lines above the header are the rows an editor shows, and the formatted but empty rows a sheet carries after its data are left out), every line the width of the widest row.
+* @param grid - The sheet's cells.
+* @returns The CSV, in UTF-8.
+*/
+function gridToCsv(grid) {
+	let last = 0;
+	for (const [number, cells] of grid.rows) if (cells.length > 0) last = Math.max(last, number);
+	const lines = [];
+	for (let number = 1; number <= last; number += 1) {
+		const cells = grid.rows.get(number) ?? [];
+		lines.push(Array.from({ length: grid.width }, (_empty, column) => csvField(cells[column] ?? "")).join(","));
+	}
+	return new TextEncoder().encode(lines.length === 0 ? "" : `${lines.join("\n")}\n`);
+}
+//#endregion
+//#region src/node/cfb.ts
+/** The signature every Compound File Binary file opens with ([MS-CFB] 2.2), the bytes D0 CF 11 E0 A1 B1 1A E1 read as one little-endian 64-bit number. */
+const SIGNATURE = 16220472316735377360n;
+const HEADER_BYTES = 512;
+/** The sector numbers that mark the end of a chain and a free sector; every regular sector number is below the first of them ([MS-CFB] 2.1). */
+const MAX_REGULAR_SECTOR = 4294967290;
+const END_OF_CHAIN = 4294967294;
+const FREE_SECTOR = 4294967295;
+/** The sibling or child id that names no directory entry. */
+const NO_STREAM = 4294967295;
+/** The DIFAT entries the header holds before the first DIFAT sector. */
+const HEADER_DIFAT_ENTRIES = 109;
+const HEADER_DIFAT_OFFSET = 76;
+const DIRECTORY_ENTRY_BYTES = 128;
+const DIRECTORY_NAME_BYTES = 64;
+const ENTRY_BYTES = 4;
+const STREAM_OBJECT = 2;
+const ROOT_OBJECT = 5;
+/** The header fields this reader uses, by byte offset ([MS-CFB] 2.2). */
+const FIELD = {
+	sectorShift: 30,
+	miniSectorShift: 32,
+	fatSectors: 44,
+	firstDirectorySector: 48,
+	miniStreamCutoff: 56,
+	firstMiniFatSector: 60,
+	miniFatSectors: 64,
+	firstDifatSector: 68,
+	difatSectors: 72
+};
+/** The directory entry fields this reader uses, by byte offset within the entry ([MS-CFB] 2.6.1). */
+const ENTRY = {
+	nameLength: 64,
+	type: 66,
+	left: 68,
+	right: 72,
+	child: 76,
+	start: 116,
+	size: 120
+};
+/** The sector sizes the format allows, as their power of two: 512 bytes for a version 3 file, 4096 for version 4. */
+const SECTOR_SHIFTS = {
+	version3: 9,
+	version4: 12
+};
+const MINI_SECTOR_SHIFT = 6;
+/**
+* Reads a stream that lives at the root of a Compound File Binary file (the container of the legacy Office formats, an xls workbook among them), following its sector chain in the file allocation table, or in the mini stream when it is shorter than the file's cutoff.
+* @param bytes - The file.
+* @param name - The stream's name, compared without regard to case as the format compares names.
+* @returns The stream's bytes, or undefined when the root storage holds no stream of that name.
+* @throws ArchiveError when the bytes are not a compound file, or a header field, a sector chain or a directory entry is malformed.
+*/
+function readRootStream(bytes, name) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (bytes.length < HEADER_BYTES || view.getBigUint64(0, true) !== SIGNATURE) throw new ArchiveError("the file is not a compound file: it does not open with the compound file signature");
+	const u32 = (offset) => view.getUint32(offset, true);
+	const sectorShift = view.getUint16(FIELD.sectorShift, true);
+	if (sectorShift !== SECTOR_SHIFTS.version3 && sectorShift !== SECTOR_SHIFTS.version4 || view.getUint16(FIELD.miniSectorShift, true) !== MINI_SECTOR_SHIFT) throw new ArchiveError(`the compound file states a sector size of 2^${String(sectorShift)} bytes, which the format does not allow`);
+	const sectorBytes = 2 ** sectorShift;
+	const sectorCount = Math.floor((bytes.length - sectorBytes) / sectorBytes) + 1;
+	const sector = (index) => {
+		if (index >= MAX_REGULAR_SECTOR || index >= sectorCount) throw new ArchiveError(`the compound file names sector ${String(index)}, which it does not have`);
+		const start = (index + 1) * sectorBytes;
+		return bytes.subarray(start, Math.min(start + sectorBytes, bytes.length));
+	};
+	const fatSectors = [];
+	for (let index = 0; index < HEADER_DIFAT_ENTRIES; index += 1) fatSectors.push(u32(HEADER_DIFAT_OFFSET + index * ENTRY_BYTES));
+	const perDifatSector = sectorBytes / ENTRY_BYTES - 1;
+	let difat = u32(FIELD.firstDifatSector);
+	for (let read = 0; read < u32(FIELD.difatSectors); read += 1) {
+		const difatSector = sector(difat);
+		const entries = new DataView(difatSector.buffer, difatSector.byteOffset, difatSector.byteLength);
+		for (let index = 0; index < perDifatSector; index += 1) fatSectors.push(entries.getUint32(index * ENTRY_BYTES, true));
+		difat = entries.getUint32(perDifatSector * ENTRY_BYTES, true);
+	}
+	const fat = concatenateEntries(fatSectors.slice(0, u32(FIELD.fatSectors)).map(sector));
+	const fatLimit = Math.min(fat.length, sectorCount);
+	const chain = (start, table, limit) => {
+		const sectors = [];
+		let current = start;
+		while (current !== END_OF_CHAIN) {
+			const next = table[current];
+			if (current >= limit || next === void 0 || sectors.length >= limit) throw new ArchiveError(`a sector chain of the compound file runs to ${current === FREE_SECTOR ? "a free sector" : `sector ${String(current)}`} instead of ending`);
+			sectors.push(current);
+			current = next;
+		}
+		return sectors;
+	};
+	const regularStream = (start, size) => {
+		const joined = concatenate(chain(start, fat, fatLimit).map(sector));
+		if (joined.length < size) throw new ArchiveError(`a stream of the compound file states ${String(size)} bytes but its sectors hold ${String(joined.length)}`);
+		return joined.subarray(0, size);
+	};
+	const directory = concatenate(chain(u32(FIELD.firstDirectorySector), fat, fatLimit).map(sector));
+	const entry = (id) => {
+		const offset = id * DIRECTORY_ENTRY_BYTES;
+		if (offset + DIRECTORY_ENTRY_BYTES > directory.length) throw new ArchiveError(`the compound file names directory entry ${String(id)}, which it does not have`);
+		const fields = new DataView(directory.buffer, directory.byteOffset + offset, DIRECTORY_ENTRY_BYTES);
+		const nameLength = fields.getUint16(ENTRY.nameLength, true);
+		if (nameLength > DIRECTORY_NAME_BYTES || nameLength % 2 !== 0) throw new ArchiveError(`directory entry ${String(id)} of the compound file states a name of ${String(nameLength)} bytes`);
+		return {
+			name: new TextDecoder("utf-16le").decode(directory.subarray(offset, offset + Math.max(0, nameLength - 2))),
+			type: fields.getUint8(ENTRY.type),
+			left: fields.getUint32(ENTRY.left, true),
+			right: fields.getUint32(ENTRY.right, true),
+			child: fields.getUint32(ENTRY.child, true),
+			start: fields.getUint32(ENTRY.start, true),
+			size: fields.getUint32(ENTRY.size, true)
+		};
+	};
+	const root = entry(0);
+	if (root.type !== ROOT_OBJECT) throw new ArchiveError("the first directory entry of the compound file is not its root storage");
+	const wanted = name.toUpperCase();
+	const pending = root.child === NO_STREAM ? [] : [root.child];
+	const visited = /* @__PURE__ */ new Set();
+	let found;
+	while (pending.length > 0 && found === void 0) {
+		const id = pending.pop();
+		if (id === void 0 || visited.has(id)) throw new ArchiveError("the directory tree of the compound file has a cycle");
+		visited.add(id);
+		const candidate = entry(id);
+		if (candidate.type === STREAM_OBJECT && candidate.name.toUpperCase() === wanted) found = candidate;
+		for (const sibling of [candidate.left, candidate.right]) if (sibling !== NO_STREAM) pending.push(sibling);
+	}
+	if (found === void 0) return;
+	if (found.size >= u32(FIELD.miniStreamCutoff)) return regularStream(found.start, found.size);
+	const miniStream = regularStream(root.start, root.size);
+	const miniFat = u32(FIELD.miniFatSectors) === 0 ? /* @__PURE__ */ new Uint32Array() : concatenateEntries(chain(u32(FIELD.firstMiniFatSector), fat, fatLimit).map(sector));
+	const miniBytes = 2 ** MINI_SECTOR_SHIFT;
+	const joined = concatenate(chain(found.start, miniFat, Math.min(miniFat.length, Math.floor(miniStream.length / miniBytes))).map((index) => miniStream.subarray(index * miniBytes, (index + 1) * miniBytes)));
+	if (joined.length < found.size) throw new ArchiveError(`a stream of the compound file states ${String(found.size)} bytes but its mini sectors hold ${String(joined.length)}`);
+	return joined.subarray(0, found.size);
+}
+/**
+* Joins byte runs.
+* @param parts - The runs, in order.
+* @returns One array holding them all.
+*/
+function concatenate(parts) {
+	const joined = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+	let offset = 0;
+	for (const part of parts) {
+		joined.set(part, offset);
+		offset += part.length;
+	}
+	return joined;
+}
+/**
+* Reads sectors of an allocation table as one list of little-endian 32-bit entries.
+* @param sectors - The table's sectors, in order.
+* @returns The entries.
+*/
+function concatenateEntries(sectors) {
+	const joined = concatenate(sectors);
+	const view = new DataView(joined.buffer, joined.byteOffset, joined.byteLength);
+	return Uint32Array.from({ length: Math.floor(joined.length / ENTRY_BYTES) }, (_unused, index) => view.getUint32(index * ENTRY_BYTES, true));
+}
+//#endregion
+//#region src/node/xls.ts
+/** The BIFF record types this reader acts on ([MS-XLS] 2.3), by name. */
+const RECORD = {
+	bof: 2057,
+	eof: 10,
+	filePass: 47,
+	dateMode: 34,
+	format: 1054,
+	xf: 224,
+	boundSheet: 133,
+	sst: 252,
+	continue: 60,
+	labelSst: 253,
+	label: 516,
+	richString: 214,
+	number: 515,
+	rk: 638,
+	mulRk: 189,
+	boolErr: 517,
+	formula: 6,
+	string: 519,
+	array: 545,
+	sharedFormula: 1212,
+	table: 566
+};
+/** The records that may stand between a formula and the STRING record holding its text result: the array, shared formula or data table the formula belongs to ([MS-XLS] 2.1.7.20.6, the CELL rule). */
+const FORMULA_COMPANIONS = /* @__PURE__ */ new Set([
+	RECORD.array,
+	RECORD.sharedFormula,
+	RECORD.table
+]);
+/** The BOF version of a BIFF8 stream, the format of Excel 97 to 2003; earlier BIFF versions store text in a code page and lay their records out differently. */
+const BIFF8 = 1536;
+const RECORD_HEADER_BYTES = 4;
+/** The widths of the unsigned integers a string's header holds. */
+const U8 = 1;
+const U16 = 2;
+const U32 = 4;
+/** The flag bits of a BIFF8 Unicode string ([MS-XLS] 2.5.293 and 2.5.294): two-byte characters, phonetic data after the runs, and formatting runs. */
+const HIGH_BYTE = 1;
+const EXTENDED = 4;
+const RICH = 8;
+const FORMATTING_RUN_BYTES = 4;
+/** A FORMULA record's cached result is not a number when its last two bytes are all ones; its first byte then says what it is ([MS-XLS] 2.5.133). */
+const NON_NUMERIC_RESULT = 65535;
+const FORMULA_RESULT = {
+	string: 0,
+	boolean: 1,
+	error: 2,
+	empty: 3
+};
+/** The error values a cell can hold, with the code BIFF stores for each ([MS-XLS] 2.5.97.2). */
+const ERRORS = [
+	{
+		code: 0,
+		text: "#NULL!"
+	},
+	{
+		code: 7,
+		text: "#DIV/0!"
+	},
+	{
+		code: 15,
+		text: "#VALUE!"
+	},
+	{
+		code: 23,
+		text: "#REF!"
+	},
+	{
+		code: 29,
+		text: "#NAME?"
+	},
+	{
+		code: 36,
+		text: "#NUM!"
+	},
+	{
+		code: 42,
+		text: "#N/A"
+	},
+	{
+		code: 43,
+		text: "#GETTING_DATA"
+	}
+];
+const HEXADECIMAL = 16;
+/** The byte offsets of the fields this reader uses: a cell record's style after its row and column, the unique string count in the SST header, and the high half of a double, little-endian. */
+const STYLE_OFFSET = 4;
+const SST_UNIQUE_OFFSET = 4;
+const DOUBLE_HIGH_HALF = 4;
+/** An RK number's flags ([MS-XLS] 2.5.217): its value is a hundredth of what is stored, and what is stored is a signed integer rather than the high bits of a double. */
+const RK_HUNDREDTHS = 1;
+const RK_INTEGER = 2;
+const HUNDRED = 100;
+const RK_INTEGER_SHIFT = 2;
+const RK_DOUBLE_MASK = 4294967292;
+const MULRK_ENTRY_BYTES = 6;
+/** A MULRK's row and first column before its values, and its last column after them. */
+const MULRK_FIRST_ENTRY = 4;
+const MULRK_FIXED_BYTES = 6;
+/** A cell record's row, column and cell style, the first six bytes of every cell record. */
+const CELL_HEADER_BYTES = 6;
+const DOUBLE_BYTES = 8;
+const BOOLERR_VALUE_OFFSET = 6;
+const BOOLERR_KIND_OFFSET = 7;
+const SHEET_NAME_OFFSET = 6;
+const SST_STRINGS_OFFSET = 8;
+/** The records that hold a cell's value; a BLANK or MULBLANK holds only a style, so an empty cell, and is not among them. */
+const CELL_RECORDS = /* @__PURE__ */ new Set([
+	RECORD.labelSst,
+	RECORD.label,
+	RECORD.richString,
+	RECORD.number,
+	RECORD.rk,
+	RECORD.mulRk,
+	RECORD.boolErr,
+	RECORD.formula
+]);
+/**
+* A boolean cell's text.
+* @param value - The stored byte: zero for false.
+* @returns TRUE or FALSE, as the xlsx reader writes them.
+*/
+function booleanText(value) {
+	return value === 0 ? "FALSE" : "TRUE";
+}
+/**
+* An error cell's text.
+* @param code - The stored error code.
+* @param row - The 0-based row, for the error.
+* @returns The error as a spreadsheet shows it, such as `#N/A`.
+* @throws ArchiveError for a code BIFF does not define.
+*/
+function errorText(code, row) {
+	const text = ERRORS.find((error) => error.code === code)?.text;
+	if (text === void 0) throw new ArchiveError(`row ${String(row + 1)} holds the error code 0x${code.toString(HEXADECIMAL)}, which BIFF does not define`);
+	return text;
+}
+/**
+* Splits a BIFF stream into records.
+* @param stream - The stream, or the part of it from a substream's BOF.
+* @returns The records, in order.
+* @throws ArchiveError when a record runs past the end of the stream.
+*/
+function* records(stream) {
+	const view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+	for (let offset = 0; offset + RECORD_HEADER_BYTES <= stream.length;) {
+		const type = view.getUint16(offset, true);
+		const length = view.getUint16(offset + 2, true);
+		const start = offset + RECORD_HEADER_BYTES;
+		if (start + length > stream.length) throw new ArchiveError(`the workbook's record of type 0x${type.toString(HEXADECIMAL)} at byte ${String(offset)} runs past the end of its stream`);
+		const body = stream.subarray(start, start + length);
+		yield {
+			type,
+			body,
+			view: new DataView(body.buffer, body.byteOffset, body.byteLength)
+		};
+		offset = start + length;
+	}
+}
+/** Reads the characters of BIFF8 strings across a record and the CONTINUE records after it: a string whose characters cross into a CONTINUE record starts that record with a fresh flag byte saying how wide the rest of its characters are, while the other parts of a string cross without one ([MS-XLS] 2.5.293). */
+var StringReader = class {
+	parts;
+	part = 0;
+	offset;
+	constructor(parts, start) {
+		this.parts = parts;
+		this.offset = start;
+	}
+	/** @returns The current part, moving to the next one when the current one is spent. */
+	current() {
+		let body = this.parts[this.part];
+		while (body !== void 0 && this.offset >= body.length) {
+			this.part += 1;
+			this.offset = 0;
+			body = this.parts[this.part];
+		}
+		if (body === void 0) throw new ArchiveError("a string of the workbook runs past the end of its records");
+		return body;
+	}
+	/**
+	* Reads bytes that are not characters, which may cross from one part to the next.
+	* @param count - How many.
+	* @returns The bytes.
+	*/
+	bytes(count) {
+		const out = new Uint8Array(count);
+		for (let filled = 0; filled < count;) {
+			const body = this.current();
+			const taken = Math.min(count - filled, body.length - this.offset);
+			out.set(body.subarray(this.offset, this.offset + taken), filled);
+			filled += taken;
+			this.offset += taken;
+		}
+		return out;
+	}
+	/**
+	* Reads a little-endian unsigned integer.
+	* @param width - Its width in bytes.
+	* @returns The integer.
+	*/
+	uint(width) {
+		const raw = this.bytes(width);
+		const view = new DataView(raw.buffer);
+		return width === U8 ? view.getUint8(0) : width === U16 ? view.getUint16(0, true) : view.getUint32(0, true);
+	}
+	/**
+	* Reads characters, taking a fresh flag byte at the start of each later part they cross into.
+	* @param count - How many characters.
+	* @param high - Whether the characters start as two bytes each.
+	* @returns The text.
+	*/
+	characters(count, high) {
+		let text = "";
+		let wide = high;
+		for (let left = count; left > 0;) {
+			let body = this.parts[this.part];
+			if (body !== void 0 && this.offset >= body.length) {
+				this.part += 1;
+				this.offset = 0;
+				wide = (this.uint(U8) & HIGH_BYTE) !== 0;
+			}
+			body = this.current();
+			const width = wide ? 2 : 1;
+			const taken = Math.min(left, Math.floor((body.length - this.offset) / width));
+			if (taken === 0) throw new ArchiveError("a character of a workbook string is split across two records");
+			const run = body.subarray(this.offset, this.offset + taken * width);
+			text += wide ? new TextDecoder("utf-16le").decode(run) : String.fromCharCode(...run);
+			this.offset += taken * width;
+			left -= taken;
+		}
+		return text;
+	}
+	/**
+	* Reads one string: its character count (one or two bytes wide), its flags, the counts of any formatting runs and phonetic data, its characters, and then skips the runs and the phonetic data.
+	* @param countWidth - The width of its character count.
+	* @returns The text.
+	*/
+	string(countWidth) {
+		this.current();
+		const count = this.uint(countWidth);
+		const flags = this.uint(U8);
+		const runs = (flags & RICH) === 0 ? 0 : this.uint(U16);
+		const extended = (flags & EXTENDED) === 0 ? 0 : this.uint(U32);
+		const text = this.characters(count, (flags & HIGH_BYTE) !== 0);
+		this.bytes(runs * FORMATTING_RUN_BYTES + extended);
+		return text;
+	}
+};
+/**
+* Reads the workbook globals substream, up to its EOF.
+* @param stream - The Workbook stream.
+* @returns The globals.
+* @throws ArchiveError when the stream is not BIFF8, is encrypted or its shared string table is malformed.
+*/
+function readGlobals(stream) {
+	const iterator = records(stream);
+	const first = iterator.next();
+	if (first.done === true || first.value.type !== RECORD.bof || first.value.body.length < 2) throw new ArchiveError("the workbook stream does not open with a BOF record");
+	const version = first.value.view.getUint16(0, true);
+	if (version !== BIFF8) throw new ArchiveError(`the workbook is BIFF version 0x${version.toString(HEXADECIMAL)}; only BIFF8 (Excel 97 to 2003) is read`);
+	const formats = /* @__PURE__ */ new Map();
+	const styleFormats = [];
+	const sheets = /* @__PURE__ */ new Map();
+	let strings = [];
+	let date1904 = false;
+	let sst;
+	const finishSst = () => {
+		if (sst === void 0) return;
+		const [head] = sst;
+		if (head === void 0 || head.length < SST_STRINGS_OFFSET) throw new ArchiveError("the workbook's shared string table is shorter than its header");
+		const unique = new DataView(head.buffer, head.byteOffset, head.byteLength).getUint32(SST_UNIQUE_OFFSET, true);
+		const reader = new StringReader(sst, SST_STRINGS_OFFSET);
+		strings = Array.from({ length: unique }, () => reader.string(U16));
+		sst = void 0;
+	};
+	for (const record of iterator) {
+		if (record.type !== RECORD.continue) finishSst();
+		if (record.type === RECORD.eof) break;
+		if (record.type === RECORD.filePass) throw new ArchiveError("the workbook is encrypted");
+		if (record.type === RECORD.dateMode) date1904 = record.view.getUint16(0, true) === 1;
+		else if (record.type === RECORD.format) formats.set(record.view.getUint16(0, true), new StringReader([record.body], 2).string(U16));
+		else if (record.type === RECORD.xf) styleFormats.push(record.view.getUint16(2, true));
+		else if (record.type === RECORD.boundSheet) sheets.set(new StringReader([record.body], SHEET_NAME_OFFSET).string(U8), record.view.getUint32(0, true));
+		else if (record.type === RECORD.sst) sst = [record.body];
+		else if (record.type === RECORD.continue && sst !== void 0) sst.push(record.body);
+	}
+	finishSst();
+	const dateStyles = /* @__PURE__ */ new Set();
+	for (const [index, id] of styleFormats.entries()) {
+		const code = formats.get(id);
+		if (code === void 0 ? BUILT_IN_DATE_FORMATS.some((range) => id >= range.first && id <= range.last) : isDateFormat(code)) dateStyles.add(index);
+	}
+	return {
+		strings,
+		dateStyles,
+		date1904,
+		sheets
+	};
+}
+/**
+* Decodes an RK number ([MS-XLS] 2.5.217): a signed 30-bit integer or the high 30 bits of a double, either of them possibly a hundredth of the value.
+* @param rk - The stored 32 bits.
+* @returns The number.
+*/
+function rkValue(rk) {
+	let value;
+	if ((rk & RK_INTEGER) === 0) {
+		const bits = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(DOUBLE_BYTES));
+		bits.setUint32(DOUBLE_HIGH_HALF, (rk & RK_DOUBLE_MASK) >>> 0, true);
+		value = bits.getFloat64(0, true);
+	} else value = rk >> RK_INTEGER_SHIFT;
+	return (rk & RK_HUNDREDTHS) === 0 ? value : value / HUNDRED;
+}
+/**
+* Reads one sheet of a legacy binary Excel workbook (`.xls`, BIFF8 in a compound file) as the same text the xlsx reader gives: a date cell as ISO 8601 text (recognised by its cell style's number format, in either date system), a boolean as TRUE or FALSE, an error as its text, a number as the shortest decimal that is the stored double, and a formula as its cached result.
+* @param bytes - The workbook.
+* @param sheet - The sheet's name.
+* @returns The sheet's cells.
+* @throws ArchiveError when the bytes are not a BIFF8 workbook, it is encrypted, the sheet is missing, or a record is malformed.
+*/
+function xlsGrid(bytes, sheet) {
+	const stream = readRootStream(bytes, "Workbook");
+	if (stream === void 0) throw new ArchiveError(readRootStream(bytes, "Book") === void 0 ? "the compound file holds no Workbook stream, so it is not an Excel workbook" : "the workbook is BIFF5 or earlier (Excel 95), which stores text in a code page; only BIFF8 (Excel 97 to 2003) is read");
+	const globals = readGlobals(stream);
+	const start = globals.sheets.get(sheet);
+	if (start === void 0) throw new ArchiveError(`the workbook has no sheet ${sheet}; it has ${[...globals.sheets.keys()].join(", ")}`);
+	if (start >= stream.length) throw new ArchiveError(`the workbook places the sheet ${sheet} at byte ${String(start)}, past the end of its stream`);
+	const rows = /* @__PURE__ */ new Map();
+	let width = 0;
+	const put = (row, column, text) => {
+		if (text === "") return;
+		const cells = rows.get(row + 1) ?? [];
+		cells[column] = text;
+		rows.set(row + 1, cells);
+		width = Math.max(width, column + 1);
+	};
+	const numberText = (value, style, row) => {
+		if (!globals.dateStyles.has(style)) return String(value);
+		if (!Number.isFinite(value) || value < 0) throw new ArchiveError(`row ${String(row + 1)} has a date cell holding ${String(value)}`);
+		return isoOf(value, globals.date1904);
+	};
+	let depth = 0;
+	let pendingString;
+	const finishString = () => {
+		if (pendingString !== void 0) {
+			put(pendingString.row, pendingString.column, new StringReader(pendingString.parts, 0).string(U16));
+			pendingString = void 0;
+		}
+	};
+	for (const record of records(stream.subarray(start))) {
+		if (pendingString !== void 0) {
+			if (pendingString.parts.length === 0) {
+				if (FORMULA_COMPANIONS.has(record.type)) continue;
+				if (record.type !== RECORD.string) throw new ArchiveError(`row ${String(pendingString.row + 1)} has a formula with a text result but no STRING record after it`);
+				pendingString.parts.push(record.body);
+				continue;
+			}
+			if (record.type === RECORD.continue) {
+				pendingString.parts.push(record.body);
+				continue;
+			}
+			finishString();
+		}
+		if (record.type === RECORD.bof) {
+			depth += 1;
+			continue;
+		}
+		if (record.type === RECORD.eof) {
+			depth -= 1;
+			if (depth === 0) break;
+			continue;
+		}
+		if (record.type === RECORD.string && depth === 1) throw new ArchiveError("the sheet has a STRING record that follows no formula");
+		if (depth !== 1 || !CELL_RECORDS.has(record.type)) continue;
+		if (record.body.length < CELL_HEADER_BYTES) throw new ArchiveError(`the sheet has a cell record of type 0x${record.type.toString(HEXADECIMAL)} shorter than a cell's row, column and style`);
+		const row = record.view.getUint16(0, true);
+		const column = record.view.getUint16(2, true);
+		const style = record.view.getUint16(STYLE_OFFSET, true);
+		if (record.type === RECORD.labelSst) {
+			const index = record.view.getUint32(CELL_HEADER_BYTES, true);
+			const text = globals.strings[index];
+			if (text === void 0) throw new ArchiveError(`row ${String(row + 1)} names the shared string ${String(index)}, which the workbook does not have`);
+			put(row, column, text);
+		} else if (record.type === RECORD.label || record.type === RECORD.richString) put(row, column, new StringReader([record.body], CELL_HEADER_BYTES).string(U16));
+		else if (record.type === RECORD.number) put(row, column, numberText(record.view.getFloat64(CELL_HEADER_BYTES, true), style, row));
+		else if (record.type === RECORD.rk) put(row, column, numberText(rkValue(record.view.getUint32(CELL_HEADER_BYTES, true)), style, row));
+		else if (record.type === RECORD.mulRk) {
+			const count = (record.body.length - MULRK_FIXED_BYTES) / MULRK_ENTRY_BYTES;
+			if (!Number.isInteger(count)) throw new ArchiveError(`row ${String(row + 1)} has a MULRK record whose length is not a whole number of values`);
+			for (let index = 0; index < count; index += 1) {
+				const offset = MULRK_FIRST_ENTRY + index * MULRK_ENTRY_BYTES;
+				put(row, column + index, numberText(rkValue(record.view.getUint32(offset + 2, true)), record.view.getUint16(offset, true), row));
+			}
+		} else if (record.type === RECORD.boolErr) {
+			const value = record.view.getUint8(BOOLERR_VALUE_OFFSET);
+			put(row, column, record.view.getUint8(BOOLERR_KIND_OFFSET) === 0 ? booleanText(value) : errorText(value, row));
+		} else if (record.view.getUint16(12, true) === NON_NUMERIC_RESULT) {
+			const kind = record.view.getUint8(CELL_HEADER_BYTES);
+			const value = record.view.getUint8(8);
+			if (kind === FORMULA_RESULT.string) pendingString = {
+				row,
+				column,
+				parts: []
+			};
+			else if (kind === FORMULA_RESULT.boolean) put(row, column, booleanText(value));
+			else if (kind === FORMULA_RESULT.error) put(row, column, errorText(value, row));
+			else if (kind !== FORMULA_RESULT.empty) throw new ArchiveError(`row ${String(row + 1)} has a formula whose cached result is of unknown kind ${String(kind)}`);
+		} else put(row, column, numberText(record.view.getFloat64(CELL_HEADER_BYTES, true), style, row));
+	}
+	finishString();
+	return {
+		rows,
+		width
+	};
+}
+//#endregion
+//#region src/node/xlsx.ts
+const LETTERS = 26;
+const FIRST_LETTER = "A".charCodeAt(0);
+/**
+* The strings of a workbook's shared string table, in index order: each item's text runs joined, the phonetic runs of East Asian text left out.
+* @param xml - The `sharedStrings.xml` text.
+* @returns The strings.
+*/
+function sharedStrings(xml) {
+	return [...xml.matchAll(/<si(?:\s[^>]*)?>([\s\S]*?)<\/si>/g)].map((item) => {
+		return [...(item[1] ?? "").replaceAll(/<rPh[\s\S]*?<\/rPh>/g, "").matchAll(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g)].map((text) => unescape(text[1] ?? "")).join("");
+	});
+}
+/**
+* Which cell styles show dates, by the style's index.
+* @param xml - The `styles.xml` text, or undefined when the workbook has none.
+* @returns The style indexes whose number format is a date or a time.
+*/
+function dateStyles(xml) {
+	if (xml === void 0) return /* @__PURE__ */ new Set();
+	const custom = /* @__PURE__ */ new Map();
+	for (const format of elements(xml, "numFmt")) if (format["numFmtId"] !== void 0 && format["formatCode"] !== void 0) custom.set(Number(format["numFmtId"]), format["formatCode"]);
+	const cellFormats = /<cellXfs(?:\s[^>]*)?>([\s\S]*?)<\/cellXfs>/.exec(xml)?.[1] ?? "";
+	const styles = /* @__PURE__ */ new Set();
+	for (const [index, format] of elements(cellFormats, "xf").entries()) {
+		const id = Number(format["numFmtId"] ?? "0");
+		const code = custom.get(id);
+		if (code === void 0 ? BUILT_IN_DATE_FORMATS.some((range) => id >= range.first && id <= range.last) : isDateFormat(code)) styles.add(index);
+	}
+	return styles;
+}
+/**
 * The 0-based column of a cell reference such as `AB12`.
 * @param reference - The reference.
 * @returns The column index.
@@ -3785,13 +4600,13 @@ function sheetNames(bytes) {
 	});
 }
 /**
-* Writes one sheet of an xlsx workbook as CSV text, so a recipe reads it with the table parser: one line for every row number from the first to the last (a row the sheet leaves out is an empty line, so the lines above the header are the rows an editor shows), every line the width of the sheet's widest row, a date cell as ISO 8601 text, a boolean as TRUE or FALSE, a number as the text the workbook stores, and a formula as its stored result.
+* Reads one sheet of an xlsx workbook: a date cell as ISO 8601 text (recognised by its cell style's number format, in either date system), a boolean as TRUE or FALSE, a number as the text the workbook stores, and a formula as its stored result.
 * @param bytes - The workbook.
 * @param sheet - The sheet's name.
-* @returns The CSV, in UTF-8.
+* @returns The sheet's cells.
 * @throws ArchiveError when the bytes are not a workbook, the sheet is missing, or a cell cannot be read.
 */
-function sheetToCsv(bytes, sheet) {
+function xlsxGrid(bytes, sheet) {
 	let parts;
 	try {
 		const wanted = /* @__PURE__ */ new Set([
@@ -3815,14 +4630,7 @@ function sheetToCsv(bytes, sheet) {
 	const sheetBytes = getOwn(unzipSync(bytes, { filter: (file) => file.name === path }), path);
 	if (sheetBytes === void 0) throw new ArchiveError(`the workbook names the sheet ${sheet} in ${path}, which the file does not have`);
 	const strings = text("xl/sharedStrings.xml");
-	const { rows, width } = readRows(new TextDecoder("utf-8").decode(sheetBytes), strings === void 0 ? [] : sharedStrings(strings), dateStyles(text("xl/styles.xml")), /<workbookPr(?=[\s/>])[^>]*date1904="(?:1|true)"/.test(workbook));
-	const last = Math.max(0, ...rows.keys());
-	const lines = [];
-	for (let number = 1; number <= last; number += 1) {
-		const cells = rows.get(number) ?? [];
-		lines.push(Array.from({ length: width }, (_empty, column) => csvField(cells[column] ?? "")).join(","));
-	}
-	return new TextEncoder().encode(lines.length === 0 ? "" : `${lines.join("\n")}\n`);
+	return readRows(new TextDecoder("utf-8").decode(sheetBytes), strings === void 0 ? [] : sharedStrings(strings), dateStyles(text("xl/styles.xml")), /<workbookPr(?=[\s/>])[^>]*date1904="(?:1|true)"/.test(workbook));
 }
 //#endregion
 //#region src/node/archive.ts
@@ -3882,7 +4690,7 @@ function pick(paths, member) {
 	return only;
 }
 /**
-* Unpacks downloaded bytes into the one file the parser reads. A member with an `inner` archive is unpacked again by that layout, and the path reported is the outer member's, joined by `/` to the inner member's when the inner layout selects one, as though the inner archive were a directory.
+* Unpacks downloaded bytes into the one file the parser reads. A member with an `inner` archive is unpacked again by that layout, and the path reported is the outer member's, joined by `/` to the inner member's or the inner sheet's name when the inner layout selects one, as though the inner archive were a directory.
 * @param bytes - The downloaded bytes.
 * @param archive - The recipe's archive layout.
 * @returns The file's bytes, and its member path for a multi-file archive.
@@ -3892,8 +4700,8 @@ function unpack(bytes, archive) {
 	if (archive.kind === "none") return { bytes };
 	if (archive.kind === "gzip") return { bytes: gunzip(bytes) };
 	if (archive.kind === "bzip2") return { bytes: bunzip2(bytes) };
-	if (archive.kind === "xlsx") return {
-		bytes: sheetToCsv(bytes, archive.sheet),
+	if ("sheet" in archive) return {
+		bytes: sheetToCsv(bytes, archive),
 		member: archive.sheet
 	};
 	if (archive.kind === "shapefile") return unpackShapefile(bytes, archive.member);
@@ -3903,6 +4711,10 @@ function unpack(bytes, archive) {
 		bytes: gunzip(outer.bytes),
 		member: outer.member
 	};
+	if ("sheet" in archive.inner) return {
+		bytes: sheetToCsv(outer.bytes, archive.inner),
+		member: `${outer.member}/${archive.inner.sheet}`
+	};
 	const inner = selectMember(outer.bytes, archive.inner);
 	return {
 		bytes: inner.bytes,
@@ -4007,7 +4819,10 @@ function unpackMembers(bytes, archive) {
 		if (names.length === 0) throw new ArchiveError(`member ${member.path} has no sheet matching ${sheets ?? ""}`);
 		return names.map((sheet) => ({
 			path: `${member.path}/${sheet}`,
-			bytes: sheetToCsv(member.bytes, sheet)
+			bytes: sheetToCsv(member.bytes, {
+				kind: "xlsx",
+				sheet
+			})
 		}));
 	});
 }
@@ -4082,6 +4897,21 @@ function untarred(bytes, kind) {
 	return kind === "tar.gz" ? gunzip(bytes) : bunzip2(bytes);
 }
 /**
+* Reads one sheet of a spreadsheet as CSV text, by the spreadsheet's format.
+* @param bytes - The spreadsheet.
+* @param archive - Its format and the sheet to read.
+* @returns The CSV, in UTF-8.
+* @throws ArchiveError when the bytes are not a spreadsheet of that format, the sheet is missing, or a cell cannot be read.
+*/
+function sheetToCsv(bytes, archive) {
+	const read = {
+		xlsx: xlsxGrid,
+		xls: xlsGrid,
+		ods: odsGrid
+	}[archive.kind];
+	return gridToCsv(read(bytes, archive.sheet));
+}
+/**
 * Gunzips bytes, rethrowing zlib's failure in the package's taxonomy.
 * @param bytes - Gzip data.
 * @returns The decompressed bytes.