keepset 0.34.0 → 0.36.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-CPSe9InV.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-BrTVG8j1.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "crossmap";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -128,8 +128,8 @@ function parseEdgeList(text, options) {
 }
 //#endregion
 //#region src/parsers/gd-contest.ts
-const FORMAT$10 = "gd-contest";
-const NUMBER$8 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
+const FORMAT$11 = "gd-contest";
+const NUMBER$9 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?$/;
 /**
 * Reads a vertex number, which the format numbers from 0 to N - 1.
 * @param token - The token.
@@ -137,7 +137,7 @@ const NUMBER$8 = /^[+-]?(?:\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$10, 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$11, token.line, `expected a vertex number from 0 to ${String(count - 1)}, found ${JSON.stringify(token.text)}`);
 	return token.text;
 }
 /**
@@ -157,17 +157,17 @@ function parseGdContest(text) {
 		});
 	}
 	const [first] = tokens;
-	if (first === void 0) throw new NativeParseError(FORMAT$10, 1, "the file holds no vertex count");
-	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$10, first.line, `the vertex count must be a non-negative integer, found ${JSON.stringify(first.text)}`);
+	if (first === void 0) throw new NativeParseError(FORMAT$11, 1, "the file holds no vertex count");
+	if (!/^(?:0|[1-9]\d*)$/.test(first.text)) throw new NativeParseError(FORMAT$11, 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$10, lines(text).length, `expected ${String(2 * count)} coordinates for ${String(count)} vertices, found ${String(coordinates.length)}`);
-	for (const coordinate of coordinates) if (!NUMBER$8.test(coordinate.text)) throw new NativeParseError(FORMAT$10, coordinate.line, `coordinate ${JSON.stringify(coordinate.text)} is not a number`);
+	if (coordinates.length < 2 * count) throw new NativeParseError(FORMAT$11, 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$11, 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$10, source.line, `edge from vertex ${source.text} has no second vertex`);
+		if (target === void 0) throw new NativeParseError(FORMAT$11, source.line, `edge from vertex ${source.text} has no second vertex`);
 		edges.push({
 			source: vertex$1(source, count),
 			target: vertex$1(target, count)
@@ -181,7 +181,7 @@ function parseGdContest(text) {
 //#endregion
 //#region src/parsers/gml.ts
 const KEY = /[A-Za-z_][A-Za-z0-9_]*/y;
-const NUMBER$7 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
+const NUMBER$8 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
 /**
 * Matches a sticky pattern at a position.
 * @param pattern - A sticky regular expression.
@@ -232,7 +232,7 @@ function tokenise(text) {
 			position = end + 1;
 		} else {
 			const key = matchAt(KEY, text, position);
-			const number = key === void 0 ? matchAt(NUMBER$7, text, position) : void 0;
+			const number = key === void 0 ? matchAt(NUMBER$8, text, position) : void 0;
 			const match = key ?? number;
 			if (match === void 0) throw new NativeParseError("gml", line, `unexpected character ${JSON.stringify(char)}`);
 			tokens.push({
@@ -337,7 +337,7 @@ function parseGml(text) {
 }
 //#endregion
 //#region src/parsers/konect.ts
-const FORMAT$9 = "konect";
+const FORMAT$10 = "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",
@@ -412,9 +412,9 @@ function parseKonect(pieces, options) {
 		}));
 	});
 	const { header } = state;
-	if (header === void 0) throw new NativeParseError(FORMAT$9, lastLine, "the file has no first line naming its format and weights");
-	if (edges.length === 0) throw new NativeParseError(FORMAT$9, lastLine, "the file holds no edges");
-	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$9, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
+	if (header === void 0) throw new NativeParseError(FORMAT$10, lastLine, "the file has no first line naming its format and weights");
+	if (edges.length === 0) throw new NativeParseError(FORMAT$10, lastLine, "the file holds no edges");
+	if (header.counts !== void 0 && header.counts.edges !== edges.length) throw new NativeParseError(FORMAT$10, lastLine, `the second line declares ${String(header.counts.edges)} edges, the file holds ${String(edges.length)}`);
 	return {
 		nodes: order.nodes(),
 		edges
@@ -432,9 +432,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$9, 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$9, 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$9, 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$10, 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$10, 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$10, 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
@@ -454,15 +454,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$9, 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$10, 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$9, 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$9, number, `the weight ${JSON.stringify(third)} is not a number`);
-	if (time !== void 0 && !DECIMAL$3.test(time)) throw new NativeParseError(FORMAT$9, number, `the time ${JSON.stringify(time)} is not a number`);
+	if (third !== void 0 && !options.weighted && (!DECIMAL$3.test(third) || Number(third) !== 1)) throw new NativeParseError(FORMAT$10, 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$10, number, `the weight ${JSON.stringify(third)} is not a number`);
+	if (time !== void 0 && !DECIMAL$3.test(time)) throw new NativeParseError(FORMAT$10, number, `the time ${JSON.stringify(time)} is not a number`);
 	const edge = {
 		source,
 		target
@@ -481,7 +481,7 @@ 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$9, 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$10, number, `${JSON.stringify(token)} is not a node id from 1${size === void 0 ? "" : ` to ${String(size)}`}`);
 	return `${prefix}${token}`;
 }
 //#endregion
@@ -739,6 +739,15 @@ function* records(pieces, delimiter, firstLine) {
 	if (last !== void 0) yield last;
 }
 /**
+* Splits comma-separated text into its records' fields by RFC 4180, as `records` does, keeping every record (blank lines included) at its position: the grid a workbook sheet's CSV makes, for a parser that reads a layout of blocks and not one table.
+* @param text - The text.
+* @returns Each record's fields, in order.
+* @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);
+}
+/**
 * Drops the first physical lines of a file given in pieces.
 * @param pieces - The file text in order.
 * @param count - How many physical lines to drop.
@@ -885,7 +894,7 @@ function pointOf(geometry) {
 * @returns The cell: null for a missing, null or empty value.
 * @throws NativeParseError when the value is not the kind the recipe declares.
 */
