keepset 0.37.1 → 0.39.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-6dYCPVD-.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "crossmap";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -127,6 +127,15 @@ function endpoint$1(fields, column, lineNumber) {
 	return value.trim();
 }
 /**
+* Whether a line meets one of the recipe's `where` conditions.
+* @param fields - The line's fields, at least as many as the highest column the recipe names.
+* @param condition - The condition.
+* @returns True when the condition's column, trimmed, equals its value.
+*/
+function meets(fields, condition) {
+	return fields[condition.column]?.trim() === condition.equals;
+}
+/**
 * Resolves `detect` to a fixed delimiter from the first data line: tab when it holds a tab, comma when it holds a comma, whitespace otherwise. The rule is a function of the file's bytes, so a recipe that detects still reads the same way every time.
 * @param dataLine - The first line that is neither skipped, blank nor a comment.
 * @returns The fixed delimiter.
@@ -136,34 +145,76 @@ 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.
-* @param text - The file text.
+* 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, and one that states `where` reads only the lines whose listed columns, trimmed, equal their values, so a file that records several kinds of row (an interaction file listing genetic beside physical interactions) is read for the rows the dataset is made of; a line that is not read is still checked for the fields it needs. A recipe 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. The text is read line by line, so a file longer than the engine's longest string is read too.
+* @param text - The file text, whole or in pieces.
 * @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 no line is an edge.
 */
 function parseEdgeList(text, options) {
 	let split = options.delimiter === "detect" ? void 0 : splitters[options.delimiter];
-	const needed = Math.max(options.sourceColumn, options.targetColumn) + 1;
+	const { where } = options;
+	const needed = Math.max(options.sourceColumn, options.targetColumn, options.keep?.column ?? 0, options.multiplicityColumn ?? 0, ...where === void 0 ? [] : where.map((condition) => condition.column)) + 1;
 	const order = new NodeOrder();
 	const edges = [];
-	for (const [index, line] of lines(text).entries()) {
-		const lineNumber = index + 1;
+	const awaiting = /* @__PURE__ */ new Map();
+	let lastLine = 0;
+	forEachLine(typeof text === "string" ? [text] : text, (line, lineNumber) => {
+		lastLine = lineNumber;
 		const content = line.trimStart();
-		if (index < options.skipLines || content === "" || options.commentPrefixes.some((prefix) => content.startsWith(prefix))) continue;
+		if (lineNumber <= options.skipLines || content === "" || options.commentPrefixes.some((prefix) => content.startsWith(prefix))) return;
 		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() ?? "")) return;
+		if (where !== void 0 && !where.every((condition) => meets(fields, condition))) return;
 		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) return;
 		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();
+				return;
+			}
+			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
 		});
