@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Datatype-DQvkNkiH.mjs

@@ -0,0 +1,1001 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { Y as literal$1, Z as namedNode } from "./Term-CFLG1qu4.mjs";
+import { S as toValue, _ as isValidLexical } from "./Xsd-Cdgx5zRB.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 Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+import * as BigDecimal from "effect/BigDecimal";
+// src/csvw/internal/dateFormat.ts
+/**
+* Date and time formats (Tabular Data Model §Formats for dates and times):
+* the UAX 35 date field symbols the specification requires (`yyyy`, `MM`,
+* `M`, `dd`, `d`, `HH`, `mm`, `ss`, `S…`, `X…`, `x…`), compiled to a matcher
+* that yields the XML Schema lexical form.
+*
+* @internal
+*/
+/** Timezone offsets by marker length (`x`, `xx`, `xxx`); `X…` also allows `Z`. */
+const TZ_OFFSETS = [
+	"[+-]\\d{2}(?:\\d{2})?",
+	"[+-]\\d{4}",
+	"[+-]\\d{2}:\\d{2}"
+];
+const field = (f, source) => Option.some({
+	field: Option.some(f),
+	source: `(${source})`
+});
+const tzOffset = (n, allowZ) => Option.flatMap(Arr.get(TZ_OFFSETS, n - 1), (offset) => field("tz", allowZ ? `Z|${offset}` : offset));
+const tokenize = (pattern) => pattern.match(/(.)\1*/gu) ?? [];
+/** A field symbol of exactly `n` letters (`yyyy`, `HH`, …). */
+const exactly = (n, f, source) => (length) => length === n ? field(f, source) : Option.none();
+/** A one- or two-letter numeric field (`M` / `MM`, `d` / `dd`). */
+const oneOrTwo = (f) => (length) => length > 2 ? Option.none() : field(f, length === 2 ? "\\d{2}" : "\\d{1,2}");
+/** The field symbols this implementation recognises, by letter. */
+const symbols = {
+	y: exactly(4, "year", "\\d{4}"),
+	M: oneOrTwo("month"),
+	d: oneOrTwo("day"),
+	H: exactly(2, "hour", "\\d{2}"),
+	m: exactly(2, "minute", "\\d{2}"),
+	s: exactly(2, "second", "\\d{2}"),
+	S: (length) => field("fraction", `\\d{1,${length}}`),
+	X: (length) => tzOffset(length, true),
+	x: (length) => tzOffset(length, false)
+};
+const literal = (run) => /^[-/.: T]+$/.test(run) ? Option.some({
+	field: Option.none(),
+	source: run.replace(/[.]/g, "\\.")
+}) : Option.none();
+const compileToken = (run) => Option.match(Record.get(symbols, run.charAt(0)), {
+	onNone: () => literal(run),
+	onSome: (symbol) => symbol(run.length)
+});
+/**
+* Compiles a date/time pattern; `None` when it uses a symbol this
+* implementation does not recognise.
+*
+* @internal
+*/
+const compile = (pattern) => {
+	const tokens = Arr.map(tokenize(pattern), compileToken);
+	if (!Arr.every(tokens, Option.isSome) || !Arr.isReadonlyArrayNonEmpty(tokens)) return Option.none();
+	const compiled = Arr.getSomes(tokens);
+	const fields = Arr.getSomes(Arr.map(compiled, (t) => t.field));
+	const has = (f) => Arr.contains(fields, f);
+	const hasDate = has("year") || has("month") || has("day");
+	const hasTime = has("hour") || has("minute") || has("second");
+	if (Arr.length(Arr.dedupe(fields)) !== Arr.length(fields)) return Option.none();
+	if (has("fraction") && !has("second")) return Option.none();
+	return Option.some({
+		regex: new RegExp(`^${Arr.join(Arr.map(compiled, (t) => t.source), "")}$`, "u"),
+		fields,
+		hasDate,
+		hasTime
+	});
+};
+const pad = (s, n) => s.padStart(n, "0");
+const timezone = (tz) => {
+	if (tz === "Z") return "Z";
+	const sign = tz.charAt(0);
+	const digits = tz.slice(1).replace(":", "");
+	return `${sign}${digits.slice(0, 2)}:${digits.length > 2 ? digits.slice(2, 4) : "00"}`;
+};
+const daysInMonth = (year, month) => month === 2 ? year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28 : [
+	4,
+	6,
+	9,
+	11
+].includes(month) ? 30 : 31;
+const fieldsOf = (m, pattern) => {
+	const values = Arr.map(pattern.fields, (f, i) => [f, m[i + 1] ?? ""]);
+	const get = (f, otherwise) => Option.getOrElse(Option.map(Arr.findFirst(values, ([g]) => g === f), ([, v]) => v), () => otherwise);
+	const fraction = get("fraction", "");
+	const tz = get("tz", "");
+	return {
+		date: `${get("year", "")}-${pad(get("month", ""), 2)}-${pad(get("day", ""), 2)}`,
+		time: `${get("hour", "00")}:${get("minute", "00")}:${get("second", "00")}${fraction === "" ? "" : `.${fraction}`}`,
+		tz: tz === "" ? "" : timezone(tz)
+	};
+};
+const validDate = (date) => {
+	const [y = 0, mo = 0, d = 0] = Arr.map(date.split("-"), Number);
+	return mo >= 1 && mo <= 12 && d >= 1 && d <= daysInMonth(y, mo);
+};
+const validTime = (time) => {
+	const [h = 0, mi = 0, s = 0] = Arr.map(time.split(":"), Number);
+	return h <= 23 && mi <= 59 && s < 60;
+};
+const lexicalFor = (fields, pattern, base) => {
+	if (base === "date") return pattern.hasDate ? Result.succeed(fields.date + fields.tz) : Result.fail("has no date");
+	if (base === "time") return pattern.hasTime ? Result.succeed(fields.time + fields.tz) : Result.fail("has no time");
+	if (!pattern.hasDate) return Result.fail("has no date");
+	if (base === "dateTimeStamp" && fields.tz === "") return Result.fail("has no timezone");
+	return Result.succeed(`${fields.date}T${fields.time}${fields.tz}`);
+};
+/**
+* Matches a cell string against a compiled pattern and returns the XML Schema
+* lexical form for the base datatype (`date`, `time`, `dateTime` or
+* `dateTimeStamp`).
+*
+* @internal
+*/
+const parse$2 = (text, pattern, base) => Option.match(Option.fromNullishOr(pattern.regex.exec(text)), {
+	onNone: () => Result.fail("does not match the format"),
+	onSome: (m) => {
+		const fields = fieldsOf(m, pattern);
+		if (pattern.hasDate && !validDate(fields.date)) return Result.fail("is not a valid date");
+		if (pattern.hasTime && !validTime(fields.time)) return Result.fail("is not a valid time");
+		return lexicalFor(fields, pattern, base);
+	}
+});
+// src/csvw/internal/numberFormat.ts
+/**
+* Numeric formats (Tabular Data Model §Formats for numeric types): the UAX 35
+* number-pattern subset (`0`, `#`, the decimal and group characters, `E`,
+* `+`, `-`, `%` and `‰`), the pattern-less grouped form, and the decimal
+* arithmetic that applies percent and per-mille signs.
+*
+* @internal
+*/
+const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const count = (s, c) => Arr.length(Arr.filter(Array.from(s), (x) => x === c));
+/** Primary and secondary grouping sizes of a grouped integer pattern (`#,##,#00` → 3, 2). */
+const integerGrouping = (segments) => Arr.match(Arr.reverse(segments), {
+	onEmpty: () => Option.some(Option.none()),
+	onNonEmpty: ([primary, ...rest]) => Arr.match(rest, {
+		onEmpty: () => Option.some(Option.none()),
+		onNonEmpty: ([secondary, ...others]) => {
+			const size = Arr.isReadonlyArrayNonEmpty(others) ? secondary.length : primary.length;
+			return primary === "" || size === 0 ? Option.none() : Option.some(Option.some([primary.length, size]));
+		}
+	})
+});
+/** The grouping size of a grouped fraction pattern (`0.0#,#` → 2). */
+const fractionGrouping = (segments) => Arr.match(segments, {
+	onEmpty: () => Option.some(Option.none()),
+	onNonEmpty: ([first, ...rest]) => !Arr.isReadonlyArrayNonEmpty(rest) ? Option.some(Option.none()) : first === "" ? Option.none() : Option.some(Option.some(first.length))
+});
+/** Whether `#`s precede the `0`s of the integer part and follow those of the fraction. */
+const wellOrdered = (int, frac) => !/0[^0]*#/.test(int) && !/#[^#]*0/.test(frac);
+/**
+* Parses a number format pattern; `None` when it uses anything this
+* implementation does not recognise.
+*
+* @internal
+*/
+const parsePattern = (pattern, decimalChar, groupChar) => {
+	const g = escape(groupChar);
+	const re = new RegExp(`^([+\\-%‰]*)([#0${g}]*[#0])(?:${escape(decimalChar)}([#0${g}]*))?(?:E(\\+?)([#0]+))?([%‰]*)$`, "u");
+	return Option.flatMap(Option.fromNullishOr(re.exec(pattern)), (m) => {
+		const int = m[2] ?? "";
+		const frac = Option.fromNullishOr(m[3]);
+		const fracText = Option.getOrElse(frac, () => "");
+		const fracDigits = digitsOf(fracText, groupChar);
+		const affixes = (m[1] ?? "") + (m[6] ?? "");
+		if (!wellOrdered(digitsOf(int, groupChar), fracDigits)) return Option.none();
+		if (count(affixes, "%") + count(affixes, "‰") > 1) return Option.none();
+		return Option.map(Option.all([integerGrouping(int.split(groupChar)), fractionGrouping(Option.isSome(frac) ? fracText.split(groupChar) : [])]), ([grouping, fracGrouping]) => ({
+			prefix: m[1] ?? "",
+			suffix: m[6] ?? "",
+			minInt: count(int, "0"),
+			grouping,
+			minFrac: count(fracDigits, "0"),
+			maxFrac: fracDigits.length,
+			fracGrouping,
+			hasDecimal: Option.isSome(frac),
+			exponent: Option.map(Option.fromNullishOr(m[5]), (e) => count(e, "0"))
+		}));
+	});
+};
+const checkIntegerGrouping = (int, groupChar, grouping) => {
+	const groups = int.split(groupChar);
+	const ungrouped = !int.includes(groupChar);
+	return Option.match(grouping, {
+		onNone: () => ungrouped,
+		onSome: ([primary, secondary]) => {
+			if (ungrouped) return int.length <= primary;
+			const reversed = Arr.reverse(groups);
+			const last = Arr.length(reversed) - 1;
+			return Arr.every(reversed, (group, i) => {
+				const size = i === 0 ? primary : secondary;
+				return i === last ? group !== "" && group.length <= size : group.length === size;
+			});
+		}
+	});
+};
+const checkFractionGrouping = (frac, groupChar, grouping) => {
+	const groups = frac.split(groupChar);
+	return Option.match(grouping, {
+		onNone: () => !frac.includes(groupChar),
+		onSome: (size) => Arr.every(groups, (group, i) => i === Arr.length(groups) - 1 ? group !== "" && group.length <= size : group.length === size)
+	});
+};
+const digitsOf = (s, groupChar) => s.split(groupChar).join("");
+/**
+* Shifts the decimal point of a decimal lexical form `places` to the left
+* (dividing by 10^places), returning a canonical decimal.
+*
+* @internal
+*/
+const shiftDecimal = (lexical, places) => {
+	const negative = lexical.startsWith("-");
+	const [int = "", frac = ""] = lexical.replace(/^[+-]/, "").split(".");
+	const padded = int.padStart(places + 1, "0");
+	const newInt = padded.slice(0, padded.length - places).replace(/^0+(?=\d)/, "");
+	const newFrac = (padded.slice(padded.length - places) + frac).replace(/0+$/, "");
+	const body = newFrac === "" ? newInt : `${newInt}.${newFrac}`;
+	return negative && /[1-9]/.test(body) ? `-${body}` : body;
+};
+const SPECIAL = /^(?:NaN|INF|-INF)$/;
+/** The checks a number read with a pattern must pass, each failing with a reason. */
+const patternChecks = [
+	({ int, frac }) => int === "" && Option.isNone(frac) ? Option.some("does not match the pattern") : Option.none(),
+	({ int }, _, g) => int.endsWith(g) || int.includes(g + g) ? Option.some("does not match the pattern") : Option.none(),
+	({ int }, pattern, g) => checkIntegerGrouping(int, g, pattern.grouping) ? Option.none() : Option.some("does not match the grouping of the pattern"),
+	({ int }, pattern, g) => digitsOf(int, g).length < pattern.minInt ? Option.some("has fewer integer digits than the pattern") : Option.none(),
+	({ frac }, pattern) => Option.isSome(frac) && !pattern.hasDecimal ? Option.some("has a fraction the pattern does not allow") : Option.none(),
+	({ frac }, pattern, g) => Option.exists(frac, (f) => digitsOf(f, g).length > pattern.maxFrac || !checkFractionGrouping(f, g, pattern.fracGrouping)) ? Option.some("does not match the fraction of the pattern") : Option.none(),
+	({ frac }, pattern, g) => digitsOf(Option.getOrElse(frac, () => ""), g).length < pattern.minFrac ? Option.some("has fewer fraction digits than the pattern") : Option.none(),
+	({ exp }, pattern) => Option.match(pattern.exponent, {
+		onNone: () => Option.isSome(exp) ? Option.some("has an exponent the pattern does not allow") : Option.none(),
+		onSome: (min) => Option.exists(exp, (e) => e.replace(/^[+-]/, "").length >= min) ? Option.none() : Option.some("does not have the exponent digits of the pattern")
+	})
+];
+const partsOf = (body, format, g) => {
+	const re = new RegExp(`^([+-]?)(\\d[\\d${escape(g)}]*)?(?:${escape(format.decimalChar)}([\\d${escape(g)}]*))?(?:E([+-]?\\d+))?$`, "u");
+	return Option.map(Option.fromNullishOr(re.exec(body)), (m) => ({
+		sign: m[1] ?? "",
+		int: m[2] ?? "",
+		frac: Option.fromNullishOr(m[3]),
+		exp: Option.fromNullishOr(m[4])
+	}));
+};
+const parseWithPattern = (text, format, pattern) => {
+	const g = Option.getOrElse(format.groupChar, () => ",");
+	const prefix = pattern.prefix.replace(/[+-]/g, "");
+	const suffix = pattern.suffix;
+	const parts = text.startsWith(prefix) && text.endsWith(suffix) ? partsOf(text.slice(prefix.length, text.length - suffix.length), format, g) : Option.none();
+	return Option.match(parts, {
+		onNone: () => Result.fail("does not match the pattern"),
+		onSome: (p) => Option.match(Arr.findFirst(patternChecks, (check) => Option.isSome(check(p, pattern, g))).pipe(Option.flatMap((check) => check(p, pattern, g))), {
+			onSome: Result.fail,
+			onNone: () => Result.succeed(finish(p.sign, digitsOf(p.int, g), Option.map(p.frac, (f) => digitsOf(f, g)), p.exp, text))
+		})
+	});
+};
+const finish = (sign, int, frac, exp, text) => {
+	const mantissa = `${sign}${int === "" ? "0" : int}${Option.match(frac, {
+		onNone: () => "",
+		onSome: (f) => `.${f}`
+	})}`;
+	const plain = Option.match(exp, {
+		onNone: () => mantissa,
+		onSome: (e) => `${mantissa}e${e}`
+	});
+	const percent = text.includes("%");
+	const permille = text.includes("‰");
+	return {
+		lexical: percent || permille ? Option.isNone(exp) ? shiftDecimal(mantissa, percent ? 2 : 3) : String(Number(plain) / (percent ? 100 : 1e3)) : plain,
+		hasDecimal: Option.isSome(frac),
+		hasExponent: Option.isSome(exp),
+		special: false
+	};
+};
+const parseWithoutPattern = (text, format) => {
+	if (SPECIAL.test(text)) return Result.succeed({
+		lexical: text,
+		hasDecimal: false,
+		hasExponent: false,
+		special: true
+	});
+	const g = Option.getOrUndefined(format.groupChar);
+	const d = format.decimalChar;
+	const groupClass = g === void 0 ? "" : escape(g);
+	const m = new RegExp(`^([+-]?)(\\d(?:\\d|${g === void 0 ? "(?!)" : groupClass})*)?(?:${escape(d)}(\\d+))?(?:[Ee]([+-]?\\d+))?([%‰]?)$`, "u").exec(text);
+	if (m === null || m[2] === void 0 && m[3] === void 0) return Result.fail("is not a number");
+	const int = m[2] ?? "";
+	if (g !== void 0 && (int.includes(g + g) || int.endsWith(g))) return Result.fail("contains consecutive group characters");
+	return Result.succeed(finish(m[1] ?? "", g === void 0 ? int : digitsOf(int, g), Option.fromNullishOr(m[3]), Option.fromNullishOr(m[4]), text));
+};
+/**
+* Parses a cell string with a numeric format.
+*
+* @internal
+*/
+const parse$1 = (text, format) => Option.match(format.pattern, {
+	onNone: () => parseWithoutPattern(text, format),
+	onSome: (pattern) => SPECIAL.test(text) ? Result.succeed({
+		lexical: text,
+		hasDecimal: false,
+		hasExponent: false,
+		special: true
+	}) : parseWithPattern(text, format, pattern)
+});
+// src/csvw/internal/vocab.ts
+/**
+* The fixed CSVW JSON-LD context (`http://www.w3.org/ns/csvw`): its prefixes
+* (the RDFa 1.1 initial context plus `csvw`), its terms, prefixed-name
+* expansion and URL compaction (Metadata Vocabulary §URL Compaction).
+*
+* @internal
+*/
+/** @internal */
+const CSVW = "http://www.w3.org/ns/csvw#";
+/** @internal */
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/** @internal */
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+/**
+* The prefixes of the CSVW context, which metadata MUST NOT override.
+*
+* @internal
+*/
+const prefixes = {
+	as: "https://www.w3.org/ns/activitystreams#",
+	cc: "http://creativecommons.org/ns#",
+	csvw: CSVW,
+	ctag: "http://commontag.org/ns#",
+	dc: "http://purl.org/dc/terms/",
+	dc11: "http://purl.org/dc/elements/1.1/",
+	dcat: "http://www.w3.org/ns/dcat#",
+	dcterms: "http://purl.org/dc/terms/",
+	dctypes: "http://purl.org/dc/dcmitype/",
+	dqv: "http://www.w3.org/ns/dqv#",
+	duv: "https://www.w3.org/TR/vocab-duv#",
+	foaf: "http://xmlns.com/foaf/0.1/",
+	gr: "http://purl.org/goodrelations/v1#",
+	grddl: "http://www.w3.org/2003/g/data-view#",
+	ical: "http://www.w3.org/2002/12/cal/icaltzd#",
+	ldp: "http://www.w3.org/ns/ldp#",
+	ma: "http://www.w3.org/ns/ma-ont#",
+	oa: "http://www.w3.org/ns/oa#",
+	og: "http://ogp.me/ns#",
+	org: "http://www.w3.org/ns/org#",
+	owl: "http://www.w3.org/2002/07/owl#",
+	prov: "http://www.w3.org/ns/prov#",
+	qb: "http://purl.org/linked-data/cube#",
+	rdf: RDF,
+	rdfa: "http://www.w3.org/ns/rdfa#",
+	rdfs: "http://www.w3.org/2000/01/rdf-schema#",
+	rev: "http://purl.org/stuff/rev#",
+	rif: "http://www.w3.org/2007/rif#",
+	rr: "http://www.w3.org/ns/r2rml#",
+	schema: "http://schema.org/",
+	sd: "http://www.w3.org/ns/sparql-service-description#",
+	sioc: "http://rdfs.org/sioc/ns#",
+	skos: "http://www.w3.org/2004/02/skos/core#",
+	skosxl: "http://www.w3.org/2008/05/skos-xl#",
+	v: "http://rdf.data-vocabulary.org/#",
+	vcard: "http://www.w3.org/2006/vcard/ns#",
+	void: "http://rdfs.org/ns/void#",
+	wdr: "http://www.w3.org/2007/05/powder#",
+	wrds: "http://www.w3.org/2007/05/powder-s#",
+	xhv: "http://www.w3.org/1999/xhtml/vocab#",
+	xsd: XSD
+};
+const xsdTerms = [
+	"anyURI",
+	"base64Binary",
+	"boolean",
+	"byte",
+	"date",
+	"dateTime",
+	"dayTimeDuration",
+	"dateTimeStamp",
+	"decimal",
+	"double",
+	"duration",
+	"float",
+	"gDay",
+	"gMonth",
+	"gMonthDay",
+	"gYear",
+	"gYearMonth",
+	"hexBinary",
+	"int",
+	"integer",
+	"language",
+	"long",
+	"Name",
+	"NCName",
+	"NMTOKEN",
+	"negativeInteger",
+	"nonNegativeInteger",
+	"nonPositiveInteger",
+	"normalizedString",
+	"positiveInteger",
+	"QName",
+	"short",
+	"string",
+	"time",
+	"token",
+	"unsignedByte",
+	"unsignedInt",
+	"unsignedLong",
+	"unsignedShort",
+	"yearMonthDuration"
+];
+const csvwClasses = [
+	"Cell",
+	"Column",
+	"Datatype",
+	"Dialect",
+	"Direction",
+	"ForeignKey",
+	"NumericFormat",
+	"Row",
+	"Schema",
+	"Table",
+	"TableGroup",
+	"TableReference",
+	"Transformation",
+	"JSON",
+	"uriTemplate"
+];
+const csvwProperties = {
+	aboutUrl: "aboutUrl",
+	base: "base",
+	columnReference: "columnReference",
+	columns: "column",
+	commentPrefix: "commentPrefix",
+	datatype: "datatype",
+	decimalChar: "decimalChar",
+	default: "default",
+	describes: "describes",
+	delimiter: "delimiter",
+	dialect: "dialect",
+	doubleQuote: "doubleQuote",
+	encoding: "encoding",
+	foreignKeys: "foreignKey",
+	format: "format",
+	groupChar: "groupChar",
+	header: "header",
+	headerRowCount: "headerRowCount",
+	lang: "lang",
+	length: "length",
+	lineTerminators: "lineTerminators",
+	maxExclusive: "maxExclusive",
+	maxInclusive: "maxInclusive",
+	maxLength: "maxLength",
+	minExclusive: "minExclusive",
+	minInclusive: "minInclusive",
+	minLength: "minLength",
+	name: "name",
+	notes: "note",
+	null: "null",
+	ordered: "ordered",
+	pattern: "pattern",
+	primaryKey: "primaryKey",
+	propertyUrl: "propertyUrl",
+	quoteChar: "quoteChar",
+	reference: "reference",
+	referencedRows: "referencedRow",
+	required: "required",
+	resource: "resource",
+	row: "row",
+	rowTitles: "rowTitle",
+	rownum: "rownum",
+	scriptFormat: "scriptFormat",
+	schemaReference: "schemaReference",
+	separator: "separator",
+	skipBlankRows: "skipBlankRows",
+	skipColumns: "skipColumns",
+	skipInitialSpace: "skipInitialSpace",
+	skipRows: "skipRows",
+	source: "source",
+	suppressOutput: "suppressOutput",
+	tables: "table",
+	tableDirection: "tableDirection",
+	tableSchema: "tableSchema",
+	targetFormat: "targetFormat",
+	transformations: "transformations",
+	textDirection: "textDirection",
+	titles: "title",
+	trim: "trim",
+	url: "url",
+	valueUrl: "valueUrl",
+	virtual: "virtual"
+};
+/**
+* Every term of the CSVW context mapped to its absolute IRI.
+*
+* @internal
+*/
+const terms = {
+	...Record.map(prefixes, (iri) => iri),
+	xml: `${RDF}XMLLiteral`,
+	html: `${RDF}HTML`,
+	json: `${CSVW}JSON`,
+	any: `${XSD}anyAtomicType`,
+	anyAtomicType: `${XSD}anyAtomicType`,
+	binary: `${XSD}base64Binary`,
+	datetime: `${XSD}dateTime`,
+	number: `${XSD}double`,
+	describedby: "http://www.w3.org/2007/05/powder-s#describedby",
+	license: "http://www.w3.org/1999/xhtml/vocab#license",
+	role: "http://www.w3.org/1999/xhtml/vocab#role",
+	maximum: `${CSVW}maxInclusive`,
+	minimum: `${CSVW}minInclusive`,
+	...Record.fromEntries(Arr.map(xsdTerms, (t) => [t, `${XSD}${t}`])),
+	...Record.fromEntries(Arr.map(csvwClasses, (t) => [t, `${CSVW}${t}`])),
+	...Record.map(csvwProperties, (local) => `${CSVW}${local}`)
+};
+const PREFIXED = /^([A-Za-z][\w.-]*):(.*)$/;
+/**
+* The expansion of `value` if it is a prefixed name with a CSVW prefix.
+*
+* @internal
+*/
+const expandPrefixed = (value) => Option.flatMap(Option.fromNullishOr(PREFIXED.exec(value)), (m) => Option.map(Record.get(prefixes, m[1] ?? ""), (ns) => ns + (m[2] ?? "")));
+/**
+* Expands a term or prefixed name of the CSVW context; anything else is
+* returned unchanged.
+*
+* @internal
+*/
+const expand = (value) => Option.getOrElse(Record.get(terms, value), () => Option.getOrElse(expandPrefixed(value), () => value));
+/**
+* Whether `value` is an absolute URL (has a scheme).
+*
+* @internal
+*/
+const isAbsoluteUrl = (value) => /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value);
+const compactable = Arr.sort(Arr.filter(Record.toEntries(prefixes), ([prefix]) => prefix !== "dcterms"), Order.mapInput(Order.Number, ([, ns]) => -ns.length));
+const termOf = Record.fromEntries(Arr.map(Arr.filter(Record.toEntries(terms), ([term]) => !Record.has(prefixes, term)), ([term, iri]) => [iri, term]));
+/**
+* URL compaction (Metadata Vocabulary §URL Compaction): an absolute URL to a
+* term or prefixed name of the CSVW context; `rdf:type` becomes `@type`.
+*
+* @internal
+*/
+const compact = (url) => url === `http://www.w3.org/1999/02/22-rdf-syntax-ns#type` ? "@type" : Option.getOrElse(Record.get(termOf, url), () => Option.getOrElse(Option.map(Arr.findFirst(compactable, ([, ns]) => url.startsWith(ns) && url.length > ns.length), ([prefix, ns]) => `${prefix}:${url.slice(ns.length)}`), () => url));
+// src/csvw/Datatype.ts
+/**
+* CSVW datatypes (Metadata Vocabulary §Datatypes, Tabular Data Model §Parsing
+* Cells): the built-in datatypes, datatype descriptions, and parsing a cell's
+* string value into a typed value with its `format`, length and value
+* constraints.
+*
+* @since 0.1.0
+*/
+var Datatype_exports = /* @__PURE__ */ __exportAll({
+	Bound: () => Bound,
+	Datatype: () => Datatype,
+	NumericFormat: () => NumericFormat,
+	boundKey: () => boundKey,
+	builtIn: () => builtIn,
+	canonicalName: () => canonicalName,
+	checkFormat: () => checkFormat,
+	datatypeIri: () => datatypeIri,
+	fromIri: () => fromIri,
+	iri: () => iri,
+	isBinary: () => isBinary,
+	isBuiltIn: () => isBuiltIn,
+	isDateTime: () => isDateTime,
+	isDecimal: () => isDecimal,
+	isDuration: () => isDuration,
+	isInteger: () => isInteger,
+	isNumeric: () => isNumeric,
+	isString: () => isString$1,
+	parse: () => parse,
+	string: () => string,
+	stringValue: () => stringValue
+});
+/**
+* The names of the built-in datatypes, including the CSVW aliases (`number`,
+* `binary`, `datetime`, `any`, `xml`, `html`, `json`).
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const builtIn = [
+	"anyAtomicType",
+	"anyURI",
+	"base64Binary",
+	"boolean",
+	"date",
+	"dateTime",
+	"dateTimeStamp",
+	"decimal",
+	"integer",
+	"long",
+	"int",
+	"short",
+	"byte",
+	"nonNegativeInteger",
+	"positiveInteger",
+	"unsignedLong",
+	"unsignedInt",
+	"unsignedShort",
+	"unsignedByte",
+	"nonPositiveInteger",
+	"negativeInteger",
+	"double",
+	"duration",
+	"dayTimeDuration",
+	"yearMonthDuration",
+	"float",
+	"gDay",
+	"gMonth",
+	"gMonthDay",
+	"gYear",
+	"gYearMonth",
+	"hexBinary",
+	"QName",
+	"string",
+	"normalizedString",
+	"token",
+	"language",
+	"Name",
+	"NMTOKEN",
+	"xml",
+	"html",
+	"json",
+	"time",
+	"number",
+	"binary",
+	"datetime",
+	"any"
+];
+const aliases = {
+	number: "double",
+	binary: "base64Binary",
+	datetime: "dateTime",
+	any: "anyAtomicType"
+};
+/**
+* Whether `name` names a built-in datatype.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isBuiltIn = (name) => Arr.contains(builtIn, name);
+/**
+* The XML Schema name of a built-in datatype (`number` is `double`, …).
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const canonicalName = (name) => Option.getOrElse(Record.get(aliases, name), () => name);
+/**
+* The IRI of a built-in datatype.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const iri = (name) => Match.value(canonicalName(name)).pipe(Match.when("xml", () => `${RDF}XMLLiteral`), Match.when("html", () => `${RDF}HTML`), Match.when("json", () => `${CSVW}JSON`), Match.orElse((n) => `${XSD}${n}`));
+/**
+* The built-in datatype an IRI identifies, if any.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const fromIri = (url) => Arr.findFirst(builtIn, (name) => !Record.has(aliases, name) && iri(name) === url);
+const integerTypes = [
+	"integer",
+	"long",
+	"int",
+	"short",
+	"byte",
+	"nonNegativeInteger",
+	"positiveInteger",
+	"unsignedLong",
+	"unsignedInt",
+	"unsignedShort",
+	"unsignedByte",
+	"nonPositiveInteger",
+	"negativeInteger"
+];
+const dateTypes = [
+	"date",
+	"dateTime",
+	"dateTimeStamp",
+	"time",
+	"gDay",
+	"gMonth",
+	"gMonthDay",
+	"gYear",
+	"gYearMonth"
+];
+const durationTypes = [
+	"duration",
+	"dayTimeDuration",
+	"yearMonthDuration"
+];
+const stringTypes = [
+	"string",
+	"normalizedString",
+	"token",
+	"language",
+	"Name",
+	"NMTOKEN",
+	"xml",
+	"html",
+	"json"
+];
+/**
+* Whether a built-in datatype is an integer type.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isInteger = (name) => Arr.contains(integerTypes, canonicalName(name));
+/**
+* Whether a built-in datatype is `decimal` or one of its subtypes.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isDecimal = (name) => canonicalName(name) === "decimal" || isInteger(name);
+/**
+* Whether a built-in datatype is numeric.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isNumeric = (name) => isDecimal(name) || canonicalName(name) === "double" || canonicalName(name) === "float";
+/**
+* Whether a built-in datatype is a date or time type.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isDateTime = (name) => Arr.contains(dateTypes, canonicalName(name));
+/**
+* Whether a built-in datatype is a duration type.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isDuration = (name) => Arr.contains(durationTypes, canonicalName(name));
+/**
+* Whether a built-in datatype is `string` or one of its subtypes.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isString$1 = (name) => Arr.contains(stringTypes, canonicalName(name));
+/**
+* Whether a built-in datatype is a binary type.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const isBinary = (name) => canonicalName(name) === "base64Binary" || canonicalName(name) === "hexBinary";
+/**
+* A numeric format object (`decimalChar`, `groupChar`, `pattern`).
+*
+* @since 0.1.0
+* @category models
+*/
+const NumericFormat = Schema.Struct({
+	decimalChar: Schema.optional(Schema.String),
+	groupChar: Schema.optional(Schema.String),
+	pattern: Schema.optional(Schema.String)
+});
+/**
+* A bound of a value constraint, as written in the metadata.
+*
+* @since 0.1.0
+* @category models
+*/
+const Bound = Schema.Union([Schema.String, Schema.Finite]);
+/**
+* A normalized datatype description: a built-in `base`, an optional `@id`,
+* a `format`, and length and value constraints.
+*
+* @since 0.1.0
+* @category models
+*/
+const Datatype = Schema.Struct({
+	base: Schema.String,
+	id: Schema.optional(Schema.String),
+	format: Schema.optional(Schema.Union([Schema.String, NumericFormat])),
+	length: Schema.optional(Schema.Int),
+	minLength: Schema.optional(Schema.Int),
+	maxLength: Schema.optional(Schema.Int),
+	minInclusive: Schema.optional(Bound),
+	maxInclusive: Schema.optional(Bound),
+	minExclusive: Schema.optional(Bound),
+	maxExclusive: Schema.optional(Bound),
+	common: Schema.Record(Schema.String, Schema.Json)
+});
+/**
+* The `string` datatype.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const string = {
+	base: "string",
+	common: {}
+};
+/**
+* The IRI a value of the datatype has in RDF: its `@id`, or its base's IRI.
+*
+* @since 0.1.0
+* @category datatypes
+*/
+const datatypeIri = (datatype) => datatype.id ?? iri(datatype.base);
+const quote = (s) => `"${s}"`;
+const isValidRegex = (source) => Result.isSuccess(regexOf(source));
+const regexOf = (source) => Result.try({
+	try: () => new RegExp(`^(?:${source})$`, "u"),
+	catch: (e) => String(e)
+});
+/**
+* Checks a datatype's `format` against its base, returning a warning when the
+* format is unusable (it is then ignored).
+*
+* @since 0.1.0
+* @category validation
+*/
+const checkFormat = (base, format) => {
+	if (isNumeric(base)) return checkNumberFormat(format);
+	if (!Predicate.isString(format)) return Option.some(`format for a ${base} datatype must be a string`);
+	return Arr.contains([
+		"date",
+		"dateTime",
+		"dateTimeStamp",
+		"time"
+	], canonicalName(base)) ? invalidUnless(Option.isSome(compile(format)), `invalid date/time format ${quote(format)}`) : canonicalName(base) === "boolean" ? invalidUnless(/^[^|]+\|[^|]+$/.test(format), `invalid boolean format ${quote(format)}`) : invalidUnless(isValidRegex(format), `invalid regular expression format ${quote(format)}`);
+};
+const invalidUnless = (valid, message) => valid ? Option.none() : Option.some(message);
+const checkNumberFormat = (format) => {
+	const { pattern, decimalChar, groupChar } = Predicate.isString(format) ? {
+		pattern: format,
+		decimalChar: ".",
+		groupChar: ","
+	} : {
+		pattern: format.pattern,
+		decimalChar: format.decimalChar ?? ".",
+		groupChar: format.groupChar ?? ","
+	};
+	return Option.flatMap(Option.fromNullishOr(pattern), (p) => invalidUnless(Option.isSome(parsePattern(p, decimalChar, groupChar)), `invalid number format pattern ${quote(p)}`));
+};
+const numberFormatOf = (format) => {
+	if (format === void 0) return {
+		pattern: Option.none(),
+		decimalChar: ".",
+		groupChar: Option.none()
+	};
+	const decimalChar = Predicate.isString(format) ? "." : format.decimalChar ?? ".";
+	const groupChar = Predicate.isString(format) ? void 0 : format.groupChar;
+	const pattern = Predicate.isString(format) ? format : format.pattern;
+	return {
+		decimalChar,
+		groupChar: Option.fromNullishOr(groupChar),
+		pattern: Option.flatMap(Option.fromNullishOr(pattern), (p) => parsePattern(p, decimalChar, groupChar ?? ","))
+	};
+};
+const xsdValid = (base, lexical) => isValidLexical(`${XSD}${canonicalName(base)}`, lexical);
+const parseNumber = (text, datatype) => {
+	const base = datatype.base;
+	if (datatype.format === void 0) return xsdValid(base, text) ? Result.succeed(text) : Result.fail(`${quote(text)} is not a valid ${base}`);
+	return Result.flatMap(Result.mapError(parse$1(text, numberFormatOf(datatype.format)), (reason) => `${quote(text)} ${reason}`), (parsed) => {
+		if (isInteger(base) && parsed.hasDecimal) return Result.fail(`${quote(text)} has a decimal part but ${base} is an integer`);
+		if (isDecimal(base) && (parsed.hasExponent || parsed.special)) return Result.fail(`${quote(text)} is not a valid ${base}`);
+		return xsdValid(base, parsed.lexical) ? Result.succeed(parsed.lexical) : Result.fail(`${quote(text)} is not a valid ${base}`);
+	});
+};
+const parseBoolean = (text, datatype) => {
+	const format = datatype.format;
+	if (Predicate.isString(format)) {
+		const [yes, no] = format.split("|");
+		if (text === yes) return Result.succeed("true");
+		if (text === no) return Result.succeed("false");
+		return Result.fail(`${quote(text)} does not match the format ${format}`);
+	}
+	if (text === "true" || text === "1") return Result.succeed("true");
+	if (text === "false" || text === "0") return Result.succeed("false");
+	return Result.fail(`${quote(text)} is not a valid boolean`);
+};
+const parseDateTime = (text, datatype) => {
+	const base = canonicalName(datatype.base);
+	const pattern = Predicate.isString(datatype.format) ? compile(datatype.format) : Option.none();
+	return Option.match(pattern, {
+		onNone: () => xsdValid(base, text) ? Result.succeed(text) : Result.fail(`${quote(text)} is not a valid ${base}`),
+		onSome: (p) => Result.flatMap(Result.mapError(parse$2(text, p, base), (r) => `${quote(text)} ${r}`), (lexical) => xsdValid(base, lexical) ? Result.succeed(lexical) : Result.fail(`${quote(text)} is not a valid ${base}`))
+	});
+};
+const parseOther = (text, datatype) => {
+	const base = canonicalName(datatype.base);
+	const format = datatype.format;
+	if (!(Predicate.isString(format) ? Result.match(regexOf(format), {
+		onFailure: () => true,
+		onSuccess: (re) => re.test(text)
+	}) : true)) return Result.fail(`${quote(text)} does not match its format`);
+	if (base === "json" || base === "xml" || base === "html" || base === "anyAtomicType") return Result.succeed(text);
+	return base === "string" || xsdValid(base, text) ? Result.succeed(text) : Result.fail(`${quote(text)} is not a valid ${base}`);
+};
+const lengthOf = (lexical, base) => {
+	if (canonicalName(base) === "hexBinary") return lexical.length / 2;
+	if (canonicalName(base) === "base64Binary") {
+		const clean = lexical.replace(/\s/g, "");
+		return clean.length * 3 / 4 - (clean.match(/=+$/)?.[0].length ?? 0);
+	}
+	return Array.from(lexical).length;
+};
+const orderKey = (lexical, datatype) => {
+	const value = toValue(literal$1(lexical, namedNode(datatype)));
+	return Match.valueTags(value, {
+		Integer: ({ value: n }) => Option.some(Number(n)),
+		Decimal: ({ value: d }) => Option.some(BigDecimal.toNumberUnsafe(d)),
+		Float: ({ value: f }) => Option.some(f),
+		Double: ({ value: f }) => Option.some(f),
+		DateTime: ({ epochMillis }) => Option.some(epochMillis),
+		Duration: ({ months, seconds }) => Option.some(months * 2629746 + seconds),
+		String: () => Option.none(),
+		Boolean: () => Option.none(),
+		Other: () => Option.none()
+	});
+};
+/**
+* The order key of a constraint bound for a base datatype, if it is a valid
+* value of that datatype.
+*
+* @since 0.1.0
+* @category validation
+*/
+const boundKey = (bound, base) => Predicate.isNumber(bound) ? Option.some(bound) : xsdValid(base, bound) ? orderKey(bound, iri(base)) : Option.none();
+const checkConstraints = (value, datatype) => {
+	const length = lengthOf(value.lexical, datatype.base);
+	const lengthErrors = Arr.getSomes([
+		datatype.length !== void 0 && length !== datatype.length ? Option.some(`length ${length} is not ${datatype.length}`) : Option.none(),
+		datatype.minLength !== void 0 && length < datatype.minLength ? Option.some(`length ${length} is less than minLength ${datatype.minLength}`) : Option.none(),
+		datatype.maxLength !== void 0 && length > datatype.maxLength ? Option.some(`length ${length} is greater than maxLength ${datatype.maxLength}`) : Option.none()
+	]);
+	const key = orderKey(value.lexical, iri(datatype.base));
+	const bound = (b, ok, name) => Option.flatMap(b, (limit) => Option.flatMap(Option.all([key, boundKey(limit, datatype.base)]), ([v, l]) => ok(v, l) ? Option.none() : Option.some(`value violates ${name} ${limit}`)));
+	const of = Option.fromNullishOr;
+	return [...lengthErrors, ...Arr.getSomes([
+		bound(of(datatype.minInclusive), (v, l) => v >= l, "minimum"),
+		bound(of(datatype.maxInclusive), (v, l) => v <= l, "maximum"),
+		bound(of(datatype.minExclusive), (v, l) => v > l, "minExclusive"),
+		bound(of(datatype.maxExclusive), (v, l) => v < l, "maxExclusive")
+	])];
+};
+/**
+* Parses a (non-empty, non-null) cell string with a datatype: the value, or
+* the errors that make the cell invalid.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (text, datatype, language) => {
+	const base = canonicalName(datatype.base);
+	const lexical = isNumeric(base) ? parseNumber(text, datatype) : base === "boolean" ? parseBoolean(text, datatype) : isDateTime(base) || isDuration(base) ? isDuration(base) ? parseOther(text, datatype) : parseDateTime(text, datatype) : parseOther(text, datatype);
+	return Result.match(lexical, {
+		onFailure: (e) => Result.fail([e]),
+		onSuccess: (l) => {
+			const value = {
+				lexical: l,
+				base: datatype.base,
+				datatype: datatypeIri(datatype),
+				language: base === "string" && datatype.id === void 0 ? language : Option.none()
+			};
+			const errors = checkConstraints(value, datatype);
+			return Arr.isReadonlyArrayNonEmpty(errors) ? Result.fail(errors) : Result.succeed(value);
+		}
+	});
+};
+/**
+* A plain string value, as an invalid cell's value.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const stringValue = (text, language) => ({
+	lexical: text,
+	base: "string",
+	datatype: `${XSD}string`,
+	language
+});
+export { terms as A, CSVW as C, expand as D, compact as E, expandPrefixed as O, stringValue as S, XSD as T, isInteger as _, boundKey as a, parse as b, checkFormat as c, iri as d, isBinary as f, isDuration as g, isDecimal as h, NumericFormat as i, isAbsoluteUrl as k, datatypeIri as l, isDateTime as m, Datatype as n, builtIn as o, isBuiltIn as p, Datatype_exports as r, canonicalName as s, Bound as t, fromIri as u, isNumeric as v, RDF as w, string as x, isString$1 as y };
+
+//# sourceMappingURL=Datatype-DQvkNkiH.mjs.map