@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Metadata-D4HsQNXr.mjs

@@ -0,0 +1,1273 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { c as removeDotSegments, l as resolve$1, u as withoutFragment$1 } from "./Iri-Cr92gsQV.mjs";
+import { r as isWellFormed } from "./LanguageTag-BcOpMGZ4.mjs";
+import { A as terms, D as expand, O as expandPrefixed, a as boundKey, c as checkFormat, f as isBinary, g as isDuration, k as isAbsoluteUrl, m as isDateTime, n as Datatype, p as isBuiltIn, u as fromIri, v as isNumeric, x as string, y as isString$1 } from "./Datatype-DQvkNkiH.mjs";
+import { d as warning, s as error$1 } from "./Report-XHs8htzK.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 Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/csvw/internal/json.ts
+/**
+* Parses JSON text, failing with the engine's `SyntaxError` message.
+*
+* @internal
+*/
+const parseJson = (text) => Result.try({
+	try: () => JSON.parse(text),
+	catch: (e) => e instanceof SyntaxError ? e.message : String(e)
+});
+/**
+* Whether a JSON value is an object (not an array, not `null`).
+*
+* @internal
+*/
+const isObject = (value) => Predicate.isObject(value) && !Array.isArray(value);
+/**
+* Whether a JSON value is an array.
+*
+* @internal
+*/
+const isArray = (value) => Array.isArray(value);
+/**
+* The entries of a JSON object, in insertion order.
+*
+* @internal
+*/
+const entries = (obj) => Record.toEntries(obj);
+/**
+* The keys of a JSON object, in insertion order.
+*
+* @internal
+*/
+const keys = (obj) => Record.keys(obj);
+/**
+* Whether a JSON object has a key.
+*
+* @internal
+*/
+const has = (obj, key) => obj[key] !== void 0;
+/**
+* The value of a key of a JSON object.
+*
+* @internal
+*/
+const get$1 = (obj, key) => Record.get(obj, key);
+/**
+* Maps the values of a JSON object.
+*
+* @internal
+*/
+const mapValues = (obj, f) => Record.map(obj, f);
+/**
+* A JSON object with one key set.
+*
+* @internal
+*/
+const set = (obj, key, value) => Record.set(Record.map(obj, (v) => v), key, value);
+/**
+* A short description of a JSON value for messages: strings quoted, numbers
+* and booleans as written, `null`, and the kind of anything else.
+*
+* @internal
+*/
+const describe = (value) => {
+	if (Predicate.isString(value)) return `"${value}"`;
+	if (Predicate.isNumber(value) || Predicate.isBoolean(value)) return `${value}`;
+	if (Predicate.isNull(value)) return "null";
+	return isArray(value) ? "an array" : "an object";
+};
+// src/csvw/internal/object.ts
+/**
+* Building objects whose optional properties are set only when present, as
+* `exactOptionalPropertyTypes` requires.
+*
+* @internal
+*/
+/**
+* `{ [key]: value }` when the value is present, `{}` otherwise; spread it
+* into an object literal.
+*
+* @internal
+*/
+const optional = (key, value) => Option.match(value, {
+	onNone: () => ({}),
+	onSome: (v) => Record.singleton(key, v)
+});
+// src/csvw/internal/url.ts
+/**
+* URL helpers: resolution, RFC 3986 syntax- and scheme-based normalization
+* (Tabular Data Model §URL Normalization) and the percent-encoding of column
+* names derived from titles.
+*
+* @internal
+*/
+/**
+* Resolves a reference against a base URL.
+*
+* @internal
+*/
+const resolve = (reference, base) => resolve$1(reference, base);
+const URL_RE = /^([A-Za-z][A-Za-z0-9+.-]*):(?:\/\/([^/?#]*))?([^?#]*)(\?[^#]*)?(#.*)?$/;
+const UNRESERVED = /[A-Za-z0-9\-._~]/;
+const normalizePercent = (s) => s.replace(/%([0-9A-Fa-f]{2})/g, (_, hex) => {
+	const c = String.fromCharCode(Number.parseInt(hex, 16));
+	return UNRESERVED.test(c) ? c : `%${hex.toUpperCase()}`;
+});
+const isDefaultPort = (scheme, port) => scheme === "http" && port === "80" || scheme === "https" && port === "443";
+const normalizeAuthority = (authority, scheme) => {
+	const at = authority.lastIndexOf("@");
+	const userinfo = at === -1 ? "" : authority.slice(0, at + 1);
+	const hostPort = (at === -1 ? authority : authority.slice(at + 1)).toLowerCase();
+	const m = /^(.*?)(?::(\d*))?$/.exec(hostPort);
+	const host = m?.[1] ?? hostPort;
+	const port = m?.[2];
+	return `${userinfo}${host}${port !== void 0 && port !== "" && !isDefaultPort(scheme, port) ? `:${port}` : ""}`;
+};
+/**
+* Normalizes a URL for comparison: lower-case scheme and host, upper-case
+* percent-encodings, decoded unreserved characters, no dot segments, no
+* default HTTP(S) port and a `/` path for an HTTP(S) URL with an authority.
+*
+* @internal
+*/
+const normalize = (url) => {
+	const m = URL_RE.exec(url);
+	if (m === null) return url;
+	const scheme = (m[1] ?? "").toLowerCase();
+	const authority = m[2];
+	const rawPath = normalizePercent(m[3] ?? "");
+	const path = removeDotSegments(rawPath);
+	const query = m[4] === void 0 ? "" : normalizePercent(m[4]);
+	const fragment = m[5] === void 0 ? "" : normalizePercent(m[5]);
+	if (authority === void 0) return `${scheme}:${path}${query}${fragment}`;
+	const p = path === "" && (scheme === "http" || scheme === "https") ? "/" : path;
+	return `${scheme}://${normalizeAuthority(authority, scheme)}${p}${query}${fragment}`;
+};
+/**
+* Percent-encodes every character of a title that cannot appear in a URI
+* template variable name (anything but `A-Z`, `a-z`, `0-9`, `_` and `.`),
+* for a column name derived from it.
+*
+* @internal
+*/
+const encodeName = (title) => encodeURIComponent(title).replace(/[!'()*~-]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+/**
+* Percent-decodes a column name (`_name` and JSON property names).
+*
+* @internal
+*/
+const decodeName = (name) => name.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+	const bytes = run.match(/%([0-9A-Fa-f]{2})/g) ?? [];
+	return new TextDecoder("utf-8", { fatal: false }).decode(Uint8Array.from(bytes, (b) => Number.parseInt(b.slice(1), 16)));
+});
+/**
+* Removes the fragment from a URL.
+*
+* @internal
+*/
+const withoutFragment = (url) => withoutFragment$1(url);
+// src/csvw/Metadata.ts
+/**
+* CSVW metadata documents (Metadata Vocabulary for Tabular Data): the
+* normalized description model as Effect `Schema`s (table groups, tables,
+* schemas, columns, dialects, foreign keys, transformations), and decoding a
+* JSON-LD metadata document with its fixed `http://www.w3.org/ns/csvw`
+* context into that model — validating every property, warning about and
+* dropping invalid values, failing on errors, and normalizing per §Normalization
+* (absolute URLs, natural-language and common properties, referenced schemas
+* and dialects fetched and inlined).
+*
+* @since 0.1.0
+*/
+var Metadata_exports = /* @__PURE__ */ __exportAll({
+	Column: () => Column,
+	CommonProperties: () => CommonProperties,
+	Dialect: () => Dialect,
+	ForeignKey: () => ForeignKey,
+	Inherited: () => Inherited,
+	LanguageMap: () => LanguageMap,
+	MetadataError: () => MetadataError,
+	Reference: () => Reference,
+	Table: () => Table,
+	TableDirection: () => TableDirection,
+	TableGroup: () => TableGroup,
+	TableSchema: () => TableSchema,
+	TextDirection: () => TextDirection,
+	Transformation: () => Transformation,
+	Trim: () => Trim,
+	checkCompatible: () => checkCompatible,
+	columnsCompatible: () => columnsCompatible,
+	decode: () => decode,
+	decodeJson: () => decodeJson,
+	defaultDialect: () => defaultDialect,
+	describes: () => describes,
+	dialectOfTable: () => dialectOfTable,
+	inherit: () => inherit,
+	languagesMatch: () => languagesMatch,
+	noFetch: () => noFetch,
+	schemaOfTable: () => schemaOfTable
+});
+/**
+* A metadata document that cannot be used: invalid JSON, an invalid
+* `@context`, a missing required property, or a value the specification
+* says is an error (processing stops).
+*
+* @since 0.1.0
+* @category errors
+*/
+var MetadataError = class extends Schema.TaggedError()("MetadataError", {
+	message: Schema.String,
+	url: Schema.optional(Schema.String)
+}) {};
+/**
+* A natural-language property's value: language tags (`und` when unknown)
+* mapped to strings.
+*
+* @since 0.1.0
+* @category models
+*/
+const LanguageMap = Schema.Record(Schema.String, Schema.Array(Schema.String));
+/**
+* Common properties and notes in normalized form: prefixed names or absolute
+* URLs mapped to JSON-LD values.
+*
+* @since 0.1.0
+* @category models
+*/
+const CommonProperties = Schema.Record(Schema.String, Schema.Json);
+/**
+* The text direction of cells.
+*
+* @since 0.1.0
+* @category models
+*/
+const TextDirection = Schema.Literals([
+	"ltr",
+	"rtl",
+	"auto",
+	"inherit"
+]);
+/**
+* The direction of a table's columns.
+*
+* @since 0.1.0
+* @category models
+*/
+const TableDirection = Schema.Literals([
+	"ltr",
+	"rtl",
+	"auto"
+]);
+/**
+* The inherited properties of a description (§Inherited Properties), set
+* where they were specified; a column inherits each unset one from its
+* schema, table and table group.
+*
+* @since 0.1.0
+* @category models
+*/
+const Inherited = Schema.Struct({
+	aboutUrl: Schema.optional(Schema.String),
+	datatype: Schema.optional(Datatype),
+	default: Schema.optional(Schema.String),
+	lang: Schema.optional(Schema.String),
+	null: Schema.optional(Schema.Array(Schema.String)),
+	ordered: Schema.optional(Schema.Boolean),
+	propertyUrl: Schema.optional(Schema.String),
+	required: Schema.optional(Schema.Boolean),
+	separator: Schema.optional(Schema.NullOr(Schema.String)),
+	textDirection: Schema.optional(TextDirection),
+	valueUrl: Schema.optional(Schema.String)
+});
+/**
+* A column description.
+*
+* @since 0.1.0
+* @category models
+*/
+const Column = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	name: Schema.optional(Schema.String),
+	/** The name derived from the first title in the metadata's default language. */
+	titleName: Schema.optional(Schema.String),
+	titles: LanguageMap,
+	isVirtual: Schema.Boolean,
+	isSuppressed: Schema.Boolean,
+	inherited: Inherited,
+	common: CommonProperties
+});
+/**
+* The referenced side of a foreign key: a table by `resource` URL or by
+* `schemaReference`, and its columns.
+*
+* @since 0.1.0
+* @category models
+*/
+const Reference = Schema.Struct({
+	resource: Schema.optional(Schema.String),
+	schemaReference: Schema.optional(Schema.String),
+	columnReference: Schema.Array(Schema.String)
+});
+/**
+* A foreign key definition.
+*
+* @since 0.1.0
+* @category models
+*/
+const ForeignKey = Schema.Struct({
+	columnReference: Schema.Array(Schema.String),
+	reference: Reference
+});
+/**
+* A schema description (`tableSchema`).
+*
+* @since 0.1.0
+* @category models
+*/
+const TableSchema = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	columns: Schema.Array(Column),
+	primaryKey: Schema.optional(Schema.Array(Schema.String)),
+	rowTitles: Schema.optional(Schema.Array(Schema.String)),
+	foreignKeys: Schema.Array(ForeignKey),
+	inherited: Inherited,
+	common: CommonProperties
+});
+/**
+* The trim flag of a dialect.
+*
+* @since 0.1.0
+* @category models
+*/
+const Trim = Schema.Literals([
+	"true",
+	"false",
+	"start",
+	"end"
+]);
+/**
+* A dialect description with every flag resolved (`header` folded into
+* `headerRowCount`, `skipInitialSpace` into `trim`).
+*
+* @since 0.1.0
+* @category models
+*/
+const Dialect = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	commentPrefix: Schema.optional(Schema.String),
+	delimiter: Schema.String,
+	isDoubleQuoted: Schema.Boolean,
+	encoding: Schema.String,
+	headerRowCount: Schema.Int,
+	lineTerminators: Schema.Array(Schema.String),
+	quoteChar: Schema.NullOr(Schema.String),
+	shouldSkipBlankRows: Schema.Boolean,
+	skipColumns: Schema.Int,
+	skipRows: Schema.Int,
+	trim: Trim
+});
+/**
+* The default dialect: UTF-8 CSV with one header row.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const defaultDialect = {
+	delimiter: ",",
+	isDoubleQuoted: true,
+	encoding: "utf-8",
+	headerRowCount: 1,
+	lineTerminators: ["\r\n", "\n"],
+	quoteChar: "\"",
+	shouldSkipBlankRows: false,
+	skipColumns: 0,
+	skipRows: 0,
+	trim: "true"
+};
+/**
+* A transformation definition.
+*
+* @since 0.1.0
+* @category models
+*/
+const Transformation = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	url: Schema.String,
+	scriptFormat: Schema.String,
+	targetFormat: Schema.String,
+	source: Schema.optional(Schema.String),
+	titles: LanguageMap,
+	common: CommonProperties
+});
+/**
+* A table description.
+*
+* @since 0.1.0
+* @category models
+*/
+const Table = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	url: Schema.String,
+	dialect: Schema.optional(Dialect),
+	notes: Schema.Array(Schema.Json),
+	isSuppressed: Schema.Boolean,
+	tableDirection: Schema.optional(TableDirection),
+	tableSchema: Schema.optional(TableSchema),
+	transformations: Schema.Array(Transformation),
+	inherited: Inherited,
+	common: CommonProperties
+});
+/**
+* A table group description: the normalized form of every metadata document
+* (a table description is wrapped in a group of one).
+*
+* @since 0.1.0
+* @category models
+*/
+const TableGroup = Schema.Struct({
+	id: Schema.optional(Schema.String),
+	tables: Schema.Array(Table),
+	dialect: Schema.optional(Dialect),
+	notes: Schema.Array(Schema.Json),
+	tableDirection: Schema.optional(TableDirection),
+	tableSchema: Schema.optional(TableSchema),
+	transformations: Schema.Array(Transformation),
+	inherited: Inherited,
+	common: CommonProperties
+});
+const warn = (ctx, message) => {
+	ctx.issues.push(warning(message, { table: ctx.url }));
+};
+const error = (ctx, message) => {
+	ctx.issues.push(error$1(message, { table: ctx.url }));
+};
+const quote = describe;
+const CSVW_CONTEXT = "http://www.w3.org/ns/csvw";
+const inheritedKeys = [
+	"aboutUrl",
+	"datatype",
+	"default",
+	"lang",
+	"null",
+	"ordered",
+	"propertyUrl",
+	"required",
+	"separator",
+	"textDirection",
+	"valueUrl"
+];
+const ownKeys = {
+	TableGroup: [
+		"tables",
+		"dialect",
+		"notes",
+		"tableDirection",
+		"tableSchema",
+		"transformations",
+		...inheritedKeys
+	],
+	Table: [
+		"url",
+		"dialect",
+		"notes",
+		"suppressOutput",
+		"tableDirection",
+		"tableSchema",
+		"transformations",
+		...inheritedKeys
+	],
+	Schema: [
+		"columns",
+		"foreignKeys",
+		"primaryKey",
+		"rowTitles",
+		...inheritedKeys
+	],
+	Column: [
+		"name",
+		"suppressOutput",
+		"titles",
+		"virtual",
+		...inheritedKeys
+	],
+	Dialect: [
+		"commentPrefix",
+		"delimiter",
+		"doubleQuote",
+		"encoding",
+		"header",
+		"headerRowCount",
+		"lineTerminators",
+		"quoteChar",
+		"skipBlankRows",
+		"skipColumns",
+		"skipInitialSpace",
+		"skipRows",
+		"trim"
+	],
+	Template: [
+		"url",
+		"scriptFormat",
+		"targetFormat",
+		"source",
+		"titles"
+	],
+	Datatype: [
+		"base",
+		"format",
+		"length",
+		"minLength",
+		"maxLength",
+		"minimum",
+		"maximum",
+		"minInclusive",
+		"maxInclusive",
+		"minExclusive",
+		"maxExclusive"
+	],
+	ForeignKey: ["columnReference", "reference"],
+	Reference: [
+		"resource",
+		"schemaReference",
+		"columnReference"
+	]
+};
+const isCommonPropertyName = (key) => key.includes(":");
+const get = (obj, key) => get$1(obj, key);
+/**
+* Checks the keys of a description object: `@id` (a link that must not be a
+* blank node), `@type` (must name the kind), warnings for properties that are
+* not defined for this kind, and errors for unknown keywords.
+*/
+const checkKeys = (obj, kind, ctx) => {
+	const strict = kind === "ForeignKey" || kind === "Reference";
+	Arr.forEach(keys(obj), (key) => {
+		if (key === "@id") {
+			const id = obj[key];
+			if (Predicate.isString(id) && id.startsWith("_:")) error(ctx, `${kind} @id ${quote(id)} must not be a blank node`);
+			else if (!Predicate.isString(id)) warn(ctx, `${kind} @id must be a string`);
+			return;
+		}
+		if (key === "@type") {
+			if (obj[key] !== kind) error(ctx, `${kind} @type must be "${kind}"`);
+			return;
+		}
+		if (key === "@context") return;
+		if (key.startsWith("@")) {
+			error(ctx, `${kind} must not use the keyword ${key}`);
+			return;
+		}
+		if (Arr.contains(ownKeys[kind], key)) return;
+		if (isCommonPropertyName(key) && !strict) return;
+		if (strict) error(ctx, `${kind} must not have the property ${key}`);
+		else warn(ctx, `${kind} has an unknown property ${key}`);
+	});
+};
+const idOf = (obj, ctx) => Option.flatMap(get(obj, "@id"), (id) => Predicate.isString(id) ? id.startsWith("_:") ? Option.none() : Option.some(resolve(expand(id), ctx.base)) : Option.some(resolve("", ctx.base)));
+const booleanProperty = (obj, key, ctx) => Option.flatMap(get(obj, key), (v) => {
+	if (Predicate.isBoolean(v)) return Option.some(v);
+	warn(ctx, `${key} must be a boolean, not ${quote(v)}`);
+	return Option.none();
+});
+const stringProperty = (obj, key, ctx) => Option.flatMap(get(obj, key), (v) => {
+	if (Predicate.isString(v)) return Option.some(v);
+	warn(ctx, `${key} must be a string, not ${quote(v)}`);
+	return Option.none();
+});
+const nonNegativeInteger = (obj, key, ctx) => Option.flatMap(get(obj, key), (v) => {
+	if (Predicate.isNumber(v) && Number.isInteger(v) && v >= 0) return Option.some(v);
+	warn(ctx, `${key} must be a non-negative integer, not ${quote(v)}`);
+	return Option.none();
+});
+const linkProperty = (obj, key, ctx) => Option.map(get(obj, key), (v) => {
+	if (Predicate.isString(v)) return resolve(v, ctx.base);
+	warn(ctx, `${key} must be a string, not ${quote(v)}`);
+	return resolve("", ctx.base);
+});
+const templateProperty = (obj, key, ctx) => Option.map(get(obj, key), (v) => {
+	if (Predicate.isString(v)) return v;
+	warn(ctx, `${key} must be a URI template string, not ${quote(v)}`);
+	return "";
+});
+const isLanguageTag = (tag) => isWellFormed(tag);
+/** A natural-language property (§Natural Language Properties). */
+const naturalLanguage = (value, key, ctx) => {
+	const lang = Option.getOrElse(ctx.language, () => "und");
+	const strings = (vs) => Arr.filter(vs, (v) => {
+		if (Predicate.isString(v)) return true;
+		warn(ctx, `${key} values must be strings, not ${quote(v)}`);
+		return false;
+	});
+	if (Predicate.isString(value)) return { [lang]: [value] };
+	if (isArray(value)) return Arr.isReadonlyArrayNonEmpty(value) ? { [lang]: strings(value) } : {};
+	if (isObject(value)) return Record.fromEntries(Arr.flatMap(entries(value), ([tag, v]) => {
+		if (!isLanguageTag(tag)) {
+			warn(ctx, `${key} has an invalid language tag ${quote(tag)}`);
+			return [];
+		}
+		if (Predicate.isString(v)) return [[tag, [v]]];
+		if (isArray(v)) return [[tag, strings(v)]];
+		warn(ctx, `${key} values must be strings, not ${quote(v)}`);
+		return [];
+	}));
+	warn(ctx, `${key} must be a string, array or language map, not ${quote(value)}`);
+	return {};
+};
+const columnReference = (obj, key, ctx, required) => Option.flatMap(get(obj, key), (v) => {
+	const refs = Predicate.isString(v) ? Option.some([v]) : isArray(v) && Arr.isReadonlyArrayNonEmpty(v) && Arr.every(v, Predicate.isString) ? Option.some(Arr.filter(v, Predicate.isString)) : Option.none();
+	if (Option.isNone(refs)) {
+		if (required) error(ctx, `${key} must be a column name or a non-empty array of them`);
+		else warn(ctx, `${key} must be a column name or a non-empty array of them`);
+	}
+	return refs;
+});
+const legitimateTypes = [
+	"TableGroup",
+	"Table",
+	"Schema",
+	"Column",
+	"Dialect",
+	"Template",
+	"Datatype"
+];
+const isValidType = (t, valueType) => !t.startsWith("_:") && ((valueType ? isBuiltIn(t) : Arr.contains(legitimateTypes, t)) || Record.has(terms, t) || Option.isSome(expandPrefixed(t)) || isAbsoluteUrl(t) && !t.includes(" "));
+const normalizeCommon = (value, ctx) => {
+	if (isArray(value)) return Arr.map(value, (v) => normalizeCommon(v, ctx));
+	if (Predicate.isString(value)) return Option.match(ctx.language, {
+		onNone: () => ({ "@value": value }),
+		onSome: (language) => ({
+			"@value": value,
+			"@language": language
+		})
+	});
+	if (!isObject(value)) return value;
+	if (has(value, "@value")) {
+		const v = value["@value"];
+		const extra = Arr.filter(keys(value), (k) => !Arr.contains([
+			"@value",
+			"@type",
+			"@language"
+		], k));
+		if (Arr.isReadonlyArrayNonEmpty(extra)) error(ctx, `a value object must not have the properties ${Arr.join(extra, ", ")}`);
+		if (has(value, "@type") && has(value, "@language")) error(ctx, "a value object must not have both @type and @language");
+		if (!(Predicate.isString(v) || Predicate.isNumber(v) || Predicate.isBoolean(v))) error(ctx, "@value must be a string, number or boolean");
+		Option.map(get(value, "@type"), (t) => {
+			if (!Predicate.isString(t) || !isValidType(t, true)) error(ctx, `invalid value @type ${quote(t)}`);
+		});
+		Option.map(get(value, "@language"), (l) => {
+			if (!(Predicate.isNull(l) || Predicate.isString(l) && isLanguageTag(l))) error(ctx, `invalid @language ${quote(l)}`);
+		});
+		return value;
+	}
+	return Record.fromEntries(Arr.map(entries(value), ([key, v]) => {
+		if (key === "@id") {
+			if (!Predicate.isString(v)) {
+				error(ctx, "@id must be a string");
+				return [key, v];
+			}
+			if (v.startsWith("_:")) error(ctx, `@id ${quote(v)} must not be a blank node`);
+			return [key, resolve(expand(v), ctx.base)];
+		}
+		if (key === "@type") {
+			const types = isArray(v) ? v : [v];
+			Arr.forEach(types, (t) => {
+				if (!Predicate.isString(t) || !isValidType(t, false)) error(ctx, `invalid node @type ${quote(t)}`);
+			});
+			return [key, v];
+		}
+		if (key === "@language") error(ctx, "@language must only be used with @value");
+		else if (key === "@context") error(ctx, "a metadata document must not add a new @context");
+		else if (key === "@list" || key === "@set") error(ctx, `${key} must not be used`);
+		else if (key.startsWith("@")) error(ctx, `unknown keyword ${key}`);
+		return [key, normalizeCommon(v, ctx)];
+	}));
+};
+/** The common properties of a description object. */
+const commonProperties = (obj, ctx) => Record.fromEntries(Arr.map(Arr.filter(entries(obj), ([key]) => isCommonPropertyName(key) && !key.startsWith("@")), ([key, value]) => [key, normalizeCommon(value, ctx)]));
+const notesOf = (obj, ctx) => Option.match(get(obj, "notes"), {
+	onNone: () => [],
+	onSome: (v) => {
+		if (isArray(v)) return Arr.map(v, (n) => normalizeCommon(n, ctx));
+		warn(ctx, "notes must be an array");
+		return [];
+	}
+});
+const bound = (obj, key, base, ctx) => Option.flatMap(get(obj, key), (v) => {
+	if (Predicate.isNumber(v) || Predicate.isString(v)) {
+		if (Option.isNone(boundKey(v, base))) error(ctx, `${key} ${quote(v)} is not a valid ${base}`);
+		return Option.some(v);
+	}
+	warn(ctx, `${key} must be a number or string`);
+	return Option.none();
+});
+const sameBound = (a, b, base) => Option.makeEquivalence((x, y) => x === y)(boundKey(a, base), boundKey(b, base));
+/** Whether both values are present and satisfy `f`. */
+const both = (a, b, f) => Option.exists(Option.all([a, b]), ([x, y]) => f(x, y));
+const of = Option.fromNullishOr;
+/** Whether bound `a` is below bound `b` (`strict`) or at most `b`, in `base`'s value space. */
+const below = (base, strict) => (a, b) => Option.exists(Option.all([boundKey(a, base), boundKey(b, base)]), ([x, y]) => strict ? x < y : x <= y);
+const hasLength = (d) => d.length !== void 0 || d.minLength !== void 0 || d.maxLength !== void 0;
+const hasBounds = (d) => d.minInclusive !== void 0 || d.maxInclusive !== void 0 || d.minExclusive !== void 0 || d.maxExclusive !== void 0;
+const lengthApplies = (base) => isString$1(base) || isBinary(base) || base === "anyAtomicType";
+const boundsApply = (base) => isNumeric(base) || isDateTime(base) || isDuration(base);
+/** The datatype constraint combinations that are errors (§Derived Datatypes). */
+const datatypeRules = [
+	[(d) => both(of(d.length), of(d.minLength), (l, m) => l < m), () => "length is less than minLength"],
+	[(d) => both(of(d.length), of(d.maxLength), (l, m) => l > m), () => "length is greater than maxLength"],
+	[(d) => both(of(d.minLength), of(d.maxLength), (l, m) => l > m), () => "minLength is greater than maxLength"],
+	[(d) => hasLength(d) && !lengthApplies(d.base), (d) => `length constraints do not apply to ${d.base}`],
+	[(d) => hasBounds(d) && !boundsApply(d.base), (d) => `value constraints do not apply to ${d.base}`],
+	[(d) => both(of(d.minInclusive), of(d.minExclusive), () => true), () => "minInclusive and minExclusive must not both be specified"],
+	[(d) => both(of(d.maxInclusive), of(d.maxExclusive), () => true), () => "maxInclusive and maxExclusive must not both be specified"],
+	[(d) => both(of(d.maxInclusive), of(d.minInclusive), below(d.base, true)), () => "maxInclusive is less than minInclusive"],
+	[(d) => both(of(d.maxExclusive), of(d.minInclusive), below(d.base, false)), () => "maxExclusive is not greater than minInclusive"],
+	[(d) => both(of(d.maxExclusive), of(d.minExclusive), below(d.base, true)), () => "maxExclusive is less than minExclusive"],
+	[(d) => both(of(d.maxInclusive), of(d.minExclusive), below(d.base, false)), () => "maxInclusive is not greater than minExclusive"]
+];
+const checkDatatype = (d, ctx) => Arr.forEach(datatypeRules, ([violated, message]) => {
+	if (violated(d)) error(ctx, message(d));
+});
+const datatypeObject = (obj, ctx) => {
+	checkKeys(obj, "Datatype", ctx);
+	const id = idOf(obj, ctx);
+	if (Option.isSome(id) && Option.isSome(fromIri(id.value))) {
+		if (Arr.some(keys(obj), (k) => k !== "@id" && k !== "@type")) error(ctx, `a datatype with the built-in @id ${id.value} must not have other properties`);
+	}
+	const base = Option.getOrElse(Option.flatMap(stringProperty(obj, "base", ctx), (b) => {
+		if (isBuiltIn(b)) return Option.some(b);
+		warn(ctx, `base ${quote(b)} is not a built-in datatype`);
+		return Option.some("string");
+	}), () => "string");
+	const format = Option.flatMap(get(obj, "format"), (f) => {
+		const candidate = Predicate.isString(f) ? Option.some(f) : isObject(f) && isNumeric(base) ? Option.some({
+			...optional("decimalChar", stringProperty(f, "decimalChar", ctx)),
+			...optional("groupChar", stringProperty(f, "groupChar", ctx)),
+			...optional("pattern", stringProperty(f, "pattern", ctx))
+		}) : Option.none();
+		if (Option.isNone(candidate)) {
+			warn(ctx, `invalid format for a ${base} datatype`);
+			return Option.none();
+		}
+		return Option.match(checkFormat(base, candidate.value), {
+			onNone: () => candidate,
+			onSome: (message) => {
+				warn(ctx, message);
+				return Option.none();
+			}
+		});
+	});
+	const minimum = bound(obj, "minimum", base, ctx);
+	const maximum = bound(obj, "maximum", base, ctx);
+	const minInclusive = bound(obj, "minInclusive", base, ctx);
+	const maxInclusive = bound(obj, "maxInclusive", base, ctx);
+	if (Option.isSome(minimum) && Option.isSome(minInclusive) && !sameBound(minimum.value, minInclusive.value, base)) error(ctx, "minimum and minInclusive differ");
+	if (Option.isSome(maximum) && Option.isSome(maxInclusive) && !sameBound(maximum.value, maxInclusive.value, base)) error(ctx, "maximum and maxInclusive differ");
+	const datatype = {
+		base,
+		...optional("id", id),
+		...optional("format", format),
+		...optional("length", nonNegativeInteger(obj, "length", ctx)),
+		...optional("minLength", nonNegativeInteger(obj, "minLength", ctx)),
+		...optional("maxLength", nonNegativeInteger(obj, "maxLength", ctx)),
+		...optional("minInclusive", Option.orElse(minInclusive, () => minimum)),
+		...optional("maxInclusive", Option.orElse(maxInclusive, () => maximum)),
+		...optional("minExclusive", bound(obj, "minExclusive", base, ctx)),
+		...optional("maxExclusive", bound(obj, "maxExclusive", base, ctx)),
+		common: commonProperties(obj, ctx)
+	};
+	checkDatatype(datatype, ctx);
+	return datatype;
+};
+const datatypeProperty = (value, ctx) => {
+	if (Predicate.isString(value)) {
+		if (isBuiltIn(value)) return Option.some({
+			base: value,
+			common: {}
+		});
+		warn(ctx, `datatype ${quote(value)} is not a built-in datatype`);
+		return Option.some(string);
+	}
+	if (isObject(value)) return Option.some(datatypeObject(value, ctx));
+	warn(ctx, `datatype must be a string or object, not ${quote(value)}`);
+	return Option.some(string);
+};
+const inheritedOf = (obj, ctx) => {
+	const nulls = Option.flatMap(get(obj, "null"), (v) => {
+		if (Predicate.isString(v)) return Option.some([v]);
+		if (isArray(v)) {
+			const strings = Arr.filter(v, Predicate.isString);
+			if (Arr.length(strings) !== Arr.length(v)) warn(ctx, "null values must be strings");
+			return Option.some(strings);
+		}
+		warn(ctx, `null must be a string or array of strings, not ${quote(v)}`);
+		return Option.some([""]);
+	});
+	const lang = Option.flatMap(stringProperty(obj, "lang", ctx), (l) => {
+		if (isLanguageTag(l)) return Option.some(l);
+		warn(ctx, `lang ${quote(l)} is not a valid language tag`);
+		return Option.some("und");
+	});
+	const separator = Option.flatMap(get(obj, "separator"), (v) => {
+		if (Predicate.isString(v) || Predicate.isNull(v)) return Option.some(v);
+		warn(ctx, `separator must be a string or null, not ${quote(v)}`);
+		return Option.some(null);
+	});
+	const textDirection = Option.flatMap(get(obj, "textDirection"), (v) => {
+		if (v === "ltr" || v === "rtl" || v === "auto" || v === "inherit") return Option.some(v);
+		warn(ctx, `textDirection must be "ltr", "rtl", "auto" or "inherit", not ${quote(v)}`);
+		return Option.some("inherit");
+	});
+	const defaultValue = Option.flatMap(get(obj, "default"), (v) => {
+		if (Predicate.isString(v)) return Option.some(v);
+		warn(ctx, `default must be a string, not ${quote(v)}`);
+		return Option.some("");
+	});
+	const flag = (key) => Option.flatMap(get(obj, key), (v) => {
+		if (Predicate.isBoolean(v)) return Option.some(v);
+		warn(ctx, `${key} must be a boolean, not ${quote(v)}`);
+		return Option.some(false);
+	});
+	return {
+		...optional("aboutUrl", templateProperty(obj, "aboutUrl", ctx)),
+		...optional("datatype", Option.flatMap(get(obj, "datatype"), (v) => datatypeProperty(v, ctx))),
+		...optional("default", defaultValue),
+		...optional("lang", lang),
+		...optional("null", nulls),
+		...optional("ordered", flag("ordered")),
+		...optional("propertyUrl", templateProperty(obj, "propertyUrl", ctx)),
+		...optional("required", flag("required")),
+		...optional("separator", separator),
+		...optional("textDirection", textDirection),
+		...optional("valueUrl", templateProperty(obj, "valueUrl", ctx))
+	};
+};
+const COLUMN_NAME = /^(?:[A-Za-z0-9]|%[0-9A-Fa-f]{2})(?:[A-Za-z0-9_.]|%[0-9A-Fa-f]{2})*$/;
+const columnOf = (obj, ctx) => {
+	checkKeys(obj, "Column", ctx);
+	const titles = Option.match(get(obj, "titles"), {
+		onNone: () => ({}),
+		onSome: (v) => naturalLanguage(v, "titles", ctx)
+	});
+	const name = Option.flatMap(get(obj, "name"), (v) => {
+		if (!Predicate.isString(v)) {
+			warn(ctx, `column name must be a string, not ${quote(v)}`);
+			return Option.none();
+		}
+		if (!COLUMN_NAME.test(v) || v.startsWith("_")) {
+			warn(ctx, `invalid column name ${quote(v)}`);
+			return Option.none();
+		}
+		return Option.some(v);
+	});
+	return {
+		...optional("id", idOf(obj, ctx)),
+		...optional("name", name),
+		...optional("titleName", Option.flatMap(Record.get(titles, Option.getOrElse(ctx.language, () => "und")), Arr.head)),
+		titles,
+		isVirtual: Option.getOrElse(booleanProperty(obj, "virtual", ctx), () => false),
+		isSuppressed: Option.getOrElse(booleanProperty(obj, "suppressOutput", ctx), () => false),
+		inherited: inheritedOf(obj, ctx),
+		common: commonProperties(obj, ctx)
+	};
+};
+const arrayProperty = (obj, key, ctx) => Option.match(get(obj, key), {
+	onNone: () => [],
+	onSome: (v) => {
+		if (!isArray(v)) {
+			warn(ctx, `${key} must be an array`);
+			return [];
+		}
+		return Arr.filter(v, (item) => {
+			if (isObject(item)) return true;
+			warn(ctx, `${key} items must be objects, not ${quote(item)}`);
+			return false;
+		});
+	}
+});
+const foreignKeyOf = (obj, ctx) => {
+	checkKeys(obj, "ForeignKey", ctx);
+	const columns = columnReference(obj, "columnReference", ctx, true);
+	const reference = Option.flatMap(get(obj, "reference"), (r) => {
+		if (!isObject(r)) {
+			error(ctx, "foreign key reference must be an object");
+			return Option.none();
+		}
+		checkKeys(r, "Reference", ctx);
+		const resource = linkProperty(r, "resource", ctx);
+		const schemaReference = linkProperty(r, "schemaReference", ctx);
+		if (Option.isSome(resource) === Option.isSome(schemaReference)) error(ctx, "foreign key reference needs exactly one of resource and schemaReference");
+		return Option.map(columnReference(r, "columnReference", ctx, true), (cols) => ({
+			...optional("resource", resource),
+			...optional("schemaReference", schemaReference),
+			columnReference: cols
+		}));
+	});
+	if (Option.isNone(reference) && !has(obj, "reference")) error(ctx, "foreign key needs a reference");
+	return Option.map(Option.all([columns, reference]), ([from, to]) => ({
+		columnReference: from,
+		reference: to
+	}));
+};
+const schemaOf = (obj, ctx) => {
+	checkKeys(obj, "Schema", ctx);
+	const columns = Arr.map(arrayProperty(obj, "columns", ctx), (c) => columnOf(c, ctx));
+	const names = Arr.getSomes(Arr.map(columns, (c) => Option.fromNullishOr(c.name)));
+	if (Arr.length(Arr.dedupe(names)) !== Arr.length(names)) error(ctx, "column names must be unique");
+	const firstVirtual = Arr.findFirstIndex(columns, (c) => c.isVirtual);
+	if (Option.exists(firstVirtual, (i) => Arr.some(Arr.drop(columns, i), (c) => !c.isVirtual))) error(ctx, "virtual columns must follow every non-virtual column");
+	const references = (key) => Option.flatMap(columnReference(obj, key, ctx, false), (refs) => {
+		if (Arr.every(refs, (r) => Arr.contains(names, r))) return Option.some(refs);
+		warn(ctx, `${key} references a column that does not exist`);
+		return Option.none();
+	});
+	const foreignKeys = Arr.getSomes(Arr.map(arrayProperty(obj, "foreignKeys", ctx), (fk) => foreignKeyOf(fk, ctx)));
+	Arr.forEach(foreignKeys, (fk) => {
+		if (!Arr.every(fk.columnReference, (r) => Arr.contains(names, r))) error(ctx, "foreign key columnReference references a column that does not exist");
+	});
+	return {
+		...optional("id", idOf(obj, ctx)),
+		columns,
+		...optional("primaryKey", references("primaryKey")),
+		...optional("rowTitles", references("rowTitles")),
+		foreignKeys,
+		inherited: inheritedOf(obj, ctx),
+		common: commonProperties(obj, ctx)
+	};
+};
+const isEncoding = (encoding) => Result.isSuccess(Result.try(() => new TextDecoder(encoding)));
+const dialectOf = (obj, ctx) => {
+	checkKeys(obj, "Dialect", ctx);
+	const d = defaultDialect;
+	const header = booleanProperty(obj, "header", ctx);
+	const headerRowCount = nonNegativeInteger(obj, "headerRowCount", ctx);
+	const skipInitialSpace = booleanProperty(obj, "skipInitialSpace", ctx);
+	const trim = Option.flatMap(get(obj, "trim"), (v) => {
+		if (Predicate.isBoolean(v)) return Option.some(v ? "true" : "false");
+		if (v === "true" || v === "false" || v === "start" || v === "end") return Option.some(v);
+		warn(ctx, `trim must be a boolean or "true", "false", "start" or "end", not ${quote(v)}`);
+		return Option.none();
+	});
+	const quoteChar = Option.flatMap(get(obj, "quoteChar"), (v) => {
+		if (Predicate.isString(v) || Predicate.isNull(v)) return Option.some(v);
+		warn(ctx, `quoteChar must be a string or null, not ${quote(v)}`);
+		return Option.none();
+	});
+	const lineTerminators = Option.flatMap(get(obj, "lineTerminators"), (v) => {
+		if (Predicate.isString(v)) return Option.some([v]);
+		if (isArray(v) && Arr.every(v, Predicate.isString)) return Option.some(Arr.filter(v, Predicate.isString));
+		warn(ctx, "lineTerminators must be a string or an array of strings");
+		return Option.none();
+	});
+	const encoding = Option.flatMap(stringProperty(obj, "encoding", ctx), (e) => {
+		if (isEncoding(e)) return Option.some(e);
+		warn(ctx, `unknown encoding ${quote(e)}`);
+		return Option.none();
+	});
+	return {
+		...optional("id", idOf(obj, ctx)),
+		...optional("commentPrefix", stringProperty(obj, "commentPrefix", ctx)),
+		delimiter: Option.getOrElse(stringProperty(obj, "delimiter", ctx), () => d.delimiter),
+		isDoubleQuoted: Option.getOrElse(booleanProperty(obj, "doubleQuote", ctx), () => d.isDoubleQuoted),
+		encoding: Option.getOrElse(encoding, () => d.encoding),
+		headerRowCount: Option.getOrElse(headerRowCount, () => Option.getOrElse(Option.map(header, (h) => h ? 1 : 0), () => d.headerRowCount)),
+		lineTerminators: Option.getOrElse(lineTerminators, () => d.lineTerminators),
+		quoteChar: Option.getOrElse(quoteChar, () => d.quoteChar),
+		shouldSkipBlankRows: Option.getOrElse(booleanProperty(obj, "skipBlankRows", ctx), () => d.shouldSkipBlankRows),
+		skipColumns: Option.getOrElse(nonNegativeInteger(obj, "skipColumns", ctx), () => d.skipColumns),
+		skipRows: Option.getOrElse(nonNegativeInteger(obj, "skipRows", ctx), () => d.skipRows),
+		trim: Option.getOrElse(trim, () => Option.getOrElse(Option.map(skipInitialSpace, (s) => s ? "start" : "false"), () => d.trim))
+	};
+};
+const transformationOf = (obj, ctx) => {
+	checkKeys(obj, "Template", ctx);
+	const required = (key) => {
+		const v = linkProperty(obj, key, ctx);
+		if (Option.isNone(v)) error(ctx, `transformation needs ${key}`);
+		return v;
+	};
+	const url = required("url");
+	const scriptFormat = required("scriptFormat");
+	const targetFormat = required("targetFormat");
+	const source = Option.flatMap(stringProperty(obj, "source", ctx), (s) => {
+		if (s === "json" || s === "rdf") return Option.some(s);
+		warn(ctx, `transformation source must be "json" or "rdf", not ${quote(s)}`);
+		return Option.none();
+	});
+	return Option.map(Option.all([
+		url,
+		scriptFormat,
+		targetFormat
+	]), ([u, sf, tf]) => ({
+		...optional("id", idOf(obj, ctx)),
+		url: u,
+		scriptFormat: sf,
+		targetFormat: tf,
+		...optional("source", source),
+		titles: Option.match(get(obj, "titles"), {
+			onNone: () => ({}),
+			onSome: (v) => naturalLanguage(v, "titles", ctx)
+		}),
+		common: commonProperties(obj, ctx)
+	}));
+};
+const tableDirectionOf = (obj, ctx) => Option.flatMap(get(obj, "tableDirection"), (v) => {
+	if (v === "ltr" || v === "rtl" || v === "auto") return Option.some(v);
+	warn(ctx, `tableDirection must be "ltr", "rtl" or "auto", not ${quote(v)}`);
+	return Option.some("auto");
+});
+const contextOf = (doc, url, issues, required) => {
+	const fail = (message) => Result.fail(new MetadataError({
+		message,
+		url
+	}));
+	const ctx = {
+		url,
+		base: url,
+		language: Option.none(),
+		issues
+	};
+	return Option.match(get(doc, "@context"), {
+		onNone: () => required ? fail("a metadata document must have a @context") : Result.succeed(ctx),
+		onSome: (c) => {
+			if (c === CSVW_CONTEXT) return Result.succeed(ctx);
+			if (!isArray(c) || Arr.length(c) !== 2 || c[0] !== CSVW_CONTEXT) return fail(`@context must be "${CSVW_CONTEXT}" or ["${CSVW_CONTEXT}", {…}]`);
+			const local = c[1];
+			if (local === void 0 || !isObject(local)) return fail("the local @context must be an object");
+			const others = Arr.filter(keys(local), (k) => k !== "@base" && k !== "@language");
+			if (Arr.isReadonlyArrayNonEmpty(others)) return fail(`the local @context must only define @base and @language, not ${Arr.join(others, ", ")}`);
+			const base = Option.match(get(local, "@base"), {
+				onNone: () => url,
+				onSome: (b) => {
+					if (Predicate.isString(b)) return resolve(b, url);
+					issues.push(warning("@base must be a string", { table: url }));
+					return url;
+				}
+			});
+			const language = Option.flatMap(get(local, "@language"), (l) => {
+				if (Predicate.isString(l) && isLanguageTag(l)) return Option.some(l);
+				issues.push(warning(`@language ${quote(l)} is not a valid language tag`, { table: url }));
+				return Option.none();
+			});
+			return Result.succeed({
+				url,
+				base,
+				language,
+				issues
+			});
+		}
+	});
+};
+const parseDocument = (text, url) => Result.mapError(parseJson(text), (message) => new MetadataError({
+	message: `invalid JSON: ${message}`,
+	url
+}));
+const objectProperty = (obj, key, ctx, load) => Option.match(get(obj, key), {
+	onNone: () => Effect.succeedNone,
+	onSome: (v) => {
+		if (isObject(v)) {
+			if (has(v, "@context")) error(ctx, `${key} must not have a @context`);
+			return Effect.succeedSome({
+				obj: v,
+				ctx
+			});
+		}
+		if (Predicate.isString(v)) {
+			const url = resolve(v, ctx.base);
+			return Effect.flatMap(load(url), (text) => Effect.fromResult(Result.flatMap(parseDocument(text, url), (doc) => {
+				if (!isObject(doc)) return Result.fail(new MetadataError({
+					message: `${key} must be an object`,
+					url
+				}));
+				return Result.map(contextOf(doc, url, ctx.issues, false), (sub) => Option.some({
+					obj: has(doc, "@id") ? doc : set(doc, "@id", url),
+					ctx: sub
+				}));
+			})));
+		}
+		warn(ctx, `${key} must be an object or a URL, not ${quote(v)}`);
+		return Effect.succeedSome({
+			obj: {},
+			ctx
+		});
+	}
+});
+/** The properties table and table group descriptions share. */
+const sharedProperties = Effect.fnUntraced(function* (obj, ctx, load) {
+	const schema = yield* objectProperty(obj, "tableSchema", ctx, load);
+	const dialect = yield* objectProperty(obj, "dialect", ctx, load);
+	return {
+		...optional("id", idOf(obj, ctx)),
+		...optional("dialect", Option.map(dialect, (d) => dialectOf(d.obj, d.ctx))),
+		notes: notesOf(obj, ctx),
+		...optional("tableDirection", tableDirectionOf(obj, ctx)),
+		...optional("tableSchema", Option.map(schema, (s) => schemaOf(s.obj, s.ctx))),
+		transformations: Arr.getSomes(Arr.map(arrayProperty(obj, "transformations", ctx), (t) => transformationOf(t, ctx))),
+		inherited: inheritedOf(obj, ctx),
+		common: commonProperties(obj, ctx)
+	};
+});
+const describedTable = Effect.fnUntraced(function* (obj, ctx, load) {
+	checkKeys(obj, "Table", ctx);
+	const url = linkProperty(obj, "url", ctx);
+	if (Option.isNone(url) || !Predicate.isString(obj["url"])) error(ctx, "a table must have a url");
+	return {
+		...yield* sharedProperties(obj, ctx, load),
+		url: Option.getOrElse(url, () => ctx.base),
+		isSuppressed: Option.getOrElse(booleanProperty(obj, "suppressOutput", ctx), () => false)
+	};
+});
+const describedGroup = Effect.fnUntraced(function* (obj, ctx, load) {
+	checkKeys(obj, "TableGroup", ctx);
+	const tables = yield* Effect.forEach(arrayProperty(obj, "tables", ctx), (t) => describedTable(t, ctx, load), { concurrency: 1 });
+	if (!Arr.isReadonlyArrayNonEmpty(tables)) error(ctx, "a table group must have at least one table");
+	return {
+		...yield* sharedProperties(obj, ctx, load),
+		tables
+	};
+});
+/**
+* Decodes a parsed metadata document found at `url` into a normalized table
+* group (a table description becomes a group of one), fetching the schemas
+* and dialects it references by URL with `load`. Warnings are returned with
+* the group; errors fail with `MetadataError`.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const decodeJson = Effect.fnUntraced(function* (document, url, load) {
+	if (!isObject(document)) return yield* new MetadataError({
+		message: "a metadata document must be an object",
+		url
+	});
+	const issues = [];
+	const ctx = yield* Effect.fromResult(contextOf(document, url, issues, true));
+	const isGroup = has(document, "tables");
+	if (!isGroup && !has(document, "url")) return yield* new MetadataError({
+		message: "a metadata document must describe a table group (tables) or a table (url)",
+		url
+	});
+	const group = isGroup ? yield* describedGroup(document, ctx, load) : {
+		tables: [yield* describedTable(document, ctx, load)],
+		notes: [],
+		transformations: [],
+		inherited: {},
+		common: {}
+	};
+	const first = Arr.findFirst(issues, (i) => i.level === "error");
+	if (Option.isSome(first)) return yield* new MetadataError({
+		message: first.value.message,
+		url
+	});
+	return {
+		group,
+		warnings: issues
+	};
+});
+/**
+* Decodes metadata text found at `url` (see `decodeJson`); invalid JSON fails
+* with `MetadataError`.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const decode = (text, url, load) => Effect.flatMap(Effect.fromResult(parseDocument(text, url)), (doc) => decodeJson(doc, url, load));
+/**
+* A `Fetch` that fails for every URL: for metadata that references no other
+* document.
+*
+* @since 0.1.0
+* @category decoding
+*/
+const noFetch = (url) => Effect.fail(new MetadataError({
+	message: `cannot fetch ${url}`,
+	url
+}));
+/**
+* The effective inherited properties of a column: its own, then its schema's,
+* its table's and its group's.
+*
+* @since 0.1.0
+* @category inheritance
+*/
+const inherit = (...levels) => Arr.reduceRight(levels, noInherited, (acc, level) => ({
+	...acc,
+	...level
+}));
+const noInherited = {};
+/**
+* The table's effective schema: its own, or its group's.
+*
+* @since 0.1.0
+* @category inheritance
+*/
+const schemaOfTable = (group, table) => Option.orElse(Option.fromNullishOr(table.tableSchema), () => Option.fromNullishOr(group.tableSchema));
+/**
+* The table's effective dialect: its own, its group's, or the default.
+*
+* @since 0.1.0
+* @category inheritance
+*/
+const dialectOfTable = (group, table) => table.dialect ?? group.dialect ?? defaultDialect;
+/**
+* Whether two language tags match for title comparison: `und` matches any
+* language, and tags match when equal after truncation to the shorter one.
+*
+* @since 0.1.0
+* @category compatibility
+*/
+const languagesMatch = (a, b) => {
+	if (a === "und" || b === "und") return true;
+	const x = a.toLowerCase().split("-");
+	const y = b.toLowerCase().split("-");
+	const n = Math.min(Arr.length(x), Arr.length(y));
+	return Arr.join(Arr.take(x, n), "-") === Arr.join(Arr.take(y, n), "-");
+};
+const titleEntries = (titles) => Arr.flatMap(Record.toEntries(titles), ([lang, ts]) => Arr.map(ts, (t) => [lang, t]));
+/**
+* Whether two column descriptions are compatible (§Schema Compatibility).
+*
+* @since 0.1.0
+* @category compatibility
+*/
+const columnsCompatible = (a, b, validating) => {
+	const aTitles = titleEntries(a.titles);
+	const bTitles = titleEntries(b.titles);
+	const aEmpty = a.name === void 0 && !Arr.isReadonlyArrayNonEmpty(aTitles);
+	const bEmpty = b.name === void 0 && !Arr.isReadonlyArrayNonEmpty(bTitles);
+	if (aEmpty || bEmpty) return true;
+	if (a.name !== void 0 && a.name === b.name) return true;
+	if (Arr.some(aTitles, ([la, ta]) => Arr.some(bTitles, ([lb, tb]) => ta === tb && languagesMatch(la, lb)))) return true;
+	if (!validating) {
+		const nameOnly = (c, ts) => c.name !== void 0 && !Arr.isReadonlyArrayNonEmpty(ts);
+		const titlesOnly = (c, ts) => c.name === void 0 && Arr.isReadonlyArrayNonEmpty(ts);
+		if (nameOnly(a, aTitles) && titlesOnly(b, bTitles) || titlesOnly(a, aTitles) && nameOnly(b, bTitles)) return true;
+	}
+	return false;
+};
+/**
+* Checks a table's schema against the columns embedded in its data
+* (§Schema Compatibility), returning the reason they are incompatible.
+*
+* @since 0.1.0
+* @category compatibility
+*/
+const checkCompatible = (schema, embedded, validating) => {
+	const real = Arr.filter(schema, (c) => !c.isVirtual);
+	if (Arr.length(real) !== Arr.length(embedded)) return Option.some(`the metadata describes ${Arr.length(real)} columns but the data has ${Arr.length(embedded)}`);
+	return Option.map(Arr.findFirstIndex(Arr.zip(real, embedded), ([a, b]) => !columnsCompatible(a, b, validating)), (i) => `column ${i + 1} of the metadata is not compatible with the data's header`);
+};
+/**
+* Whether a table group describes the table at `url` (URLs compared after
+* normalization).
+*
+* @since 0.1.0
+* @category compatibility
+*/
+const describes = (group, url) => Arr.some(group.tables, (t) => normalize(t.url) === normalize(url));
+export { normalize as A, keys as B, dialectOfTable as C, schemaOfTable as D, noFetch as E, entries as F, get$1 as I, has as L, withoutFragment as M, optional as N, decodeName as O, describe as P, isArray as R, describes as S, languagesMatch as T, mapValues as V, checkCompatible as _, Inherited as a, decodeJson as b, Metadata_exports as c, TableDirection as d, TableGroup as f, Trim as g, Transformation as h, ForeignKey as i, resolve as j, encodeName as k, Reference as l, TextDirection as m, CommonProperties as n, LanguageMap as o, TableSchema as p, Dialect as r, MetadataError as s, Column as t, Table as u, columnsCompatible as v, inherit as w, defaultDialect as x, decode as y, isObject as z };
+
+//# sourceMappingURL=Metadata-D4HsQNXr.mjs.map