+	});
+	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", lines(text).length, "the file holds no edges");
+	if (edges.length === 0) throw new NativeParseError("edge-list", lastLine, where === void 0 ? "the file holds no edges" : "no line of the file meets the recipe's where conditions");
 	return {
 		nodes: order.nodes(),
 		edges
@@ -171,7 +222,7 @@ function parseEdgeList(text, options) {
 }
 //#endregion
 //#region src/parsers/gd-contest.ts
-const FORMAT$14 = "gd-contest";
+const FORMAT$15 = "gd-contest";
 const NUMBER$9 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
 /**
 * Reads a vertex number, which the format numbers from 0 to N - 1.
@@ -180,7 +231,7 @@ const NUMBER$9 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
 * @returns The vertex id as text.
 */
 function vertex$1(token, count) {
-	if (!/^(?:0|[1-9]\d*)$/.test(token.text) || Number(token.text) >= count) throw new NativeParseError(FORMAT$14, token.line, `expected a vertex number from 0 to ${String(count - 1)}, found ${JSON.stringify(token.text)}`);
+	if (!/^(?:0|[1-9]\d*)$/.test(token.text) || Number(token.text) >= count) throw new NativeParseError(FORMAT$15, token.line, `expected a vertex number from 0 to ${String(count - 1)}, found ${JSON.stringify(token.text)}`);
 	return token.text;
 }
 /**
@@ -200,17 +251,17 @@ function parseGdContest(text) {
 		});
 	}
 	const [first] = tokens;
-	if (first === void 0) throw new NativeParseError(FORMAT$14, 1, "the file holds no vertex count");
-	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$14, first.line, `the vertex count must be a non-negative integer, found ${JSON.stringify(first.text)}`);
+	if (first === void 0) throw new NativeParseError(FORMAT$15, 1, "the file holds no vertex count");
+	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$15, first.line, `the vertex count must be a non-negative integer, found ${JSON.stringify(first.text)}`);
 	const count = Number(first.text);
 	const coordinates = tokens.slice(1, 1 + 2 * count);
-	if (coordinates.length < 2 * count) throw new NativeParseError(FORMAT$14, lines(text).length, `expected ${String(2 * count)} coordinates for ${String(count)} vertices, found ${String(coordinates.length)}`);
-	for (const coordinate of coordinates) if (!NUMBER$9.test(coordinate.text)) throw new NativeParseError(FORMAT$14, coordinate.line, `coordinate ${JSON.stringify(coordinate.text)} is not a number`);
+	if (coordinates.length < 2 * count) throw new NativeParseError(FORMAT$15, lines(text).length, `expected ${String(2 * count)} coordinates for ${String(count)} vertices, found ${String(coordinates.length)}`);
+	for (const coordinate of coordinates) if (!NUMBER$9.test(coordinate.text)) throw new NativeParseError(FORMAT$15, coordinate.line, `coordinate ${JSON.stringify(coordinate.text)} is not a number`);
 	const ends = tokens.slice(1 + 2 * count);
 	const edges = [];
 	for (let source = ends.shift(); source !== void 0; source = ends.shift()) {
 		const target = ends.shift();
-		if (target === void 0) throw new NativeParseError(FORMAT$14, source.line, `edge from vertex ${source.text} has no second vertex`);
+		if (target === void 0) throw new NativeParseError(FORMAT$15, source.line, `edge from vertex ${source.text} has no second vertex`);
 		edges.push({
 			source: vertex$1(source, count),
 			target: vertex$1(target, count)
@@ -380,11 +431,11 @@ function parseGml(text) {
 }
 //#endregion
 //#region src/parsers/hgb.ts
-const FORMAT$13 = "hgb";
+const FORMAT$14 = "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;
@@ -400,7 +451,7 @@ const LINK_FIELDS = 4;
 */
 function resolve(field, types, where) {
 	const type = types[CODE.test(field) ? Number(field) : -1];
-	if (type === void 0) throw new NativeParseError(FORMAT$13, where.line, `${where.file}: the ${where.kind} type ${JSON.stringify(field)} is not one of the ${String(types.length)} the recipe names`);
+	if (type === void 0) throw new NativeParseError(FORMAT$14, where.line, `${where.file}: the ${where.kind} type ${JSON.stringify(field)} is not one of the ${String(types.length)} the recipe names`);
 	return type;
 }
 /**
@@ -418,9 +469,9 @@ function parseHgb(parts, options) {
 	forEachLine(parts.nodes, (line, number) => {
 		const fields = line.split("	");
 		const [id, , type] = fields;
-		if (fields.length !== NODE_FIELDS && fields.length !== NODE_FIELDS_WITH_ATTRIBUTES || id === void 0 || type === void 0) throw new NativeParseError(FORMAT$13, number, `node.dat: expected ${String(NODE_FIELDS)} or ${String(NODE_FIELDS_WITH_ATTRIBUTES)} fields separated by tabs, found ${String(fields.length)}`);
-		if (!CODE.test(id)) throw new NativeParseError(FORMAT$13, number, `node.dat: the node id ${JSON.stringify(id)} is not a non-negative integer`);
-		if (typeOf.has(id)) throw new NativeParseError(FORMAT$13, number, `node.dat: the node id ${id} is repeated`);
+		if (fields.length !== NODE_FIELDS && fields.length !== NODE_FIELDS_WITH_ATTRIBUTES || id === void 0 || type === void 0) throw new NativeParseError(FORMAT$14, number, `node.dat: expected ${String(NODE_FIELDS)} or ${String(NODE_FIELDS_WITH_ATTRIBUTES)} fields separated by tabs, found ${String(fields.length)}`);
+		if (!CODE.test(id)) throw new NativeParseError(FORMAT$14, number, `node.dat: the node id ${JSON.stringify(id)} is not a non-negative integer`);
+		if (typeOf.has(id)) throw new NativeParseError(FORMAT$14, number, `node.dat: the node id ${id} is repeated`);
 		const nodeType = resolve(type, options.nodeTypes, {
 			file: "node.dat",
 			line: number,
@@ -432,12 +483,12 @@ function parseHgb(parts, options) {
 			type: nodeType
 		});
 	});
-	if (nodes.length === 0) throw new NativeParseError(FORMAT$13, 1, "node.dat: the file holds no nodes");
+	if (nodes.length === 0) throw new NativeParseError(FORMAT$14, 1, "node.dat: the file holds no nodes");
 	const edges = [];
 	forEachLine(parts.links, (line, number) => {
 		const fields = line.split("	");
 		const [source, target, type, weight] = fields;
-		if (fields.length !== LINK_FIELDS || source === void 0 || target === void 0 || type === void 0 || weight === void 0) throw new NativeParseError(FORMAT$13, number, `link.dat: expected ${String(LINK_FIELDS)} fields separated by tabs, found ${String(fields.length)}`);
+		if (fields.length !== LINK_FIELDS || source === void 0 || target === void 0 || type === void 0 || weight === void 0) throw new NativeParseError(FORMAT$14, number, `link.dat: expected ${String(LINK_FIELDS)} fields separated by tabs, found ${String(fields.length)}`);
 		const linkType = resolve(type, options.linkTypes, {
 			file: "link.dat",
 			line: number,
@@ -453,17 +504,17 @@ function parseHgb(parts, options) {
 			linkType.target
 		]]) {
 			const actual = typeOf.get(id);
-			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 (actual === void 0) throw new NativeParseError(FORMAT$14, number, `link.dat: the ${end} ${JSON.stringify(id)} is not a node of node.dat`);
+			if (actual !== expected) throw new NativeParseError(FORMAT$14, 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$14, number, `link.dat: the weight ${JSON.stringify(weight)} is not 1; a weighted HGB file would lose its weights`);
 		edges.push({
 			source,
 			target,
 			type: linkType.name
 		});
 	});
-	if (edges.length === 0) throw new NativeParseError(FORMAT$13, 1, "link.dat: the file holds no links");
+	if (edges.length === 0) throw new NativeParseError(FORMAT$14, 1, "link.dat: the file holds no links");
 	return {
 		nodes,
 		edges
@@ -471,7 +522,7 @@ function parseHgb(parts, options) {
 }
 //#endregion
 //#region src/parsers/kg-triples.ts
-const FORMAT$12 = "kg-triples";
+const FORMAT$13 = "kg-triples";
 /** The character each delimiter option splits a line on. A line is split on exactly that character, so a field cannot hide a second delimiter. */
 const DELIMITERS$1 = {
 	tab: "	",
@@ -493,8 +544,8 @@ const QUOTE$2 = "\"";
 */
 function value(field, quoted, where) {
 	const inner = quoted ? field.slice(1, -1) : field;
-	if (quoted && (field.length < 2 || !field.startsWith(QUOTE$2) || !field.endsWith(QUOTE$2) || inner.includes(QUOTE$2))) throw new NativeParseError(FORMAT$12, where.line, `${where.part}the field ${JSON.stringify(field)} is not one value wrapped in double quotes`);
-	if (inner === "") throw new NativeParseError(FORMAT$12, where.line, `${where.part}a field is empty`);
+	if (quoted && (field.length < 2 || !field.startsWith(QUOTE$2) || !field.endsWith(QUOTE$2) || inner.includes(QUOTE$2))) throw new NativeParseError(FORMAT$13, where.line, `${where.part}the field ${JSON.stringify(field)} is not one value wrapped in double quotes`);
+	if (inner === "") throw new NativeParseError(FORMAT$13, where.line, `${where.part}a field is empty`);
 	return inner;
 }
 /**
@@ -518,16 +569,16 @@ function parseKgTriples(parts, options) {
 		let lastLine = 0;
 		forEachLine(part.pieces, (line, number) => {
 			lastLine = number;
-			if (line.trim() === "") throw new NativeParseError(FORMAT$12, number, `${label}the line is blank`);
+			if (line.trim() === "") throw new NativeParseError(FORMAT$13, number, `${label}the line is blank`);
 			if (number === 1 && options.header === "names") return;
 			if (number === 1 && options.header === "count") {
-				if (!COUNT$1.test(line)) throw new NativeParseError(FORMAT$12, number, `${label}expected the number of triples on the first line, found ${JSON.stringify(line)}`);
+				if (!COUNT$1.test(line)) throw new NativeParseError(FORMAT$13, number, `${label}expected the number of triples on the first line, found ${JSON.stringify(line)}`);
 				declared = Number(line);
 				return;
 			}
 			const fields = line.split(delimiter);
 			const [head, middle, last] = fields;
-			if (fields.length !== TRIPLE_FIELDS || head === void 0 || middle === void 0 || last === void 0) throw new NativeParseError(FORMAT$12, number, `${label}expected ${String(TRIPLE_FIELDS)} fields separated by ${options.delimiter}, found ${String(fields.length)}`);
+			if (fields.length !== TRIPLE_FIELDS || head === void 0 || middle === void 0 || last === void 0) throw new NativeParseError(FORMAT$13, number, `${label}expected ${String(TRIPLE_FIELDS)} fields separated by ${options.delimiter}, found ${String(fields.length)}`);
 			const where = {
 				line: number,
 				part: label
@@ -553,8 +604,8 @@ function parseKgTriples(parts, options) {
 			});
 			triples += 1;
 		});
-		if (triples === 0) throw new NativeParseError(FORMAT$12, lastLine, `${label}the file holds no triples`);
-		if (declared !== void 0 && declared !== triples) throw new NativeParseError(FORMAT$12, lastLine, `${label}the first line declares ${String(declared)} triples, the file holds ${String(triples)}`);
+		if (triples === 0) throw new NativeParseError(FORMAT$13, lastLine, `${label}the file holds no triples`);
+		if (declared !== void 0 && declared !== triples) throw new NativeParseError(FORMAT$13, lastLine, `${label}the first line declares ${String(declared)} triples, the file holds ${String(triples)}`);
 	}
 	return {
 		nodes: order.nodes(),
@@ -563,7 +614,7 @@ function parseKgTriples(parts, options) {
 }
 //#endregion
 //#region src/parsers/konect.ts
-const FORMAT$11 = "konect";
+const FORMAT$12 = "konect";
 /** The network formats of KONECT's first line (Kunegis, "The KONECT Handbook", table 1): undirected, directed and bipartite. */
 const NETWORK_FORMATS = /* @__PURE__ */ new Set([
 	"sym",
@@ -588,7 +639,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;
@@ -638,9 +689,9 @@ function parseKonect(pieces, options) {
 		}));
 	});
 	const { header } = state;
