keepset 0.25.0 → 0.27.0

package/dist/node/fetch-dataset.js

@@ -1,4 +1,4 @@
-import { $ as NativeParseError, F as getOwn, J as ArchiveError, L as countTarget, Q as KeepsetError, et as RecipeError, t as getDataset, z as getTarget } from "../bundled-Dkvod55t.js";
+import { $ as NativeParseError, F as getOwn, J as ArchiveError, L as countTarget, Q as KeepsetError, et as RecipeError, t as getDataset, z as getTarget } from "../bundled-qRweq3SB.js";
 import { RoundTripMismatchError, assertRoundTrip, encode } from "twindex";
 import { z } from "zod";
 import { createHash } from "node:crypto";
@@ -104,7 +104,7 @@ function parseEdgeList(text, options) {
 //#endregion
 //#region src/parsers/gml.ts
 const KEY = /[A-Za-z_][A-Za-z0-9_]*/y;
-const NUMBER$3 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
+const NUMBER$6 = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[Ee][+-]?\d+)?/y;
 /**
 * Matches a sticky pattern at a position.
 * @param pattern - A sticky regular expression.
@@ -155,7 +155,7 @@ function tokenise(text) {
 			position = end + 1;
 		} else {
 			const key = matchAt(KEY, text, position);
-			const number = key === void 0 ? matchAt(NUMBER$3, text, position) : void 0;
+			const number = key === void 0 ? matchAt(NUMBER$6, text, position) : void 0;
 			const match = key ?? number;
 			if (match === void 0) throw new NativeParseError("gml", line, `unexpected character ${JSON.stringify(char)}`);
 			tokens.push({
@@ -356,7 +356,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$1 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+const DECIMAL$2 = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** The byte order mark some exporters put before the first header. */
 const BYTE_ORDER_MARK = "";
 /**
@@ -559,7 +559,7 @@ function* withoutByteOrderMark(text) {
 */
 function numeric$1(cell, factor, column, line) {
 	if (cell === "") return null;
-	if (!DECIMAL$1.test(cell)) throw new NativeParseError("csv-table", line, `column ${column} is declared numeric but holds ${JSON.stringify(cell)}`);
+	if (!DECIMAL$2.test(cell)) throw new NativeParseError("csv-table", line, `column ${column} is declared numeric but holds ${JSON.stringify(cell)}`);
 	return Number(cell) * factor;
 }
 /**
@@ -832,10 +832,47 @@ function parsePajek(text) {
 	};
 }
 //#endregion
+//#region src/parsers/customer-points.ts
+const FORMAT$6 = "customer-points";
+const NUMBER$5 = /^-?\d+(?:\.\d+)?$/;
+const WHOLE$2 = /^\d+$/;
+/**
+* Parses a customer points file, as the OAR Bench arc routing benchmark generator writes the customers of an instance: the line `customers <count>`, then one row per customer of its id, x and y, separated by tabs or spaces, with blank lines skipped. The positions are planar coordinates in the instance's own unit, which the file does not name. The row count must be the announced count, which catches a truncated file.
+* @param text - The file text.
+* @returns The instance: the customer count as `meta` and the customers as nodes, in file order.
+* @throws NativeParseError naming the line for a first line that is not `customers <count>`, a row that is not an id and two numbers, a repeated id, or a row count that is not the announced one.
+*/
+function parseCustomerPoints(text) {
+	const rows = lines(text).map((raw, index) => ({
+		line: index + 1,
+		fields: raw.trim().split(/\s+/).filter((field) => field !== "")
+	})).filter((row) => row.fields.length > 0);
+	const [first, ...body] = rows;
+	const [key, count, ...extra] = first?.fields ?? [];
+	if (first === void 0 || key !== "customers" || count === void 0 || !WHOLE$2.test(count) || extra.length > 0) throw new NativeParseError(FORMAT$6, first?.line ?? 1, `expected "customers <count>", found ${JSON.stringify(first?.fields.join(" "))}`);
+	const seen = /* @__PURE__ */ new Set();
+	const nodes = body.map((row) => {
+		const [id, x, y, ...rest] = row.fields;
+		if (id === void 0 || x === void 0 || y === void 0 || rest.length > 0 || !WHOLE$2.test(id) || !NUMBER$5.test(x) || !NUMBER$5.test(y)) throw new NativeParseError(FORMAT$6, row.line, `expected a customer id and two numbers, found ${JSON.stringify(row.fields.join(" "))}`);
+		if (seen.has(id)) throw new NativeParseError(FORMAT$6, row.line, `customer ${id} appears twice`);
+		seen.add(id);
+		return {
+			id,
+			x: Number(x),
+			y: Number(y)
+		};
+	});
+	if (nodes.length !== Number(count)) throw new NativeParseError(FORMAT$6, rows[rows.length - 1]?.line ?? first.line, `the file announces ${count} customers, found ${String(nodes.length)}`);
+	return {
+		meta: { customers: Number(count) },
+		nodes
+	};
+}
+//#endregion
 //#region src/parsers/solomon.ts
-const FORMAT$2 = "solomon";
+const FORMAT$5 = "solomon";
 /** A line of integers or decimals separated by any run of spaces and tabs, as the files write rows (Solomon's with padded spaces, the Tenerife set with tabs). */
-const NUMBER$2 = /^-?\d+(?:\.\d+)?$/;
+const NUMBER$4 = /^-?\d+(?:\.\d+)?$/;
 /**
 * Reads a token as a finite number.
 * @param token - The token.
@@ -844,8 +881,8 @@ const NUMBER$2 = /^-?\d+(?:\.\d+)?$/;
 * @returns The number.
 * @throws NativeParseError when the token is not a decimal number.
 */
