@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Functions-AvjNcId_.mjs

@@ -0,0 +1,1346 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, N as isBlankNode, Y as literal, Z as namedNode, o as Literal, rt as triple, w as XSD_STRING, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { l as resolve } from "./Iri-Cr92gsQV.mjs";
+import { S as toValue, _ as isValidLexical, a as canonicalDouble, g as isNumericDatatype, h as isKnownDatatype, i as canonicalDecimal, v as isWellFormed } from "./Xsd-Cdgx5zRB.mjs";
+import { a as setOf, i as fromEntries, n as empty } from "./stringMap-D5YIpYtR.mjs";
+import { t as loop } from "./loop-D5-gNx9K.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 Str from "effect/String";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+import * as BigDecimal from "effect/BigDecimal";
+// src/sparql/internal/hash.ts
+/**
+* Pure, synchronous implementations of MD5, SHA-1, SHA-256, SHA-384 and
+* SHA-512 over UTF-8 strings, returning lower-case hex digests.
+*
+* @internal
+*/
+const utf8 = (s) => new TextEncoder().encode(s);
+const hex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+/** `0 … n - 1`. */
+const range = (n) => Array.from({ length: n }, (_, i) => i);
+/** The offsets of the `blockSize`-byte blocks of a padded message. */
+const blocks = (m, blockSize) => range(m.length / blockSize).map((b) => b * blockSize);
+const pad = (msg, blockSize, lengthBytes, littleEndian) => {
+	const bitLen = BigInt(msg.length) * 8n;
+	const total = Math.ceil((msg.length + 1 + lengthBytes) / blockSize) * blockSize;
+	const out = new Uint8Array(total);
+	out.set(msg);
+	out[msg.length] = 128;
+	range(lengthBytes).forEach((i) => {
+		const byte = Number(bitLen >> BigInt(8 * i) & 255n);
+		if (littleEndian) out[total - lengthBytes + i] = byte;
+		else out[total - 1 - i] = byte;
+	});
+	return out;
+};
+const rotl = (x, n) => x << n | x >>> 32 - n;
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/** Big-endian 32-bit words of a digest, as hex. */
+const hexWords = (words) => words.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+const MD5_STEPS = [
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	7,
+	12,
+	17,
+	22,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	5,
+	9,
+	14,
+	20,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	4,
+	11,
+	16,
+	23,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21,
+	6,
+	10,
+	15,
+	21
+].map((s, i) => ({
+	i,
+	k: Math.floor(Math.abs(Math.sin(i + 1)) * 2 ** 32) | 0,
+	s,
+	g: i < 16 ? i : i < 32 ? (5 * i + 1) % 16 : i < 48 ? (3 * i + 5) % 16 : 7 * i % 16
+}));
+const md5 = (input) => {
+	const m = pad(utf8(input), 64, 8, true);
+	let a0 = 1732584193;
+	let b0 = -271733879;
+	let c0 = -1732584194;
+	let d0 = 271733878;
+	const view = new DataView(m.buffer);
+	blocks(m, 64).forEach((off) => {
+		let a = a0;
+		let b = b0;
+		let c = c0;
+		let d = d0;
+		MD5_STEPS.forEach(({ i, k, s, g }) => {
+			const f = i < 16 ? b & c | ~b & d : i < 32 ? d & b | ~d & c : i < 48 ? b ^ c ^ d : c ^ (b | ~d);
+			const tmp = d;
+			d = c;
+			c = b;
+			b = b + rotl(a + f + k + (view.getUint32(off + g * 4, true) | 0) | 0, s) | 0;
+			a = tmp;
+		});
+		a0 = a0 + a | 0;
+		b0 = b0 + b | 0;
+		c0 = c0 + c | 0;
+		d0 = d0 + d | 0;
+	});
+	const out = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(16));
+	[
+		a0,
+		b0,
+		c0,
+		d0
+	].forEach((x, i) => out.setUint32(i * 4, x >>> 0, true));
+	return hex(new Uint8Array(out.buffer));
+};
+const ROUNDS_16 = range(16);
+const SCHEDULE_80 = range(80).slice(16);
+const SCHEDULE_64 = range(64).slice(16);
+const SHA1_ROUNDS = range(80);
+const sha1 = (input) => {
+	const m = pad(utf8(input), 64, 8, false);
+	let h0 = 1732584193;
+	let h1 = -271733879;
+	let h2 = -1732584194;
+	let h3 = 271733878;
+	let h4 = -1009589776;
+	const view = new DataView(m.buffer);
+	const w = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(320));
+	const word = (i) => w.getInt32(i * 4);
+	blocks(m, 64).forEach((off) => {
+		ROUNDS_16.forEach((i) => w.setInt32(i * 4, view.getUint32(off + i * 4) | 0));
+		SCHEDULE_80.forEach((i) => w.setInt32(i * 4, rotl(word(i - 3) ^ word(i - 8) ^ word(i - 14) ^ word(i - 16), 1)));
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		SHA1_ROUNDS.forEach((i) => {
+			const f = i < 20 ? b & c | ~b & d : i < 40 ? b ^ c ^ d : i < 60 ? b & c | b & d | c & d : b ^ c ^ d;
+			const k = i < 20 ? 1518500249 : i < 40 ? 1859775393 : i < 60 ? -1894007588 : -899497514;
+			const t = rotl(a, 5) + f + e + k + word(i) | 0;
+			e = d;
+			d = c;
+			c = rotl(b, 30);
+			b = a;
+			a = t;
+		});
+		h0 = h0 + a | 0;
+		h1 = h1 + b | 0;
+		h2 = h2 + c | 0;
+		h3 = h3 + d | 0;
+		h4 = h4 + e | 0;
+	});
+	return hexWords([
+		h0,
+		h1,
+		h2,
+		h3,
+		h4
+	]);
+};
+const K256 = [
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+].map((x) => x | 0);
+const sha256 = (input) => {
+	const m = pad(utf8(input), 64, 8, false);
+	let h0 = 1779033703;
+	let h1 = -1150833019;
+	let h2 = 1013904242;
+	let h3 = -1521486534;
+	let h4 = 1359893119;
+	let h5 = -1694144372;
+	let h6 = 528734635;
+	let h7 = 1541459225;
+	const view = new DataView(m.buffer);
+	const w = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(256));
+	const word = (i) => w.getInt32(i * 4);
+	blocks(m, 64).forEach((off) => {
+		ROUNDS_16.forEach((i) => w.setInt32(i * 4, view.getUint32(off + i * 4) | 0));
+		SCHEDULE_64.forEach((i) => {
+			const x = word(i - 15);
+			const y = word(i - 2);
+			const s0 = rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3;
+			const s1 = rotr(y, 17) ^ rotr(y, 19) ^ y >>> 10;
+			w.setInt32(i * 4, word(i - 16) + s0 + word(i - 7) + s1 | 0);
+		});
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		let f = h5;
+		let g = h6;
+		let hh = h7;
+		K256.forEach((k, i) => {
+			const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+			const ch = e & f ^ ~e & g;
+			const t1 = hh + S1 + ch + k + word(i) | 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		});
+		h0 = h0 + a | 0;
+		h1 = h1 + b | 0;
+		h2 = h2 + c | 0;
+		h3 = h3 + d | 0;
+		h4 = h4 + e | 0;
+		h5 = h5 + f | 0;
+		h6 = h6 + g | 0;
+		h7 = h7 + hh | 0;
+	});
+	return hexWords([
+		h0,
+		h1,
+		h2,
+		h3,
+		h4,
+		h5,
+		h6,
+		h7
+	]);
+};
+const K512 = [
+	"428a2f98d728ae22",
+	"7137449123ef65cd",
+	"b5c0fbcfec4d3b2f",
+	"e9b5dba58189dbbc",
+	"3956c25bf348b538",
+	"59f111f1b605d019",
+	"923f82a4af194f9b",
+	"ab1c5ed5da6d8118",
+	"d807aa98a3030242",
+	"12835b0145706fbe",
+	"243185be4ee4b28c",
+	"550c7dc3d5ffb4e2",
+	"72be5d74f27b896f",
+	"80deb1fe3b1696b1",
+	"9bdc06a725c71235",
+	"c19bf174cf692694",
+	"e49b69c19ef14ad2",
+	"efbe4786384f25e3",
+	"0fc19dc68b8cd5b5",
+	"240ca1cc77ac9c65",
+	"2de92c6f592b0275",
+	"4a7484aa6ea6e483",
+	"5cb0a9dcbd41fbd4",
+	"76f988da831153b5",
+	"983e5152ee66dfab",
+	"a831c66d2db43210",
+	"b00327c898fb213f",
+	"bf597fc7beef0ee4",
+	"c6e00bf33da88fc2",
+	"d5a79147930aa725",
+	"06ca6351e003826f",
+	"142929670a0e6e70",
+	"27b70a8546d22ffc",
+	"2e1b21385c26c926",
+	"4d2c6dfc5ac42aed",
+	"53380d139d95b3df",
+	"650a73548baf63de",
+	"766a0abb3c77b2a8",
+	"81c2c92e47edaee6",
+	"92722c851482353b",
+	"a2bfe8a14cf10364",
+	"a81a664bbc423001",
+	"c24b8b70d0f89791",
+	"c76c51a30654be30",
+	"d192e819d6ef5218",
+	"d69906245565a910",
+	"f40e35855771202a",
+	"106aa07032bbd1b8",
+	"19a4c116b8d2d0c8",
+	"1e376c085141ab53",
+	"2748774cdf8eeb99",
+	"34b0bcb5e19b48a8",
+	"391c0cb3c5c95a63",
+	"4ed8aa4ae3418acb",
+	"5b9cca4f7763e373",
+	"682e6ff3d6b2b8a3",
+	"748f82ee5defb2fc",
+	"78a5636f43172f60",
+	"84c87814a1f0ab72",
+	"8cc702081a6439ec",
+	"90befffa23631e28",
+	"a4506cebde82bde9",
+	"bef9a3f7b2c67915",
+	"c67178f2e372532b",
+	"ca273eceea26619c",
+	"d186b8c721c0c207",
+	"eada7dd6cde0eb1e",
+	"f57d4f7fee6ed178",
+	"06f067aa72176fba",
+	"0a637dc5a2c898a6",
+	"113f9804bef90dae",
+	"1b710b35131c471b",
+	"28db77f523047d84",
+	"32caab7b40c72493",
+	"3c9ebe0a15c9bebc",
+	"431d67c49c100d4c",
+	"4cc5d4becb3e42b6",
+	"597f299cfc657e2a",
+	"5fcb6fab3ad6faec",
+	"6c44198c4a475817"
+].map((h) => BigInt(`0x${h}`));
+const MASK64 = (1n << 64n) - 1n;
+const rotr64 = (x, n) => (x >> n | x << 64n - n) & MASK64;
+const SCHEDULE_512 = range(80).slice(16);
+const sha512core = (input, init, outWords) => {
+	const m = pad(utf8(input), 128, 16, false);
+	let h = init;
+	const view = new DataView(m.buffer);
+	const w = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(640));
+	const word = (i) => w.getBigUint64(i * 8);
+	blocks(m, 128).forEach((off) => {
+		ROUNDS_16.forEach((i) => w.setBigUint64(i * 8, view.getBigUint64(off + i * 8)));
+		SCHEDULE_512.forEach((i) => {
+			const x = word(i - 15);
+			const y = word(i - 2);
+			const s0 = rotr64(x, 1n) ^ rotr64(x, 8n) ^ x >> 7n;
+			const s1 = rotr64(y, 19n) ^ rotr64(y, 61n) ^ y >> 6n;
+			w.setBigUint64(i * 8, word(i - 16) + s0 + word(i - 7) + s1 & MASK64);
+		});
+		let [a, b, c, d, e, f, g, hh] = h;
+		K512.forEach((k, i) => {
+			const S1 = rotr64(e, 14n) ^ rotr64(e, 18n) ^ rotr64(e, 41n);
+			const ch = e & f ^ ~e & MASK64 & g;
+			const t1 = hh + S1 + ch + k + word(i) & MASK64;
+			const t2 = (rotr64(a, 28n) ^ rotr64(a, 34n) ^ rotr64(a, 39n)) + (a & b ^ a & c ^ b & c) & MASK64;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 & MASK64;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 & MASK64;
+		});
+		const [h0, h1, h2, h3, h4, h5, h6, h7] = h;
+		h = [
+			h0 + a & MASK64,
+			h1 + b & MASK64,
+			h2 + c & MASK64,
+			h3 + d & MASK64,
+			h4 + e & MASK64,
+			h5 + f & MASK64,
+			h6 + g & MASK64,
+			h7 + hh & MASK64
+		];
+	});
+	return h.slice(0, outWords).map((x) => x.toString(16).padStart(16, "0")).join("");
+};
+const big = (x) => BigInt(`0x${x}`);
+/** A SHA-512 initial state, from its hex words. */
+const state512 = (...[a, b, c, d, e, f, g, h]) => [
+	big(a),
+	big(b),
+	big(c),
+	big(d),
+	big(e),
+	big(f),
+	big(g),
+	big(h)
+];
+const sha512 = (input) => sha512core(input, state512("6a09e667f3bcc908", "bb67ae8584caa73b", "3c6ef372fe94f82b", "a54ff53a5f1d36f1", "510e527fade682d1", "9b05688c2b3e6c1f", "1f83d9abfb41bd6b", "5be0cd19137e2179"), 8);
+const sha384 = (input) => sha512core(input, state512("cbbb9d5dc1059ed8", "629a292a367cd507", "9159015a3070dd17", "152fecd8f70e5939", "67332667ffc00b31", "8eb44a8768581511", "db0c2e0d64f98fa7", "47b5481dbefa4fa4"), 6);
+// src/sparql/internal/values.ts
+/**
+* Value-level helpers for expression evaluation: numeric type promotion and
+* arithmetic, comparisons, effective boolean value and the ORDER BY term
+* ordering.
+*
+* Errors are signalled by throwing `EvalFailure` (a cheap, stack-less
+* object); the public API converts them to `ExpressionError`s.
+*
+* @internal
+*/
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+/** A thrown expression evaluation error. */
+var EvalFailure = class {
+	message;
+	constructor(message) {
+		this.message = message;
+	}
+};
+/**
+* Runs `f`, returning a thrown `EvalFailure` (an expression error) as the
+* failure; any other exception is a defect and propagates.
+*/
+const catchEvalFailure = (f) => Result.try({
+	try: f,
+	catch: (cause) => {
+		if (cause instanceof EvalFailure) return cause;
+		throw cause;
+	}
+});
+const fail = (message) => {
+	throw new EvalFailure(message);
+};
+const dt = {
+	string: namedNode(`${XSD}string`),
+	boolean: namedNode(`${XSD}boolean`),
+	integer: namedNode(`${XSD}integer`),
+	decimal: namedNode(`${XSD}decimal`),
+	float: namedNode(`${XSD}float`),
+	double: namedNode(`${XSD}double`),
+	dateTime: namedNode(`${XSD}dateTime`),
+	dayTimeDuration: namedNode(`${XSD}dayTimeDuration`),
+	langString: namedNode(`${RDF}langString`),
+	dirLangString: namedNode(`${RDF}dirLangString`)
+};
+const TRUE = new Literal("true", dt.boolean);
+const FALSE = new Literal("false", dt.boolean);
+const bool = (b) => b ? TRUE : FALSE;
+/** A simple literal or `xsd:string` (no language tag). */
+const isSimpleString = (t) => isLiteral(t) && t.language === "" && t.datatype.value === "http://www.w3.org/2001/XMLSchema#string";
+/** A string literal: simple, `xsd:string` or language-tagged. */
+const isStringLiteral = (t) => isLiteral(t) && (t.language !== "" || t.datatype.value === "http://www.w3.org/2001/XMLSchema#string");
+const stringLike = (value, like) => like.language === "" ? new Literal(value, dt.string) : like.direction === void 0 ? new Literal(value, dt.langString, like.language) : new Literal(value, dt.dirLangString, like.language, like.direction);
+const simple = (value) => new Literal(value, dt.string);
+/** The numeric value of each literal met, `None` for a non-numeric one. */
+const numCache = /* @__PURE__ */ new WeakMap();
+const numOfValue = (v) => Predicate.isTagged(v, "Integer") ? Option.some({
+	kind: 0,
+	v: v.value
+}) : Predicate.isTagged(v, "Decimal") ? Option.some({
+	kind: 1,
+	v: v.value
+}) : Predicate.isTagged(v, "Float") ? Option.some({
+	kind: 2,
+	v: v.value
+}) : Predicate.isTagged(v, "Double") ? Option.some({
+	kind: 3,
+	v: v.value
+}) : Option.none();
+/** The numeric value of a literal, `None` if it is not a valid numeric literal. */
+const numeric = (t) => {
+	if (!isLiteral(t) || t.language !== "") return Option.none();
+	const cached = numCache.get(t);
+	if (cached !== void 0) return cached;
+	const d = t.datatype.value;
+	const result = isNumericDatatype(d) && isValidLexical(d, t.value) ? numOfValue(toValue(t)) : Option.none();
+	numCache.set(t, result);
+	return result;
+};
+const isNumeric = (t) => Option.isSome(numeric(t));
+const toNumber = (n) => n.kind === 0 ? Number(n.v) : n.kind === 1 ? BigDecimal.toNumberUnsafe(n.v) : n.v;
+const toDecimal = (n) => n.kind === 0 ? BigDecimal.fromBigInt(n.v) : n.kind === 1 ? n.v : fail("Not a decimal");
+/** Promotes a numeric value to (at least) the given kind. */
+const promote = (n, kind) => {
+	if (n.kind >= kind) return n;
+	return kind === 1 ? {
+		kind: 1,
+		v: toDecimal(n)
+	} : kind === 2 ? {
+		kind: 2,
+		v: Math.fround(toNumber(n))
+	} : {
+		kind: 3,
+		v: toNumber(n)
+	};
+};
+const numLiteral = (n) => n.kind === 0 ? new Literal(n.v.toString(), dt.integer) : n.kind === 1 ? new Literal(canonicalDecimal(n.v), dt.decimal) : n.kind === 2 ? new Literal(canonicalDouble(Math.fround(n.v)), dt.float) : new Literal(canonicalDouble(n.v), dt.double);
+/** The numeric value of a literal; an evaluation error if it has none. */
+const requireNum = (t) => {
+	const n = numeric(t);
+	return Option.isSome(n) ? n.value : fail("Expected a numeric literal");
+};
+const DIVISION_SCALE = 18;
+/** `op` on two values already promoted to the common `kind`. */
+const arithmeticAt = (kind, op, px, py) => {
+	if (px.kind === 0 && py.kind === 0) {
+		const u = px.v;
+		const v = py.v;
+		return numLiteral({
+			kind: 0,
+			v: op === "+" ? u + v : op === "-" ? u - v : u * v
+		});
+	}
+	if (px.kind === 1 && py.kind === 1) {
+		const u = px.v;
+		const v = py.v;
+		if (op === "/") {
+			if (BigDecimal.isZero(v)) return fail("Division by zero");
+			return numLiteral({
+				kind: 1,
+				v: divideDecimal(u, v)
+			});
+		}
+		return numLiteral({
+			kind: 1,
+			v: op === "+" ? BigDecimal.sum(u, v) : op === "-" ? BigDecimal.subtract(u, v) : BigDecimal.multiply(u, v)
+		});
+	}
+	const u = toNumber(px);
+	const v = toNumber(py);
+	const r = op === "+" ? u + v : op === "-" ? u - v : op === "*" ? u * v : u / v;
+	return numLiteral(kind === 2 ? {
+		kind: 2,
+		v: Math.fround(r)
+	} : {
+		kind: 3,
+		v: r
+	});
+};
+const arithmetic = (op, a, b) => {
+	const x = requireNum(a);
+	const y = requireNum(b);
+	let kind = Math.max(x.kind, y.kind);
+	if (op === "/" && kind === 0) kind = 1;
+	const px = promote(x, kind);
+	const py = promote(y, kind);
+	return arithmeticAt(kind, op, px, py);
+};
+/** Decimal division with a fixed number of fractional digits (rounded half-even). */
+const divideDecimal = (u, v) => {
+	const exact = BigDecimal.divide(u, v);
+	const scaled = BigDecimal.round(Option.getOrElse(exact, () => BigDecimal.fromBigInt(0n)), {
+		scale: DIVISION_SCALE,
+		mode: "half-even"
+	});
+	return BigDecimal.normalize(scaled);
+};
+const negate = (a) => {
+	return negateNum(requireNum(a));
+};
+const negateNum = (x) => numLiteral(x.kind === 0 ? {
+	kind: 0,
+	v: -x.v
+} : x.kind === 1 ? {
+	kind: 1,
+	v: BigDecimal.negate(x.v)
+} : x.kind === 2 ? {
+	kind: 2,
+	v: -x.v
+} : {
+	kind: 3,
+	v: -x.v
+});
+/** Compares two numerics; returns NaN when unordered (NaN operands). */
+const compareNum = (x, y) => {
+	const kind = Math.max(x.kind, y.kind);
+	if (kind <= 1) {
+		if (x.kind === 0 && y.kind === 0) {
+			const u = x.v;
+			const v = y.v;
+			return u < v ? -1 : u > v ? 1 : 0;
+		}
+		const u = toDecimal(x);
+		const v = toDecimal(y);
+		return BigDecimal.isLessThan(u, v) ? -1 : BigDecimal.isGreaterThan(u, v) ? 1 : 0;
+	}
+	const u = toNumber(promote(x, kind));
+	const v = toNumber(promote(y, kind));
+	if (Number.isNaN(u) || Number.isNaN(v)) return NaN;
+	return u < v ? -1 : u > v ? 1 : 0;
+};
+const DATE_KINDS = setOf([
+	"dateTime",
+	"dateTimeStamp",
+	"date",
+	"time",
+	"gYear",
+	"gYearMonth",
+	"gMonth",
+	"gMonthDay",
+	"gDay"
+]);
+const dateValue = (t) => {
+	if (!isLiteral(t) || !t.datatype.value.startsWith("http://www.w3.org/2001/XMLSchema#")) return Option.none();
+	const local = t.datatype.value.slice(33);
+	if (!DATE_KINDS.has(local) || !isValidLexical(t.datatype.value, t.value)) return Option.none();
+	const v = toValue(t);
+	if (!Predicate.isTagged(v, "DateTime")) return Option.none();
+	return Option.some({
+		kind: local === "dateTimeStamp" ? "dateTime" : local,
+		millis: v.epochMillis,
+		zoned: v.timezone !== void 0
+	});
+};
+const FOURTEEN_HOURS = 504e5;
+const BEFORE = Option.some(-1);
+const SAME = Option.some(0);
+const AFTER = Option.some(1);
+/** Compares two date/time values of the same kind; `None` if indeterminate. */
+const compareDates = (a, b) => {
+	if (a.kind !== b.kind) return Option.none();
+	if (a.zoned !== b.zoned) {
+		const diff = a.millis - b.millis;
+		if (Math.abs(diff) <= FOURTEEN_HOURS) return Option.none();
+		return diff < 0 ? BEFORE : AFTER;
+	}
+	return a.millis < b.millis ? BEFORE : a.millis > b.millis ? AFTER : SAME;
+};
+const durationValue = (t) => {
+	if (!isLiteral(t)) return Option.none();
+	const d = t.datatype.value;
+	if (d !== `http://www.w3.org/2001/XMLSchema#duration` && d !== `http://www.w3.org/2001/XMLSchema#dayTimeDuration` && d !== `http://www.w3.org/2001/XMLSchema#yearMonthDuration`) return Option.none();
+	if (!isValidLexical(d, t.value)) return Option.none();
+	const v = toValue(t);
+	return Predicate.isTagged(v, "Duration") ? Option.some({
+		kind: d.slice(33),
+		months: v.months,
+		seconds: v.seconds
+	}) : Option.none();
+};
+/** Compares strings by Unicode code points. */
+const compareCodepoints = (a, b) => {
+	if (a === b) return 0;
+	const n = Math.min(a.length, b.length);
+	let i = 0;
+	loop(() => {
+		if (i >= n || a.charCodeAt(i) !== b.charCodeAt(i)) return false;
+		i++;
+		return true;
+	});
+	if (i < n) {
+		const x = a.charCodeAt(i);
+		const y = b.charCodeAt(i);
+		const xs = x >= 55296 && x <= 57343;
+		if (xs !== (y >= 55296 && y <= 57343)) return xs ? 1 : -1;
+		return x < y ? -1 : 1;
+	}
+	return a.length < b.length ? -1 : a.length > b.length ? 1 : 0;
+};
+const isBooleanLiteral = (t) => isLiteral(t) && t.datatype.value === `http://www.w3.org/2001/XMLSchema#boolean` && isValidLexical(t.datatype.value, t.value);
+const booleanValue = (t) => t.value === "true" || t.value === "1";
+/**
+* Compares two literals by value (for `<`, `>`, …). Returns a number (NaN for
+* unordered) or throws if they are not comparable.
+*/
+const compareLiterals = (a, b) => {
+	const x = numeric(a);
+	const y = numeric(b);
+	if (Option.isSome(x) && Option.isSome(y)) return compareNum(x.value, y.value);
+	if (isSimpleString(a) && isSimpleString(b)) return compareCodepoints(a.value, b.value);
+	if (isLiteral(a) && isLiteral(b) && a.language !== "" && a.language === b.language && a.direction === b.direction) return compareCodepoints(a.value, b.value);
+	if (isBooleanLiteral(a) && isBooleanLiteral(b)) return Number(booleanValue(a)) - Number(booleanValue(b));
+	const da = dateValue(a);
+	const db = dateValue(b);
+	if (Option.isSome(da) && Option.isSome(db)) {
+		const c = compareDates(da.value, db.value);
+		if (Option.isSome(c)) return c.value;
+		return fail("Indeterminate date comparison");
+	}
+	const ua = durationValue(a);
+	const ub = durationValue(b);
+	if (Option.isSome(ua) && Option.isSome(ub)) {
+		const u = ua.value;
+		const v = ub.value;
+		if (u.months === v.months) return Math.sign(u.seconds - v.seconds);
+		if (u.seconds === v.seconds) return Math.sign(u.months - v.months);
+		return fail("Indeterminate duration comparison");
+	}
+	return fail("Incomparable values");
+};
+const isKnownLiteral = (t) => t.language !== "" || isKnownDatatype(t.datatype.value);
+/** RDF term equality with value semantics (`=`). Throws on type errors. */
+const equals = (a, b) => {
+	const ta = isTriple(a);
+	const tb = isTriple(b);
+	if (ta || tb) {
+		if (!ta || !tb) return false;
+		return equals(a.subject, b.subject) && equals(a.predicate, b.predicate) && equals(a.object, b.object);
+	}
+	if (!isLiteral(a) || !isLiteral(b)) return a.key === b.key;
+	const x = numeric(a);
+	const y = numeric(b);
+	if (Option.isSome(x) && Option.isSome(y)) return compareNum(x.value, y.value) === 0;
+	if (a.key === b.key) return true;
+	if (isSimpleString(a) && isSimpleString(b)) return a.value === b.value;
+	if (isBooleanLiteral(a) && isBooleanLiteral(b)) return booleanValue(a) === booleanValue(b);
+	const da = dateValue(a);
+	const db = dateValue(b);
+	if (Option.isSome(da) && Option.isSome(db)) {
+		if (da.value.kind !== db.value.kind) return false;
+		const c = compareDates(da.value, db.value);
+		if (Option.isNone(c)) return fail("Indeterminate date comparison");
+		return c.value === 0;
+	}
+	const ua = durationValue(a);
+	const ub = durationValue(b);
+	if (Option.isSome(ua) && Option.isSome(ub)) return ua.value.months === ub.value.months && ua.value.seconds === ub.value.seconds;
+	if (a.language !== "" || b.language !== "") return false;
+	if (isKnownLiteral(a) && isKnownLiteral(b) && isWellFormed(a) && isWellFormed(b) && a.datatype.value !== b.datatype.value) return false;
+	return fail("Cannot compare literals");
+};
+/** Effective boolean value. */
+const numEbv = (n) => n.kind === 0 ? n.v !== 0n : n.kind === 1 ? !BigDecimal.isZero(n.v) : !(n.v === 0 || Number.isNaN(n.v));
+const ebv = (t) => {
+	if (!isLiteral(t)) return fail("EBV of a non-literal");
+	const d = t.datatype.value;
+	if (d === `http://www.w3.org/2001/XMLSchema#boolean`) {
+		if (!isValidLexical(d, t.value)) return fail("Invalid boolean");
+		return booleanValue(t);
+	}
+	if (t.language === "" && d === "http://www.w3.org/2001/XMLSchema#string") return Str.isNonEmpty(t.value);
+	if (isNumericDatatype(d)) {
+		const n = numeric(t);
+		return Option.isSome(n) && numEbv(n.value);
+	}
+	return fail("EBV is not defined for this literal");
+};
+/** The `ORDER BY` rank of a bound term: blank nodes < IRIs < literals < triple terms. */
+const termRank = (t) => isBlankNode(t) ? 1 : isNamedNode(t) ? 2 : isLiteral(t) ? 3 : isTriple(t) ? 4 : 5;
+/** Orders two literals: by value where comparable, else syntactically. */
+const compareLiteralOrder = (a, l) => {
+	const compared = Result.try(() => compareLiterals(a, l));
+	if (Result.isSuccess(compared)) {
+		const c = compared.success;
+		if (!Number.isNaN(c) && c !== 0) return c;
+		if (c === 0 && a.key === l.key) return 0;
+	}
+	const ka = a.language !== "" ? 1 : a.datatype.value === "http://www.w3.org/2001/XMLSchema#string" ? 0 : 2;
+	const kb = l.language !== "" ? 1 : l.datatype.value === "http://www.w3.org/2001/XMLSchema#string" ? 0 : 2;
+	if (ka !== kb) return ka - kb;
+	return compareCodepoints(a.datatype.value, l.datatype.value) || compareCodepoints(a.language, l.language) || compareCodepoints(a.value, l.value);
+};
+/**
+* The total ordering used by `ORDER BY` on bound terms: blank nodes < IRIs <
+* literals < triple terms; literals are ordered by value where comparable
+* and otherwise by datatype, language and lexical form.
+*/
+const compareTerms = (a, b) => {
+	const ra = termRank(a);
+	const rb = termRank(b);
+	if (ra !== rb) return ra - rb;
+	if (isLiteral(a) && isLiteral(b)) return compareLiteralOrder(a, b);
+	if (isTriple(a) && isTriple(b)) return compareTerms(a.subject, b.subject) || compareTerms(a.predicate, b.predicate) || compareTerms(a.object, b.object);
+	if ((isBlankNode(a) || isNamedNode(a)) && (isBlankNode(b) || isNamedNode(b))) return compareCodepoints(a.value, b.value);
+	return 0;
+};
+/** `compareTerms` on possibly unbound terms (`None`), with unbound first. */
+const orderCompare = (a, b) => Option.isNone(a) ? Option.isNone(b) ? 0 : -1 : Option.isNone(b) ? 1 : compareTerms(a.value, b.value);
+// src/sparql/Functions.ts
+/**
+* SPARQL built-in functions, XSD casts and the registry of extension
+* functions.
+*
+* Extension functions are plain synchronous functions from argument terms
+* to a term, registered by IRI and passed to the engine (see
+* `Engine.EngineOptions.functions`). They signal type errors by throwing
+* `ExpressionError` (or calling `Functions.error`).
+*
+* @since 0.1.0
+*/
+var Functions_exports = /* @__PURE__ */ __exportAll({
+	ExpressionError: () => ExpressionError,
+	builtIns: () => builtIns,
+	cast: () => cast,
+	compileRegex: () => compileRegex,
+	error: () => error,
+	isCast: () => isCast,
+	registry: () => registry
+});
+/**
+* An expression evaluation error (a SPARQL "type error"): unbound
+* variables, wrong argument types, division by zero, …
+*
+* @since 0.1.0
+* @category errors
+*/
+var ExpressionError = class extends Schema.TaggedError()("ExpressionError", { message: Schema.String }) {};
+/**
+* Signals an expression error from inside a function implementation.
+*
+* @since 0.1.0
+* @category errors
+*/
+const error = (message) => fail(message);
+/**
+* Creates a registry from a record of IRI → function.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const registry = (functions) => fromEntries(Record.toEntries(functions));
+const literalArg = (t) => isLiteral(t) ? t : fail("Expected a literal");
+const stringArg = (t) => isStringLiteral(t) ? t : fail("Expected a string literal");
+const simpleArg = (t) => isSimpleString(t) ? t : fail("Expected a simple literal");
+/** Argument compatibility (SPARQL 1.1 §17.4.3.1.2). */
+const compatible = (a, b) => b.language === "" || a.language === b.language && a.direction === b.direction;
+const codepoints = (s) => Array.from(s);
+const intLiteral = (n) => new Literal(BigInt(n).toString(), dt.integer);
+const numArg = requireNum;
+const roundNum = (t, mode, fn) => {
+	const n = numArg(t);
+	return numLiteral(n.kind === 0 ? n : n.kind === 1 ? {
+		kind: 1,
+		v: BigDecimal.round(n.v, {
+			scale: 0,
+			mode
+		})
+	} : n.kind === 2 ? {
+		kind: 2,
+		v: fn(n.v)
+	} : {
+		kind: 3,
+		v: fn(n.v)
+	});
+};
+const xpathRound = (x) => {
+	if (!Number.isFinite(x) || Object.is(x, -0)) return x;
+	const r = Math.floor(x + .5);
+	return r === 0 && x < 0 ? -0 : r;
+};
+/** Compiled regular expressions by flags and pattern (read on every `REGEX` / `REPLACE` call). */
+const regexCache = empty();
+/** Compiles an XPath regular expression with XPath flags to a JS RegExp. */
+const compileRegex = (pattern, flags, global = false) => {
+	const key = `${global ? "g" : ""}${flags}/${pattern}`;
+	const cached = regexCache.get(key);
+	if (cached !== void 0) return cached;
+	let source = pattern;
+	let jsFlags = global ? "g" : "";
+	Array.from(flags).forEach((flag) => {
+		if (flag === "i" || flag === "s" || flag === "m") {
+			if (!jsFlags.includes(flag)) jsFlags += flag;
+		} else if (flag === "x") source = source.replace(/[\t\n\r ]/g, "");
+		else if (flag === "q") source = source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		else fail(`Invalid regex flag '${flag}'`);
+	});
+	const compiled = Result.try(() => new RegExp(source, `${jsFlags}u`)).pipe(Result.orElse(() => Result.try(() => new RegExp(source, jsFlags))));
+	if (Result.isFailure(compiled)) return fail("Invalid regular expression");
+	const re = compiled.success;
+	if (regexCache.size > 1e3) regexCache.clear();
+	regexCache.set(key, re);
+	return re;
+};
+/** The flags argument of `REGEX` / `REPLACE`, absent beyond the arguments given. */
+const regexFlags = (args, i) => {
+	const t = Option.fromUndefinedOr(args[i]);
+	return Option.isSome(t) ? simpleArg(t.value).value : "";
+};
+const parseDateParts = (t) => {
+	const lit = literalArg(t);
+	const d = lit.datatype.value;
+	if (!(d === `http://www.w3.org/2001/XMLSchema#dateTime` || d === `http://www.w3.org/2001/XMLSchema#date` || d === `http://www.w3.org/2001/XMLSchema#time` || d === `http://www.w3.org/2001/XMLSchema#dateTimeStamp`) || !isValidLexical(d, lit.value)) return fail("Expected an xsd:dateTime");
+	const m = /^(?:(-?\d{4,})-(\d\d)-(\d\d))?T?(?:(\d\d):(\d\d):(\d\d(?:\.\d+)?))?(Z|[+-]\d\d:\d\d)?$/.exec(lit.value);
+	if (m === null) return fail("Invalid date/time");
+	return {
+		year: m[1],
+		month: m[2],
+		day: m[3],
+		hours: m[4],
+		minutes: m[5],
+		seconds: m[6],
+		tz: m[7]
+	};
+};
+const timezoneDuration = (tz) => {
+	if (tz === "Z") return "PT0S";
+	const sign = tz.startsWith("-") ? "-" : "";
+	const h = Number(tz.slice(1, 3));
+	const mi = Number(tz.slice(4, 6));
+	if (h === 0 && mi === 0) return "PT0S";
+	return `${sign}PT${h > 0 ? `${h}H` : ""}${mi > 0 ? `${mi}M` : ""}`;
+};
+const encodeForUri = (s) => encodeURIComponent(s).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+const uuid = (random) => {
+	const h = Array.from({ length: 16 }, (_, i) => {
+		const b = Math.floor(random() * 256);
+		return i === 6 ? b & 15 | 64 : i === 8 ? b & 63 | 128 : b;
+	}).map((b) => b.toString(16).padStart(2, "0")).join("");
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+};
+const LANG_TAG = /^[a-zA-Z]{1,8}(?:-[a-zA-Z0-9]{1,8})*$/;
+/** The two string arguments of a string function, which must be compatible (§17.4.3.1.2). */
+const compatibleStrings = ([a, b]) => {
+	const x = stringArg(a);
+	const y = stringArg(b);
+	return compatible(x, y) ? [x, y] : fail("Incompatible arguments");
+};
+/**
+* `STRBEFORE` / `STRAFTER`: `part` of the first string around the first
+* occurrence of the second, or the empty simple literal if there is none.
+*/
+const around = (args, part) => {
+	const [x, y] = compatibleStrings(args);
+	const i = x.value.indexOf(y.value);
+	return i === -1 ? simple("") : stringLike(part(x.value, y.value, i), x);
+};
+const iriFn = ([a], ctx) => {
+	if (isNamedNode(a)) return a;
+	const s = simpleArg(a).value;
+	return namedNode(ctx.baseIri !== void 0 ? resolve(s, ctx.baseIri) : s);
+};
+const hashFn = (f) => ([a]) => simple(f(simpleArg(a).value));
+/**
+* The strict built-in functions, keyed by canonical name. Functional forms
+* (`BOUND`, `IF`, `COALESCE`, `&&`, `||`, `IN`, `EXISTS`) are handled by the
+* expression evaluator.
+*
+* @since 0.1.0
+* @category built-ins
+*/
+const builtIns = {
+	STR: ([a]) => isNamedNode(a) || isLiteral(a) ? simple(a.value) : fail("STR of a blank node or triple term"),
+	LANG: ([a]) => simple(literalArg(a).language),
+	LANGDIR: ([a]) => simple(literalArg(a).direction ?? ""),
+	LANGMATCHES: ([tag, range]) => {
+		const t = simpleArg(tag).value.toLowerCase();
+		const r = simpleArg(range).value.toLowerCase();
+		if (r === "*") return bool(t !== "");
+		return bool(t === r || t.startsWith(`${r}-`));
+	},
+	DATATYPE: ([a]) => literalArg(a).datatype,
+	IRI: iriFn,
+	URI: iriFn,
+	BNODE: (args, ctx, sol) => ctx.blankNode(Arr.isReadonlyArrayEmpty(args) ? void 0 : simpleArg(args[0]).value, sol),
+	RAND: (_, ctx) => numLiteral({
+		kind: 3,
+		v: ctx.random()
+	}),
+	ABS: ([a]) => {
+		const n = numArg(a);
+		return numLiteral(n.kind === 0 ? {
+			kind: 0,
+			v: n.v < 0n ? -n.v : n.v
+		} : n.kind === 1 ? {
+			kind: 1,
+			v: BigDecimal.abs(n.v)
+		} : n.kind === 2 ? {
+			kind: 2,
+			v: Math.abs(n.v)
+		} : {
+			kind: 3,
+			v: Math.abs(n.v)
+		});
+	},
+	CEIL: ([a]) => roundNum(a, "ceil", Math.ceil),
+	FLOOR: ([a]) => roundNum(a, "floor", Math.floor),
+	ROUND: ([a]) => roundNum(a, "half-ceil", xpathRound),
+	CONCAT: (args) => {
+		const lits = args.map(stringArg);
+		const first = lits[0];
+		const sameLang = first !== void 0 && first.language !== "" && lits.every((l) => l.language === first.language && l.direction === first.direction);
+		const value = lits.map((l) => l.value).join("");
+		return sameLang ? stringLike(value, first) : simple(value);
+	},
+	SUBSTR: ([s, start, len]) => {
+		const str = stringArg(s);
+		const chars = codepoints(str.value);
+		const st = toNumber(numArg(start));
+		const from = xpathRound(st);
+		let to = Infinity;
+		if (len !== void 0) to = from + xpathRound(toNumber(numArg(len)));
+		if (Number.isNaN(from) || Number.isNaN(to)) return stringLike("", str);
+		const out = chars.filter((_, i) => i + 1 >= from && i + 1 < to).join("");
+		return stringLike(out, str);
+	},
+	STRLEN: ([a]) => intLiteral(codepoints(stringArg(a).value).length),
+	REPLACE: (args) => {
+		const [s, pattern, replacement] = args;
+		const str = stringArg(s);
+		const re = compileRegex(simpleArg(pattern).value, regexFlags(args, 3), true);
+		if (re.test("")) {
+			re.lastIndex = 0;
+			return fail("REPLACE pattern matches the empty string");
+		}
+		re.lastIndex = 0;
+		const repl = simpleArg(replacement).value.replace(/\\(\$|\\)|\$/g, (m, esc) => esc === "$" ? "$$" : esc === "\\" ? "\\" : m);
+		return stringLike(str.value.replace(re, repl), str);
+	},
+	UCASE: ([a]) => {
+		const s = stringArg(a);
+		return stringLike(s.value.toUpperCase(), s);
+	},
+	LCASE: ([a]) => {
+		const s = stringArg(a);
+		return stringLike(s.value.toLowerCase(), s);
+	},
+	ENCODE_FOR_URI: ([a]) => simple(encodeForUri(stringArg(a).value)),
+	CONTAINS: (args) => {
+		const [x, y] = compatibleStrings(args);
+		return bool(x.value.includes(y.value));
+	},
+	STRSTARTS: (args) => {
+		const [x, y] = compatibleStrings(args);
+		return bool(x.value.startsWith(y.value));
+	},
+	STRENDS: (args) => {
+		const [x, y] = compatibleStrings(args);
+		return bool(x.value.endsWith(y.value));
+	},
+	STRBEFORE: (args) => around(args, (x, _y, i) => x.slice(0, i)),
+	STRAFTER: (args) => around(args, (x, y, i) => x.slice(i + y.length)),
+	YEAR: ([a]) => {
+		const p = parseDateParts(a);
+		return p.year !== void 0 ? intLiteral(BigInt(p.year)) : fail("No year");
+	},
+	MONTH: ([a]) => {
+		const p = parseDateParts(a);
+		return p.month !== void 0 ? intLiteral(Number(p.month)) : fail("No month");
+	},
+	DAY: ([a]) => {
+		const p = parseDateParts(a);
+		return p.day !== void 0 ? intLiteral(Number(p.day)) : fail("No day");
+	},
+	HOURS: ([a]) => {
+		const p = parseDateParts(a);
+		return p.hours !== void 0 ? intLiteral(Number(p.hours)) : fail("No hours");
+	},
+	MINUTES: ([a]) => {
+		const p = parseDateParts(a);
+		return p.minutes !== void 0 ? intLiteral(Number(p.minutes)) : fail("No minutes");
+	},
+	SECONDS: ([a]) => {
+		const p = parseDateParts(a);
+		if (p.seconds === void 0) return fail("No seconds");
+		return numLiteral({
+			kind: 1,
+			v: BigDecimal.fromStringUnsafe(p.seconds)
+		});
+	},
+	TIMEZONE: ([a]) => {
+		const p = parseDateParts(a);
+		if (p.tz === void 0) return fail("No timezone");
+		return new Literal(timezoneDuration(p.tz), dt.dayTimeDuration);
+	},
+	TZ: ([a]) => simple(parseDateParts(a).tz ?? ""),
+	NOW: (_, ctx) => new Literal(ctx.now.toISOString(), dt.dateTime),
+	UUID: (_, ctx) => namedNode(`urn:uuid:${uuid(ctx.random)}`),
+	STRUUID: (_, ctx) => simple(uuid(ctx.random)),
+	MD5: hashFn(md5),
+	SHA1: hashFn(sha1),
+	SHA256: hashFn(sha256),
+	SHA384: hashFn(sha384),
+	SHA512: hashFn(sha512),
+	STRLANG: ([s, lang]) => {
+		const lex = simpleArg(s).value;
+		const tag = simpleArg(lang).value;
+		if (!LANG_TAG.test(tag)) return fail("Invalid language tag");
+		return literal(lex, tag);
+	},
+	STRLANGDIR: ([s, lang, dir]) => {
+		const lex = simpleArg(s).value;
+		const tag = simpleArg(lang).value;
+		const d = simpleArg(dir).value;
+		if (!LANG_TAG.test(tag)) return fail("Invalid language tag");
+		if (d !== "ltr" && d !== "rtl") return fail("Invalid base direction");
+		return literal(lex, {
+			language: tag,
+			direction: d
+		});
+	},
+	STRDT: ([s, datatype]) => {
+		const lex = simpleArg(s).value;
+		if (!isNamedNode(datatype)) return fail("STRDT requires an IRI");
+		if (datatype.value === dt.langString.value || datatype.value === dt.dirLangString.value) return fail("STRDT cannot create language-tagged strings");
+		return new Literal(lex, datatype);
+	},
+	SAMETERM: ([a, b]) => bool(a.key === b.key),
+	ISIRI: ([a]) => bool(isNamedNode(a)),
+	ISURI: ([a]) => bool(isNamedNode(a)),
+	ISBLANK: ([a]) => bool(isBlankNode(a)),
+	ISLITERAL: ([a]) => bool(isLiteral(a)),
+	ISNUMERIC: ([a]) => bool(isNumeric(a)),
+	HASLANG: ([a]) => bool(isLiteral(a) && a.language !== ""),
+	HASLANGDIR: ([a]) => bool(isLiteral(a) && a.direction !== void 0),
+	REGEX: (args) => {
+		const [s, pattern] = args;
+		const str = stringArg(s);
+		const re = compileRegex(simpleArg(pattern).value, regexFlags(args, 2));
+		return bool(re.test(str.value));
+	},
+	ISTRIPLE: ([a]) => bool(isTriple(a)),
+	TRIPLE: ([s, p, o]) => {
+		if (!isNamedNode(s) && !isBlankNode(s)) return fail("TRIPLE subject must be an IRI or blank node");
+		if (!isNamedNode(p)) return fail("TRIPLE predicate must be an IRI");
+		return triple(s, p, o);
+	},
+	SUBJECT: ([a]) => isTriple(a) ? a.subject : fail("Not a triple term"),
+	PREDICATE: ([a]) => isTriple(a) ? a.predicate : fail("Not a triple term"),
+	OBJECT: ([a]) => isTriple(a) ? a.object : fail("Not a triple term")
+};
+const XSD_INTEGER_TYPE_NAMES = [
+	"integer",
+	"long",
+	"int",
+	"short",
+	"byte",
+	"nonNegativeInteger",
+	"positiveInteger",
+	"nonPositiveInteger",
+	"negativeInteger",
+	"unsignedLong",
+	"unsignedInt",
+	"unsignedShort",
+	"unsignedByte"
+].map((t) => XSD + t);
+const XSD_INTEGER_TYPES = setOf(XSD_INTEGER_TYPE_NAMES);
+/** The XPath string form of a float/double (`fn:string`). */
+const xpathDoubleString = (v) => {
+	if (Number.isNaN(v)) return "NaN";
+	if (!Number.isFinite(v)) return v > 0 ? "INF" : "-INF";
+	const abs = Math.abs(v);
+	if (abs === 0) return Object.is(v, -0) ? "-0" : "0";
+	if (abs >= 1e-6 && abs < 1e6) return String(v);
+	return canonicalDouble(v);
+};
+const castString = (a) => {
+	if (isNamedNode(a)) return a.value;
+	const l = literalArg(a);
+	const numeric$1 = numeric(l);
+	if (Option.isSome(numeric$1)) {
+		const n = numeric$1.value;
+		if (n.kind === 0) return n.v.toString();
+		if (n.kind === 1) {
+			const s = canonicalDecimal(n.v);
+			return s.endsWith(".0") ? s.slice(0, -2) : s;
+		}
+		return xpathDoubleString(n.v);
+	}
+	if (l.datatype.value === dt.boolean.value && isValidLexical(l.datatype.value, l.value)) return l.value === "true" || l.value === "1" ? "true" : "false";
+	return l.value;
+};
+const castBoolean = ({ l, numeric, isBool, boolValue, fromString, lexical }) => {
+	if (isBool) return bool(boolValue);
+	if (Option.isSome(numeric)) return bool(ebv(l));
+	if (fromString && /^(true|false|1|0)$/.test(lexical)) return bool(lexical === "true" || lexical === "1");
+	return fail("Invalid boolean cast");
+};
+const integerOf = (n) => {
+	if (n.kind === 0) return n.v;
+	if (n.kind === 1) return BigInt(BigDecimal.format(BigDecimal.truncate(n.v)).split(".")[0] ?? "0");
+	if (!Number.isFinite(n.v)) return fail("Cannot cast NaN/INF to integer");
+	return BigInt(Math.trunc(n.v));
+};
+const castInteger = (source) => {
+	const { target, dtNode, numeric, isBool, boolValue, fromString, lexical } = source;
+	const value = isBool ? boolValue ? 1n : 0n : Option.isSome(numeric) ? integerOf(numeric.value) : fromString && /^[+-]?\d+$/.test(lexical) ? BigInt(lexical) : fail("Invalid integer cast");
+	const lit = new Literal(value.toString(), dtNode);
+	return isValidLexical(target, lit.value) ? lit : fail("Integer out of range");
+};
+const castDecimal = ({ numeric, isBool, boolValue, fromString, lexical }) => {
+	if (isBool) return numLiteral({
+		kind: 1,
+		v: BigDecimal.fromBigInt(boolValue ? 1n : 0n)
+	});
+	if (Option.isSome(numeric)) {
+		const n = numeric.value;
+		if (n.kind === 0 || n.kind === 1) return numLiteral({
+			kind: 1,
+			v: toDecimal(n)
+		});
+		if (!Number.isFinite(n.v)) return fail("Cannot cast NaN/INF to decimal");
+		return numLiteral({
+			kind: 1,
+			v: BigDecimal.fromNumberUnsafe(n.v)
+		});
+	}
+	if (fromString && /^[+-]?(\d+(\.\d*)?|\.\d+)$/.test(lexical)) return numLiteral({
+		kind: 1,
+		v: BigDecimal.fromStringUnsafe(lexical.replace(/\.$/, ""))
+	});
+	return fail("Invalid decimal cast");
+};
+const floatingOf = (lexical) => lexical === "INF" || lexical === "+INF" ? Infinity : lexical === "-INF" ? -Infinity : Number(lexical);
+const castFloating = (source) => {
+	const { target, numeric, isBool, boolValue, fromString, lexical } = source;
+	const kind = target === dt.double.value ? 3 : 2;
+	const value = isBool ? boolValue ? 1 : 0 : Option.isSome(numeric) ? toNumber(numeric.value) : fromString && isValidLexical(target, lexical) ? floatingOf(lexical) : fail("Invalid floating point cast");
+	return numLiteral({
+		kind,
+		v: kind === 2 ? Math.fround(value) : value
+	});
+};
+const castDateTime = ({ target, dtNode, l, fromString, lexical }) => {
+	if (l.datatype.value === target && isValidLexical(target, l.value)) return l;
+	if (l.datatype.value === `http://www.w3.org/2001/XMLSchema#date` && isValidLexical(l.datatype.value, l.value)) {
+		const m = /^(-?\d+-\d\d-\d\d)(.*)$/.exec(l.value);
+		if (m === null) return fail("Invalid date");
+		return new Literal(`${m[1]}T00:00:00${m[2]}`, dtNode);
+	}
+	if (fromString && isValidLexical(target, lexical)) return new Literal(lexical, dtNode);
+	return fail("Invalid dateTime cast");
+};
+/** Other XSD types: from strings with a valid lexical form, or the same type. */
+const castOther = ({ target, dtNode, l, fromString, lexical }) => {
+	if (l.datatype.value === target) return l;
+	if (fromString && isValidLexical(target, lexical)) return new Literal(lexical, dtNode);
+	return fail(`Invalid cast to ${target}`);
+};
+const castTo = (target, a) => {
+	if (target === "http://www.w3.org/2001/XMLSchema#string") {
+		if (isLiteral(a) && a.language !== "") return fail("Cannot cast a language-tagged string");
+		return simple(castString(a));
+	}
+	const l = literalArg(a);
+	if (l.language !== "") return fail("Cannot cast a language-tagged string");
+	const isBool = l.datatype.value === dt.boolean.value && isValidLexical(l.datatype.value, l.value);
+	const source = {
+		target,
+		dtNode: namedNode(target),
+		l,
+		numeric: numeric(l),
+		isBool,
+		boolValue: isBool && (l.value === "true" || l.value === "1"),
+		fromString: isSimpleString(l),
+		lexical: l.value.trim()
+	};
+	if (target === dt.boolean.value) return castBoolean(source);
+	if (XSD_INTEGER_TYPES.has(target)) return castInteger(source);
+	if (target === dt.decimal.value) return castDecimal(source);
+	if (target === dt.double.value || target === dt.float.value) return castFloating(source);
+	if (target === dt.dateTime.value) return castDateTime(source);
+	return castOther(source);
+};
+const CASTABLE = setOf([
+	XSD_STRING,
+	`${XSD}boolean`,
+	`${XSD}decimal`,
+	`${XSD}float`,
+	`${XSD}double`,
+	`${XSD}dateTime`,
+	`${XSD}date`,
+	`${XSD}time`,
+	...XSD_INTEGER_TYPE_NAMES
+]);
+/**
+* Whether an IRI is an XSD constructor function (cast) supported by this
+* implementation.
+*
+* @since 0.1.0
+* @category casts
+*/
+const isCast = (iri) => CASTABLE.has(iri);
+/**
+* Casts a term to an XSD datatype (`xsd:integer(?x)` etc.). Throws an
+* expression error when the cast is not possible.
+*
+* @since 0.1.0
+* @category casts
+*/
+const cast = (datatype, term) => {
+	if (isBlankNode(term) || isTriple(term)) return fail("Cannot cast");
+	if (isNamedNode(term) && datatype !== "http://www.w3.org/2001/XMLSchema#string") return fail("Cannot cast an IRI");
+	return castTo(datatype, term);
+};
+export { orderCompare as C, negate as S, dt as _, compileRegex as a, fail as b, registry as c, TRUE as d, arithmetic as f, compareTerms as g, compareLiterals as h, cast as i, EvalFailure as l, catchEvalFailure as m, Functions_exports as n, error as o, bool as p, builtIns as r, isCast as s, ExpressionError as t, FALSE as u, ebv as v, simple as w, isNumeric as x, equals as y };
+
+//# sourceMappingURL=Functions-AvjNcId_.mjs.map