@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Message-fIvTJSXM.d.mts

@@ -0,0 +1,49 @@
+import { T as Term, d as NamedNode, l as Literal } from "./Term-B_4ezyXq.mjs";
+import "./index-Cms2TYfC.mjs";
+declare namespace Message_d_exports {
+  export { display, format, localName, substitute, variables };
+}
+/**
+ * A human-readable string for a term inside a message: the lexical form of
+ * literals, the IRI of named nodes, `_:label` for blank nodes and the
+ * N-Triples-like form of triple terms.
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const display: (term: Term) => string;
+/**
+ * The variable names referenced by a template, in order of appearance.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+declare const variables: (template: string) => ReadonlyArray<string>;
+/**
+ * Replaces the `{?name}` / `{$name}` placeholders of a template string.
+ * Placeholders whose variable `lookup` does not know are left unchanged.
+ *
+ * @since 0.1.0
+ * @category substitution
+ */
+declare const format: (template: string, lookup: (name: string) => Term | undefined) => string;
+/**
+ * Substitutes the placeholders of a message literal, keeping its language
+ * tag (or datatype).
+ *
+ * @since 0.1.0
+ * @category substitution
+ */
+declare const substitute: (message: Literal, lookup: (name: string) => Term | undefined) => Literal;
+/**
+ * The local name of an IRI: the longest NCName at its end (SHACL §6.2.1).
+ * SPARQL-based constraint components derive their parameter names (and
+ * thus the pre-bound variable names) this way. Returns an empty string when
+ * the IRI does not end with an NCName.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const localName: (iri: NamedNode | string) => string;
+export { substitute as a, localName as i, display as n, variables as o, format as r, Message_d_exports as t };
+//# sourceMappingURL=Message-fIvTJSXM.d.mts.map

package/dist/Metadata-BbffwGDZ.mjs

@@ -0,0 +1,445 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, N as isBlankNode, O as defaultGraph, T as blankNode, Y as literal, c as NamedNode, d as Quad, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { D as mutate, E as match, I as subjects, c as empty$1, k as objects } from "./Dataset-BlmlcI7J.mjs";
+import { m as RDF } from "./Namespaces-Bz85vpjW.mjs";
+import * as Arr from "effect/Array";
+import { dual } from "effect/Function";
+import * as HashSet from "effect/HashSet";
+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 Order from "effect/Order";
+import * as Result from "effect/Result";
+// src/xmp/Metadata.ts
+/**
+* The XMP data model (ISO 16684-1 §6) on top of an RDF `Dataset`: one
+* resource described by properties whose values are simple values,
+* structures or arrays (`rdf:Bag`, `rdf:Seq`, `rdf:Alt`), each of which may
+* carry qualifiers.
+*
+* `fromDataset` reads the RDF an XMP packet parses to into this model and
+* `toDataset` writes it back. Values are immutable; `set` and `remove`
+* return a new `Metadata`. Properties, fields and qualifiers are
+* `[iri, value]` entries. Their order carries no meaning in XMP, so
+* `fromDataset` sorts them by IRI and the serializer writes them in entry
+* order, making output deterministic.
+*
+* @since 0.1.0
+*/
+var Metadata_exports = /* @__PURE__ */ __exportAll({
+	X_DEFAULT: () => X_DEFAULT,
+	XmpModelError: () => XmpModelError,
+	array: () => array,
+	bag: () => bag,
+	empty: () => empty,
+	fromDataset: () => fromDataset,
+	fromDatasetResult: () => fromDatasetResult,
+	get: () => get,
+	getItems: () => getItems,
+	getLocalized: () => getLocalized,
+	getText: () => getText,
+	isArray: () => isArray,
+	isSimple: () => isSimple,
+	isStruct: () => isStruct,
+	itemsOf: () => itemsOf,
+	languageAlternative: () => languageAlternative,
+	localizedOf: () => localizedOf,
+	lookup: () => lookup,
+	make: () => make,
+	remove: () => remove,
+	seq: () => seq,
+	set: () => set,
+	setLocalized: () => setLocalized,
+	struct: () => struct,
+	text: () => text,
+	textOf: () => textOf,
+	toDataset: () => toDataset,
+	uri: () => uri,
+	withQualifiers: () => withQualifiers
+});
+const RDF_VALUE = `${RDF}value`;
+const RDF_TYPE = `${RDF}type`;
+const MEMBER_RE = /^http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#_([1-9][0-9]*)$/;
+/**
+* The `xml:lang` value of the default item of a language alternative.
+*
+* @since 0.1.0
+* @category constants
+*/
+const X_DEFAULT = "x-default";
+/**
+* RDF that does not have the shape of the XMP data model: a cycle, a triple
+* term, an array with non-member properties or a property given twice.
+*
+* @since 0.1.0
+* @category errors
+*/
+var XmpModelError = class extends Schema.TaggedError()("XmpModelError", { message: Schema.String }) {};
+/**
+* Whether a value is a simple value.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isSimple = (value) => Predicate.isTagged(value, "Simple");
+/**
+* Whether a value is a structure.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isStruct = (value) => Predicate.isTagged(value, "Struct");
+/**
+* Whether a value is an array.
+*
+* @since 0.1.0
+* @category guards
+*/
+const isArray = (value) => Predicate.isTagged(value, "Array");
+/**
+* The value of the entry with the given IRI.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const lookup = (entries, iri) => Option.map(Arr.findFirst(entries, ([key]) => key === iri), ([, value]) => value);
+/** Replaces the entry with the same IRI in place, or appends it. */
+const upsert = (entries, entry) => Arr.some(entries, ([key]) => key === entry[0]) ? Arr.map(entries, (e) => e[0] === entry[0] ? entry : e) : [...entries, entry];
+const entriesOf = (entries) => Arr.reduce(entries, noEntries, upsert);
+const noEntries = [];
+/**
+* Metadata with no properties, about the containing file (`rdf:about=""`).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const empty = {
+	about: "",
+	properties: noEntries
+};
+/**
+* Builds metadata from `[iri, value]` entries (a later entry replaces an
+* earlier one with the same IRI).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (properties, about = "") => ({
+	about,
+	properties: entriesOf(properties)
+});
+/**
+* A text value, optionally with an `xml:lang` qualifier.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const text = (value, language) => ({
+	_tag: "Simple",
+	value,
+	isUri: false,
+	language: Option.fromNullishOr(language),
+	qualifiers: noEntries
+});
+/**
+* A URI value, written with `rdf:resource`.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const uri = (value) => ({
+	_tag: "Simple",
+	value,
+	isUri: true,
+	language: Option.none(),
+	qualifiers: noEntries
+});
+/**
+* A structure from `[iri, value]` field entries.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const struct = (fields) => ({
+	_tag: "Struct",
+	fields: entriesOf(fields),
+	qualifiers: noEntries
+});
+/**
+* An array of the given form.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const array = (form, items) => ({
+	_tag: "Array",
+	form,
+	items: Arr.fromIterable(items),
+	qualifiers: noEntries
+});
+/**
+* An unordered array (`rdf:Bag`) of text values.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const bag = (items) => array("Bag", Arr.map(Arr.fromIterable(items), (item) => text(item)));
+/**
+* An ordered array (`rdf:Seq`) of text values.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const seq = (items) => array("Seq", Arr.map(Arr.fromIterable(items), (item) => text(item)));
+const isDefaultLanguage = ([language]) => language === X_DEFAULT;
+/**
+* A language alternative: an `rdf:Alt` of text values each qualified by
+* `xml:lang`, from `[language, text]` pairs. An `x-default` entry is moved
+* first, as ISO 16684-1 requires.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const languageAlternative = (entries) => {
+	const all = Arr.fromIterable(entries);
+	return array("Alt", Arr.map([...Arr.filter(all, isDefaultLanguage), ...Arr.filter(all, (entry) => !isDefaultLanguage(entry))], ([language, value]) => text(value, language)));
+};
+/**
+* Returns the value with the given qualifiers added (replacing qualifiers
+* of the same IRI).
+*
+* @since 0.1.0
+* @category combinators
+*/
+const withQualifiers = dual(2, (self, qualifiers) => ({
+	...self,
+	qualifiers: Arr.reduce(qualifiers, self.qualifiers, upsert)
+}));
+/**
+* The value of a top-level property.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const get = dual(2, (self, iri) => lookup(self.properties, iri));
+/**
+* Sets a top-level property, keeping its position if it was already set.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const set = dual(3, (self, iri, value) => ({
+	about: self.about,
+	properties: upsert(self.properties, [iri, value])
+}));
+/**
+* Removes a top-level property.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const remove = dual(2, (self, iri) => ({
+	about: self.about,
+	properties: Arr.filter(self.properties, ([key]) => key !== iri)
+}));
+const asSimple = Option.liftPredicate(isSimple);
+const asArray = Option.liftPredicate(isArray);
+/**
+* The string of a simple (text or URI) value.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const textOf = (value) => Option.map(asSimple(value), (simple) => simple.value);
+/**
+* The strings of an array's simple items, in order; items that are not
+* simple values are skipped.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const itemsOf = (value) => Option.map(asArray(value), (arr) => Arr.getSomes(Arr.map(arr.items, textOf)));
+const hasLanguage = (language) => (item) => Option.exists(item.language, (l) => l.toLowerCase() === language.toLowerCase());
+/**
+* Looks up a language alternative the way ISO 16684-1 §8.2.2.4 describes:
+* the item whose `xml:lang` matches `language` (case-insensitively), else
+* the `x-default` item, else the first item. A simple value is its own
+* only alternative.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const localizedOf = (value, language = X_DEFAULT) => {
+	if (isSimple(value)) return Option.some(value.value);
+	if (!isArray(value)) return Option.none();
+	const items = Arr.getSomes(Arr.map(value.items, asSimple));
+	return Option.map(Option.firstSomeOf([
+		Arr.findFirst(items, hasLanguage(language)),
+		Arr.findFirst(items, hasLanguage(X_DEFAULT)),
+		Arr.head(items)
+	]), (item) => item.value);
+};
+/**
+* The string of a simple top-level property.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const getText = dual(2, (self, iri) => Option.flatMap(get(self, iri), textOf));
+/**
+* The strings of an array-valued top-level property.
+*
+* @since 0.1.0
+* @category accessors
+*/
+const getItems = dual(2, (self, iri) => Option.flatMap(get(self, iri), itemsOf));
+/**
+* A language-alternative top-level property in the given language (see
+* `localizedOf`).
+*
+* @since 0.1.0
+* @category accessors
+*/
+const getLocalized = (self, iri, language = X_DEFAULT) => Option.flatMap(get(self, iri), (value) => localizedOf(value, language));
+/**
+* Sets one language of a language-alternative top-level property, keeping
+* its other languages. Setting `x-default` puts that item first.
+*
+* @since 0.1.0
+* @category combinators
+*/
+const setLocalized = (self, iri, value, language = X_DEFAULT) => {
+	const existing = Option.match(Option.flatMap(get(self, iri), asArray), {
+		onNone: () => [],
+		onSome: (alt) => Arr.getSomes(Arr.map(alt.items, asSimple))
+	});
+	const kept = Arr.map(Arr.filter(existing, (item) => !hasLanguage(language)(item)), (item) => [Option.getOrElse(item.language, () => X_DEFAULT), item.value]);
+	return set(self, iri, languageAlternative([...kept, [language, value]]));
+};
+const memberIndex = (iri) => Option.map(Option.fromNullishOr(MEMBER_RE.exec(iri)), (m) => Number(m[1]));
+const ARRAY_FORMS = [
+	"Bag",
+	"Seq",
+	"Alt"
+];
+const arrayForm = (type) => isNamedNode(type) ? Arr.findFirst(ARRAY_FORMS, (form) => type.value === `${RDF}${form}`) : Option.none();
+const byMember = Order.mapInput(Order.Number, (entry) => entry[0]);
+const byPredicate = Order.mapInput(Order.String, (q) => q.predicate.value);
+const isRdfValueQuad = (q) => q.predicate.value === RDF_VALUE;
+var ModelReader = class {
+	dataset;
+	constructor(dataset) {
+		this.dataset = dataset;
+	}
+	fail(message) {
+		throw new XmpModelError({ message });
+	}
+	properties(subject) {
+		return match(this.dataset, { subject });
+	}
+	/** Reads entries from quads, rejecting a property given twice. */
+	entries(quads, visiting) {
+		const keys = Arr.map(quads, (q) => q.predicate.value);
+		Option.map(Arr.findFirst(keys, (key, i) => keys.indexOf(key) !== i), (key) => this.fail(`Property <${key}> is given more than once`));
+		return Arr.map(Arr.sort(quads, byPredicate), (q) => [q.predicate.value, this.value(q.object, visiting)]);
+	}
+	value(object, visiting) {
+		if (isLiteral(object)) return text(object.value, object.language === "" ? void 0 : object.language);
+		if (isNamedNode(object)) return uri(object.value);
+		if (isTriple(object)) return this.fail("XMP values cannot be triple terms");
+		if (HashSet.has(visiting, object.key)) return this.fail(`Blank node ${object.key} contains itself`);
+		return this.node(object, HashSet.add(visiting, object.key));
+	}
+	node(node, visiting) {
+		const quads = this.properties(node);
+		const value = Arr.findFirst(quads, isRdfValueQuad);
+		if (Option.isSome(value)) {
+			const others = Arr.filter(quads, (q) => !isRdfValueQuad(q));
+			return withQualifiers(this.value(value.value.object, visiting), this.entries(others, visiting));
+		}
+		const form = Option.flatMap(Arr.findFirst(quads, (q) => q.predicate.value === RDF_TYPE), (q) => arrayForm(q.object));
+		if (Option.isNone(form)) return struct(this.entries(quads, visiting));
+		const members = Arr.filterMap(quads, (q) => Option.match(memberIndex(q.predicate.value), {
+			onNone: () => q.predicate.value === RDF_TYPE ? Result.failVoid : this.fail(`Array ${node.key} has the non-member property <${q.predicate.value}>`),
+			onSome: (i) => Result.succeed([i, q])
+		}));
+		return array(form.value, Arr.map(Arr.sort(members, byMember), ([, q]) => this.value(q.object, visiting)));
+	}
+	/**
+	* Every top-level description: a subject that is an IRI or a blank node no
+	* other triple refers to. ISO 16684-1 §7.4 requires all of them to describe
+	* the same resource; readers accept differing or absent `rdf:about` values
+	* and merge them.
+	*/
+	metadata() {
+		const referenced = HashSet.fromIterable(Arr.map(Arr.filter(objects(this.dataset), isBlankNode), (o) => o.key));
+		const roots = Arr.filter(subjects(this.dataset), (s) => {
+			if (isTriple(s)) return this.fail("XMP descriptions cannot be about triple terms");
+			return isNamedNode(s) || !HashSet.has(referenced, s.key);
+		});
+		const about = Option.getOrElse(Arr.findFirst(roots, (s) => isNamedNode(s) && s.value !== "" ? Option.some(s.value) : Option.none()), () => "");
+		return make(this.entries(Arr.flatMap(roots, (s) => this.properties(s)), HashSet.empty()), about);
+	}
+};
+/**
+* Reads the XMP data model from the RDF of an XMP packet, returning a
+* `Result`. Typed literals keep only their lexical form (XMP has no
+* datatypes); named graphs are ignored.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromDatasetResult = (dataset) => Result.try({
+	try: () => new ModelReader(dataset).metadata(),
+	catch: (e) => {
+		if (e instanceof XmpModelError) return e;
+		throw e;
+	}
+});
+/**
+* Reads the XMP data model from the RDF of an XMP packet.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromDataset = (dataset) => Effect.suspend(() => Effect.fromResult(fromDatasetResult(dataset)));
+const rdf = (local) => new NamedNode(`${RDF}${local}`);
+const simpleTerm = (value) => value.isUri ? new NamedNode(value.value) : literal(value.value, Option.getOrUndefined(value.language));
+/**
+* The RDF of the XMP data model: the properties of one `rdf:about` subject,
+* structures and arrays as blank nodes, and qualified values in the
+* `rdf:value` form.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toDataset = (self) => mutate(empty$1, (builder) => {
+	const emit = (s, p, o) => {
+		builder.add(new Quad(s, new NamedNode(p), o, defaultGraph));
+	};
+	const emitAll = (s, entries) => {
+		entries.forEach(([p, v]) => emit(s, p, term(v)));
+	};
+	const bare = (value) => {
+		if (isSimple(value)) return simpleTerm(value);
+		const node = blankNode();
+		if (isStruct(value)) emitAll(node, value.fields);
+		else {
+			emit(node, RDF_TYPE, rdf(value.form));
+			value.items.forEach((item, i) => emit(node, `${RDF}_${i + 1}`, term(item)));
+		}
+		return node;
+	};
+	const term = (value) => {
+		if (!Arr.isReadonlyArrayNonEmpty(value.qualifiers)) return bare(value);
+		const node = blankNode();
+		emit(node, RDF_VALUE, bare(value));
+		emitAll(node, value.qualifiers);
+		return node;
+	};
+	emitAll(new NamedNode(self.about), self.properties);
+});
+export { withQualifiers as A, set as C, textOf as D, text as E, toDataset as O, seq as S, struct as T, languageAlternative as _, bag as a, make as b, fromDatasetResult as c, getLocalized as d, getText as f, itemsOf as g, isStruct as h, array as i, uri as k, get as l, isSimple as m, X_DEFAULT as n, empty as o, isArray as p, XmpModelError as r, fromDataset as s, Metadata_exports as t, getItems as u, localizedOf as v, setLocalized as w, remove as x, lookup as y };
+
+//# sourceMappingURL=Metadata-BbffwGDZ.mjs.map

package/dist/Metadata-BbffwGDZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metadata-BbffwGDZ.mjs","names":["Term.isNamedNode","Dataset.match","Term.isLiteral","Term.isTriple","Dataset.objects","Term.isBlankNode","Dataset.subjects","Term.NamedNode","Term.literal","Dataset.mutate","Dataset.empty","Term.Quad","Term.defaultGraph","Term.blankNode"],"sources":["../src/xmp/Metadata.ts"],"sourcesContent":["/**\n * The XMP data model (ISO 16684-1 §6) on top of an RDF `Dataset`: one\n * resource described by properties whose values are simple values,\n * structures or arrays (`rdf:Bag`, `rdf:Seq`, `rdf:Alt`), each of which may\n * carry qualifiers.\n *\n * `fromDataset` reads the RDF an XMP packet parses to into this model and\n * `toDataset` writes it back. Values are immutable; `set` and `remove`\n * return a new `Metadata`. Properties, fields and qualifiers are\n * `[iri, value]` entries. Their order carries no meaning in XMP, so\n * `fromDataset` sorts them by IRI and the serializer writes them in entry\n * order, making output deterministic.\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Effect from 'effect/Effect';\nimport { dual } from 'effect/Function';\nimport * as HashSet from 'effect/HashSet';\nimport * as Option from 'effect/Option';\nimport * as Order from 'effect/Order';\nimport * as Predicate from 'effect/Predicate';\nimport * as Result from 'effect/Result';\nimport * as Schema from 'effect/Schema';\nimport * as Dataset from '../Dataset.ts';\nimport * as Term from '../Term.ts';\nimport { RDF } from './Namespaces.ts';\n\nconst RDF_VALUE = `${RDF}value`;\nconst RDF_TYPE = `${RDF}type`;\nconst MEMBER_RE = /^http:\\/\\/www\\.w3\\.org\\/1999\\/02\\/22-rdf-syntax-ns#_([1-9][0-9]*)$/;\n\n/**\n * The `xml:lang` value of the default item of a language alternative.\n *\n * @since 0.1.0\n * @category constants\n */\nexport const X_DEFAULT = 'x-default';\n\n/**\n * A named value: a property, a structure field or a qualifier, keyed by its\n * full IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Entry = readonly [iri: string, value: Value];\n\n/**\n * Named values, each IRI at most once.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Entries = ReadonlyArray<Entry>;\n\n/**\n * A simple value: a text string, or a URI (written with `rdf:resource`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Simple {\n  readonly _tag: 'Simple';\n  readonly value: string;\n  /** Whether the value is a URI rather than text. */\n  readonly isUri: boolean;\n  /** The `xml:lang` qualifier of a text value. */\n  readonly language: Option.Option<string>;\n  /** The other qualifiers (`xml:lang` is `language`). */\n  readonly qualifiers: Entries;\n}\n\n/**\n * A structure: named fields, each keyed by its full IRI.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Struct {\n  readonly _tag: 'Struct';\n  readonly fields: Entries;\n  readonly qualifiers: Entries;\n}\n\n/**\n * The form of an array: unordered (`Bag`), ordered (`Seq`) or alternatives\n * (`Alt`, of which the first is the default).\n *\n * @since 0.1.0\n * @category models\n */\nexport type ArrayForm = 'Bag' | 'Seq' | 'Alt';\n\n/**\n * An array value (`rdf:Bag`, `rdf:Seq` or `rdf:Alt`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface ArrayValue {\n  readonly _tag: 'Array';\n  readonly form: ArrayForm;\n  readonly items: ReadonlyArray<Value>;\n  readonly qualifiers: Entries;\n}\n\n/**\n * An XMP property or field value.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Value = Simple | Struct | ArrayValue;\n\n/**\n * The metadata of one resource: the `rdf:about` value of its descriptions\n * (usually `\"\"`, the containing file) and its top-level properties.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Metadata {\n  readonly about: string;\n  readonly properties: Entries;\n}\n\n/**\n * RDF that does not have the shape of the XMP data model: a cycle, a triple\n * term, an array with non-member properties or a property given twice.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class XmpModelError extends Schema.TaggedError<XmpModelError>()('XmpModelError', {\n  message: Schema.String,\n}) {}\n\n// -----------------------------------------------------------------------------\n// Guards and entries\n// -----------------------------------------------------------------------------\n\n/**\n * Whether a value is a simple value.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isSimple = (value: Value): value is Simple => Predicate.isTagged(value, 'Simple');\n\n/**\n * Whether a value is a structure.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isStruct = (value: Value): value is Struct => Predicate.isTagged(value, 'Struct');\n\n/**\n * Whether a value is an array.\n *\n * @since 0.1.0\n * @category guards\n */\nexport const isArray = (value: Value): value is ArrayValue => Predicate.isTagged(value, 'Array');\n\n/**\n * The value of the entry with the given IRI.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const lookup = (entries: Entries, iri: string): Option.Option<Value> =>\n  Option.map(\n    Arr.findFirst(entries, ([key]) => key === iri),\n    ([, value]) => value,\n  );\n\n/** Replaces the entry with the same IRI in place, or appends it. */\nconst upsert = (entries: Entries, entry: Entry): Entries =>\n  Arr.some(entries, ([key]) => key === entry[0])\n    ? Arr.map(entries, (e) => (e[0] === entry[0] ? entry : e))\n    : [...entries, entry];\n\nconst entriesOf = (entries: Iterable<Entry>): Entries => Arr.reduce(entries, noEntries, upsert);\n\nconst noEntries: Entries = [];\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * Metadata with no properties, about the containing file (`rdf:about=\"\"`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const empty: Metadata = { about: '', properties: noEntries };\n\n/**\n * Builds metadata from `[iri, value]` entries (a later entry replaces an\n * earlier one with the same IRI).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = (properties: Iterable<Entry>, about: string = ''): Metadata => ({\n  about,\n  properties: entriesOf(properties),\n});\n\n/**\n * A text value, optionally with an `xml:lang` qualifier.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const text = (value: string, language?: string): Simple => ({\n  _tag: 'Simple',\n  value,\n  isUri: false,\n  language: Option.fromNullishOr(language),\n  qualifiers: noEntries,\n});\n\n/**\n * A URI value, written with `rdf:resource`.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const uri = (value: string): Simple => ({\n  _tag: 'Simple',\n  value,\n  isUri: true,\n  language: Option.none(),\n  qualifiers: noEntries,\n});\n\n/**\n * A structure from `[iri, value]` field entries.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const struct = (fields: Iterable<Entry>): Struct => ({\n  _tag: 'Struct',\n  fields: entriesOf(fields),\n  qualifiers: noEntries,\n});\n\n/**\n * An array of the given form.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const array = (form: ArrayForm, items: Iterable<Value>): ArrayValue => ({\n  _tag: 'Array',\n  form,\n  items: Arr.fromIterable(items),\n  qualifiers: noEntries,\n});\n\n/**\n * An unordered array (`rdf:Bag`) of text values.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const bag = (items: Iterable<string>): ArrayValue =>\n  array(\n    'Bag',\n    Arr.map(Arr.fromIterable(items), (item) => text(item)),\n  );\n\n/**\n * An ordered array (`rdf:Seq`) of text values.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const seq = (items: Iterable<string>): ArrayValue =>\n  array(\n    'Seq',\n    Arr.map(Arr.fromIterable(items), (item) => text(item)),\n  );\n\nconst isDefaultLanguage = ([language]: readonly [string, string]) => language === X_DEFAULT;\n\n/**\n * A language alternative: an `rdf:Alt` of text values each qualified by\n * `xml:lang`, from `[language, text]` pairs. An `x-default` entry is moved\n * first, as ISO 16684-1 requires.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const languageAlternative = (entries: Iterable<readonly [string, string]>): ArrayValue => {\n  const all = Arr.fromIterable(entries);\n  return array(\n    'Alt',\n    Arr.map(\n      [\n        ...Arr.filter(all, isDefaultLanguage),\n        ...Arr.filter(all, (entry) => !isDefaultLanguage(entry)),\n      ],\n      ([language, value]) => text(value, language),\n    ),\n  );\n};\n\n/**\n * Returns the value with the given qualifiers added (replacing qualifiers\n * of the same IRI).\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const withQualifiers: {\n  (qualifiers: Iterable<Entry>): <V extends Value>(self: V) => V;\n  <V extends Value>(self: V, qualifiers: Iterable<Entry>): V;\n} = dual(2, <V extends Value>(self: V, qualifiers: Iterable<Entry>): V => ({\n  ...self,\n  qualifiers: Arr.reduce(qualifiers, self.qualifiers, upsert),\n}));\n\n// -----------------------------------------------------------------------------\n// Access\n// -----------------------------------------------------------------------------\n\n/**\n * The value of a top-level property.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const get: {\n  (iri: string): (self: Metadata) => Option.Option<Value>;\n  (self: Metadata, iri: string): Option.Option<Value>;\n} = dual(2, (self: Metadata, iri: string): Option.Option<Value> => lookup(self.properties, iri));\n\n/**\n * Sets a top-level property, keeping its position if it was already set.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const set: {\n  (iri: string, value: Value): (self: Metadata) => Metadata;\n  (self: Metadata, iri: string, value: Value): Metadata;\n} = dual(3, (self: Metadata, iri: string, value: Value): Metadata => ({\n  about: self.about,\n  properties: upsert(self.properties, [iri, value]),\n}));\n\n/**\n * Removes a top-level property.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const remove: {\n  (iri: string): (self: Metadata) => Metadata;\n  (self: Metadata, iri: string): Metadata;\n} = dual(2, (self: Metadata, iri: string): Metadata => ({\n  about: self.about,\n  properties: Arr.filter(self.properties, ([key]) => key !== iri),\n}));\n\nconst asSimple = Option.liftPredicate(isSimple);\n\nconst asArray = Option.liftPredicate(isArray);\n\n/**\n * The string of a simple (text or URI) value.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const textOf = (value: Value): Option.Option<string> =>\n  Option.map(asSimple(value), (simple) => simple.value);\n\n/**\n * The strings of an array's simple items, in order; items that are not\n * simple values are skipped.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const itemsOf = (value: Value): Option.Option<ReadonlyArray<string>> =>\n  Option.map(asArray(value), (arr) => Arr.getSomes(Arr.map(arr.items, textOf)));\n\nconst hasLanguage = (language: string) => (item: Simple) =>\n  Option.exists(item.language, (l) => l.toLowerCase() === language.toLowerCase());\n\n/**\n * Looks up a language alternative the way ISO 16684-1 §8.2.2.4 describes:\n * the item whose `xml:lang` matches `language` (case-insensitively), else\n * the `x-default` item, else the first item. A simple value is its own\n * only alternative.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const localizedOf = (value: Value, language: string = X_DEFAULT): Option.Option<string> => {\n  if (isSimple(value)) return Option.some(value.value);\n  if (!isArray(value)) return Option.none();\n  const items = Arr.getSomes(Arr.map(value.items, asSimple));\n  return Option.map(\n    Option.firstSomeOf([\n      Arr.findFirst(items, hasLanguage(language)),\n      Arr.findFirst(items, hasLanguage(X_DEFAULT)),\n      Arr.head(items),\n    ]),\n    (item) => item.value,\n  );\n};\n\n/**\n * The string of a simple top-level property.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const getText: {\n  (iri: string): (self: Metadata) => Option.Option<string>;\n  (self: Metadata, iri: string): Option.Option<string>;\n} = dual(2, (self: Metadata, iri: string): Option.Option<string> =>\n  Option.flatMap(get(self, iri), textOf),\n);\n\n/**\n * The strings of an array-valued top-level property.\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const getItems: {\n  (iri: string): (self: Metadata) => Option.Option<ReadonlyArray<string>>;\n  (self: Metadata, iri: string): Option.Option<ReadonlyArray<string>>;\n} = dual(2, (self: Metadata, iri: string): Option.Option<ReadonlyArray<string>> =>\n  Option.flatMap(get(self, iri), itemsOf),\n);\n\n/**\n * A language-alternative top-level property in the given language (see\n * `localizedOf`).\n *\n * @since 0.1.0\n * @category accessors\n */\nexport const getLocalized = (\n  self: Metadata,\n  iri: string,\n  language: string = X_DEFAULT,\n): Option.Option<string> => Option.flatMap(get(self, iri), (value) => localizedOf(value, language));\n\n/**\n * Sets one language of a language-alternative top-level property, keeping\n * its other languages. Setting `x-default` puts that item first.\n *\n * @since 0.1.0\n * @category combinators\n */\nexport const setLocalized = (\n  self: Metadata,\n  iri: string,\n  value: string,\n  language: string = X_DEFAULT,\n): Metadata => {\n  const existing = Option.match(Option.flatMap(get(self, iri), asArray), {\n    onNone: () => [],\n    onSome: (alt) => Arr.getSomes(Arr.map(alt.items, asSimple)),\n  });\n  const kept = Arr.map(\n    Arr.filter(existing, (item) => !hasLanguage(language)(item)),\n    (item) => [Option.getOrElse(item.language, () => X_DEFAULT), item.value] as const,\n  );\n  return set(self, iri, languageAlternative([...kept, [language, value]]));\n};\n\n// -----------------------------------------------------------------------------\n// RDF ⇄ model\n// -----------------------------------------------------------------------------\n\nconst memberIndex = (iri: string): Option.Option<number> =>\n  Option.map(Option.fromNullishOr(MEMBER_RE.exec(iri)), (m) => Number(m[1]));\n\nconst ARRAY_FORMS: ReadonlyArray<ArrayForm> = ['Bag', 'Seq', 'Alt'];\n\nconst arrayForm = (type: Term.Object): Option.Option<ArrayForm> =>\n  Term.isNamedNode(type)\n    ? Arr.findFirst(ARRAY_FORMS, (form) => type.value === `${RDF}${form}`)\n    : Option.none();\n\nconst byMember = Order.mapInput(Order.Number, (entry: readonly [number, Term.Quad]) => entry[0]);\n\nconst byPredicate = Order.mapInput(Order.String, (q: Term.Quad) => q.predicate.value);\n\ntype Visiting = HashSet.HashSet<string>;\n\nconst isRdfValueQuad = (q: Term.Quad) => q.predicate.value === RDF_VALUE;\n\nclass ModelReader {\n  readonly dataset: Dataset.Dataset;\n  constructor(dataset: Dataset.Dataset) {\n    this.dataset = dataset;\n  }\n\n  fail(message: string): never {\n    throw new XmpModelError({ message });\n  }\n\n  properties(subject: Term.Subject): ReadonlyArray<Term.Quad> {\n    return Dataset.match(this.dataset, { subject });\n  }\n\n  /** Reads entries from quads, rejecting a property given twice. */\n  entries(quads: ReadonlyArray<Term.Quad>, visiting: Visiting): Entries {\n    const keys = Arr.map(quads, (q) => q.predicate.value);\n    Option.map(\n      Arr.findFirst(keys, (key, i) => keys.indexOf(key) !== i),\n      (key) => this.fail(`Property <${key}> is given more than once`),\n    );\n    return Arr.map(\n      Arr.sort(quads, byPredicate),\n      (q) => [q.predicate.value, this.value(q.object, visiting)] as const,\n    );\n  }\n\n  value(object: Term.Object, visiting: Visiting): Value {\n    if (Term.isLiteral(object)) {\n      return text(object.value, object.language === '' ? undefined : object.language);\n    }\n    if (Term.isNamedNode(object)) return uri(object.value);\n    if (Term.isTriple(object)) return this.fail('XMP values cannot be triple terms');\n    if (HashSet.has(visiting, object.key)) {\n      return this.fail(`Blank node ${object.key} contains itself`);\n    }\n    return this.node(object, HashSet.add(visiting, object.key));\n  }\n\n  node(node: Term.BlankNode, visiting: Visiting): Value {\n    const quads = this.properties(node);\n    const value = Arr.findFirst(quads, isRdfValueQuad);\n    if (Option.isSome(value)) {\n      const others = Arr.filter(quads, (q) => !isRdfValueQuad(q));\n      return withQualifiers(\n        this.value(value.value.object, visiting),\n        this.entries(others, visiting),\n      );\n    }\n    const form = Option.flatMap(\n      Arr.findFirst(quads, (q) => q.predicate.value === RDF_TYPE),\n      (q) => arrayForm(q.object),\n    );\n    if (Option.isNone(form)) return struct(this.entries(quads, visiting));\n    const members = Arr.filterMap(quads, (q) =>\n      Option.match(memberIndex(q.predicate.value), {\n        onNone: () =>\n          q.predicate.value === RDF_TYPE\n            ? Result.failVoid\n            : this.fail(`Array ${node.key} has the non-member property <${q.predicate.value}>`),\n        onSome: (i) => Result.succeed([i, q] as const),\n      }),\n    );\n    return array(\n      form.value,\n      Arr.map(Arr.sort(members, byMember), ([, q]) => this.value(q.object, visiting)),\n    );\n  }\n\n  /**\n   * Every top-level description: a subject that is an IRI or a blank node no\n   * other triple refers to. ISO 16684-1 §7.4 requires all of them to describe\n   * the same resource; readers accept differing or absent `rdf:about` values\n   * and merge them.\n   */\n  metadata(): Metadata {\n    const referenced = HashSet.fromIterable(\n      Arr.map(Arr.filter(Dataset.objects(this.dataset), Term.isBlankNode), (o) => o.key),\n    );\n    const roots = Arr.filter(Dataset.subjects(this.dataset), (s) => {\n      if (Term.isTriple(s)) return this.fail('XMP descriptions cannot be about triple terms');\n      return Term.isNamedNode(s) || !HashSet.has(referenced, s.key);\n    });\n    const about = Option.getOrElse(\n      Arr.findFirst(roots, (s) =>\n        Term.isNamedNode(s) && s.value !== '' ? Option.some(s.value) : Option.none(),\n      ),\n      () => '',\n    );\n    return make(\n      this.entries(\n        Arr.flatMap(roots, (s) => this.properties(s)),\n        HashSet.empty(),\n      ),\n      about,\n    );\n  }\n}\n\n/**\n * Reads the XMP data model from the RDF of an XMP packet, returning a\n * `Result`. Typed literals keep only their lexical form (XMP has no\n * datatypes); named graphs are ignored.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromDatasetResult = (\n  dataset: Dataset.Dataset,\n): Result.Result<Metadata, XmpModelError> =>\n  Result.try({\n    try: () => new ModelReader(dataset).metadata(),\n    catch: (e) => {\n      if (e instanceof XmpModelError) return e;\n      throw e;\n    },\n  });\n\n/**\n * Reads the XMP data model from the RDF of an XMP packet.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromDataset = (dataset: Dataset.Dataset): Effect.Effect<Metadata, XmpModelError> =>\n  Effect.suspend(() => Effect.fromResult(fromDatasetResult(dataset)));\n\nconst rdf = (local: string) => new Term.NamedNode(`${RDF}${local}`);\n\nconst simpleTerm = (value: Simple): Term.Object =>\n  value.isUri\n    ? new Term.NamedNode(value.value)\n    : Term.literal(value.value, Option.getOrUndefined(value.language));\n\n/**\n * The RDF of the XMP data model: the properties of one `rdf:about` subject,\n * structures and arrays as blank nodes, and qualified values in the\n * `rdf:value` form.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toDataset = (self: Metadata): Dataset.Dataset =>\n  Dataset.mutate(Dataset.empty, (builder) => {\n    const emit = (s: Term.Subject, p: string, o: Term.Object) => {\n      builder.add(new Term.Quad(s, new Term.NamedNode(p), o, Term.defaultGraph));\n    };\n    const emitAll = (s: Term.Subject, entries: Entries) => {\n      entries.forEach(([p, v]) => emit(s, p, term(v)));\n    };\n    const bare = (value: Value): Term.Object => {\n      if (isSimple(value)) return simpleTerm(value);\n      const node = Term.blankNode();\n      if (isStruct(value)) {\n        emitAll(node, value.fields);\n      } else {\n        emit(node, RDF_TYPE, rdf(value.form));\n        value.items.forEach((item, i) => emit(node, `${RDF}_${i + 1}`, term(item)));\n      }\n      return node;\n    };\n    const term = (value: Value): Term.Object => {\n      if (!Arr.isReadonlyArrayNonEmpty(value.qualifiers)) return bare(value);\n      const node = Term.blankNode();\n      emit(node, RDF_VALUE, bare(value));\n      emitAll(node, value.qualifiers);\n      return node;\n    };\n    emitAll(new Term.NamedNode(self.about), self.properties);\n  });\n\n// -----------------------------------------------------------------------------\n// Typed accessors\n// -----------------------------------------------------------------------------\n\n/**\n * A typed setter of one property, data-first or data-last.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Setter<A> {\n  (value: A): (self: Metadata) => Metadata;\n  (self: Metadata, value: A): Metadata;\n}\n\n/**\n * A typed setter of one language of a language-alternative property\n * (`x-default` unless a language is given), data-first or data-last.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LocalizedSetter {\n  (value: string, language?: string): (self: Metadata) => Metadata;\n  (self: Metadata, value: string, language?: string): Metadata;\n}\n"],"mappings":"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"}