-function numberOf$1(token, line, what) {
-	if (!NUMBER$2.test(token)) throw new NativeParseError(FORMAT$2, line, `expected ${what}, found ${JSON.stringify(token)}`);
+function numberOf$3(token, line, what) {
+	if (!NUMBER$4.test(token)) throw new NativeParseError(FORMAT$5, line, `expected ${what}, found ${JSON.stringify(token)}`);
 	return Number(token);
 }
 /**
@@ -858,7 +895,7 @@ function parseSolomon(text) {
 	const all = lines(text);
 	const present = (index) => (all[index] ?? "").trim();
 	const name = present(0);
-	if (name === "") throw new NativeParseError(FORMAT$2, 1, "expected the instance name on the first line");
+	if (name === "") throw new NativeParseError(FORMAT$5, 1, "expected the instance name on the first line");
 	const meta = { name };
 	const nodes = [];
 	const seen = /* @__PURE__ */ new Set();
@@ -874,7 +911,7 @@ function parseSolomon(text) {
 			awaitingHeader = true;
 			continue;
 		}
-		if (section === "preamble") throw new NativeParseError(FORMAT$2, line, `expected VEHICLE or CUSTOMER, found ${JSON.stringify(trimmed)}`);
+		if (section === "preamble") throw new NativeParseError(FORMAT$5, line, `expected VEHICLE or CUSTOMER, found ${JSON.stringify(trimmed)}`);
 		if (awaitingHeader) {
 			awaitingHeader = false;
 			continue;
@@ -882,29 +919,29 @@ function parseSolomon(text) {
 		const tokens = trimmed.split(/\s+/);
 		if (section === "vehicle") {
 			const [vehicles, capacity, ...extra] = tokens;
-			if (vehicles === void 0 || capacity === void 0 || extra.length > 0) throw new NativeParseError(FORMAT$2, line, `expected the vehicle count and capacity, found ${JSON.stringify(trimmed)}`);
-			meta.vehicles = numberOf$1(vehicles, line, "the vehicle count");
-			meta.capacity = numberOf$1(capacity, line, "the vehicle capacity");
+			if (vehicles === void 0 || capacity === void 0 || extra.length > 0) throw new NativeParseError(FORMAT$5, line, `expected the vehicle count and capacity, found ${JSON.stringify(trimmed)}`);
+			meta.vehicles = numberOf$3(vehicles, line, "the vehicle count");
+			meta.capacity = numberOf$3(capacity, line, "the vehicle capacity");
 			continue;
 		}
 		const [id, x, y, demand, ready, due, service, ...extra] = tokens;
-		if (id === void 0 || x === void 0 || y === void 0 || demand === void 0 || ready === void 0 || due === void 0 || service === void 0 || extra.length > 0) throw new NativeParseError(FORMAT$2, line, `expected seven numbers (id, x, y, demand, ready, due, service), found ${JSON.stringify(trimmed)}`);
-		if (!/^\d+$/.test(id)) throw new NativeParseError(FORMAT$2, line, `expected a whole number node id, found ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw new NativeParseError(FORMAT$2, line, `node ${id} appears twice`);
+		if (id === void 0 || x === void 0 || y === void 0 || demand === void 0 || ready === void 0 || due === void 0 || service === void 0 || extra.length > 0) throw new NativeParseError(FORMAT$5, line, `expected seven numbers (id, x, y, demand, ready, due, service), found ${JSON.stringify(trimmed)}`);
+		if (!/^\d+$/.test(id)) throw new NativeParseError(FORMAT$5, line, `expected a whole number node id, found ${JSON.stringify(id)}`);
+		if (seen.has(id)) throw new NativeParseError(FORMAT$5, line, `node ${id} appears twice`);
 		seen.add(id);
 		nodes.push({
 			id,
-			x: numberOf$1(x, line, "x"),
-			y: numberOf$1(y, line, "y"),
-			demand: numberOf$1(demand, line, "the demand"),
-			ready: numberOf$1(ready, line, "the ready time"),
-			due: numberOf$1(due, line, "the due date"),
-			service: numberOf$1(service, line, "the service time")
+			x: numberOf$3(x, line, "x"),
+			y: numberOf$3(y, line, "y"),
+			demand: numberOf$3(demand, line, "the demand"),
+			ready: numberOf$3(ready, line, "the ready time"),
+			due: numberOf$3(due, line, "the due date"),
+			service: numberOf$3(service, line, "the service time")
 		});
 	}
-	if (section !== "customer") throw new NativeParseError(FORMAT$2, all.length, "expected a CUSTOMER section");
-	if (nodes.length === 0) throw new NativeParseError(FORMAT$2, all.length, "the CUSTOMER section has no rows");
-	if (meta.vehicles === void 0 || meta.capacity === void 0) throw new NativeParseError(FORMAT$2, all.length, "expected a VEHICLE section with the vehicle count and capacity");
+	if (section !== "customer") throw new NativeParseError(FORMAT$5, all.length, "expected a CUSTOMER section");
+	if (nodes.length === 0) throw new NativeParseError(FORMAT$5, all.length, "the CUSTOMER section has no rows");
+	if (meta.vehicles === void 0 || meta.capacity === void 0) throw new NativeParseError(FORMAT$5, all.length, "expected a VEHICLE section with the vehicle count and capacity");
 	return {
 		meta: {
 			name: meta.name,
@@ -916,10 +953,10 @@ function parseSolomon(text) {
 }
 //#endregion
 //#region src/parsers/top.ts
-const FORMAT$1 = "top";
+const FORMAT$4 = "top";
 /** The header lines before the first point: `n`, `m` and `tmax`. */
 const HEADER_LINES = 3;
-const NUMBER$1 = /^-?\d+(?:\.\d+)?$/;
+const NUMBER$3 = /^-?\d+(?:\.\d+)?$/;
 /**
 * Reads the value of a header line `<key> <number>`.
 * @param text - The line.
@@ -930,7 +967,7 @@ const NUMBER$1 = /^-?\d+(?:\.\d+)?$/;
 */
 function headerOf(text, key, line) {
 	const [name, value, ...extra] = (text ?? "").trim().split(/\s+/);
-	if (name !== key || value === void 0 || extra.length > 0 || !NUMBER$1.test(value)) throw new NativeParseError(FORMAT$1, line, `expected "${key} <number>", found ${JSON.stringify((text ?? "").trim())}`);
+	if (name !== key || value === void 0 || extra.length > 0 || !NUMBER$3.test(value)) throw new NativeParseError(FORMAT$4, line, `expected "${key} <number>", found ${JSON.stringify((text ?? "").trim())}`);
 	return Number(value);
 }
 /**
@@ -949,11 +986,11 @@ function parseTop(text) {
 	const points = headerOf(first?.text, "n", first?.line ?? 1);
 	const paths = headerOf(second?.text, "m", second?.line ?? 2);
 	const budget = headerOf(third?.text, "tmax", third?.line ?? HEADER_LINES);
-	if (!Number.isInteger(points) || points < 2) throw new NativeParseError(FORMAT$1, first?.line ?? 1, `expected at least a start and an end point, found n ${String(points)}`);
-	if (rows.length !== points) throw new NativeParseError(FORMAT$1, all[all.length - 1]?.line ?? 1, `the header gives ${String(points)} points, found ${String(rows.length)} rows`);
+	if (!Number.isInteger(points) || points < 2) throw new NativeParseError(FORMAT$4, first?.line ?? 1, `expected at least a start and an end point, found n ${String(points)}`);
+	if (rows.length !== points) throw new NativeParseError(FORMAT$4, all[all.length - 1]?.line ?? 1, `the header gives ${String(points)} points, found ${String(rows.length)} rows`);
 	const nodes = rows.map((row, index) => {
 		const [x, y, score, ...extra] = row.text.split(/\s+/);
-		if (x === void 0 || y === void 0 || score === void 0 || extra.length > 0 || !NUMBER$1.test(x) || !NUMBER$1.test(y) || !NUMBER$1.test(score)) throw new NativeParseError(FORMAT$1, row.line, `expected three numbers (x, y, score), found ${JSON.stringify(row.text)}`);
+		if (x === void 0 || y === void 0 || score === void 0 || extra.length > 0 || !NUMBER$3.test(x) || !NUMBER$3.test(y) || !NUMBER$3.test(score)) throw new NativeParseError(FORMAT$4, row.line, `expected three numbers (x, y, score), found ${JSON.stringify(row.text)}`);
 		return {
 			id: String(index),
 			x: Number(x),
@@ -973,7 +1010,7 @@ function parseTop(text) {
 }
 //#endregion
 //#region src/parsers/toptw.ts
-const FORMAT = "toptw";
+const FORMAT$3 = "toptw";
 /** How many numbers the first header line holds (k, paths, customers, t) and the second (D, capacity). */
 const FIRST_HEADER_NUMBERS = 4;
 const SECOND_HEADER_NUMBERS = 2;
@@ -981,7 +1018,7 @@ const SECOND_HEADER_NUMBERS = 2;
 const LIST_LENGTH_AT = 6;
 const LIST_STARTS_AT = 7;
 const ROW_NUMBERS_BESIDE_LIST = 9;
-const NUMBER = /^-?\d+(?:\.\d+)?$/;
+const NUMBER$2 = /^-?\d+(?:\.\d+)?$/;
 /**
 * Reads a token as a finite number.
 * @param token - The token.
@@ -990,8 +1027,8 @@ const NUMBER = /^-?\d+(?:\.\d+)?$/;
 * @returns The number.
 * @throws NativeParseError when the token is not a decimal number.
 */
-function numberOf(token, line, what) {
-	if (token === void 0 || !NUMBER.test(token)) throw new NativeParseError(FORMAT, line, `expected ${what}, found ${JSON.stringify(token)}`);
+function numberOf$2(token, line, what) {
+	if (token === void 0 || !NUMBER$2.test(token)) throw new NativeParseError(FORMAT$3, line, `expected ${what}, found ${JSON.stringify(token)}`);
 	return Number(token);
 }
 /**
@@ -1005,8 +1042,8 @@ function numberOf(token, line, what) {
 */
 function numbersOf(text, count, line, what) {
 	const tokens = text.trim().split(/\s+/);
-	if (tokens.length !== count) throw new NativeParseError(FORMAT, line, `expected ${what}, found ${JSON.stringify(text.trim())}`);
-	return tokens.map((token) => numberOf(token, line, what));
+	if (tokens.length !== count) throw new NativeParseError(FORMAT$3, line, `expected ${what}, found ${JSON.stringify(text.trim())}`);
+	return tokens.map((token) => numberOf$2(token, line, what));
 }
 /**
 * Parses a team orienteering problem with time windows instance (TOPTW, in the layout of Righini and Salani, as the KU Leuven pages describe it). The first line holds four numbers, of which the second is the number of paths and the third the number of customers, the second line two, of which the second is the vehicle capacity, and then one row per node, the depot first: its id, position, service duration, profit, an unused number, the length of a list of unused numbers, that list, and the opening and closing of its time window. Columns are separated by any run of spaces, and blank or whitespace only lines are skipped. The row count must be the customer count plus one, which catches a truncated file. The time quantities are in the unit of the source's coordinate grid, which the format does not name.
@@ -1020,30 +1057,30 @@ function parseToptw(text) {
 		text: raw.trim()
 	})).filter((entry) => entry.text !== "");
 	const [first, second, ...rows] = all;
-	if (first === void 0 || second === void 0) throw new NativeParseError(FORMAT, 1, "expected the two header lines");
+	if (first === void 0 || second === void 0) throw new NativeParseError(FORMAT$3, 1, "expected the two header lines");
 	const [, paths, customers] = numbersOf(first.text, FIRST_HEADER_NUMBERS, first.line, "four numbers (k, paths, customers, t)");
 	const [, capacity] = numbersOf(second.text, SECOND_HEADER_NUMBERS, second.line, "two numbers (D, capacity)");
-	if (paths === void 0 || customers === void 0 || capacity === void 0) throw new NativeParseError(FORMAT, first.line, "the header lacks a number");
+	if (paths === void 0 || customers === void 0 || capacity === void 0) throw new NativeParseError(FORMAT$3, first.line, "the header lacks a number");
 	const seen = /* @__PURE__ */ new Set();
 	const nodes = rows.map((row) => {
 		const tokens = row.text.split(/\s+/);
-		const listLength = numberOf(tokens[LIST_LENGTH_AT], row.line, "the length of the list after the unused number");
-		if (!Number.isInteger(listLength) || listLength < 0 || tokens.length !== ROW_NUMBERS_BESIDE_LIST + listLength) throw new NativeParseError(FORMAT, row.line, `expected ${String(ROW_NUMBERS_BESIDE_LIST + listLength)} numbers for a list of ${String(listLength)}, found ${String(tokens.length)}`);
+		const listLength = numberOf$2(tokens[LIST_LENGTH_AT], row.line, "the length of the list after the unused number");
+		if (!Number.isInteger(listLength) || listLength < 0 || tokens.length !== ROW_NUMBERS_BESIDE_LIST + listLength) throw new NativeParseError(FORMAT$3, row.line, `expected ${String(ROW_NUMBERS_BESIDE_LIST + listLength)} numbers for a list of ${String(listLength)}, found ${String(tokens.length)}`);
 		const [id] = tokens;
-		if (id === void 0 || !/^\d+$/.test(id)) throw new NativeParseError(FORMAT, row.line, `expected a whole number node id, found ${JSON.stringify(id)}`);
-		if (seen.has(id)) throw new NativeParseError(FORMAT, row.line, `node ${id} appears twice`);
+		if (id === void 0 || !/^\d+$/.test(id)) throw new NativeParseError(FORMAT$3, row.line, `expected a whole number node id, found ${JSON.stringify(id)}`);
+		if (seen.has(id)) throw new NativeParseError(FORMAT$3, row.line, `node ${id} appears twice`);
 		seen.add(id);
 		return {
 			id,
-			x: numberOf(tokens[1], row.line, "x"),
-			y: numberOf(tokens[2], row.line, "y"),
-			service: numberOf(tokens[3], row.line, "the service duration"),
-			profit: numberOf(tokens[4], row.line, "the profit"),
-			open: numberOf(tokens[LIST_STARTS_AT + listLength], row.line, "the opening of the window"),
-			close: numberOf(tokens[8 + listLength], row.line, "the closing of the window")
+			x: numberOf$2(tokens[1], row.line, "x"),
+			y: numberOf$2(tokens[2], row.line, "y"),
+			service: numberOf$2(tokens[3], row.line, "the service duration"),
+			profit: numberOf$2(tokens[4], row.line, "the profit"),
+			open: numberOf$2(tokens[LIST_STARTS_AT + listLength], row.line, "the opening of the window"),
+			close: numberOf$2(tokens[8 + listLength], row.line, "the closing of the window")
 		};
 	});
-	if (nodes.length !== customers + 1) throw new NativeParseError(FORMAT, all.length === 0 ? 1 : all[all.length - 1]?.line ?? 1, `the header gives ${String(customers)} customers, so expected ${String(customers + 1)} rows with the depot, found ${String(nodes.length)}`);
+	if (nodes.length !== customers + 1) throw new NativeParseError(FORMAT$3, all.length === 0 ? 1 : all[all.length - 1]?.line ?? 1, `the header gives ${String(customers)} customers, so expected ${String(customers + 1)} rows with the depot, found ${String(nodes.length)}`);
 	return {
 		meta: {
 			paths,
@@ -1054,6 +1091,749 @@ function parseToptw(text) {
 	};
 }
 //#endregion
+//#region src/parsers/tsplib.ts
+const FORMAT$2 = "tsplib";
+/** The instance types the parser reads: the probabilistic and the clustered orienteering problem. */
+const TYPES = /* @__PURE__ */ new Set(["POP", "COP"]);
+/** The edge weight types a coordinate section is read under: planar ones keep their coordinates as `x` and `y`, `GEO` converts them to degrees, and `EXPLICIT` has no coordinates. */
+const PLANAR = /* @__PURE__ */ new Set([
+	"EUC_2D",
+	"CEIL_2D",
+	"ATT"
+]);
+const NUMBER$1 = /^-?\d+(?:\.\d+)?$/;
+const WHOLE$1 = /^\d+$/;
+const HEADER$2 = /^([A-Z][A-Z_]*)\s*:\s*(.*)$/;
+const SECTION = /^[A-Z][A-Z_]*$/;
+/** Minutes in a degree, which a `DDD.MM` coordinate counts in. */
+const MINUTES_PER_DEGREE = 60;
+/** `DDD.MM` has two digits of minutes, so the fraction is read in hundredths. */
+const MINUTE_SCALE = 100;
+/** How far a coordinate's hundredths may lie from a whole number of minutes: float error in the text's value, not a third digit. */
+const MINUTE_TOLERANCE = 1e-6;
+/**
+* Converts a TSPLIB `GEO` coordinate to decimal degrees. The value is `DDD.MM`, degrees then minutes in one number (`48.23` is 48 degrees 23 minutes), so the fraction is minutes out of a hundred, not a decimal fraction of a degree. The degrees are truncated, which is what makes the conversion agree with the optimal tour lengths the instances record where the specification's `nint` would round minutes of 50 or more up to the next degree.
+* @param value - The coordinate as the file writes it.
+* @param line - The 1-based line, for the error.
+* @returns Decimal degrees, signed like the input.
+* @throws NativeParseError when the minutes are not a whole number below sixty.
+*/
+function degrees(value, line) {
+	const magnitude = Math.abs(value);
+	const whole = Math.trunc(magnitude);
+	const hundredths = (magnitude - whole) * MINUTE_SCALE;
+	const minutes = Math.round(hundredths);
+	if (Math.abs(hundredths - minutes) > MINUTE_TOLERANCE || minutes >= MINUTES_PER_DEGREE) throw new NativeParseError(FORMAT$2, line, `expected a DDD.MM coordinate with whole minutes below 60, found ${String(value)}`);
+	return Math.sign(value) * (whole + minutes / MINUTES_PER_DEGREE);
+}
+/**
+* Reads a token as a finite number.
+* @param token - The token.
+* @param line - The 1-based line, for the error.
+* @param what - What the token should be, for the error.
+* @returns The number.
+* @throws NativeParseError when the token is not a decimal number.
+*/
+function numberOf$1(token, line, what) {
+	if (token === void 0 || !NUMBER$1.test(token)) throw new NativeParseError(FORMAT$2, line, `expected ${what}, found ${JSON.stringify(token)}`);
+	return Number(token);
+}
+/**
+* Reads a token as a whole number.
+* @param token - The token.
+* @param line - The 1-based line, for the error.
+* @param what - What the token should be, for the error.
+* @returns The number.
+* @throws NativeParseError when the token is not a whole number.
+*/
+function wholeOf(token, line, what) {
+	if (token === void 0 || !WHOLE$1.test(token)) throw new NativeParseError(FORMAT$2, line, `expected ${what}, found ${JSON.stringify(token)}`);
+	return Number(token);
+}
+/**
+* Reads the header, the coordinate section, the prize and probability section and the set section of a file, skipping every other section.
+* @param text - The file text.
+* @returns What it holds.
+* @throws NativeParseError naming the line for a repeated key, a malformed row, a repeated node or set id, or a row outside any section.
+*/
+function collect(text) {
+	const collected = {
+		header: /* @__PURE__ */ new Map(),
+		coords: /* @__PURE__ */ new Map(),
+		prizes: /* @__PURE__ */ new Map(),
+		sets: []
+	};
+	let section;
+	for (const [index, raw] of lines(text).entries()) {
+		const line = index + 1;
+		const trimmed = raw.trim();
+		if (trimmed === "" || trimmed === "EOF") continue;
+		const keyed = HEADER$2.exec(trimmed);
+		const key = keyed?.[1];
+		if (key === "CONSTRAINING_SET_SECTION") {
+			section = "sets";
+			continue;
+		}
+		if (keyed !== null && key !== void 0) {
+			if (collected.header.has(key)) throw new NativeParseError(FORMAT$2, line, `${key} appears twice`);
+			collected.header.set(key, (keyed[2] ?? "").trim());
+			section = void 0;
+			continue;
+		}
+		if (SECTION.test(trimmed)) {
+			section = trimmed === "NODE_COORD_SECTION" ? "coords" : trimmed === "NODE_PRIZE_PROBABILITY_SECTION" ? "prizes" : "skipped";
+			continue;
+		}
+		const tokens = trimmed.split(/\s+/);
+		if (section === "coords") {
+			const [id, x, y, ...extra] = tokens;
+			if (extra.length > 0) throw new NativeParseError(FORMAT$2, line, `expected "id x y", found ${JSON.stringify(trimmed)}`);
+			const node = wholeOf(id, line, "a node id");
+			if (collected.coords.has(node)) throw new NativeParseError(FORMAT$2, line, `node ${String(node)} has two coordinate rows`);
+			collected.coords.set(node, {
+				x: numberOf$1(x, line, "x"),
+				y: numberOf$1(y, line, "y"),
+				line
+			});
+		} else if (section === "prizes") {
+			const [id, prize, probability, ...extra] = tokens;
+			if (extra.length > 0) throw new NativeParseError(FORMAT$2, line, `expected "id prize probability", found ${JSON.stringify(trimmed)}`);
+			const node = wholeOf(id, line, "a node id");
+			if (collected.prizes.has(node)) throw new NativeParseError(FORMAT$2, line, `node ${String(node)} has two prize rows`);
+			collected.prizes.set(node, {
+				prize: numberOf$1(prize, line, "the prize"),
+				probability: numberOf$1(probability, line, "the probability")
+			});
+		} else if (section === "sets") {
+			const [id, prize, ...members] = tokens;
+			const setId = wholeOf(id, line, "a set id");
+			if (collected.sets.some((set) => set.id === setId)) throw new NativeParseError(FORMAT$2, line, `set ${String(setId)} appears twice`);
+			collected.sets.push({
+				id: setId,
+				prize: numberOf$1(prize, line, "the set prize"),
+				members: members.map((member) => wholeOf(member, line, "a node id in a set"))
+			});
+		} else if (section === void 0) throw new NativeParseError(FORMAT$2, line, `expected a KEY : value line or a section, found ${JSON.stringify(trimmed)}`);
+	}
+	return collected;
+}
+/**
+* Reads a header value that must be there.
+* @param header - The header.
+* @param key - The key.
+* @returns Its text.
+* @throws NativeParseError when the file has no such key.
+*/
+function required(header, key) {
+	const value = header.get(key);
+	if (value === void 0) throw new NativeParseError(FORMAT$2, 1, `expected a ${key} line`);
+	return value;
+}
+/**
+* Parses a TSPLIB style orienteering instance of type `POP` (probabilistic orienteering, Angelelli and others) or `COP` (clustered orienteering), in the layout TSPLIB95 (Reinelt) defines: `KEY : value` header lines and bare keyword sections. The nodes are 1 to `DIMENSION`. The planar weight types keep their coordinates as `x` and `y` and `GEO` converts them to `lat` and `lon`; an `EXPLICIT` file has no coordinates, so its nodes have only the prize data. A `POP` file's `NODE_PRIZE_PROBABILITY_SECTION` gives each node its prize and probability. A `COP` file has no prize on a node: its prizes belong to sets of nodes that may overlap, so each node lists the sets it is in under `clusters` and the sets' prizes are the `setPrizes` metadata, and nothing is divided among the members. The weight matrix is not read, as or/v1 has no arcs.
+* @param text - The file text.
+* @returns The instance: its header values as `meta` and its nodes in id order.
+* @throws NativeParseError naming the line for an unsupported type or weight type, a missing key or section, a node id outside 1 to `DIMENSION` or missing from a section that must cover every node, or a set that names a node outside that range.
+*/
+function parseTsplib(text) {
+	const { header, coords, prizes, sets } = collect(text);
+	const type = required(header, "TYPE");
+	if (!TYPES.has(type)) throw new NativeParseError(FORMAT$2, 1, `expected TYPE POP or COP, found ${JSON.stringify(type)}`);
+	const weightType = required(header, "EDGE_WEIGHT_TYPE");
+	const geographic = weightType === "GEO";
+	if (!geographic && !PLANAR.has(weightType) && weightType !== "EXPLICIT") throw new NativeParseError(FORMAT$2, 1, `expected EDGE_WEIGHT_TYPE EUC_2D, CEIL_2D, ATT, GEO or EXPLICIT, found ${JSON.stringify(weightType)}`);
+	const dimension = wholeOf(required(header, "DIMENSION"), 1, "DIMENSION");
+	const budget = numberOf$1(required(header, "TMAX"), 1, "TMAX");
+	if (weightType === "EXPLICIT" ? coords.size > 0 : coords.size !== dimension) throw new NativeParseError(FORMAT$2, 1, weightType === "EXPLICIT" ? "an EXPLICIT file has no NODE_COORD_SECTION" : `expected ${String(dimension)} coordinate rows, found ${String(coords.size)}`);
+	const inRange = (id) => id >= 1 && id <= dimension;
+	for (const id of [
+		...coords.keys(),
+		...prizes.keys(),
+		...sets.flatMap((set) => set.members)
+	]) if (!inRange(id)) throw new NativeParseError(FORMAT$2, 1, `node ${String(id)} is outside 1 to ${String(dimension)}`);
+	if (type === "POP" && prizes.size !== dimension) throw new NativeParseError(FORMAT$2, 1, `expected ${String(dimension)} prize rows, found ${String(prizes.size)}`);
+	if (type === "COP") {
+		const declared = wholeOf(required(header, "SETS"), 1, "SETS");
+		if (sets.length !== declared) throw new NativeParseError(FORMAT$2, 1, `expected ${String(declared)} sets, found ${String(sets.length)}`);
+	}
+	const clustersOf = (node) => {
+		const ids = sets.filter((set) => set.members.includes(node)).map((set) => String(set.id));
+		return ids.length === 0 ? null : ids.join(",");
+	};
+	const nodes = Array.from({ length: dimension }, (_, index) => {
+		const id = index + 1;
+		const position = coords.get(id);
+		const prize = prizes.get(id);
+		const lat = geographic && position !== void 0 ? degrees(position.x, position.line) : null;
+		const lon = geographic && position !== void 0 ? degrees(position.y, position.line) : null;
+		return {
+			id: String(id),
+			x: geographic ? null : position?.x ?? null,
+			y: geographic ? null : position?.y ?? null,
+			lat,
+			lon,
+			prize: prize?.prize ?? null,
+			probability: prize?.probability ?? null,
+			clusters: clustersOf(id)
+		};
+	});
+	const total = header.get("TPRIZE");
+	return {
+		meta: {
+			name: header.get("NAME") ?? null,
+			type,
+			budget,
+			edgeWeightType: weightType,
+			totalPrize: total === void 0 ? null : numberOf$1(total, 1, "TPRIZE"),
+			setPrizes: type === "COP" ? sets.map((set) => `${String(set.id)}:${String(set.prize)}`).join(",") : null
+		},
+		nodes
+	};
+}
+//#endregion
+//#region src/parsers/verolog-2019.ts
+const FORMAT$1 = "verolog-2019";
+/** The header lines, in the order the file has them, with the key of `meta` each fills and whether its value is text. */
+const HEADER$1 = [
+	[
+		"DATASET",
+		"dataset",
+		"text"
+	],
+	[
+		"NAME",
+		"name",
+		"text"
+	],
+	[
+		"DAYS",
+		"days",
+		"number"
+	],
+	[
+		"TRUCK_CAPACITY",
+		"truckCapacity",
+		"number"
+	],
+	[
+		"TRUCK_MAX_DISTANCE",
+		"truckMaxDistance",
+		"number"
+	],
+	[
+		"TRUCK_DISTANCE_COST",
+		"truckDistanceCost",
+		"number"
+	],
+	[
+		"TRUCK_DAY_COST",
+		"truckDayCost",
+		"number"
+	],
+	[
+		"TRUCK_COST",
+		"truckCost",
+		"number"
+	],
+	[
+		"TECHNICIAN_DISTANCE_COST",
+		"technicianDistanceCost",
+		"number"
+	],
+	[
+		"TECHNICIAN_DAY_COST",
+		"technicianDayCost",
+		"number"
+	],
+	[
+		"TECHNICIAN_COST",
+		"technicianCost",
+		"number"
+	]
+];
+/** The sections that hold rows, and how many numbers a row has before the per-machine flags of a technician. */
+const SECTIONS = [
+	"MACHINES",
+	"LOCATIONS",
+	"REQUESTS",
+	"TECHNICIANS"
+];
+const MACHINE_NUMBERS = 3;
+const LOCATION_NUMBERS = 3;
+const REQUEST_NUMBERS = 6;
+/** Where a request row keeps its fields after the id. */
+const REQUEST_AT = {
+	location: 1,
+	fromDay: 2,
+	toDay: 3,
+	machine: 4,
+	amount: 5
+};
+const TECHNICIAN_NUMBERS_BEFORE_FLAGS = 4;
+const WHOLE = /^\d+$/;
+const NUMBER = /^-?\d+(?:\.\d+)?$/;
+/**
+* Splits the file into non-empty rows of fields. The three layouts the files come in (space padded, tab separated with trailing tabs, and semicolon separated with trailing semicolons) differ only in separator and padding, so any run of whitespace and semicolons separates fields and empty fields are dropped.
+* @param text - The file text.
+* @returns The rows, in file order.
+*/
+function rowsOf(text) {
+	return lines(text).map((raw, index) => ({
+		line: index + 1,
+		fields: raw.split(/[;\s]+/).filter((field) => field !== "")
+	})).filter((row) => row.fields.length > 0);
+}
+/**
+* Reads a field as a finite number.
+* @param row - The row.
+* @param index - The field's position in it.
+* @param what - What the field should be, for the error.
+* @returns The number.
+* @throws NativeParseError when the field is absent or not a decimal number.
+*/
+function numberAt(row, index, what) {
+	const field = row.fields[index];
+	if (field === void 0 || !NUMBER.test(field)) throw new NativeParseError(FORMAT$1, row.line, `expected ${what}, found ${JSON.stringify(field)}`);
+	return Number(field);
+}
+/**
+* Reads a `KEY = value` row: the key, and the fields after the equals sign.
+* @param row - The row.
+* @returns The key and the value fields, or undefined for a row that is not of that form.
+*/
+function keyed(row) {
+	const [key, equals, ...value] = row.fields;
+	return key !== void 0 && equals === "=" ? {
+		key,
+		value
+	} : void 0;
+}
+/**
+* Checks that the rows of a section run from 1 with consecutive ids and have the length they should.
+* @param name - The section.
+* @param rows - Its rows.
+* @param length - How many fields a row must have, or undefined when only a minimum applies.
+* @throws NativeParseError naming the line of a row whose id is not the next one or whose length is wrong.
+*/
+function checkRows(name, rows, length) {
+	for (const [index, row] of rows.entries()) {
+		if (row.fields[0] !== String(index + 1)) throw new NativeParseError(FORMAT$1, row.line, `expected ${name} row ${String(index + 1)} to start with that id, found ${JSON.stringify(row.fields[0])}`);
+		if (length !== void 0 && row.fields.length !== length) throw new NativeParseError(FORMAT$1, row.line, `expected ${String(length)} fields in a ${name} row, found ${String(row.fields.length)}`);
+	}
+}
+/**
+* Splits the rows after the header into the rows of each section, each announced by `NAME = count`.
+* @param rows - The rows after the header.
+* @returns The rows of each section.
+* @throws NativeParseError naming the line for a section that is out of order, announced twice or short of its count, or a row outside any section.
+*/
+function sectionsOf(rows) {
+	const found = {};
+	let at = 0;
+	for (const name of SECTIONS) {
+		const start = rows[at];
+		const announced = start === void 0 ? void 0 : keyed(start);
+		if (start === void 0 || announced?.key !== name || announced.value.length !== 1 || !WHOLE.test(announced.value[0] ?? "")) throw new NativeParseError(FORMAT$1, start?.line ?? 1, `expected "${name} = <count>", found ${JSON.stringify(start?.fields.join(" "))}`);
+		const count = Number(announced.value[0]);
+		const body = rows.slice(at + 1, at + 1 + count);
+		if (body.length !== count) throw new NativeParseError(FORMAT$1, start.line, `${name} announces ${String(count)} rows, found ${String(body.length)}`);
+		found[name] = body;
+		at += 1 + count;
+	}
+	const extra = rows[at];
+	if (extra !== void 0) throw new NativeParseError(FORMAT$1, extra.line, `expected the end of the file after TECHNICIANS, found ${JSON.stringify(extra.fields.join(" "))}`);
+	return {
+		MACHINES: found.MACHINES ?? [],
+		LOCATIONS: found.LOCATIONS ?? [],
+		REQUESTS: found.REQUESTS ?? [],
+		TECHNICIANS: found.TECHNICIANS ?? []
+	};
+}
+/**
+* Parses a VeRoLog Solver Challenge 2019 instance (the technician and truck routing problem of ORTEC's challenge): `KEY = value` header lines, then the sections MACHINES (id, size, idle penalty), LOCATIONS (id, x, y), REQUESTS (id, location, first day, last day, machine, amount) and TECHNICIANS (id, home location, maximum distance per day, maximum installations per day, then a 0 or 1 flag per machine for the machines the technician can install). Location 1 is the depot. The nodes are the depot, then one node per request at its location's position, carrying the request's day window, machine and amount; the machines and technicians stay unread beyond the technician count, as or/v1 has no place for a fleet. The days are day numbers, not times, and distances are the integer coordinates' own units.
+* @param text - The file text.
+* @returns The instance: its header values as `meta` and its nodes.
+* @throws NativeParseError naming the line for a header line that is missing, out of order or not of its type, a section that is out of order or short, a row whose ids or length are wrong, or a request whose location, machine or days are outside the file's.
+*/
+function parseVerolog2019(text) {
+	const rows = rowsOf(text);
+	const meta = {};
+	let days = 0;
+	for (const [position, [key, name, kind]] of HEADER$1.entries()) {
+		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$1, row?.line ?? 1, `expected "${key} = <value>", found ${JSON.stringify(row?.fields.join(" "))}`);
+		meta[name] = kind === "text" ? header.value.join(" ") : numberAt({
+			line: row.line,
+			fields: header.value
+		}, 0, `a number for ${key}`);
+		if (key === "DAYS") days = Number(meta[name]);
+	}
+	const sections = sectionsOf(rows.slice(HEADER$1.length));
+	const machines = sections.MACHINES;
+	const locations = sections.LOCATIONS;
+	checkRows("MACHINES", machines, MACHINE_NUMBERS);
+	checkRows("LOCATIONS", locations, LOCATION_NUMBERS);
+	checkRows("REQUESTS", sections.REQUESTS, REQUEST_NUMBERS);
+	checkRows("TECHNICIANS", sections.TECHNICIANS, TECHNICIAN_NUMBERS_BEFORE_FLAGS + machines.length);
+	const position = (id) => {
+		const row = locations[id - 1];
+		return row === void 0 ? {
+			x: NaN,
+			y: NaN
+		} : {
+			x: numberAt(row, 1, "x"),
+			y: numberAt(row, 2, "y")
+		};
+	};
+	const depot = {
+		id: "depot",
+		...position(1),
+		kind: "depot",
+		location: 1,
+		fromDay: null,
+		toDay: null,
+		machine: null,
+		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");
+		if (!Number.isInteger(location) || location < 1 || location > locations.length) throw new NativeParseError(FORMAT$1, 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$1, row.line, `machine ${String(machine)} is outside 1 to ${String(machines.length)}`);
+		if (fromDay < 1 || fromDay > toDay || toDay > days) throw new NativeParseError(FORMAT$1, row.line, `the days ${String(fromDay)} to ${String(toDay)} are not within 1 to ${String(days)}`);
+		if (amount < 1) throw new NativeParseError(FORMAT$1, row.line, `expected an amount of at least 1, found ${String(amount)}`);
+		return {
+			id: row.fields[0] ?? "",
+			...position(location),
+			kind: "request",
+			location,
+			fromDay,
+			toDay,
+			machine: String(machine),
+			amount
+		};
+	});
+	return {
+		meta: {
+			...meta,
+			technicians: sections.TECHNICIANS.length
+		},
+		nodes: [depot, ...requests]
+	};
+}
+//#endregion
+//#region src/parsers/xml.ts
+/** The characters an XML name may contain, narrowed to what the formats read use. */
+const NAME = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+const ATTRIBUTE = /\s*([A-Za-z_][A-Za-z0-9_.:-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/gy;
+const PREDEFINED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+const CODE_POINT = /^#(?:x([0-9A-Fa-f]+)|(\d+))$/;
+const HEXADECIMAL$1 = 16;
+const DECIMAL$1 = 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: "<!--",
+	close: "-->"
+};
+const CDATA = {
+	open: "<![CDATA[",
+	close: "]]>"
+};
+const INSTRUCTION = {
+	open: "<?",
+	close: "?>"
+};
+const DECLARATION = "<!";
+/** Reads an XML document into a tree; see `readXml`. */
+var XmlReader = class {
+	#text;
+	#format;
+	#stack = [];
+	#root;
+	#position = 0;
+	constructor(text, format) {
+		this.#text = text;
+		this.#format = format;
+	}
+	/**
+	* Fails at a position of the document.
+	* @param index - Where in the text the fault is.
+	* @param message - What is wrong.
+	* @throws NativeParseError naming the line of the position.
+	*/
+	#fail(index, message) {
+		throw new NativeParseError(this.#format, this.#text.slice(0, index).split("\n").length, message);
+	}
+	/**
+	* Replaces the character references and the five predefined entities in text.
+	* @param text - Text from an element or an attribute value.
+	* @param index - Where the text starts, for the error.
+	* @returns The text with references resolved.
+	*/
+	#unescape(text, index) {
+		return text.replace(/&([^;&\s]*);/g, (whole, reference) => {
+			const predefined = Object.hasOwn(PREDEFINED, reference) ? PREDEFINED[reference] : void 0;
+			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));
+		});
+	}
+	/**
+	* Finishes an element: it becomes a child of the open element, or the root.
+	* @param open - The element.
+	*/
+	#finish(open) {
+		const element = {
+			name: open.name,
+			attributes: open.attributes,
+			children: open.children,
+			text: open.text
+		};
+		const parent = this.#stack[this.#stack.length - 1];
+		if (parent !== void 0) parent.children.push(element);
+		else if (this.#root === void 0) this.#root = element;
+		else this.#fail(open.index, "the document has more than one root element");
+	}
+	/**
+	* Reads the `name="value"` pairs of a tag.
+	* @param text - The tag's text after its name.
+	* @param index - Where the tag starts, for errors.
+	* @returns The attributes.
+	*/
+	#attributes(text, index) {
+		const attributes = {};
+		ATTRIBUTE.lastIndex = 0;
+		let consumed = 0;
+		for (let match = ATTRIBUTE.exec(text); match !== null; match = ATTRIBUTE.exec(text)) {
+			const [, key = "", doubled, single] = match;
+			if (Object.hasOwn(attributes, key)) this.#fail(index, `the attribute ${key} appears twice`);
+			attributes[key] = this.#unescape(doubled ?? single ?? "", index);
+			consumed = ATTRIBUTE.lastIndex;
+		}
+		if (text.slice(consumed).trim() !== "") this.#fail(index, `the attributes ${JSON.stringify(text.trim())} are not name="value" pairs`);
+		return attributes;
+	}
+	/**
+	* Reads a start tag, an empty-element tag or an end tag that begins at the position.
+	* @returns The position after it.
+	*/
+	#tag() {
+		const start = this.#position;
+		const stop = this.#text.indexOf(">", start);
+		if (stop === -1) return this.#fail(start, "a tag is never closed");
+		const tag = this.#text.slice(start + 1, stop);
+		if (tag.startsWith("/")) {
+			const finished = this.#stack.pop();
+			if (finished?.name !== tag.slice(1).trim()) return this.#fail(start, `the closing tag ${JSON.stringify(tag)} does not close ${finished === void 0 ? "any element" : JSON.stringify(finished.name)}`);
+			this.#finish(finished);
+			return stop + 1;
+		}
+		const selfClosing = tag.endsWith("/");
+		const body = selfClosing ? tag.slice(0, -1) : tag;
+		const name = /^\S+/.exec(body)?.[0] ?? "";
+		if (!NAME.test(name)) return this.#fail(start, `${JSON.stringify(name)} is not an element name`);
+		const element = {
+			name,
+			attributes: this.#attributes(body.slice(name.length), start),
+			children: [],
+			text: "",
+			index: start
+		};
+		if (selfClosing) this.#finish(element);
+		else this.#stack.push(element);
+		return stop + 1;
+	}
+	/**
+	* Skips markup that runs to a closing marker, or reads it as text.
+	* @param markers - The opening and closing markers.
+	* @param what - What the markup is, for the error.
+	* @returns The position after it and its content.
+	*/
+	#delimited(markers, what) {
+		const from = this.#position + markers.open.length;
+		const stop = this.#text.indexOf(markers.close, from);
+		if (stop === -1) return this.#fail(this.#position, `${what} is never closed`);
+		return {
+			next: stop + markers.close.length,
+			content: this.#text.slice(from, stop)
+		};
+	}
+	/**
+	* Reads the markup at the position, which starts with `<`.
+	* @returns The position after it.
+	*/
+	#markup() {
+		const rest = this.#text.startsWith.bind(this.#text);
+		const open = this.#stack[this.#stack.length - 1];
+		if (rest(COMMENT.open, this.#position)) return this.#delimited(COMMENT, "a comment").next;
+		if (rest(CDATA.open, this.#position)) {
+			const { next, content } = this.#delimited(CDATA, "a CDATA section");
+			if (open === void 0) return this.#fail(this.#position, "a CDATA section outside the root element");
+			open.text += content;
+			return next;
+		}
+		if (rest(INSTRUCTION.open, this.#position)) return this.#delimited(INSTRUCTION, "a processing instruction").next;
+		if (rest(DECLARATION, this.#position)) return this.#fail(this.#position, "a document type declaration is not read: it can define entities, and the formats here have none");
+		return this.#tag();
+	}
+	/**
+	* Reads the whole document.
+	* @returns The root element.
+	*/
+	read() {
+		while (this.#position < this.#text.length) {
+			const lessThan = this.#text.indexOf("<", this.#position);
+			const end = lessThan === -1 ? this.#text.length : lessThan;
+			const content = this.#text.slice(this.#position, end);
+			const open = this.#stack[this.#stack.length - 1];
+			if (open !== void 0) open.text += this.#unescape(content, this.#position);
+			else if (content.trim() !== "") this.#fail(this.#position, "text outside the root element");
+			if (lessThan === -1) break;
+			this.#position = lessThan;
+			this.#position = this.#markup();
+		}
+		const unclosed = this.#stack[this.#stack.length - 1];
+		if (unclosed !== void 0) this.#fail(this.#text.length, `the element ${JSON.stringify(unclosed.name)} is never closed`);
+		return this.#root ?? this.#fail(0, "the document has no root element");
+	}
+};
+/**
+* Reads an XML document into a tree. It reads what data files use: elements, attributes in single or double quotes, text, CDATA sections, comments, processing instructions and the XML declaration, and the predefined entities and character references. A document type declaration is refused, because it can define entities that expand without bound and nothing here reads one. Namespaces are not interpreted: a prefix is part of the name.
+* @param text - The document text.
+* @param format - The name of the format being parsed, for errors.
+* @returns The root element.
+* @throws NativeParseError naming the line for markup that is malformed, a tag that does not close the open one, an undeclared entity, a document type declaration, text outside the root or more than one root.
+*/
+function readXml(text, format) {
+	return new XmlReader(text, format).read();
+}
+//#endregion
+//#region src/parsers/vrp-rep.ts
+const FORMAT = "vrp-rep";
+/**
+* The child elements of an element with a name.
+* @param element - The parent.
+* @param name - The child element name.
+* @returns Them, in document order.
+*/
+function childrenOf(element, name) {
+	return element.children.filter((child) => child.name === name);
+}
+/**
+* The one child element of an element with a name.
+* @param element - The parent.
+* @param name - The child element name.
+* @returns It.
+* @throws NativeParseError when the parent has none or several.
+*/
+function childOf(element, name) {
+	const found = childrenOf(element, name);
+	const [only] = found;
+	if (found.length !== 1 || only === void 0) throw new NativeParseError(FORMAT, 1, `expected one <${name}> in <${element.name}>, found ${String(found.length)}`);
+	return only;
+}
+/**
+* Reads an attribute that must be there.
+* @param element - The element.
+* @param name - The attribute name.
+* @returns Its value.
+* @throws NativeParseError when the element has no such attribute.
+*/
+function attributeOf(element, name) {
+	const value = Object.hasOwn(element.attributes, name) ? element.attributes[name] : void 0;
+	if (value === void 0) throw new NativeParseError(FORMAT, 1, `expected <${element.name}> to have the attribute ${name}`);
+	return value;
+}
+/**
+* Reads the text of an element as a finite number.
+* @param element - The element.
+* @returns The number.
+* @throws NativeParseError when the text is not a decimal number.
+*/
+function numberOf(element) {
+	const text = element.text.trim();
+	if (!/^-?\d+(?:\.\d+)?$/.test(text)) throw new NativeParseError(FORMAT, 1, `expected <${element.name}> to hold a number, found ${JSON.stringify(text)}`);
+	return Number(text);
+}
+/**
+* Joins ids into the list text a column holds.
+* @param ids - The ids, in document order.
+* @returns The distinct ids joined by commas, or null when there are none.
+*/
+function listOf(ids) {
+	const distinct = [...new Set(ids)];
+	return distinct.length === 0 ? null : distinct.join(",");
+}
+/**
+* Parses a VRP-REP instance (the XML format of the VRP-REP repository) in the layout its technician routing instances use: an `instance` with `info`, a `network` of `node` elements with `cx` and `cy`, a `fleet` of vehicle profiles that each depart from a node, `requests` that each sit at a node and name the skill and resources they need, and `drivers` whose profiles list the skills a vehicle type's driver has. Each node becomes a row with its position and `type`; a node's request skills and resources, and the skills of the drivers whose vehicles depart from it, are attached to it. Fleet costs and resource stocks are not read, as or/v1 has no place for them.
+* @param text - The file text.
+* @returns The instance: its dataset and name as `meta`, and its nodes in document order.
+* @throws NativeParseError for malformed XML, a root that is not `instance`, a missing element or attribute, a coordinate that is not a number, a repeated node id, or a request or vehicle that names a node the network lacks.
+*/
+function parseVrpRep(text) {
+	const root = readXml(text, FORMAT);
+	if (root.name !== "instance") throw new NativeParseError(FORMAT, 1, `expected the root element <instance>, found <${root.name}>`);
+	const info = childOf(root, "info");
+	const nodeElements = childrenOf(childOf(childOf(root, "network"), "nodes"), "node");
+	const known = /* @__PURE__ */ new Set();
+	for (const node of nodeElements) {
+		const id = attributeOf(node, "id");
+		if (known.has(id)) throw new NativeParseError(FORMAT, 1, `node ${id} appears twice`);
+		known.add(id);
+	}
+	const needs = /* @__PURE__ */ new Map();
+	for (const request of childrenOf(childOf(root, "requests"), "request")) {
+		const node = attributeOf(request, "node");
+		if (!known.has(node)) throw new NativeParseError(FORMAT, 1, `request ${attributeOf(request, "id")} is at node ${node}, which the network lacks`);
+		const entry = needs.get(node) ?? {
+			skills: [],
+			resources: []
+		};
+		entry.skills.push(...childrenOf(request, "skill").map((skill) => skill.text.trim()));
+		entry.resources.push(...childrenOf(request, "resource").map((resource) => attributeOf(resource, "id")));
+		needs.set(node, entry);
+	}
+	const driverSkills = /* @__PURE__ */ new Map();
+	for (const profile of childrenOf(childOf(root, "drivers"), "driver_profile")) driverSkills.set(attributeOf(profile, "type"), childrenOf(profile, "skill").map((skill) => attributeOf(skill, "id")));
+	const offered = /* @__PURE__ */ new Map();
+	for (const vehicle of childrenOf(childOf(root, "fleet"), "vehicle_profile")) {
+		const home = childOf(vehicle, "departure_node").text.trim();
+		if (!known.has(home)) throw new NativeParseError(FORMAT, 1, `vehicle type ${attributeOf(vehicle, "type")} departs from node ${home}, which the network lacks`);
+		offered.set(home, [...offered.get(home) ?? [], ...driverSkills.get(attributeOf(vehicle, "type")) ?? []]);
+	}
+	const nodes = nodeElements.map((node) => {
+		const id = attributeOf(node, "id");
+		const need = needs.get(id);
+		return {
+			id,
+			x: numberOf(childOf(node, "cx")),
+			y: numberOf(childOf(node, "cy")),
+			type: attributeOf(node, "type"),
+			skill: listOf(need?.skills ?? []),
+			skills: listOf(offered.get(id) ?? []),
+			resources: listOf(need?.resources ?? [])
+		};
+	});
+	return {
+		meta: {
+			dataset: childOf(info, "dataset").text.trim(),
+			name: childOf(info, "name").text.trim()
+		},
+		nodes
+	};
+}
+//#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;
@@ -1109,9 +1889,13 @@ function parseNative(bytes, 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 === "customer-points") return parseCustomerPoints(text);
 	if (parser.format === "solomon") return parseSolomon(text);
 	if (parser.format === "top") return parseTop(text);
 	if (parser.format === "toptw") return parseToptw(text);
+	if (parser.format === "tsplib") return parseTsplib(text);
+	if (parser.format === "verolog-2019") return parseVerolog2019(text);
+	if (parser.format === "vrp-rep") return parseVrpRep(text);
 	return parsePajek(text);
 }
 /** The ustar header layout (POSIX.1-1988, pax(1) "ustar Interchange Format"): each field's byte offset and length. */
@@ -1499,7 +2283,7 @@ function isResourceFork(path) {
 	return path.startsWith("__MACOSX/") || path.split("/").some((segment) => segment.startsWith("._"));
 }
 /**
-* Whether a member path matches a selector: a path selector matches the whole member path or its trailing segments, an extensions selector the end of the member's name, ignoring case.
+* Whether a member path matches a selector: a path selector matches the whole member path or its trailing segments, an extensions selector the end of the member's name (ignoring case), a pattern selector the whole path.
 * @param path - The member path.
 * @param member - The recipe's selector.
 * @returns True on a match.
@@ -1507,9 +2291,20 @@ function isResourceFork(path) {
 function selects(path, member) {
 	if (isResourceFork(path) || path.endsWith("/")) return false;
 	if ("path" in member) return path === member.path || path.endsWith(`/${member.path}`);
+	if ("pattern" in member) return new RegExp(`^(?:${member.pattern})$`, "u").test(path);
 	return member.extensions.some((extension) => path.toLowerCase().endsWith(extension.toLowerCase()));
 }
 /**
+* Describes what a selector asks for, for an error message.
+* @param member - The selector.
+* @param noun - How to name the member or members.
+* @returns The member path, extensions or pattern it names.
+*/
+function describeSelector(member, noun) {
+	if ("path" in member) return `${noun === "one member" ? "member" : noun} ${member.path}`;
+	return "pattern" in member ? `${noun} matching ${member.pattern}` : `${noun} ending ${member.extensions.join(" or ")}`;
+}
+/**
 * Picks every member a selector matches, in path order, so a collection reads in the same order wherever it is unpacked.
 * @param paths - Every member path.
 * @param member - The recipe's selector.
@@ -1518,7 +2313,7 @@ function selects(path, member) {
 */
 function pickAll(paths, member) {
 	const matched = paths.filter((path) => selects(path, member)).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-	if (matched.length === 0) throw new ArchiveError(`expected at least one ${"path" in member ? `member ${member.path}` : `member ending ${member.extensions.join(" or ")}`}, found none among: ${paths.join(", ")}`);
+	if (matched.length === 0) throw new ArchiveError(`expected at least one ${describeSelector(member, "member")}, found none among: ${paths.join(", ")}`);
 	return matched;
 }
 /**
@@ -1531,10 +2326,7 @@ function pickAll(paths, member) {
 function pick(paths, member) {
 	const matched = paths.filter((path) => selects(path, member));
 	const [only] = matched;
-	if (matched.length !== 1 || only === void 0) {
-		const wanted = "path" in member ? `member ${member.path}` : `one member ending ${member.extensions.join(" or ")}`;
-		throw new ArchiveError(`expected ${wanted}, found ${String(matched.length)} among: ${paths.join(", ")}`);
-	}
+	if (matched.length !== 1 || only === void 0) throw new ArchiveError(`expected ${describeSelector(member, "one member")}, found ${String(matched.length)} among: ${paths.join(", ")}`);
 	return only;
 }
 /**
@@ -1648,6 +2440,8 @@ const REDIRECTS = new Set(Object.values({
 }));
 /** What the downloader says it is, so a server operator can tell where the traffic comes from. */
 const USER_AGENT = "keepset (+https://github.com/Mearman/keepset)";
+/** What the downloader accepts: anything, as the file is the recipe's to read. Node's HTTP client sends no `Accept` header of its own, and a server that content-negotiates a download (the VRP-REP host answers 406 to a request without one) refuses it; every other HTTP client sends this, and RFC 9110 reads an absent header as the same. */
+const ACCEPT = "*/*";
 /** The failure of a connection that sent nothing for the stall time. */
 var StalledError = class extends KeepsetError {};
 /**
@@ -1672,7 +2466,10 @@ async function get(url, signal, stall) {
 		let answered;
 		const request = send(url, {
 			method: "GET",
-			headers: { "user-agent": USER_AGENT },
+			headers: {
+				accept: ACCEPT,
+				"user-agent": USER_AGENT
+			},
 			...signal === void 0 ? {} : { signal }
 		}, (response) => {
 			answered = response;