@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Results-peJjGA2V.mjs

@@ -0,0 +1,621 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, N as isBlankNode, T as blankNode$1, Y as literal$1, Z as namedNode, it as variable, j as fromJson, rt as triple, tt as toJson, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { r as GroundTermSchema } from "./TermJson-FAg3lvjl.mjs";
+import { f as negotiate$1 } from "./Serialization-DP9H5bYQ.mjs";
+import { c as escapeAttribute, g as parseResult, l as escapeText } from "./Xml-B7iihYCS.mjs";
+import { o as fromEntries } from "./Bindings-Ck3m7JRC.mjs";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Record from "effect/Record";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+import * as Ascii from "@thomasfosterau/effect-parse/Ascii";
+import * as Compiler from "@thomasfosterau/effect-parse/Compiler";
+import * as Parser from "@thomasfosterau/effect-parse/Parser";
+import * as Token from "@thomasfosterau/effect-parse/Token";
+// src/sparql/internal/json.ts
+/**
+* JSON text parsing that keeps the engine's `SyntaxError` text, which the
+* results parsers put in their error messages (`Schema.fromJsonString`
+* reports only "Expected a valid JSON string").
+*
+* @internal
+*/
+/** Parses JSON text; the failure is the engine's `SyntaxError`, as text. */
+const parse = (text) => Result.try({
+	try: () => JSON.parse(text),
+	catch: (cause) => String(cause)
+});
+// src/sparql/internal/textResults.ts
+/**
+* Grammars of the SPARQL results text formats, written with
+* `@thomasfosterau/effect-parse`: RDF terms in the Turtle / SPARQL syntax
+* used by TSV results, and the rows of CSV results (RFC 4180).
+*
+* @internal
+*/
+const XSD$1 = "http://www.w3.org/2001/XMLSchema#";
+const xsdInteger = namedNode(`${XSD$1}integer`);
+const xsdDecimal = namedNode(`${XSD$1}decimal`);
+const xsdDouble = namedNode(`${XSD$1}double`);
+const xsdBoolean = namedNode(`${XSD$1}boolean`);
+/** The characters of ECMAScript's `\s`. */
+const whitespace = [" 	\n\v\f\r\xA0 \u2028\u2029  　", Token.range(" ", " ")];
+const ws = Token.takeWhile(whitespace);
+const hexDigit = [
+	Token.range("0", "9"),
+	Token.range("a", "f"),
+	Token.range("A", "F")
+];
+const codePoint = (digits) => Token.takeWhile(hexDigit, digits).pipe(Parser.expected(`${digits} hex digits`), Parser.map((hex) => parseInt(hex, 16)), Parser.filter((cp) => cp <= 1114111), Parser.map((cp) => String.fromCodePoint(cp)));
+/**
+* What follows a backslash: `UCHAR` (which must be a valid code point),
+* `ECHAR`, and (leniently) any other character standing for itself.
+*/
+const escape = Parser.alt(Parser.dispatch(Token.any, {
+	t: Parser.succeed("	"),
+	n: Parser.succeed("\n"),
+	r: Parser.succeed("\r"),
+	b: Parser.succeed("\b"),
+	f: Parser.succeed("\f"),
+	u: Parser.cut(codePoint(4)),
+	U: Parser.cut(codePoint(8))
+}), Token.any);
+const iri = Parser.delimited(Token.literal("<"), Parser.cut(Ascii.escaped(Token.takeTill("\\>", { min: 1 }), "\\", escape)), Parser.cut(Token.literal(">"))).pipe(Parser.map((value) => namedNode(value)));
+const blankNode = Parser.preceded(Token.literal("_:"), Parser.cut(Token.takeTill([whitespace, ")"], { min: 1 }))).pipe(Parser.map((label) => blankNode$1(label)));
+const quoted = (q) => {
+	const long = q.repeat(3);
+	return Parser.alt(Parser.delimited(Token.literal(long), Parser.cut(Ascii.escaped(Parser.alt(Token.takeTill(["\\", q], { min: 1 }), Parser.terminated(Token.literal(q), Parser.not(Token.literal(q + q)))), "\\", escape)), Parser.cut(Token.literal(long))), Parser.delimited(Token.literal(q), Parser.cut(Ascii.escaped(Token.takeTill(["\\", q], { min: 1 }), "\\", escape)), Parser.cut(Token.literal(q))));
+};
+const alpha = [Token.range("a", "z"), Token.range("A", "Z")];
+const alphanumeric = [...alpha, Token.range("0", "9")];
+const langTag = Parser.preceded(Token.literal("@"), Parser.seq(Parser.taken(Parser.seq(Token.takeWhile(alpha, { min: 1 }), Parser.repeat(Parser.preceded(Token.literal("-"), Token.takeWhile(alphanumeric, { min: 1 }))))), Parser.opt(Parser.preceded(Token.literal("--"), Parser.alt(Token.literal("ltr"), Token.literal("rtl"))))));
+const datatype = Parser.preceded(Token.literal("^^"), Parser.preceded(ws, Parser.cut(iri)));
+const literal = Parser.seq(Parser.alt(quoted("\""), quoted("'")), Parser.opt(Parser.alt(langTag, datatype))).pipe(Parser.map(([lex, suffix]) => {
+	if (Option.isNone(suffix)) return literal$1(lex);
+	const s = suffix.value;
+	if (Array.isArray(s)) {
+		const [language, direction] = s;
+		return Option.isSome(direction) ? literal$1(lex, {
+			language,
+			direction: direction.value
+		}) : literal$1(lex, language);
+	}
+	return literal$1(lex, s);
+}));
+const sign = Parser.opt(Token.oneOf("+-"));
+const exponent = Parser.seq(Token.oneOf("eE"), sign, Ascii.digit1);
+const number = Parser.taken(Parser.seq(sign, Parser.alt(Parser.seq(Ascii.digit1, Parser.opt(Token.literal(".")), Ascii.digit0, exponent), Parser.seq(Token.literal("."), Ascii.digit1, exponent), Parser.seq(Ascii.digit0, Token.literal("."), Ascii.digit1), Ascii.digit1))).pipe(Parser.map((v) => literal$1(v, /[eE]/.test(v) ? xsdDouble : v.includes(".") ? xsdDecimal : xsdInteger)));
+const boolean = Parser.terminated(Parser.alt(Token.literal("true"), Token.literal("false")), Parser.not(Token.oneOf([...alphanumeric, "_"]))).pipe(Parser.map((v) => literal$1(v, xsdBoolean)));
+const tripleTerm = Parser.preceded(Token.literal("<<("), Parser.cut(Parser.terminated(Parser.seq(Parser.suspend(() => term), Parser.suspend(() => term), Parser.suspend(() => term)), Parser.preceded(ws, Token.literal(")>>"))))).pipe(Parser.map(([s, p, o]) => triple(s, p, o)));
+const term = Parser.preceded(ws, Parser.alt(tripleTerm, iri, blankNode, literal, number, boolean).pipe(Parser.expected("RDF term")));
+/**
+* A complete term, with optional surrounding whitespace: IRIs in `<>`,
+* blank nodes, quoted literals, numbers, booleans and triple terms.
+*/
+const groundTerm = Compiler.jit(Parser.terminated(term, ws));
+const quotedField = Parser.delimited(Token.literal("\""), Parser.cut(Parser.repeat(Parser.alt(Token.takeTill("\"", { min: 1 }), Parser.as(Token.literal("\"\""), "\"")))), Parser.cut(Token.literal("\""))).pipe(Parser.map((parts) => ({
+	value: parts.join(""),
+	quoted: true
+})));
+const plainField = Token.takeTill(",\r\n").pipe(Parser.map((value) => ({
+	value,
+	quoted: false
+})));
+const csvRow = Parser.separated(Parser.alt(quotedField, plainField), Token.literal(","));
+const csvLineEnding = Parser.alt(Token.literal("\r\n"), Token.literal("\r"), Token.literal("\n"));
+/**
+* The rows of a CSV document. Lines end with CRLF, CR or LF, and the line
+* ending of the last row is optional.
+*/
+const csvRows = Compiler.jit(Parser.repeat(Parser.preceded(Parser.not(Parser.eof), Parser.terminated(csvRow, Parser.alt(csvLineEnding, Parser.eof)))));
+// src/sparql/Results.ts
+/**
+* SPARQL query results: the result models returned by the engine and the
+* standard results formats — JSON (`application/sparql-results+json`), XML
+* (`application/sparql-results+xml`), CSV and TSV — with streaming
+* serialisers and parsers, including SPARQL 1.2 triple terms and directional
+* language-tagged strings.
+*
+* @since 0.1.0
+*/
+var Results_exports = /* @__PURE__ */ __exportAll({
+	Csv: () => Csv,
+	Json: () => Json,
+	JsonResultsSchema: () => JsonResultsSchema,
+	JsonTermSchema: () => JsonTermSchema,
+	ResultsParseError: () => ResultsParseError,
+	Tsv: () => Tsv,
+	Xml: () => Xml,
+	codecFor: () => codecFor,
+	codecForExtension: () => codecForExtension,
+	codecs: () => codecs,
+	collect: () => collect,
+	fromResultSet: () => fromResultSet,
+	negotiate: () => negotiate,
+	parseTerm: () => parseTerm,
+	termFromJson: () => termFromJson,
+	termToJson: () => termToJson,
+	termToTsv: () => termToTsv
+});
+/**
+* Materialises a `SELECT` result.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const collect = (result) => Effect.map(Stream.runCollect(result.bindings), (bindings) => ({
+	_tag: "ResultSet",
+	variables: result.variables.map((v) => v.value),
+	bindings
+}));
+/**
+* Turns a materialised result set back into a streaming `SelectResult`.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromResultSet = (set) => ({
+	_tag: "Select",
+	variables: set.variables.map((v) => variable(v)),
+	bindings: Stream.fromIterable(set.bindings)
+});
+/**
+* An error parsing a results document. The text formats (TSV and CSV)
+* report the 1-based `line` and `column` of the error.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ResultsParseError = class extends Schema.TaggedError()("ResultsParseError", {
+	format: Schema.String,
+	message: Schema.String,
+	line: Schema.optional(Schema.Number),
+	column: Schema.optional(Schema.Number)
+}) {};
+/** The last line of a rendered `ParseError`: what was expected and found. */
+const parseErrorSummary = (error) => error.message.slice(error.message.lastIndexOf("\n") + 1);
+const toSelect = (result) => Predicate.isTagged(result, "ResultSet") ? fromResultSet(result) : Predicate.isTagged(result, "Boolean") ? {
+	_tag: "Ask",
+	value: result.value
+} : result;
+const stringify = (chunks) => Effect.runSync(Stream.mkString(chunks));
+const ordered = (result, row) => Stream.map(result.bindings, (b, i) => row(b, i));
+/**
+* Schema of an RDF term in SPARQL JSON results (SPARQL 1.2, including
+* triple terms; core's `TermJson.GroundTermSchema`).
+*
+* @since 0.1.0
+* @category json
+*/
+const JsonTermSchema = GroundTermSchema;
+/**
+* Schema of a SPARQL JSON results document.
+*
+* @since 0.1.0
+* @category json
+*/
+const JsonResultsSchema = Schema.Struct({
+	head: Schema.Struct({
+		vars: Schema.optional(Schema.Array(Schema.String)),
+		link: Schema.optional(Schema.Array(Schema.String))
+	}),
+	results: Schema.optional(Schema.Struct({ bindings: Schema.Array(Schema.Record(Schema.String, JsonTermSchema)) })),
+	boolean: Schema.optional(Schema.Boolean)
+});
+/**
+* Encodes a term as SPARQL JSON (core's `Term.toJson`).
+*
+* @since 0.1.0
+* @category json
+*/
+const termToJson = (t) => toJson(t);
+/**
+* Decodes a SPARQL JSON term (core's `Term.fromJson`); the positions of a
+* triple term are trusted.
+*
+* @since 0.1.0
+* @category json
+*/
+const termFromJson = (j) => fromJson(j);
+const decodeJsonResults = Schema.decodeUnknownResult(JsonResultsSchema);
+const encodeJsonText = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
+const jsonFormat = {
+	name: "SPARQL Results JSON",
+	mediaType: "application/sparql-results+json",
+	mediaTypes: ["application/sparql-results+json", "application/json"],
+	extensions: ["srj", "json"],
+	booleans: true
+};
+const serializeJson = (result) => {
+	if (Predicate.isTagged(result, "Ask")) return Stream.succeed(`{"head":{},"boolean":${result.value}}\n`);
+	const vars = result.variables.map((v) => v.value);
+	const head = `{"head":{"vars":${encodeJsonText(vars)}},"results":{"bindings":[`;
+	return Stream.concat(Stream.concat(Stream.succeed(head), ordered(result, (b, i) => {
+		const row = {};
+		vars.forEach((v) => {
+			const t = b.map.get(v);
+			if (t !== void 0) row[v] = termToJson(t);
+		});
+		return `${i > 0 ? "," : ""}\n${encodeJsonText(row)}`;
+	})), Stream.succeed("\n]}}\n"));
+};
+const parseJson = (input) => Effect.suspend(() => {
+	const err = (message) => Effect.fail(new ResultsParseError({
+		format: "json",
+		message
+	}));
+	const raw = parse(input);
+	if (Result.isFailure(raw)) return err(`Invalid JSON: ${raw.failure}`);
+	const decoded = decodeJsonResults(raw.success);
+	if (Result.isFailure(decoded)) return err(decoded.failure.message);
+	const doc = decoded.success;
+	if (doc.boolean !== void 0) return Effect.succeed({
+		_tag: "Boolean",
+		value: doc.boolean
+	});
+	if (doc.results === void 0) return err("Missing results");
+	return Effect.succeed({
+		_tag: "ResultSet",
+		variables: doc.head.vars ?? [],
+		bindings: doc.results.bindings.map((row) => fromEntries(Record.toEntries(row).map(([k, v]) => [k, termFromJson(v)])))
+	});
+});
+/**
+* SPARQL 1.1 Query Results JSON Format.
+*
+* @since 0.1.0
+* @category formats
+*/
+const Json = {
+	format: jsonFormat,
+	serialize: serializeJson,
+	serializeString: (r) => stringify(serializeJson(toSelect(r))),
+	parse: parseJson
+};
+const SRX = "http://www.w3.org/2005/sparql-results#";
+const ITS = "http://www.w3.org/2005/11/its";
+const xmlLiteral = (l) => {
+	return `<literal${l.language !== "" ? ` xml:lang="${escapeAttribute(l.language)}"${l.direction !== void 0 ? ` its:dir="${l.direction}"` : ""}` : l.datatype.value !== "http://www.w3.org/2001/XMLSchema#string" ? ` datatype="${escapeAttribute(l.datatype.value)}"` : ""}>${escapeText(l.value)}</literal>`;
+};
+/** A term as an XML results element. Plain branches: it runs for every term of every row. */
+const xmlTerm = (t) => {
+	if (isLiteral(t)) return xmlLiteral(t);
+	if (isNamedNode(t)) return `<uri>${escapeText(t.value)}</uri>`;
+	if (isBlankNode(t)) return `<bnode>${escapeText(t.value)}</bnode>`;
+	return `<triple><subject>${xmlTerm(t.subject)}</subject><predicate>${xmlTerm(t.predicate)}</predicate><object>${xmlTerm(t.object)}</object></triple>`;
+};
+const serializeXml = (result) => {
+	const open = `<?xml version="1.0"?>\n<sparql xmlns="${SRX}" xmlns:its="${ITS}">\n`;
+	if (Predicate.isTagged(result, "Ask")) return Stream.succeed(`${open}<head/>\n<boolean>${result.value}</boolean>\n</sparql>\n`);
+	const vars = result.variables.map((v) => v.value);
+	const head = `${open}<head>${vars.map((v) => `<variable name="${escapeAttribute(v)}"/>`).join("")}</head>\n<results>\n`;
+	return Stream.concat(Stream.concat(Stream.succeed(head), ordered(result, (b) => {
+		return `<result>${vars.map((v) => {
+			const t = b.map.get(v);
+			return t === void 0 ? "" : `<binding name="${escapeAttribute(v)}">${xmlTerm(t)}</binding>`;
+		}).join("")}</result>\n`;
+	})), Stream.succeed("</results>\n</sparql>\n"));
+};
+const elements = (e) => e.children.filter((c) => Predicate.isTagged(c, "Element"));
+const textOf = (e) => e.children.map((c) => Predicate.isTagged(c, "Text") ? c.value : "").join("");
+/** An attribute's value, by local name (and namespace, when given). */
+const attribute = (e, local, ns) => Option.map(Arr.findFirst(e.attributes, (a) => a.localName === local && (ns === void 0 || a.namespace === ns)), (a) => a.value);
+const XML_NS = "http://www.w3.org/XML/1998/namespace";
+const xmlTriplePart = (e, name) => {
+	const p = elements(e).find((c) => c.localName === name);
+	const inner = p === void 0 ? void 0 : elements(p)[0];
+	if (inner === void 0) throw new ResultsParseError({
+		format: "xml",
+		message: `Missing ${name} in triple term`
+	});
+	return xmlToTerm(inner);
+};
+const xmlToTerm = (e) => {
+	return Match.value(e.localName).pipe(Match.when("uri", () => namedNode(textOf(e))), Match.when("bnode", () => blankNode$1(textOf(e))), Match.when("literal", () => {
+		const lang = Option.getOrElse(attribute(e, "lang", XML_NS), () => "");
+		const dir = Option.orElse(attribute(e, "dir", ITS), () => attribute(e, "dir"));
+		const datatype = attribute(e, "datatype");
+		if (lang !== "") return Option.isSome(dir) && (dir.value === "ltr" || dir.value === "rtl") ? literal$1(textOf(e), {
+			language: lang,
+			direction: dir.value
+		}) : literal$1(textOf(e), lang);
+		return Option.isSome(datatype) ? literal$1(textOf(e), namedNode(datatype.value)) : literal$1(textOf(e));
+	}), Match.when("triple", () => triple(xmlTriplePart(e, "subject"), xmlTriplePart(e, "predicate"), xmlTriplePart(e, "object"))), Match.orElse((name) => {
+		throw new ResultsParseError({
+			format: "xml",
+			message: `Unexpected element <${name}>`
+		});
+	}));
+};
+const parseXml = (input) => Effect.suspend(() => {
+	const doc = parseResult(input);
+	if (Result.isFailure(doc)) return Effect.fail(new ResultsParseError({
+		format: "xml",
+		message: doc.failure.message
+	}));
+	return Effect.try({
+		try: () => {
+			const root = doc.success.root;
+			const head = elements(root).find((c) => c.localName === "head");
+			const vars = head === void 0 ? [] : elements(head).filter((c) => c.localName === "variable").map((c) => Option.getOrElse(attribute(c, "name"), () => ""));
+			const boolean = elements(root).find((c) => c.localName === "boolean");
+			if (boolean !== void 0) return {
+				_tag: "Boolean",
+				value: textOf(boolean).trim() === "true"
+			};
+			const results = elements(root).find((c) => c.localName === "results");
+			return {
+				_tag: "ResultSet",
+				variables: vars,
+				bindings: (results === void 0 ? [] : elements(results)).map((r) => fromEntries(elements(r).filter((c) => c.localName === "binding").map((c) => [Option.getOrElse(attribute(c, "name"), () => ""), xmlToTerm(Option.getOrThrowWith(Arr.head(elements(c)), () => new ResultsParseError({
+					format: "xml",
+					message: "Missing term in binding"
+				})))])))
+			};
+		},
+		catch: (cause) => new ResultsParseError({
+			format: "xml",
+			message: Predicate.isError(cause) ? cause.message : String(cause)
+		})
+	});
+});
+/**
+* SPARQL Query Results XML Format.
+*
+* @since 0.1.0
+* @category formats
+*/
+const Xml = {
+	format: {
+		name: "SPARQL Results XML",
+		mediaType: "application/sparql-results+xml",
+		mediaTypes: [
+			"application/sparql-results+xml",
+			"application/xml",
+			"text/xml"
+		],
+		extensions: ["srx", "xml"],
+		booleans: true
+	},
+	serialize: serializeXml,
+	serializeString: (r) => stringify(serializeXml(toSelect(r))),
+	parse: parseXml
+};
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/**
+* Formats a term in the Turtle / SPARQL syntax used by TSV results.
+*
+* @since 0.1.0
+* @category tsv
+*/
+const termToTsv = (t) => {
+	if (isLiteral(t) && t.language === "") {
+		const dt = t.datatype.value;
+		if (dt === `${XSD}integer` && /^[+-]?\d+$/.test(t.value)) return t.value;
+		if (dt === `${XSD}decimal` && /^[+-]?\d*\.\d+$/.test(t.value)) return t.value;
+		if (dt === `${XSD}double` && /^[+-]?(\d+\.?\d*|\.\d+)[eE][+-]?\d+$/.test(t.value)) return t.value;
+		if (dt === `${XSD}boolean` && (t.value === "true" || t.value === "false")) return t.value;
+	}
+	if (isTriple(t)) return `<<( ${termToTsv(t.subject)} ${termToTsv(t.predicate)} ${termToTsv(t.object)} )>>`;
+	return t.key.replace(/\t/g, "\\t");
+};
+/**
+* Parses a term written in the Turtle / SPARQL syntax used by TSV results
+* (IRIs in `<>`, blank nodes, quoted literals, numbers, booleans, triple
+* terms).
+*
+* @since 0.1.0
+* @category tsv
+*/
+const parseTerm = (text) => Result.getSuccess(Parser.parse(groundTerm, text));
+const serializeDelimited = (layout) => (result) => {
+	if (Predicate.isTagged(result, "Ask")) return Stream.succeed(`${result.value}${layout.newline}`);
+	const vars = result.variables.map((v) => v.value);
+	return Stream.concat(Stream.succeed(`${vars.map(layout.header).join(layout.separator)}${layout.newline}`), ordered(result, (b) => {
+		return `${vars.map((v) => {
+			const t = b.map.get(v);
+			return t === void 0 ? "" : layout.cell(t);
+		}).join(layout.separator)}${layout.newline}`;
+	}));
+};
+const serializeTsv = serializeDelimited({
+	separator: "	",
+	newline: "\n",
+	header: (v) => `?${v}`,
+	cell: termToTsv
+});
+const splitLines = (input) => {
+	const lines = input.split(/\r?\n/);
+	if (lines[lines.length - 1] === "") lines.pop();
+	return lines;
+};
+const parseTsv = (input) => Effect.suspend(() => {
+	const [header, ...rows] = splitLines(input);
+	if (header === void 0) return Effect.fail(new ResultsParseError({
+		format: "tsv",
+		message: "Empty document"
+	}));
+	const first = header.trim();
+	if (first === "true" || first === "false") return Effect.succeed({
+		_tag: "Boolean",
+		value: first === "true"
+	});
+	const vars = header.split("	").map((v) => v.trim().replace(/^[?$]/, ""));
+	const bindings = [];
+	const failure = Arr.findFirst(rows, (line, index) => Result.match(tsvRow(vars, line, index + 2), {
+		onFailure: Option.some,
+		onSuccess: (b) => {
+			bindings.push(b);
+			return Option.none();
+		}
+	}));
+	return Option.isSome(failure) ? Effect.fail(failure.value) : Effect.succeed({
+		_tag: "ResultSet",
+		variables: vars,
+		bindings
+	});
+});
+/** A TSV row (on 1-based line `line`) as a solution, or the error at its first invalid cell. */
+const tsvRow = (vars, line, lineNumber) => {
+	const cells = line.split("	");
+	const entries = [];
+	let offset = 0;
+	const failure = Arr.findFirst(vars, (v, i) => {
+		const cell = cells[i] ?? "";
+		const start = offset;
+		offset += cell.length + 1;
+		if (cell.trim() === "") return Option.none();
+		const t = Parser.parse(groundTerm, cell);
+		if (Result.isFailure(t)) return Option.some(new ResultsParseError({
+			format: "tsv",
+			message: `Invalid term: ${cell.trim()}: ${parseErrorSummary(t.failure)}`,
+			line: lineNumber,
+			column: start + t.failure.position.column
+		}));
+		entries.push([v, t.success]);
+		return Option.none();
+	});
+	return Option.isSome(failure) ? Result.fail(failure.value) : Result.succeed(fromEntries(entries));
+};
+/**
+* SPARQL 1.1 Query Results TSV Format.
+*
+* @since 0.1.0
+* @category formats
+*/
+const Tsv = {
+	format: {
+		name: "SPARQL Results TSV",
+		mediaType: "text/tab-separated-values",
+		mediaTypes: ["text/tab-separated-values"],
+		extensions: ["tsv"],
+		booleans: true
+	},
+	serialize: serializeTsv,
+	serializeString: (r) => stringify(serializeTsv(toSelect(r))),
+	parse: parseTsv
+};
+const csvField = (s) => /[",\r\n]/.test(s) ? `"${s.replace(/"/g, "\"\"")}"` : s;
+/** A term as a CSV cell. Plain branches: it runs for every term of every row. */
+const csvTerm = (t) => {
+	if (isNamedNode(t) || isLiteral(t)) return t.value;
+	if (isBlankNode(t)) return `_:${t.value}`;
+	return `<<( ${termToTsv(t.subject)} ${termToTsv(t.predicate)} ${termToTsv(t.object)} )>>`;
+};
+const serializeCsv = serializeDelimited({
+	separator: ",",
+	newline: "\r\n",
+	header: csvField,
+	cell: (t) => csvField(csvTerm(t))
+});
+/**
+* Interprets a CSV cell. The CSV format is lossy: blank nodes are recognised
+* by `_:`, absolute IRIs (with a scheme) become IRIs, numbers and booleans
+* become typed literals and everything else a plain string.
+*/
+const csvCell = (cell) => {
+	if (cell.startsWith("_:")) return blankNode$1(cell.slice(2));
+	if (/^[a-zA-Z][a-zA-Z0-9+.-]*:[^\s]*$/.test(cell) && !/^\d/.test(cell)) return namedNode(cell);
+	if (/^[+-]?\d+$/.test(cell)) return literal$1(cell, namedNode(`${XSD}integer`));
+	if (/^[+-]?\d*\.\d+$/.test(cell)) return literal$1(cell, namedNode(`${XSD}decimal`));
+	if (/^[+-]?(\d+\.?\d*|\.\d+)[eE][+-]?\d+$/.test(cell)) return literal$1(cell, namedNode(`${XSD}double`));
+	return literal$1(cell);
+};
+const parseCsv = (input) => Effect.suspend(() => {
+	const parsed = Parser.parse(csvRows, input);
+	if (Result.isFailure(parsed)) {
+		const { line, column } = parsed.failure.position;
+		return Effect.fail(new ResultsParseError({
+			format: "csv",
+			message: parseErrorSummary(parsed.failure),
+			line,
+			column
+		}));
+	}
+	const [first, ...rows] = parsed.success;
+	if (first === void 0) return Effect.fail(new ResultsParseError({
+		format: "csv",
+		message: "Empty document"
+	}));
+	const [only, ...others] = first;
+	if (only !== void 0 && Arr.isReadonlyArrayEmpty(others) && (only.value === "true" || only.value === "false")) return Effect.succeed({
+		_tag: "Boolean",
+		value: only.value === "true"
+	});
+	const vars = first.map((c) => c.value);
+	const bindings = rows.map((r) => fromEntries(vars.map((v, i) => {
+		const cell = r[i];
+		return [v, cell === void 0 || cell.value === "" && !cell.quoted ? void 0 : csvCell(cell.value)];
+	})));
+	return Effect.succeed({
+		_tag: "ResultSet",
+		variables: vars,
+		bindings
+	});
+});
+/**
+* SPARQL 1.1 Query Results CSV Format (lossy: parsing recovers IRIs, blank
+* nodes, numbers and strings heuristically).
+*
+* @since 0.1.0
+* @category formats
+*/
+const Csv = {
+	format: {
+		name: "SPARQL Results CSV",
+		mediaType: "text/csv",
+		mediaTypes: ["text/csv"],
+		extensions: ["csv"],
+		booleans: true
+	},
+	serialize: serializeCsv,
+	serializeString: (r) => stringify(serializeCsv(toSelect(r))),
+	parse: parseCsv
+};
+/**
+* All results formats, in order of preference.
+*
+* @since 0.1.0
+* @category formats
+*/
+const codecs = [
+	Json,
+	Xml,
+	Csv,
+	Tsv
+];
+/**
+* Finds a results codec for a media type (parameters are ignored).
+*
+* @since 0.1.0
+* @category formats
+*/
+const codecFor = (mediaType) => {
+	const mt = (mediaType.split(";")[0] ?? "").trim().toLowerCase();
+	return Option.fromNullishOr(codecs.find((c) => c.format.mediaTypes.includes(mt)));
+};
+/**
+* Finds a results codec for a file extension.
+*
+* @since 0.1.0
+* @category formats
+*/
+const codecForExtension = (extension) => {
+	const ext = extension.replace(/^\./, "").toLowerCase();
+	return Option.fromNullishOr(codecs.find((c) => c.format.extensions.includes(ext)));
+};
+/**
+* Chooses the best results codec for an HTTP `Accept` header.
+*
+* @since 0.1.0
+* @category formats
+*/
+const negotiate = (accept) => Option.flatMap(negotiate$1(accept, codecs.flatMap((c) => c.format.mediaTypes)), codecFor);
+export { termToJson as _, ResultsParseError as a, Xml as c, codecs as d, collect as f, termFromJson as g, parseTerm as h, JsonTermSchema as i, codecFor as l, negotiate as m, Json as n, Results_exports as o, fromResultSet as p, JsonResultsSchema as r, Tsv as s, Csv as t, codecForExtension as u, termToTsv as v, parse as y };
+
+//# sourceMappingURL=Results-peJjGA2V.mjs.map