-	if (header === void 0) throw new NativeParseError(FORMAT$11, lastLine, "the file has no first line naming its format and weights");
-	if (edges.length === 0) throw new NativeParseError(FORMAT$11, lastLine, "the file holds no edges");
-	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$11, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
+	if (header === void 0) throw new NativeParseError(FORMAT$12, lastLine, "the file has no first line naming its format and weights");
+	if (edges.length === 0) throw new NativeParseError(FORMAT$12, lastLine, "the file holds no edges");
+	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$12, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
 	return {
 		nodes: order.nodes(),
 		edges
@@ -658,9 +709,9 @@ function readHeader(content, number, options) {
 	const match = FORMAT_LINE.exec(content);
 	const network = match?.[1];
 	const weights = match?.[2];
-	if (network === void 0 || weights === void 0 || !NETWORK_FORMATS.has(network)) throw new NativeParseError(FORMAT$11, number, `expected a first line "% FORMAT WEIGHTS" with FORMAT one of ${[...NETWORK_FORMATS].join(", ")}, found ${JSON.stringify(content)}`);
-	if (!WEIGHTED_TYPES.has(weights) && !UNWEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$11, number, `the weight type ${JSON.stringify(weights)} is not one this parser reads (its third column is not an edge weight or a repetition count)`);
-	if (options.weighted !== WEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$11, number, `the file's weight type is ${weights}, so a recipe with weighted ${String(WEIGHTED_TYPES.has(weights))} reads it, not one with weighted ${String(options.weighted)}`);
+	if (network === void 0 || weights === void 0 || !NETWORK_FORMATS.has(network)) throw new NativeParseError(FORMAT$12, number, `expected a first line "% FORMAT WEIGHTS" with FORMAT one of ${[...NETWORK_FORMATS].join(", ")}, found ${JSON.stringify(content)}`);
+	if (!WEIGHTED_TYPES.has(weights) && !UNWEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$12, number, `the weight type ${JSON.stringify(weights)} is not one this parser reads (its third column is not an edge weight or a repetition count)`);
+	if (options.weighted !== WEIGHTED_TYPES.has(weights)) throw new NativeParseError(FORMAT$12, number, `the file's weight type is ${weights}, so a recipe with weighted ${String(WEIGHTED_TYPES.has(weights))} reads it, not one with weighted ${String(options.weighted)}`);
 	return {
 		line: number,
 		network
@@ -680,15 +731,15 @@ function readEdge(content, number, context) {
 	const [from, to, third, time] = fields;
 	const expected = options.timestamped ? TIMESTAMPED_COLUMNS : options.weighted ? WEIGHTED_COLUMNS : void 0;
 	const fits = expected === void 0 ? fields.length === ENDPOINT_COLUMNS || fields.length === WEIGHTED_COLUMNS : fields.length === expected;
-	if (from === void 0 || to === void 0 || !fits) throw new NativeParseError(FORMAT$11, number, `expected ${expected === void 0 ? `${String(ENDPOINT_COLUMNS)} or ${String(WEIGHTED_COLUMNS)}` : String(expected)} columns for this recipe, found ${String(fields.length)}`);
+	if (from === void 0 || to === void 0 || !fits) throw new NativeParseError(FORMAT$12, number, `expected ${expected === void 0 ? `${String(ENDPOINT_COLUMNS)} or ${String(WEIGHTED_COLUMNS)}` : String(expected)} columns for this recipe, found ${String(fields.length)}`);
 	const bipartite = header.network === "bip";
 	const source = endpoint(from, bipartite ? LEFT_PREFIX : "", header.counts?.left, number);
 	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$12, 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$12, number, `the weight ${JSON.stringify(third)} is not a number`);
+	if (time !== void 0 && !DECIMAL$4.test(time)) throw new NativeParseError(FORMAT$12, number, `the time ${JSON.stringify(time)} is not a number`);
 	const edge = {
 		source,
 		target
@@ -707,10 +758,215 @@ function readEdge(content, number, context) {
 * @throws NativeParseError when the token is not a positive integer or exceeds the set's size.
 */
 function endpoint(token, prefix, size, number) {
-	if (!NODE_ID.test(token) || size !== void 0 && Number(token) > size) throw new NativeParseError(FORMAT$11, number, `${JSON.stringify(token)} is not a node id from 1${size === void 0 ? "" : ` to ${String(size)}`}`);
+	if (!NODE_ID.test(token) || size !== void 0 && Number(token) > size) throw new NativeParseError(FORMAT$12, number, `${JSON.stringify(token)} is not a node id from 1${size === void 0 ? "" : ` to ${String(size)}`}`);
 	return `${prefix}${token}`;
 }
 //#endregion
+//#region src/parsers/ogb.ts
+const FORMAT$11 = "ogb";
+/** The files of an OGB raw directory this reader takes, by their path under the dataset's root directory. A relation's files sit in `raw/relations/<head>___<relation>___<tail>/`. */
+const RAW = /^(?<root>(?:[^/]+\/)*?)raw\/(?<name>num-node-list|num-node-dict|edge|num-edge-list|triplet-type-list|relations\/[^/]+\/(?:edge|num-edge-list))\.csv\.gz$/u;
+const INDEX = /^(?:0|[1-9]\d*)$/;
+/** The fields of a line of `triplet-type-list.csv.gz`: a head type, a relation and a tail type. */
+const TRIPLET_PARTS = 3;
+/**
+* Orders two names by code point, the order Python's `sorted` gives the ASCII type and relation names OGB uses.
+* @param left - A name.
+* @param right - Another.
+* @returns Negative, zero or positive.
+*/
+function compare(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+* Visits the non-blank lines of a file, read a piece at a time.
+* @param file - The file.
+* @param visit - Called with each non-blank line and its number.
+*/
+function forEachRow(file, visit) {
+	forEachLine(file.text(), (text, line) => {
+		if (text.trim() !== "") visit({
+			text,
+			line
+		});
+	});
+}
+/**
+* The non-blank lines of a small file, such as a count or the triplet list.
+* @param file - The file.
+* @returns Each non-blank line and its number.
+*/
+function rows(file) {
+	const all = [];
+	forEachRow(file, (row) => {
+		all.push(row);
+	});
+	return all;
+}
+/**
+* Reads a file that holds one line, such as a count.
+* @param file - The file.
+* @returns The line's text.
+* @throws NativeParseError when the file holds no line or more than one.
+*/
+function onlyLine(file) {
+	const all = rows(file);
+	const [only] = all;
+	if (all.length !== 1 || only === void 0) throw new NativeParseError(FORMAT$11, all[1]?.line ?? 1, `${file.path} must hold one line, found ${String(all.length)}`);
+	return only.text.trim();
+}
+/**
+* Reads a non-negative integer.
+* @param text - The field.
+* @param file - The file, for the error.
+* @param line - The 1-based line, for the error.
+* @returns The integer.
+* @throws NativeParseError when the field is not a non-negative integer.
+*/
+function index(text, file, line) {
+	const trimmed = text.trim();
+	if (!INDEX.test(trimmed)) throw new NativeParseError(FORMAT$11, line, `${file.path}: expected a non-negative integer, found ${JSON.stringify(text)}`);
+	return Number(trimmed);
+}
+/**
+* Reads an `edge.csv.gz` file, one `<source>,<target>` pair of node indices per line, checking each index against its node type's count and the line count against the relation's `num-edge-list.csv.gz`.
+* @param edges - The edge file.
+* @param count - The relation's `num-edge-list.csv.gz`.
+* @param ends - The source and target node types' counts and how each index is named.
+* @param emit - Called with each edge, in file order, so a large file is never held twice.
+* @throws NativeParseError naming the file and line for a line that is not a pair of indices, an index outside its type's nodes, or a line count other than the recorded one.
+*/
+function readEdges(edges, count, ends, emit) {
+	const recorded = index(onlyLine(count), count, 1);
+	let read = 0;
+	forEachRow(edges, ({ text, line }) => {
+		const fields = text.split(",");
+		const [first, second] = fields;
+		if (fields.length !== 2 || first === void 0 || second === void 0) throw new NativeParseError(FORMAT$11, line, `${edges.path}: expected a source and a target index, found ${JSON.stringify(text)}`);
+		const source = index(first, edges, line);
+		const target = index(second, edges, line);
+		if (source >= ends.sources || target >= ends.targets) throw new NativeParseError(FORMAT$11, line, `${edges.path}: edge ${text} names a node outside the ${String(ends.sources)} sources and ${String(ends.targets)} targets the dataset records`);
+		emit({
+			source: ends.source(source),
+			target: ends.target(target)
+		});
+		read += 1;
+	});
+	if (read !== recorded) throw new NativeParseError(FORMAT$11, read, `${edges.path} holds ${String(read)} edges, but ${count.path} records ${String(recorded)}`);
+}
+/**
+* Takes one file of the dataset directory by its name under `raw/`.
+* @param files - The files by name.
+* @param name - The name, such as `edge` or `relations/paper___cites___paper/edge`.
+* @param root - The dataset's root directory, for the error.
+* @returns The file.
+* @throws NativeParseError when the archive's selection holds no such file.
+*/
+function required$1(files, name, root) {
+	const file = files.get(name);
+	if (file === void 0) throw new NativeParseError(FORMAT$11, 1, `the dataset directory ${root} has no raw/${name}.csv.gz among the files the recipe selects`);
+	return file;
+}
+/**
+* Parses an Open Graph Benchmark dataset from the files of its raw directory, as OGB's own `read_csv_graph_raw` and `read_csv_heterograph_raw` read them (ogb/io/read_graph_raw.py in snap-stanford/ogb). A homogeneous dataset has `raw/num-node-list.csv.gz` (its one graph's node count), `raw/edge.csv.gz` (one `<source>,<target>` pair of node indices per line, no header) and `raw/num-edge-list.csv.gz`: its nodes are `0` to `N - 1`, isolated ones included, and its edges the pairs in file order. A heterogeneous dataset has `raw/num-node-dict.csv.gz` (a header of node types over one row of their counts), `raw/triplet-type-list.csv.gz` (one `<head>,<relation>,<tail>` type triplet per line) and, per triplet, `raw/relations/<head>___<relation>___<tail>/edge.csv.gz` and `num-edge-list.csv.gz`, whose indices count within the head and tail types: its nodes are `<type>:<index>` for each type in sorted order and each index from 0, and its edges are each relation's pairs in file order, relations in the sorted order of their triplets, which is the order OGB reads them in. Edges keep the file's direction. Relation names, node features, labels and splits are not carried, as no graph parser in this version carries more than topology.
+* @param files - The files the recipe's archive selects, gunzipped and decoded: every one must be a file of one dataset's raw directory named above.
+* @returns The native graph.
+* @throws NativeParseError naming the file and line for a file outside the raw layout, files of two datasets, a dataset with neither or both node-count files, a missing file, a graph count other than one, a malformed count or triplet, a relation directory the triplet list does not name, an edge that is not a pair of indices of the dataset's nodes, or an edge file whose line count differs from its recorded count.
+*/
+function parseOgb(files) {
+	const byName = /* @__PURE__ */ new Map();
+	const roots = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		const match = RAW.exec(file.path);
+		const name = match?.groups?.["name"];
+		const root = match?.groups?.["root"];
+		if (name === void 0 || root === void 0) throw new NativeParseError(FORMAT$11, 1, `${file.path} is not a file of an OGB raw directory this reader takes`);
+		roots.add(root);
+		byName.set(name, file);
+	}
+	const [root] = roots;
+	if (roots.size !== 1 || root === void 0) throw new NativeParseError(FORMAT$11, 1, `the recipe must select the raw files of one dataset, found ${roots.size === 0 ? "none" : `the directories ${[...roots].join(", ")}`}`);
+	const homogeneous = byName.get("num-node-list");
+	const heterogeneous = byName.get("num-node-dict");
+	const neitherOrBoth = `the dataset directory ${root} must have exactly one of raw/num-node-list.csv.gz (one node type) and raw/num-node-dict.csv.gz (several)`;
+	const edges = [];
+	if (homogeneous !== void 0) {
+		if (heterogeneous !== void 0) throw new NativeParseError(FORMAT$11, 1, neitherOrBoth);
+		const [relation] = [...byName.keys()].filter((name) => name.startsWith("relations/"));
+		if (relation !== void 0 || byName.has("triplet-type-list")) throw new NativeParseError(FORMAT$11, 1, `the dataset directory ${root} has raw/num-node-list.csv.gz, so it has one node type, but the recipe selects ${relation === void 0 ? "raw/triplet-type-list.csv.gz" : `raw/${relation}.csv.gz`} as well`);
+		const count = index(onlyLine(homogeneous), homogeneous, 1);
+		const name = (node) => String(node);
+		readEdges(required$1(byName, "edge", root), required$1(byName, "num-edge-list", root), {
+			sources: count,
+			targets: count,
+			source: name,
+			target: name
+		}, (edge) => {
+			edges.push(edge);
+		});
+		return {
+			nodes: Array.from({ length: count }, (_, node) => ({ id: String(node) })),
+			edges
+		};
+	}
+	if (heterogeneous === void 0) throw new NativeParseError(FORMAT$11, 1, neitherOrBoth);
+	for (const stray of ["edge", "num-edge-list"]) if (byName.has(stray)) throw new NativeParseError(FORMAT$11, 1, `the dataset directory ${root} has raw/num-node-dict.csv.gz, so its edges are in raw/relations/, but the recipe selects raw/${stray}.csv.gz as well`);
+	const header = rows(heterogeneous);
+	const [types, counts] = header;
+	if (header.length !== 2 || types === void 0 || counts === void 0) throw new NativeParseError(FORMAT$11, header[2]?.line ?? 1, `${heterogeneous.path} must hold a header of node types and one row of their counts, found ${String(header.length)} lines`);
+	const typeNames = types.text.split(",").map((type) => type.trim());
+	const typeCounts = counts.text.split(",");
+	if (typeNames.length !== typeCounts.length || typeNames.some((type) => type === "") || new Set(typeNames).size !== typeNames.length) throw new NativeParseError(FORMAT$11, counts.line, `${heterogeneous.path} must name each node type once, over one count per type`);
+	const nodeTypes = typeNames.map((type, position) => {
+		const count = typeCounts[position];
+		if (count === void 0) throw new NativeParseError(FORMAT$11, counts.line, `${heterogeneous.path} gives node type ${type} no count`);
+		return {
+			type,
+			count: index(count, heterogeneous, counts.line)
+		};
+	});
+	nodeTypes.sort((left, right) => compare(left.type, right.type));
+	const nodeCounts = new Map(nodeTypes.map(({ type, count }) => [type, count]));
+	const triplets = required$1(byName, "triplet-type-list", root);
+	const relations = [];
+	for (const { text, line } of rows(triplets)) {
+		const parts = text.split(",").map((part) => part.trim());
+		const [head, relation, tail] = parts;
+		if (parts.length !== TRIPLET_PARTS || head === void 0 || relation === void 0 || tail === void 0 || relation === "") throw new NativeParseError(FORMAT$11, line, `${triplets.path}: expected a head type, a relation and a tail type, found ${JSON.stringify(text)}`);
+		const sources = nodeCounts.get(head);
+		const targets = nodeCounts.get(tail);
+		if (sources === void 0 || targets === void 0) throw new NativeParseError(FORMAT$11, line, `${triplets.path}: ${text} names a node type that ${heterogeneous.path} does not count`);
+		relations.push({
+			head,
+			relation,
+			tail,
+			sources,
+			targets
+		});
+	}
+	relations.sort((left, right) => compare(left.head, right.head) || compare(left.relation, right.relation) || compare(left.tail, right.tail));
+	const listed = new Set(relations.map(({ head, relation, tail }) => `relations/${head}___${relation}___${tail}`));
+	for (const name of byName.keys()) {
+		const directory = name.slice(0, name.lastIndexOf("/"));
+		if (name.startsWith("relations/") && !listed.has(directory)) throw new NativeParseError(FORMAT$11, 1, `raw/${directory}/ is not one of the relations ${triplets.path} lists`);
+	}
+	for (const { head, relation, tail, sources, targets } of relations) {
+		const directory = `relations/${head}___${relation}___${tail}`;
+		readEdges(required$1(byName, `${directory}/edge`, root), required$1(byName, `${directory}/num-edge-list`, root), {
+			sources,
+			targets,
+			source: (node) => `${head}:${String(node)}`,
+			target: (node) => `${tail}:${String(node)}`
+		}, (edge) => {
+			edges.push(edge);
+		});
+	}
+	return {
+		nodes: nodeTypes.flatMap(({ type, count }) => Array.from({ length: count }, (_, node) => ({ id: `${type}:${String(node)}` }))),
+		edges
+	};
+}
+//#endregion
 //#region src/parsers/matrix-market.ts
 /** How many tokens an entry line of each field type holds: the coordinates, then the value's parts (none for a pattern, a real and an imaginary part for a complex value). */
 const tokensPerEntry = /* @__PURE__ */ new Map([
@@ -808,7 +1064,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 +1208,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 +1227,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 +1276,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 +1288,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 +2799,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 +2847,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 +3095,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;
@@ -2897,13 +3194,14 @@ function parseNative(bytes, parser) {
 		pieces: decodePieces(bytes, parser)
 	}], parser);
 	if (parser.format === "hgb") throw new NativeParseError(parser.format, 1, "an HGB dataset is two files, nodes and links, which a recipe reads from a parts archive");
+	if (parser.format === "edge-list") return parseEdgeList(decodePieces(bytes, parser), parser);
 	const text = decode(bytes, parser);
 	if (parser.format === "geojson") return parseGeojson(text, parser);
-	if (parser.format === "edge-list") return parseEdgeList(text, parser);
 	if (parser.format === "matrix-market") return parseMatrixMarket(text);
 	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);
@@ -2912,6 +3210,7 @@ function parseNative(bytes, parser) {
 	if (parser.format === "verolog-2019") return parseVerolog2019(text);
 	if (parser.format === "vrp-rep") return parseVrpRep(text);
 	if (parser.format === "hhcrsp") return parseHhcrsp(text);
+	if (parser.format === "ogb") throw new NativeParseError(parser.format, 1, "the format reads the several files a files archive selects, not one file");
 	return parsePajek(text);
 }
 /**
@@ -2937,6 +3236,20 @@ function parseNativeParts(parts, parser) {
 	}
 	throw new NativeParseError(parser.format, 1, `the ${parser.format} parser reads one file, not named parts`);
 }
+/**
+* Reads the several files of a multi-file format into the one native document they make together.
+* @param files - The files a `files` archive selects, each with its path in the archive, in path order.
+* @param parser - The recipe's parser, which must be a multi-file format.
+* @returns The native graph.
+* @throws NativeParseError when a file is not valid in the stated encoding or the files are not in the stated format, or when the parser reads one file and not several.
+*/
+function parseNativeFiles(files, parser) {
+	if (parser.format !== "ogb") throw new NativeParseError(parser.format, 1, "the format reads one file, not the several a files archive selects");
+	return parseOgb(files.map((file) => ({
+		path: file.path,
+		text: () => decodePieces(file.bytes, parser)
+	})));
+}
 //#endregion
 //#region src/node/bzip2.ts
 /** The four bytes every bzip2 stream starts with, as ASCII: `BZh` and the block size digit, `1` to `9`. */
@@ -3564,23 +3877,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 +3888,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 +3918,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 +4096,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 +4114,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 +4831,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 +4861,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 +4921,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 +4931,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 +4942,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 +5050,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 +5128,45 @@ 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));
+}
+/**
+* Unpacks downloaded bytes into every file a multi-file format's selector matches, gunzipping each when the layout's `inner` says so. The paths stay the archive's own, so a gunzipped `edge.csv.gz` keeps its name.
+* @param bytes - The downloaded bytes.
+* @param archive - The recipe's archive layout, which selects files with `files`.
+* @returns Each matching file, in path order.
+* @throws ArchiveError when the bytes, or a file `inner` gunzips, are not well-formed, or the selector matches no member.
+*/
+function unpackFiles(bytes, archive) {
+	const files = unpackMembers(bytes, {
+		kind: archive.kind,
+		members: archive.files
+	});
+	if (archive.inner === void 0) return files;
+	return files.map((file) => {
+		try {
+			return {
+				path: file.path,
+				bytes: gunzip(file.bytes)
+			};
+		} catch (error) {
+			throw new ArchiveError(`member ${file.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+	});
+}
+/**
 * Gunzips bytes, rethrowing zlib's failure in the package's taxonomy.
 * @param bytes - Gzip data.
 * @returns The decompressed bytes.
@@ -4620,6 +5705,20 @@ async function runToNative(dataset, options) {
 			provenance: provenanceOf({ members: parts.map((part) => part.path) })
 		};
 	}
+	if ("files" in archive) {
+		const files = await step(entry.id, "extract", () => unpackFiles(bytes, archive));
+		return {
+			collection: false,
+			documents: [{
+				id: void 0,
+				native: {
+					...await step(entry.id, "parse", () => parseNativeFiles(files, recipe.parser)),
+					meta: metaOf(entry)
+				}
+			}],
+			provenance: provenanceOf({ members: files.map((file) => file.path) })
+		};
+	}
 	const unpacked = await step(entry.id, "extract", () => unpack(bytes, archive));
 	const parsed = await step(entry.id, "parse", () => parseNative(unpacked.bytes, recipe.parser));
 	return {