-function cellOf(value, column, feature, kind) {
+function cellOf$1(value, column, feature, kind) {
 	if (value === void 0 || value === null) return null;
 	if (kind === "date") {
 		if (typeof value !== "number" || !Number.isFinite(value)) throw new NativeParseError("geojson", feature, `column ${column} is declared a date but holds ${JSON.stringify(value)}`);
@@ -929,7 +938,7 @@ function parseGeojson(text, options) {
 		const properties = feature.properties ?? {};
 		const point = pointOf(feature.geometry);
 		const own = (column) => Object.hasOwn(properties, column) ? properties[column] : void 0;
-		const id = options.idColumn === null ? String(number) : cellOf(own(options.idColumn), options.idColumn, number, "text");
+		const id = options.idColumn === null ? String(number) : cellOf$1(own(options.idColumn), options.idColumn, number, "text");
 		if (id === null) throw new NativeParseError("geojson", number, `the id column ${options.idColumn ?? ""} is empty`);
 		const cells = kinds.map(({ column, kind }) => {
 			if (column === POINT_COLUMNS.latitude || column === POINT_COLUMNS.longitude) {
@@ -937,7 +946,7 @@ function parseGeojson(text, options) {
 				const position = column === POINT_COLUMNS.latitude ? point?.latitude : point?.longitude;
 				return [column, position === void 0 ? null : position * (typeof kind === "object" ? kind.factor : 1)];
 			}
-			return [column, cellOf(own(column), column, number, kind)];
+			return [column, cellOf$1(own(column), column, number, kind)];
 		});
 		return {
 			...Object.fromEntries(cells),
@@ -946,6 +955,205 @@ function parseGeojson(text, options) {
 	}) };
 }
 //#endregion
+//#region src/parsers/hhcrsp.ts
+const FORMAT$9 = "hhcrsp";
+/** The labels of the sheet's blocks, each the top-left cell of a block whose header runs to its right and whose rows run below it. */
+const LABEL = {
+	patients: "Patients",
+	requests: "Pat / Ser",
+	times: "P/SerTime",
+	skills: "CgSkills",
+	caregiverWindows: "TwCaregivers",
+	patientWindows: "Tw Patients"
+};
+/** A service's header, `Service <k>`, a patient's row label and a caregiver's. */
+const SERVICE = /^Service (\d+)$/;
+const NUMBER$7 = /^-?\d+(?:\.\d+)?$/;
+/** How many required services a patient may have: the instances ask for one, or two that must be synchronised, and the parser has a duration column for each. */
+const MOST_SERVICES = 2;
+/**
+* Finds a block by its label: the one cell of the sheet that holds it, its header the cells to its right up to the first empty one, and its rows those below it up to the first whose label and cells are all empty. Past its header a block has an empty column, so the cell there must be empty in every row and a value the header does not label is refused rather than left unread; `Pat / Ser` instead keeps its count there, with the next block starting right after it, and its count is checked on its own.
+* @param grid - The sheet's cells by row.
+* @param label - The block's label.
+* @param pastHeader - What the column past the header holds: nothing, or the block's count.
+* @returns The block.
+* @throws NativeParseError when the label is in no cell or in more than one, or a row has a value in the empty column past the header.
+*/
+function blockOf(grid, label, pastHeader = "empty") {
+	const found = grid.flatMap((row, line) => row.flatMap((cell, column) => cell.trim() === label ? [{
+		line,
+		column
+	}] : []));
+	const [only] = found;
+	if (only === void 0 || found.length !== 1) throw new NativeParseError(FORMAT$9, 1, `expected one block labelled ${JSON.stringify(label)}, found ${String(found.length)}`);
+	const headerRow = grid[only.line] ?? [];
+	const end = headerRow.findIndex((cell, column) => column > only.column && cell.trim() === "");
+	const header = headerRow.slice(only.column + 1, end === -1 ? headerRow.length : end).map((cell) => cell.trim());
+	const rows = [];
+	for (let line = only.line + 1; line < grid.length; line += 1) {
+		const cells = (grid[line] ?? []).slice(only.column, only.column + 1 + header.length).map((cell) => cell.trim());
+		if (cells.every((cell) => cell === "")) break;
+		const past = (grid[line] ?? [])[only.column + 1 + header.length]?.trim();
+		if (pastHeader === "empty" && past !== void 0 && past !== "") throw new NativeParseError(FORMAT$9, line + 1, `the ${label} block's row holds ${JSON.stringify(past)} past its header ${JSON.stringify(header)}, which does not label it`);
+		rows.push({
+			line: line + 1,
+			label: cells[0] ?? "",
+			cells: cells.slice(1)
+		});
+	}
+	return {
+		line: only.line + 1,
+		column: only.column,
+		header,
+		rows
+	};
+}
+/**
+* Reads a cell as a finite number.
+* @param cell - The trimmed cell.
+* @param line - The 1-based line, for the error.
+* @param what - What the cell should be, for the error.
+* @returns The number.
+* @throws NativeParseError when the cell is not a decimal number.
+*/
+function numberOf$4(cell, line, what) {
+	if (cell === void 0 || !NUMBER$7.test(cell)) throw new NativeParseError(FORMAT$9, line, `expected ${what}, found ${JSON.stringify(cell)}`);
+	return Number(cell);
+}
+/**
+* Checks that a block's rows are labelled `<noun> 1` to `<noun> <count>` in order.
+* @param block - The block.
+* @param noun - The row label's word.
+* @param label - The block's label, for the error.
+* @throws NativeParseError naming the first row out of order.
+*/
+function checkNumbered(block, noun, label) {
+	block.rows.forEach((row, index) => {
+		if (row.label !== `${noun} ${String(index + 1)}`) throw new NativeParseError(FORMAT$9, row.line, `the ${label} block's row ${String(index + 1)} is labelled ${JSON.stringify(row.label)}, not ${noun} ${String(index + 1)}`);
+	});
+}
+/**
+* Checks that a block's header names the services 1 to k in order.
+* @param block - The block.
+* @param label - The block's label, for the error.
+* @returns The number of services, k.
+* @throws NativeParseError when a header cell is not the next service.
+*/
+function serviceCount(block, label) {
+	block.header.forEach((cell, index) => {
+		if (SERVICE.exec(cell)?.[1] !== String(index + 1)) throw new NativeParseError(FORMAT$9, block.line, `the ${label} block's header cell ${String(index + 1)} is ${JSON.stringify(cell)}, not Service ${String(index + 1)}`);
+	});
+	return block.header.length;
+}
+/**
+* Parses one sheet of a home health care routing and scheduling workbook (the layout of Bazirha's multiple-time-window, multiple-service instances, generated from Mankowska et al. 2014), read as the CSV of the sheet. The sheet holds labelled blocks side by side: `Patients` gives each node's X and Y, the care centre as node 0 first and again as the last row (the route's end, which must repeat the centre's position); `Pat / Ser` marks which of the services each patient requires with a 1 (a 0 or an empty cell is a service not required) and counts them in the column after the services, and the count must agree with the marks; `P/SerTime` gives each patient's duration for every service, after a row of zeros for the centre whose label may be empty; `CgSkills` and `TwCaregivers` give the caregivers' skills and working windows; and `Tw Patients` gives each patient's time windows by the headers `ETW 1` and `LTW 1`, and `ETW 2` and `LTW 2` where there is a second, in whatever order the sheet puts them. The travel time block, the caregivers' skills and their windows are not carried, since tasks/v1 has neither arcs nor resources: the caregivers are counted in `meta`. The sheets name no unit for their times.
+* @param text - The sheet's CSV text.
+* @returns The instance: its patient, caregiver and service counts as `meta`, and its nodes, the centre (id `0`) first and the patients (ids `1` to n) after it. A patient's `services` names its required services joined by a comma and a space (`Service 1, Service 5`), and its `duration1` and `duration2` are those services' durations in that order.
+* @throws NativeParseError when a block is missing or repeated, its rows or header are not the numbered patients, caregivers or services it should hold, the blocks disagree on the number of patients or caregivers, the centre's closing row does not repeat it, a patient requires no service or more than two, a requirement is not 0, 1 or empty or the count beside the marks disagrees with them, or a cell that should be a number is not.
+*/
+function parseHhcrsp(text) {
+	const grid = csvGrid(text);
+	const positions = blockOf(grid, LABEL.patients);
+	const requests = blockOf(grid, LABEL.requests, "count");
+	const times = blockOf(grid, LABEL.times);
+	const skills = blockOf(grid, LABEL.skills);
+	const caregiverWindows = blockOf(grid, LABEL.caregiverWindows);
+	const windows = blockOf(grid, LABEL.patientWindows);
+	const serviceKinds = serviceCount(requests, LABEL.requests);
+	if (serviceCount(times, LABEL.times) !== serviceKinds || serviceCount(skills, LABEL.skills) !== serviceKinds) throw new NativeParseError(FORMAT$9, times.line, `the ${LABEL.requests}, ${LABEL.times} and ${LABEL.skills} blocks name different numbers of services`);
+	checkNumbered(requests, "Patient", LABEL.requests);
+	checkNumbered(windows, "Patient", LABEL.patientWindows);
+	checkNumbered(skills, "Caregiver", LABEL.skills);
+	checkNumbered(caregiverWindows, "Caregiver", LABEL.caregiverWindows);
+	const patients = requests.rows.length;
+	const [centreTimes, ...patientTimes] = times.rows;
+	checkNumbered({
+		...times,
+		rows: patientTimes
+	}, "Patient", LABEL.times);
+	if (centreTimes === void 0 || ![
+		"",
+		"center",
+		"centre"
+	].includes(centreTimes.label.toLowerCase()) || windows.rows.length !== patients || patientTimes.length !== patients || skills.rows.length !== caregiverWindows.rows.length) throw new NativeParseError(FORMAT$9, requests.line, `the blocks disagree: ${String(patients)} patients requesting services, ${String(patientTimes.length)} with durations after the centre's row, ${String(windows.rows.length)} with time windows, and ${String(skills.rows.length)} caregivers with skills against ${String(caregiverWindows.rows.length)} with windows`);
+	if (positions.header.join(",") !== "X,Y" || positions.rows.length !== patients + 2 || positions.rows.some((row, index) => row.label !== String(index))) throw new NativeParseError(FORMAT$9, positions.line, `the ${LABEL.patients} block must give X and Y for nodes 0 to ${String(patients + 1)}, the centre, ${String(patients)} patients and the centre again`);
+	const position = (index) => {
+		const row = positions.rows[index];
+		if (row === void 0) throw new NativeParseError(FORMAT$9, positions.line, `the ${LABEL.patients} block has no node ${String(index)}`);
+		return {
+			x: numberOf$4(row.cells[0], row.line, "an X"),
+			y: numberOf$4(row.cells[1], row.line, "a Y"),
+			line: row.line
+		};
+	};
+	const { x, y } = position(0);
+	const closing = position(patients + 1);
+	if (closing.x !== x || closing.y !== y) throw new NativeParseError(FORMAT$9, closing.line, `the last node of the ${LABEL.patients} block is not at the centre's position, so it is not the route's end`);
+	const windowColumn = (name) => {
+		const index = windows.header.indexOf(name);
+		return index === -1 ? void 0 : index;
+	};
+	const columns = {
+		earliest1: windowColumn("ETW 1"),
+		latest1: windowColumn("LTW 1"),
+		earliest2: windowColumn("ETW 2"),
+		latest2: windowColumn("LTW 2")
+	};
+	if (columns.earliest1 === void 0 || columns.latest1 === void 0 || columns.earliest2 === void 0 !== (columns.latest2 === void 0) || windows.header.length !== (columns.earliest2 === void 0 ? 2 : 4)) throw new NativeParseError(FORMAT$9, windows.line, `the ${LABEL.patientWindows} header ${JSON.stringify(windows.header)} is not ETW 1 and LTW 1, with or without ETW 2 and LTW 2`);
+	const nodes = [{
+		id: "0",
+		role: "centre",
+		x,
+		y,
+		services: null,
+		duration1: null,
+		duration2: null,
+		earliest1: null,
+		latest1: null,
+		earliest2: null,
+		latest2: null
+	}];
+	requests.rows.forEach((request, index) => {
+		const required = request.cells.flatMap((cell, service) => {
+			if (cell !== "0" && cell !== "1" && cell !== "") throw new NativeParseError(FORMAT$9, request.line, `${request.label} has ${JSON.stringify(cell)} for Service ${String(service + 1)}, not 0, 1 or empty`);
+			return cell === "1" ? [service] : [];
+		});
+		const stated = (grid[request.line - 1] ?? [])[requests.column + serviceKinds + 1]?.trim();
+		if (stated !== String(required.length)) throw new NativeParseError(FORMAT$9, request.line, `${request.label} requires ${String(required.length)} services by its marks, and the count beside them is ${JSON.stringify(stated)}`);
+		if (required.length === 0 || required.length > MOST_SERVICES) throw new NativeParseError(FORMAT$9, request.line, `${request.label} requires ${String(required.length)} services, and a patient requires one or two`);
+		const timeRow = patientTimes[index];
+		const windowRow = windows.rows[index];
+		if (timeRow === void 0 || windowRow === void 0) throw new NativeParseError(FORMAT$9, request.line, `${request.label} has no durations or time windows`);
+		const duration = (which) => {
+			const service = required[which];
+			return service === void 0 ? null : numberOf$4(timeRow.cells[service], timeRow.line, `the duration of Service ${String(service + 1)}`);
+		};
+		const window = (column, what) => column === void 0 ? null : numberOf$4(windowRow.cells[column], windowRow.line, what);
+		const at = position(index + 1);
+		nodes.push({
+			id: String(index + 1),
+			role: "patient",
+			x: at.x,
+			y: at.y,
+			services: required.map((service) => `Service ${String(service + 1)}`).join(", "),
+			duration1: duration(0),
+			duration2: duration(1),
+			earliest1: window(columns.earliest1, "the opening of the first window"),
+			latest1: window(columns.latest1, "the closing of the first window"),
+			earliest2: window(columns.earliest2, "the opening of the second window"),
+			latest2: window(columns.latest2, "the closing of the second window")
+		});
+	});
+	return {
+		meta: {
+			patients,
+			caregivers: skills.rows.length,
+			serviceKinds
+		},
+		nodes
+	};
+}
+//#endregion
 //#region src/parsers/pajek.ts
 /** Section keywords, lower-cased, mapped to how their lines are read. `*Network` names the network and starts no section. `*Partition` and `*Vector` hold node attributes this version does not carry, so their lines are skipped, as are the `*Vertices` lines inside them. */
 const sections = /* @__PURE__ */ new Map([
@@ -1832,7 +2040,7 @@ function rowsOf(text) {
 * @returns The number.
 * @throws NativeParseError when the field is absent or not a decimal number.
 */
-function numberAt(row, index, what) {
+function numberAt$1(row, index, what) {
 	const field = row.fields[index];
 	if (field === void 0 || !NUMBER.test(field)) throw new NativeParseError(FORMAT$2, row.line, `expected ${what}, found ${JSON.stringify(field)}`);
 	return Number(field);
@@ -1904,7 +2112,7 @@ function parseVerolog2019(text) {
 		const row = rows[position];
 		const header = row === void 0 ? void 0 : keyed(row);
 		if (row === void 0 || header?.key !== key || header.value.length === 0) throw new NativeParseError(FORMAT$2, row?.line ?? 1, `expected "${key} = <value>", found ${JSON.stringify(row?.fields.join(" "))}`);
-		meta[name] = kind === "text" ? header.value.join(" ") : numberAt({
+		meta[name] = kind === "text" ? header.value.join(" ") : numberAt$1({
 			line: row.line,
 			fields: header.value
 		}, 0, `a number for ${key}`);
@@ -1923,8 +2131,8 @@ function parseVerolog2019(text) {
 			x: NaN,
 			y: NaN
 		} : {
-			x: numberAt(row, 1, "x"),
-			y: numberAt(row, 2, "y")
+			x: numberAt$1(row, 1, "x"),
+			y: numberAt$1(row, 2, "y")
 		};
 	};
 	const depot = {
@@ -1938,11 +2146,11 @@ function parseVerolog2019(text) {
 		amount: null
 	};
 	const requests = sections.REQUESTS.map((row) => {
-		const location = numberAt(row, REQUEST_AT.location, "a location id");
-		const fromDay = numberAt(row, REQUEST_AT.fromDay, "the first day");
-		const toDay = numberAt(row, REQUEST_AT.toDay, "the last day");
-		const machine = numberAt(row, REQUEST_AT.machine, "a machine id");
-		const amount = numberAt(row, REQUEST_AT.amount, "the amount");
+		const location = numberAt$1(row, REQUEST_AT.location, "a location id");
+		const fromDay = numberAt$1(row, REQUEST_AT.fromDay, "the first day");
+		const toDay = numberAt$1(row, REQUEST_AT.toDay, "the last day");
+		const machine = numberAt$1(row, REQUEST_AT.machine, "a machine id");
+		const amount = numberAt$1(row, REQUEST_AT.amount, "the amount");
 		if (!Number.isInteger(location) || location < 1 || location > locations.length) throw new NativeParseError(FORMAT$2, row.line, `location ${String(location)} is outside 1 to ${String(locations.length)}`);
 		if (!Number.isInteger(machine) || machine < 1 || machine > machines.length) throw new NativeParseError(FORMAT$2, row.line, `machine ${String(machine)} is outside 1 to ${String(machines.length)}`);
 		if (fromDay < 1 || fromDay > toDay || toDay > days) throw new NativeParseError(FORMAT$2, row.line, `the days ${String(fromDay)} to ${String(toDay)} are not within 1 to ${String(days)}`);
@@ -2433,6 +2641,7 @@ function parseNative(bytes, parser) {
 	if (parser.format === "tsplib") return parseTsplib(text);
 	if (parser.format === "verolog-2019") return parseVerolog2019(text);
 	if (parser.format === "vrp-rep") return parseVrpRep(text);
+	if (parser.format === "hhcrsp") return parseHhcrsp(text);
 	return parsePajek(text);
 }
 //#endregion
@@ -2477,6 +2686,465 @@ function bunzip2(bytes) {
 	const joined = Buffer.concat(chunks);
 	return new Uint8Array(joined.buffer, joined.byteOffset, joined.byteLength);
 }
+//#endregion
+//#region src/node/csv-text.ts
+/**
+* One CSV field as the table parser reads it: quoted, with its quotes doubled, when it holds a comma, a quote or a line break, and as it is otherwise.
+* @param text - The cell text.
+* @returns The field.
+*/
+function csvField(text) {
+	return /[",\r\n]/.test(text) ? `"${text.replaceAll("\"", "\"\"")}"` : text;
+}
+//#endregion
+//#region src/node/projection.ts
+const HALF_TURN_DEGREES = 180;
+const DEGREES_PER_RADIAN = HALF_TURN_DEGREES / Math.PI;
+/** An eighth of a turn, the angle from which `t` (Snyder 15-9) takes half the latitude. */
+const EIGHTH_TURN = Math.PI / 4;
+/** How close, in radians, two successive estimates of the latitude must be for the inverse projection to stop: far below a millimetre on the ground. */
+const LATITUDE_TOLERANCE = 1e-12;
+/** The most refinements the latitude takes; the series converges in a handful for any point a conic projection covers, so reaching this means the input is not a point the projection maps. */
+const LATITUDE_ITERATIONS = 32;
+/** The relative tolerance within which a unit's stated factor must equal the one keepset reads: a degree in radians, or the metre. */
+const UNIT_TOLERANCE = 1e-12;
+const DEGREE_IN_RADIANS = Math.PI / HALF_TURN_DEGREES;
+/**
+* The geodetic datums whose coordinates keepset takes as WGS84 without a shift: WGS84 itself, and ETRS89 and RGF93 (France's realisation of ETRS89), which were defined to coincide with WGS84 and have drifted from it by under a metre, below the precision of the geocoded addresses such data carries. Any other datum needs a transformation keepset does not make, so a coordinate system on it is refused. Names are compared without case, spaces or underscores, and both the ESRI spelling (`D_RGF_1993`) and the EPSG one (`Reseau_Geodesique_Francais_1993`) are listed.
+*/
+const WGS84_COINCIDENT_DATUMS = /* @__PURE__ */ new Set([
+	"dwgs1984",
+	"wgs1984",
+	"worldgeodeticsystem1984",
+	"drgf1993",
+	"reseaugeodesiquefrancais1993",
+	"detrs1989",
+	"europeanterrestrialreferencesystem1989"
+]);
+/**
+* Parses well-known text into its tree.
+* @param text - A `.prj` file's text.
+* @returns The root node.
+* @throws ArchiveError when the text is not well-formed WKT.
+*/
+function parseWkt(text) {
+	const tokenPattern = /\s*("(?:[^"]|"")*"|[A-Za-z_][A-Za-z0-9_]*|[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?|[[\](),])\s*/y;
+	const tokens = [];
+	while (tokenPattern.lastIndex < text.length) {
+		const at = tokenPattern.lastIndex;
+		const match = tokenPattern.exec(text);
+		if (match?.[1] === void 0) throw new ArchiveError(`the .prj is not well-known text: it has ${JSON.stringify(text.slice(at).trimStart().slice(0, 1))} where a keyword, text, number or bracket should be`);
+		tokens.push(match[1]);
+	}
+	let position = 0;
+	const node = () => {
+		const keyword = tokens[position];
+		if (keyword === void 0 || !/^[A-Za-z_]/.test(keyword) || !["[", "("].includes(tokens[position + 1] ?? "")) throw new ArchiveError(`the .prj is not well-known text: expected a keyword and a bracket at token ${String(position + 1)}`);
+		position += 2;
+		const values = [];
+		for (;;) {
+			const token = tokens[position];
+			if (token === void 0) throw new ArchiveError(`the .prj is not well-known text: ${keyword} is not closed`);
+			if (token.startsWith("\"")) {
+				values.push(token.slice(1, -1).replaceAll("\"\"", "\""));
+				position += 1;
+			} else if (/^[-+.\d]/.test(token)) {
+				values.push(Number(token));
+				position += 1;
+			} else values.push(node());
+			const separator = tokens[position];
+			position += 1;
+			if (separator === "]" || separator === ")") return {
+				keyword: keyword.toUpperCase(),
+				values
+			};
+			if (separator !== ",") throw new ArchiveError(`the .prj is not well-known text: expected a comma or a closing bracket in ${keyword}`);
+		}
+	};
+	const root = node();
+	if (position !== tokens.length) throw new ArchiveError("the .prj is not well-known text: it continues after its definition");
+	return root;
+}
+/**
+* The child nodes of a node with a keyword.
+* @param node - The parent.
+* @param keyword - The keyword, upper case.
+* @returns The children with that keyword, in order.
+*/
+function children(node, keyword) {
+	return node.values.filter((value) => typeof value === "object" && value.keyword === keyword);
+}
+/**
+* The one child node of a node with a keyword.
+* @param node - The parent.
+* @param keyword - The keyword, upper case.
+* @returns The child.
+* @throws ArchiveError when there is not exactly one.
+*/
+function child(node, keyword) {
+	const found = children(node, keyword);
+	const [only] = found;
+	if (only === void 0 || found.length !== 1) throw new ArchiveError(`the .prj's ${node.keyword} has ${String(found.length)} ${keyword} definitions, not one`);
+	return only;
+}
+/**
+* The number a node gives at a position.
+* @param node - The node.
+* @param index - The position of the number among its values.
+* @returns The number.
+* @throws ArchiveError when the value there is not a number.
+*/
+function numberAt(node, index) {
+	const value = node.values[index];
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new ArchiveError(`the .prj's ${node.keyword} has no number at position ${String(index + 1)}`);
+	return value;
+}
+/**
+* The text a node names itself by, its first value.
+* @param node - The node.
+* @returns The name.
+* @throws ArchiveError when the node does not start with a name.
+*/
+function nameOf(node) {
+	const [name] = node.values;
+	if (typeof name !== "string") throw new ArchiveError(`the .prj's ${node.keyword} has no name`);
+	return name;
+}
+/**
+* A name compared without case, spaces or underscores.
+* @param name - The name.
+* @returns Its comparison key.
+*/
+const keyOf = (name) => name.toLowerCase().replaceAll(/[\s_]+/g, "");
+/**
+* Checks that a factor is the one expected within a relative tolerance.
+* @param factor - The stated factor.
+* @param expected - The factor keepset reads.
+* @returns Whether they agree.
+*/
+const agrees = (factor, expected) => Math.abs(factor - expected) <= UNIT_TOLERANCE * expected;
+/**
+* Reads a geographic coordinate system: its datum must coincide with WGS84, its prime meridian must be Greenwich and its angular unit the degree.
+* @param geogcs - The `GEOGCS` node.
+* @returns The ellipsoid's semi-major axis in metres and its inverse flattening.
+* @throws ArchiveError naming what is not read.
+*/
+function readGeographic(geogcs) {
+	const datum = child(geogcs, "DATUM");
+	if (!WGS84_COINCIDENT_DATUMS.has(keyOf(nameOf(datum)))) throw new ArchiveError(`the .prj's datum is ${nameOf(datum)}, which needs a transformation to WGS84 that keepset does not make`);
+	const primeMeridian = numberAt(child(geogcs, "PRIMEM"), 1);
+	if (primeMeridian !== 0) throw new ArchiveError(`the .prj's prime meridian is ${String(primeMeridian)} degrees from Greenwich, which keepset does not read`);
+	const unit = numberAt(child(geogcs, "UNIT"), 1);
+	if (!agrees(unit, DEGREE_IN_RADIANS)) throw new ArchiveError(`the .prj's angular unit is ${String(unit)} radians, not the degree`);
+	const spheroid = child(datum, "SPHEROID");
+	return {
+		semiMajorAxis: numberAt(spheroid, 1),
+		inverseFlattening: numberAt(spheroid, 2)
+	};
+}
+/**
+* The inverse of the ellipsoidal Lambert conformal conic projection (Snyder, Map Projections: A Working Manual, USGS Professional Paper 1395, 1987, equations 15-1 to 15-11 and 7-9), which takes projected metres back to geodetic longitude and latitude.
+* @param projection - The projection's parameters.
+* @returns The inverse, which gives degrees.
+* @throws ArchiveError, when the returned function is called, for a point whose latitude does not converge.
+*/
+function inverseLambertConformalConic(projection) {
+	const flattening = 1 / projection.inverseFlattening;
+	const eccentricity = Math.sqrt(2 * flattening - flattening * flattening);
+	const m = (latitude) => Math.cos(latitude) / Math.sqrt(1 - (eccentricity * Math.sin(latitude)) ** 2);
+	const t = (latitude) => Math.tan(EIGHTH_TURN - latitude / 2) / ((1 - eccentricity * Math.sin(latitude)) / (1 + eccentricity * Math.sin(latitude))) ** (eccentricity / 2);
+	const { standardParallel1: phi1, standardParallel2: phi2 } = projection;
+	const n = phi1 === phi2 ? Math.sin(phi1) : (Math.log(m(phi1)) - Math.log(m(phi2))) / (Math.log(t(phi1)) - Math.log(t(phi2)));
+	const scaledF = projection.scaleFactor * m(phi1) / (n * t(phi1) ** n);
+	const rho0 = projection.semiMajorAxis * scaledF * t(projection.latitudeOfOrigin) ** n;
+	const sign = Math.sign(n);
+	return (x, y) => {
+		const easting = x - projection.falseEasting;
+		const northing = rho0 - (y - projection.falseNorthing);
+		const rho = sign * Math.hypot(easting, northing);
+		const theta = Math.atan2(sign * easting, sign * northing);
+		const tOfPoint = (rho / (projection.semiMajorAxis * scaledF)) ** (1 / n);
+		let latitude = Math.PI / 2 - 2 * Math.atan(tOfPoint);
+		for (let iteration = 0; iteration < LATITUDE_ITERATIONS; iteration += 1) {
+			const sine = eccentricity * Math.sin(latitude);
+			const next = Math.PI / 2 - 2 * Math.atan(tOfPoint * ((1 - sine) / (1 + sine)) ** (eccentricity / 2));
+			if (Math.abs(next - latitude) < LATITUDE_TOLERANCE) return {
+				longitude: (theta / n + projection.centralMeridian) * DEGREES_PER_RADIAN,
+				latitude: next * DEGREES_PER_RADIAN
+			};
+			latitude = next;
+		}
+		throw new ArchiveError(`the point (${String(x)}, ${String(y)}) is not one the projection maps: its latitude does not converge`);
+	};
+}
+/** The ESRI and OGC names of the Lambert conformal conic projection with two standard parallels, compared as `keyOf` compares them. */
+const LAMBERT_CONFORMAL_CONIC = /* @__PURE__ */ new Set(["lambertconformalconic", "lambertconformalconic2sp"]);
+/**
+* Reads a projected coordinate system on a Lambert conformal conic projection.
+* @param projcs - The `PROJCS` node.
+* @returns The inverse projection.
+* @throws ArchiveError naming what is not read.
+*/
+function readProjected(projcs) {
+	const ellipsoid = readGeographic(child(projcs, "GEOGCS"));
+	const projection = nameOf(child(projcs, "PROJECTION"));
+	if (!LAMBERT_CONFORMAL_CONIC.has(keyOf(projection))) throw new ArchiveError(`the .prj's projection is ${projection}, which keepset does not invert (it reads the Lambert conformal conic with two standard parallels)`);
+	const metresPerUnit = numberAt(child(projcs, "UNIT"), 1);
+	if (!agrees(metresPerUnit, 1)) throw new ArchiveError(`the .prj's linear unit is ${String(metresPerUnit)} metres, not the metre`);
+	const parameters = new Map(children(projcs, "PARAMETER").map((parameter) => [keyOf(nameOf(parameter)), numberAt(parameter, 1)]));
+	const parameter = (name, absent) => {
+		const value = parameters.get(keyOf(name)) ?? absent;
+		if (value === void 0) throw new ArchiveError(`the .prj's projection has no ${name} parameter`);
+		return value;
+	};
+	const known = new Set([
+		"False_Easting",
+		"False_Northing",
+		"Central_Meridian",
+		"Standard_Parallel_1",
+		"Standard_Parallel_2",
+		"Latitude_Of_Origin",
+		"Scale_Factor"
+	].map(keyOf));
+	const unknown = [...parameters.keys()].filter((name) => !known.has(name));
+	if (unknown.length > 0) throw new ArchiveError(`the .prj's projection has parameters keepset does not read: ${unknown.join(", ")}`);
+	return inverseLambertConformalConic({
+		...ellipsoid,
+		falseEasting: parameter("False_Easting"),
+		falseNorthing: parameter("False_Northing"),
+		centralMeridian: parameter("Central_Meridian") * DEGREE_IN_RADIANS,
+		latitudeOfOrigin: parameter("Latitude_Of_Origin") * DEGREE_IN_RADIANS,
+		standardParallel1: parameter("Standard_Parallel_1") * DEGREE_IN_RADIANS,
+		standardParallel2: parameter("Standard_Parallel_2") * DEGREE_IN_RADIANS,
+		scaleFactor: parameter("Scale_Factor", 1)
+	});
+}
+/**
+* The conversion a shapefile's `.prj` states from its coordinates to WGS84 longitude and latitude in degrees. A geographic system on a datum that coincides with WGS84 is read as it is; a projected one must use the Lambert conformal conic projection with two standard parallels in metres on such a datum. Every other system is refused, so a position is never given in the wrong place.
+* @param text - The `.prj` file's text.
+* @returns The conversion.
+* @throws ArchiveError naming the part of the definition keepset does not read.
+*/
+function toWgs84Of(text) {
+	const root = parseWkt(text);
+	if (root.keyword === "GEOGCS") {
+		readGeographic(root);
+		return (x, y) => ({
+			longitude: x,
+			latitude: y
+		});
+	}
+	if (root.keyword === "PROJCS") return readProjected(root);
+	throw new ArchiveError(`the .prj defines a ${root.keyword}, not a GEOGCS or a PROJCS`);
+}
+//#endregion
+//#region src/node/shapefile.ts
+/** The columns a point's position fills after the attribute table's: its coordinates as the shapefile stores them, then its WGS84 latitude and longitude, the same names the geojson parser gives a point feature's position. */
+const SHAPEFILE_POINT_COLUMNS = [
+	"geometry_x",
+	"geometry_y",
+	POINT_COLUMNS.latitude,
+	POINT_COLUMNS.longitude
+];
+/** The `.shp` file code and version every shapefile starts with (ESRI Shapefile Technical Description, 1998). */
+const SHP_FILE_CODE = 9994;
+const SHP_VERSION = 1e3;
+const SHP_HEADER_BYTES = 100;
+const SHP_RECORD_HEADER_BYTES = 8;
+/** Bytes in the 16-bit word the `.shp` measures lengths in. */
+const SHP_WORD_BYTES = 2;
+const SHP_VERSION_OFFSET = 28;
+const SHP_TYPE_OFFSET = 32;
+/** The shape types of a point layer: the null shape (no position), and the point with x and y, with a measure (`PointM`) or with z and a measure (`PointZ`), whose x and y come first. */
+const SHAPE = {
+	null: 0,
+	point: 1,
+	pointZ: 11,
+	pointM: 21
+};
+const POINT_TYPES = /* @__PURE__ */ new Set([
+	SHAPE.point,
+	SHAPE.pointZ,
+	SHAPE.pointM
+]);
+const COORDINATE_BYTES = 8;
+const SHAPE_TYPE_BYTES = 4;
+/** The dBASE header's offsets: the record count, the header's length and one record's length, then the field descriptors from byte 32, each 32 bytes, ended by a carriage return (dBASE III and later). */
+const DBF = {
+	recordCount: 4,
+	headerLength: 8,
+	recordLength: 10,
+	firstField: 32,
+	fieldBytes: 32,
+	nameBytes: 11,
+	typeOffset: 11,
+	lengthOffset: 16,
+	terminator: 13
+};
+/** The first byte of a dBASE record: a space for a live record and an asterisk for a deleted one. */
+const LIVE_RECORD = 32;
+const DATE_DIGITS = 8;
+const YEAR_DIGITS = 4;
+const MONTH_END = 6;
+/** The text encodings a `.cpg` may name, by the names a `.cpg` writes them with, compared without case, spaces, hyphens or underscores. ISO-8859-1 maps each byte to the code point of the same value and is decoded so, not with `TextDecoder`'s "latin1" label, which the WHATWG Encoding Standard maps to windows-1252 and so reads bytes 0x80 to 0x9F differently. */
+const CPG_ENCODINGS = /* @__PURE__ */ new Map([
+	["utf8", () => {
+		const decoder = new TextDecoder("utf-8", { fatal: true });
+		return (bytes) => decoder.decode(bytes);
+	}],
+	["88591", () => (bytes) => String.fromCharCode(...bytes)],
+	["iso88591", () => (bytes) => String.fromCharCode(...bytes)]
+]);
+/**
+* The decoder of the text encoding a `.cpg` names.
+* @param cpg - The `.cpg` file.
+* @returns The decoder, strict for UTF-8 so bytes that are not valid fail rather than becoming replacement characters.
+* @throws ArchiveError when it names an encoding keepset does not decode.
+*/
+function decoderOf(cpg) {
+	const named = new TextDecoder("utf-8").decode(cpg).trim();
+	const encoding = CPG_ENCODINGS.get(named.toLowerCase().replaceAll(/[\s_-]+/g, ""));
+	if (encoding === void 0) throw new ArchiveError(`the .cpg names the encoding ${JSON.stringify(named)}, and keepset decodes a shapefile's attributes only in UTF-8 or ISO-8859-1`);
+	return encoding();
+}
+/**
+* Reads a dBASE table's field descriptors.
+* @param dbf - The `.dbf` file.
+* @param decode - Decodes the field names.
+* @returns The record count, the header and record lengths, and the fields in order.
+* @throws ArchiveError when the header is cut short, a field is a memo or other type kept outside the table, or the fields do not fill a record.
+*/
+function dbfLayout(dbf, decode) {
+	if (dbf.length < DBF.firstField + 1) throw new ArchiveError("the .dbf is shorter than a dBASE header");
+	const view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
+	const headerLength = view.getUint16(DBF.headerLength, true);
+	const recordLength = view.getUint16(DBF.recordLength, true);
+	const fields = [];
+	let offset = 1;
+	for (let at = DBF.firstField; dbf[at] !== DBF.terminator; at += DBF.fieldBytes) {
+		if (at + DBF.fieldBytes > headerLength) throw new ArchiveError("the .dbf's field descriptors run past its header without the terminator");
+		const nameBytes = dbf.subarray(at, at + DBF.nameBytes);
+		const end = nameBytes.indexOf(0);
+		const name = decode(end === -1 ? nameBytes : nameBytes.subarray(0, end));
+		const type = String.fromCharCode(dbf[at + DBF.typeOffset] ?? 0);
+		const length = dbf[at + DBF.lengthOffset] ?? 0;
+		if (![
+			"C",
+			"N",
+			"F",
+			"D",
+			"L"
+		].includes(type)) throw new ArchiveError(`the .dbf field ${name} has the type ${JSON.stringify(type)}, which keeps its value outside the table or is not one keepset reads (it reads C, N, F, D and L)`);
+		fields.push({
+			name,
+			type,
+			offset,
+			length
+		});
+		offset += length;
+	}
+	if (offset !== recordLength) throw new ArchiveError(`the .dbf's fields fill ${String(offset)} bytes of a record its header says is ${String(recordLength)}`);
+	return {
+		records: view.getUint32(DBF.recordCount, true),
+		headerLength,
+		recordLength,
+		fields
+	};
+}
+/**
+* One dBASE value as the text of a CSV cell: character text trimmed, a number as written (an overflowed field of asterisks is empty, as dBASE writes no value that way), a date `YYYYMMDD` as ISO 8601 (all zeros or blank is empty), and a logical as `true` or `false` (`?` or blank is empty).
+* @param bytes - The field's bytes in the record.
+* @param field - The field.
+* @param decode - Decodes character text.
+* @param record - The 1-based record number, for errors.
+* @returns The cell text, empty for no value.
+* @throws ArchiveError when a date or logical value is malformed.
+*/
+function cellOf(bytes, field, decode, record) {
+	const text = decode(bytes).trim();
+	if (field.type === "C") return text;
+	if (field.type === "N" || field.type === "F") return /^\**$/.test(text) ? "" : text;
+	if (field.type === "D") {
+		if (text === "" || /^0+$/.test(text)) return "";
+		if (!new RegExp(`^\\d{${String(DATE_DIGITS)}}$`).test(text)) throw new ArchiveError(`record ${String(record)} has the date ${JSON.stringify(text)} in ${field.name}, not YYYYMMDD`);
+		return `${text.slice(0, YEAR_DIGITS)}-${text.slice(YEAR_DIGITS, MONTH_END)}-${text.slice(MONTH_END)}`;
+	}
+	if (text === "" || text === "?") return "";
+	if (/^[TtYy]$/.test(text)) return "true";
+	if (/^[FfNn]$/.test(text)) return "false";
+	throw new ArchiveError(`record ${String(record)} has the logical value ${JSON.stringify(text)} in ${field.name}`);
+}
+/**
+* Reads a point shapefile's positions in record order.
+* @param shp - The `.shp` file.
+* @returns Each record's x and y, or undefined for a null shape.
+* @throws ArchiveError when the file is not a shapefile, a record is not a point or the null shape, or the records are not numbered in order.
+*/
+function pointsOf(shp) {
+	const view = new DataView(shp.buffer, shp.byteOffset, shp.byteLength);
+	if (shp.length < SHP_HEADER_BYTES || view.getInt32(0, false) !== SHP_FILE_CODE || view.getInt32(SHP_VERSION_OFFSET, true) !== SHP_VERSION) throw new ArchiveError("the .shp is not a shapefile: it lacks the file code and version a shapefile starts with");
+	const layerType = view.getInt32(SHP_TYPE_OFFSET, true);
+	if (!POINT_TYPES.has(layerType) && layerType !== SHAPE.null) throw new ArchiveError(`the .shp holds shapes of type ${String(layerType)}, not points, and keepset reads only point shapefiles`);
+	const points = [];
+	for (let at = SHP_HEADER_BYTES; at < shp.length;) {
+		if (at + SHP_RECORD_HEADER_BYTES + SHAPE_TYPE_BYTES > shp.length) throw new ArchiveError(`the .shp ends inside the header of record ${String(points.length + 1)}`);
+		const number = view.getInt32(at, false);
+		const length = view.getInt32(at + SHAPE_TYPE_BYTES, false) * SHP_WORD_BYTES;
+		if (number !== points.length + 1) throw new ArchiveError(`the .shp's record ${String(points.length + 1)} is numbered ${String(number)}`);
+		const content = at + SHP_RECORD_HEADER_BYTES;
+		if (content + length > shp.length) throw new ArchiveError(`the .shp ends inside record ${String(number)}`);
+		const type = view.getInt32(content, true);
+		if (type === SHAPE.null) points.push(void 0);
+		else if (POINT_TYPES.has(type) && length >= 20) points.push({
+			x: view.getFloat64(content + SHAPE_TYPE_BYTES, true),
+			y: view.getFloat64(content + SHAPE_TYPE_BYTES + COORDINATE_BYTES, true)
+		});
+		else throw new ArchiveError(`the .shp's record ${String(number)} is a shape of type ${String(type)}, not a point`);
+		at = content + length;
+	}
+	return points;
+}
+/**
+* The position cells of a point, in the order of `SHAPEFILE_POINT_COLUMNS`.
+* @param x - The stored x.
+* @param y - The stored y.
+* @param toWgs84 - The conversion the `.prj` defines.
+* @returns The stored x and y, then the WGS84 latitude and longitude.
+*/
+function positionCells(x, y, toWgs84) {
+	const { latitude, longitude } = toWgs84(x, y);
+	return [
+		String(x),
+		String(y),
+		String(latitude),
+		String(longitude)
+	];
+}
+/**
+* Writes a point shapefile as CSV text, so a recipe reads it with the table parser: a header of the attribute table's field names followed by `geometry_x`, `geometry_y`, `geometry_latitude` and `geometry_longitude`, then one line per record in file order with its attributes (`cellOf` says how each is written), its coordinates as the shapefile stores them, and its position in WGS84 degrees, converted by the coordinate system the `.prj` defines (`toWgs84Of`). A record whose shape is null has empty position cells.
+* @param parts - The shapefile's parts.
+* @returns The CSV, in UTF-8.
+* @throws ArchiveError when a part is malformed, the geometry is not points, the geometry and the attribute table hold different numbers of records, an attribute record is marked deleted (it would leave the table and the geometry paired by nothing), a field is named like a position column, or the coordinate system is not one keepset converts.
+*/
+function pointShapefileToCsv(parts) {
+	const toWgs84 = toWgs84Of(new TextDecoder("utf-8").decode(parts.prj));
+	const decode = decoderOf(parts.cpg);
+	const layout = dbfLayout(parts.dbf, decode);
+	const points = pointsOf(parts.shp);
+	if (points.length !== layout.records) throw new ArchiveError(`the .shp holds ${String(points.length)} records and the .dbf ${String(layout.records)}, so they do not pair`);
+	if (parts.dbf.length < layout.headerLength + layout.records * layout.recordLength) throw new ArchiveError(`the .dbf ends before its ${String(layout.records)} records`);
+	const clash = layout.fields.find((field) => SHAPEFILE_POINT_COLUMNS.some((column) => column === field.name));
+	if (clash !== void 0) throw new ArchiveError(`the .dbf has a field named ${clash.name}, which is a column of the point's position`);
+	const lines = [[...layout.fields.map((field) => field.name), ...SHAPEFILE_POINT_COLUMNS].map(csvField).join(",")];
+	points.forEach((point, index) => {
+		const start = layout.headerLength + index * layout.recordLength;
+		if (parts.dbf[start] !== LIVE_RECORD) throw new ArchiveError(`the .dbf's record ${String(index + 1)} is marked deleted`);
+		const cells = layout.fields.map((field) => cellOf(parts.dbf.subarray(start + field.offset, start + field.offset + field.length), field, decode, index + 1));
+		const geometry = point === void 0 ? SHAPEFILE_POINT_COLUMNS.map(() => "") : positionCells(point.x, point.y, toWgs84);
+		lines.push([...cells, ...geometry].map(csvField).join(","));
+	});
+	return new TextEncoder().encode(`${lines.join("\n")}\n`);
+}
 /** The ustar header layout (POSIX.1-1988, pax(1) "ustar Interchange Format"): each field's byte offset and length. */
 const HEADER = {
 	name: {
@@ -2523,7 +3191,7 @@ const BYTE_RADIX = 256;
 * @param length - Field length.
 * @returns The field text.
 */
-function field$1(bytes, offset, length) {
+function field(bytes, offset, length) {
 	const slice = bytes.subarray(offset, offset + length);
 	const end = slice.indexOf(0);
 	return new TextDecoder().decode(end === -1 ? slice : slice.subarray(0, end));
@@ -2542,7 +3210,7 @@ function numeric(bytes, offset, length) {
 		for (const byte of bytes.subarray(offset + 1, offset + length)) value = value * BYTE_RADIX + byte;
 		return value;
 	}
-	const text = field$1(bytes, offset, length).trim();
+	const text = field(bytes, offset, length).trim();
 	if (!/^[0-7]*$/.test(text)) throw new ArchiveError(`tar header field is not octal: ${JSON.stringify(text)}`);
 	return text === "" ? 0 : Number.parseInt(text, 8);
 }
@@ -2578,21 +3246,21 @@ function readTar(bytes) {
 		for (const [index, byte] of header.entries()) sum += index >= checksum.offset && index < checksum.offset + checksum.length ? 32 : byte;
 		if (sum !== numeric(header, checksum.offset, checksum.length)) throw new ArchiveError(`tar header at byte ${String(offset)} fails its checksum`);
 		const size = numeric(header, HEADER.size.offset, HEADER.size.length);
-		const type = field$1(header, HEADER.type.offset, HEADER.type.length);
+		const type = field(header, HEADER.type.offset, HEADER.type.length);
 		const dataStart = offset + 512;
 		if (dataStart + size > bytes.length) throw new ArchiveError(`tar member at byte ${String(offset)} runs past the end of the archive`);
 		const data = bytes.subarray(dataStart, dataStart + size);
 		offset = dataStart + Math.ceil(size / 512) * 512;
 		if (type === "L") {
-			longName = field$1(data, 0, data.length);
+			longName = field(data, 0, data.length);
 			continue;
 		}
 		if (type === "x") {
 			longName = paxPath(data);
 			continue;
 		}
-		const name = field$1(header, HEADER.name.offset, HEADER.name.length);
-		const prefix = field$1(header, HEADER.magic.offset, HEADER.magic.length).startsWith("ustar") ? field$1(header, HEADER.prefix.offset, HEADER.prefix.length) : "";
+		const name = field(header, HEADER.name.offset, HEADER.name.length);
+		const prefix = field(header, HEADER.magic.offset, HEADER.magic.length).startsWith("ustar") ? field(header, HEADER.prefix.offset, HEADER.prefix.length) : "";
 		const path = longName ?? (prefix === "" ? name : `${prefix}/${name}`);
 		longName = void 0;
 		if (type === "0" || type === "" || type === "7") members.push({
@@ -2741,14 +3409,6 @@ function columnOf(reference) {
 	return index - 1;
 }
 /**
-* One CSV field: quoted when it holds a comma, a quote or a line break.
-* @param text - The cell text.
-* @returns The field.
-*/
-function field(text) {
-	return /[",\r\n]/.test(text) ? `"${text.replaceAll("\"", "\"\"")}"` : text;
-}
-/**
 * Finds the part that holds a named sheet.
 * @param workbook - The `workbook.xml` text.
 * @param rels - The workbook's relationships text.
@@ -2812,6 +3472,26 @@ function readRows(xml, strings, dates, date1904) {
 	};
 }
 /**
+* The names of a workbook's sheets, in the order the workbook lists them, which is the order of the tabs an editor shows.
+* @param bytes - The workbook.
+* @returns The sheet names.
+* @throws ArchiveError when the bytes are not a workbook.
+*/
+function sheetNames(bytes) {
+	let part;
+	try {
+		part = getOwn(unzipSync(bytes, { filter: (file) => file.name === "xl/workbook.xml" }), "xl/workbook.xml");
+	} catch (error) {
+		throw new ArchiveError(`not a valid workbook: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	if (part === void 0) throw new ArchiveError("the file is not an xlsx workbook: it has no xl/workbook.xml");
+	return elements(new TextDecoder("utf-8").decode(part), "sheet").map((sheet, index) => {
+		const name = sheet["name"];
+		if (name === void 0) throw new ArchiveError(`the workbook's sheet ${String(index + 1)} has no name`);
+		return name;
+	});
+}
+/**
 * 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.
 * @param bytes - The workbook.
 * @param sheet - The sheet's name.
@@ -2847,7 +3527,7 @@ function sheetToCsv(bytes, sheet) {
 	const lines = [];
 	for (let number = 1; number <= last; number += 1) {
 		const cells = rows.get(number) ?? [];
-		lines.push(Array.from({ length: width }, (_empty, column) => field(cells[column] ?? "")).join(","));
+		lines.push(Array.from({ length: width }, (_empty, column) => csvField(cells[column] ?? "")).join(","));
 	}
 	return new TextEncoder().encode(lines.length === 0 ? "" : `${lines.join("\n")}\n`);
 }
@@ -2923,6 +3603,7 @@ function unpack(bytes, archive) {
 		bytes: sheetToCsv(bytes, archive.sheet),
 		member: archive.sheet
 	};
+	if (archive.kind === "shapefile") return unpackShapefile(bytes, archive.member);
 	const outer = selectMember(bytes, archive);
 	if (archive.inner === void 0) return outer;
 	if (archive.inner.kind === "gzip") return {
@@ -2967,13 +3648,84 @@ function selectMember(bytes, archive) {
 	};
 }
 /**
-* Unpacks downloaded bytes into every file a collection's selector matches.
+* Unpacks a zipped point shapefile into the CSV its attribute table and positions make. The `.dbf`, `.prj` and `.cpg` are the members with the `.shp`'s path and their own extension, matched without case as GIS tools write extensions either way.
+* @param bytes - The zip's bytes.
+* @param member - The selector of the `.shp`.
+* @returns The CSV, and the `.shp`'s path as the member read.
+* @throws ArchiveError when the bytes are not a zip, the selector does not match exactly one `.shp`, a part beside it is missing or there is more than one of it, or the shapefile cannot be read.
+*/
+function unpackShapefile(bytes, member) {
+	const names = [];
+	unzip(bytes, (file) => {
+		names.push(file.name);
+		return false;
+	});
+	const shp = pick(names, member);
+	if (!shp.toLowerCase().endsWith(".shp")) throw new ArchiveError(`the shapefile member ${shp} is not a .shp`);
+	const stem = shp.slice(0, -4);
+	const beside = (extension) => {
+		const matched = names.filter((name) => name.length === stem.length + extension.length && name.startsWith(stem) && name.toLowerCase().endsWith(extension));
+		const [only] = matched;
+		if (only === void 0 || matched.length !== 1) throw new ArchiveError(`expected one ${extension} beside ${shp}, found ${String(matched.length)} among: ${names.join(", ")}`);
+		return only;
+	};
+	const paths = {
+		shp,
+		dbf: beside(".dbf"),
+		prj: beside(".prj"),
+		cpg: beside(".cpg")
+	};
+	const wanted = new Set(Object.values(paths));
+	const files = unzip(bytes, (candidate) => wanted.has(candidate.name));
+	const read = (path) => {
+		const file = getOwn(files, path);
+		if (file === void 0) throw new ArchiveError(`zip member ${path} could not be read`);
+		return file;
+	};
+	return {
+		bytes: pointShapefileToCsv({
+			shp: read(paths.shp),
+			dbf: read(paths.dbf),
+			prj: read(paths.prj),
+			cpg: read(paths.cpg)
+		}),
+		member: shp
+	};
+}
+/**
+* Unpacks downloaded bytes into every file a collection's selector matches, or, with an `xlsx` inner layout, into every sheet of every matched workbook that its `sheets` pattern matches as the sheet's CSV, at the member's path and the sheet's name joined by `/`, members in path order and sheets in the workbook's order.
 * @param bytes - The downloaded bytes.
 * @param archive - The recipe's archive layout, which selects members with `members`.
-* @returns Each matching file, in path order.
-* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or the selector matches no member.
+* @returns Each file.
+* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind, the selector matches no member, or a member an `xlsx` layout reads is not a workbook or has no sheet the pattern matches.
 */
 function unpackMembers(bytes, archive) {
+	const members = selectMembers(bytes, archive);
+	if (archive.inner === void 0) return members;
+	const { sheets } = archive.inner;
+	const wanted = sheets === void 0 ? void 0 : new RegExp(`^(?:${sheets})$`, "u");
+	return members.flatMap((member) => {
+		let names;
+		try {
+			names = sheetNames(member.bytes).filter((sheet) => wanted === void 0 || wanted.test(sheet));
+		} catch (error) {
+			throw new ArchiveError(`member ${member.path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		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)
+		}));
+	});
+}
+/**
+* Unpacks every member a collection's selector matches.
+* @param bytes - The downloaded bytes.
+* @param archive - The recipe's archive layout.
+* @returns Each matching member, in path order.
+* @throws ArchiveError when the bytes are not a well-formed archive of the stated kind or the selector matches no member.
+*/
+function selectMembers(bytes, archive) {
 	if (archive.kind === "zip") {
 		const names = [];
 		unzip(bytes, (file) => {