@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/JsonLd-DOwS2FHg.mjs

@@ -0,0 +1,2836 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, N as isBlankNode, O as defaultGraph, P as isDefaultGraph, Q as quad, T as blankNode$1, X as mapTerms, Y as literal, Z as namedNode, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { m as fromIterable } from "./Dataset-BlmlcI7J.mjs";
+import { a as isValid, c as removeDotSegments, l as resolve } from "./Iri-Cr92gsQV.mjs";
+import { s as make } from "./PrefixMap-BHFPDLO-.mjs";
+import { C as withParseSpan, c as makeCodec, d as makeSerializer, l as makeFormat, n as RdfParseError, o as freshBlankNodePrefix, r as RdfSerializeError, u as makeParser, w as withSerializeSpan } from "./Serialization-DP9H5bYQ.mjs";
+import { f as none, m as parseJson, t as DocumentLoader } from "./DocumentLoader-D3lZREnB.mjs";
+import { a as make$1, i as isJsonLdError } from "./JsonLdError-C9J-BxfG.mjs";
+import * as Arr from "effect/Array";
+import * as Iterable from "effect/Iterable";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Order from "effect/Order";
+import * as Record from "effect/Record";
+import * as Result from "effect/Result";
+// src/jsonld/internal/iri.ts
+/** @internal */
+/**
+* Resolves `reference` against `base`; a `null` base (`"@base": null`, or no
+* document URL) leaves it unchanged.
+*
+* @internal
+*/
+const resolveIri = (reference, base) => base === null ? reference : resolve(reference, base);
+const PARTS = /^(?:([A-Za-z][A-Za-z0-9+.-]*):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/s;
+/**
+* Turns an absolute IRI into a reference relative to `base`, when possible.
+*
+* @internal
+*/
+const removeBase = (base, iri) => {
+	if (base === null) return iri;
+	const b = PARTS.exec(base);
+	if (b === null) return iri;
+	let root = "";
+	if (base !== "") {
+		if (b[1] === void 0) return iri;
+		root = `${b[1]}:${b[2] !== void 0 ? `//${b[2]}` : ""}`;
+	}
+	if (!iri.startsWith(root)) return iri;
+	const restStart = iri.charAt(root.length);
+	if (root !== "" && restStart !== "" && !"/?#".includes(restStart)) return iri;
+	const rel = PARTS.exec(iri.slice(root.length));
+	if (rel === null) return iri;
+	const baseSegments = removeDotSegments(b[3] ?? "").split("/");
+	const iriSegments = removeDotSegments(rel[3] ?? "").split("/");
+	const last = rel[5] !== void 0 || rel[4] !== void 0 ? 0 : 1;
+	const differs = baseSegments.findIndex((segment, i) => iriSegments.length - i <= last || segment !== iriSegments[i]);
+	const common = differs === -1 ? baseSegments.length : differs;
+	const baseRest = baseSegments.length - common;
+	let out = baseRest > 0 ? "../".repeat(baseRest - 1) : "";
+	out += iriSegments.slice(common).join("/");
+	if (rel[4] !== void 0) out += `?${rel[4]}`;
+	if (rel[5] !== void 0) out += `#${rel[5]}`;
+	if (out === "") out = "./";
+	if (/^[^/?#]*:/.test(out)) out = `./${out}`;
+	if (/^@[a-zA-Z]+$/.test(out)) out = `./${out}`;
+	return base === "" || resolveIri(out, base) === iri ? out : iri;
+};
+// src/jsonld/internal/util.ts
+/** @internal */
+const JsonText = Schema.fromJsonString(Schema.Unknown);
+const encodeJson = Schema.encodeUnknownResult(JsonText);
+/**
+* Serialises a JSON value (`JSON.stringify` semantics); a value with no JSON
+* form (`undefined`) renders as `String(value)`, as in a template literal.
+*
+* @internal
+*/
+const stringifyJson = (value) => Result.getOrElse(encodeJson(value), () => String(value));
+/** @internal */
+const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+/**
+* A membership test for a fixed set of strings: a lookup in a prototype-less
+* record, so that no `Object.prototype` member is a member.
+*
+* @internal
+*/
+const stringSet = (members) => {
+	const record = Object.create(null);
+	members.forEach((m) => {
+		record[m] = true;
+	});
+	return (s) => record[s] === true;
+};
+const isKeywordString = stringSet([
+	"@base",
+	"@container",
+	"@context",
+	"@default",
+	"@direction",
+	"@embed",
+	"@explicit",
+	"@graph",
+	"@id",
+	"@import",
+	"@included",
+	"@index",
+	"@json",
+	"@language",
+	"@list",
+	"@nest",
+	"@none",
+	"@omitDefault",
+	"@prefix",
+	"@preserve",
+	"@protected",
+	"@requireAll",
+	"@reverse",
+	"@set",
+	"@type",
+	"@value",
+	"@version",
+	"@vocab"
+]);
+/** @internal */
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+/** @internal */
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/** @internal */
+const RDF_TYPE = `${RDF}type`;
+/** @internal */
+const RDF_FIRST = `${RDF}first`;
+/** @internal */
+const RDF_REST = `${RDF}rest`;
+/** @internal */
+const RDF_NIL = `${RDF}nil`;
+/** @internal */
+const RDF_JSON = `${RDF}JSON`;
+/** @internal */
+const RDF_VALUE = `${RDF}value`;
+/** @internal */
+const RDF_LANGUAGE = `${RDF}language`;
+/** @internal */
+const RDF_DIRECTION = `${RDF}direction`;
+/** @internal */
+const RDF_LANG_STRING = `${RDF}langString`;
+/** @internal */
+const XSD_STRING = `${XSD}string`;
+/** @internal */
+const XSD_BOOLEAN = `${XSD}boolean`;
+/** @internal */
+const XSD_INTEGER = `${XSD}integer`;
+/** @internal */
+const XSD_DOUBLE = `${XSD}double`;
+/** @internal */
+const I18N = "https://www.w3.org/ns/i18n#";
+/**
+* Throws the `JsonLdError` with this code. Its type is declared on the
+* binding, so that a call statement narrows like a `throw`.
+*
+* @internal
+*/
+const fail = (code, message) => {
+	throw make$1(code, message);
+};
+/**
+* Runs `f`, handing a thrown `JsonLdError` to `onError` (which rethrows a
+* different one); any other thrown value propagates unchanged.
+*
+* @internal
+*/
+const mapJsonLdError = (f, onError) => Result.getOrElse(Result.try({
+	try: f,
+	catch: (e) => {
+		if (isJsonLdError(e)) return e;
+		throw e;
+	}
+}), onError);
+/** @internal */
+const GRAPH_PROPERTY = Option.some("@graph");
+/** @internal */
+const REVERSE_PROPERTY = Option.some("@reverse");
+/**
+* The active property is `keyword` (`@graph`, `@reverse`, …).
+*
+* @internal
+*/
+const isProperty = (activeProperty, keyword) => Option.isSome(activeProperty) && activeProperty.value === keyword;
+/**
+* At the top level, or directly under `@graph`: where free-floating values are dropped.
+*
+* @internal
+*/
+const isTopLevel = (activeProperty) => Option.isNone(activeProperty) || activeProperty.value === "@graph";
+/** @internal */
+const getOrInit = (o, k, init) => {
+	if (!hasOwn(o, k)) o[k] = init();
+	return o[k];
+};
+/** @internal */
+const isKeyword = (v) => Predicate.isString(v) && isKeywordString(v);
+const KEYWORD_FORM = /^@[a-zA-Z]+$/;
+const ABSOLUTE_IRI = /^[A-Za-z][A-Za-z0-9+.-]*:[^\s]*$/;
+/** @internal */
+const hasKeywordForm = (v) => KEYWORD_FORM.test(v);
+/** @internal */
+const isObject = (v) => Predicate.isObject(v);
+/** @internal */
+const isEmptyObject = (v) => isObject(v) && Arr.isReadonlyArrayEmpty(Record.keys(v));
+/** @internal */
+const isString$1 = (v) => Predicate.isString(v);
+/** @internal */
+const isScalar = (v) => Predicate.isString(v) || Predicate.isNumber(v) || Predicate.isBoolean(v);
+/** @internal */
+const asArray = (v) => Array.isArray(v) ? v : [v];
+/** @internal */
+const isBlankNodeId = (v) => Predicate.isString(v) && v.startsWith("_:");
+/** @internal */
+const isAbsoluteIri = (v) => ABSOLUTE_IRI.test(v);
+/** @internal */
+const isWellFormedIri = (v) => isValid(v);
+/** @internal */
+const isWellFormedLanguage = (v) => /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/.test(v);
+/** @internal */
+const isValueObject = (v) => isObject(v) && "@value" in v;
+/** @internal */
+const isListObject = (v) => isObject(v) && "@list" in v;
+/** @internal */
+const isGraphObject = (v) => {
+	if (!isObject(v) || !("@graph" in v)) return false;
+	return Record.keys(v).every((k) => k === "@graph" || k === "@id" || k === "@index" || k === "@context");
+};
+/** @internal */
+const isSimpleGraphObject = (v) => isGraphObject(v) && !("@id" in v);
+/** @internal */
+const deepEqual = (a, b) => {
+	if (a === b) return true;
+	if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((x, i) => deepEqual(x, b[i]));
+	if (isObject(a)) {
+		if (!isObject(b)) return false;
+		const ka = Record.keys(a);
+		return ka.length === Record.keys(b).length && ka.every((k) => hasOwn(b, k) && deepEqual(a[k], b[k]));
+	}
+	return false;
+};
+/** @internal */
+const compareStrings = Order.String;
+/**
+* Appends every item to `target` (one `push` per item: spreading a large
+* array into `push` can overflow the stack).
+*
+* @internal
+*/
+const pushAll = (target, items) => {
+	items.forEach((item) => target.push(item));
+};
+/**
+* Adds a value to an entry of a map. When `forceArray` is true the entry is
+* always an array.
+*
+* @internal
+*/
+const addValue = (object, key, value, forceArray) => {
+	if (Array.isArray(value)) {
+		if (Arr.isReadonlyArrayEmpty(value) && forceArray && !hasOwn(object, key)) object[key] = [];
+		value.forEach((v) => addValue(object, key, v, forceArray));
+		return;
+	}
+	if (!hasOwn(object, key)) object[key] = forceArray ? [value] : value;
+	else {
+		if (!Array.isArray(object[key])) object[key] = [object[key]];
+		object[key].push(value);
+	}
+};
+/** @internal */
+const addUnique = (array, value) => {
+	if (!array.some((v) => deepEqual(v, value))) array.push(value);
+};
+/**
+* Steps a state until `step` returns none, and returns the last state: a
+* loop as a function, for the scans that walk a structure of unknown length.
+*
+* @internal
+*/
+const loop = (initial, step) => {
+	let state = initial;
+	Arr.unfold(void 0, () => Option.map(step(state), (next) => {
+		state = next;
+		return [void 0, void 0];
+	}));
+	return state;
+};
+/** @internal */
+const clone = (v) => v === void 0 ? v : structuredClone(v);
+/**
+* The JSON Canonicalization Scheme (RFC 8785).
+*
+* @internal
+*/
+const canonicalJson = (v) => {
+	if (v === null || Predicate.isBoolean(v) || Predicate.isNumber(v) || Predicate.isString(v)) return stringifyJson(v);
+	if (Array.isArray(v)) return `[${v.map(canonicalJson).join(",")}]`;
+	return `{${Arr.sort(Record.keys(v), compareStrings).map((k) => `${stringifyJson(k)}:${canonicalJson(v[k])}`).join(",")}}`;
+};
+/**
+* A blank node identifier issuer.
+*
+* @internal
+*/
+var IdIssuer = class {
+	#counter = 0;
+	#map = MutableHashMap.empty();
+	prefix;
+	constructor(prefix = "_:b") {
+		this.prefix = prefix;
+	}
+	/** A fresh identifier, or the one already issued for `old`. */
+	issue(old) {
+		if (old === void 0) return this.#next();
+		return Option.getOrElse(MutableHashMap.get(this.#map, old), () => {
+			const id = this.#next();
+			MutableHashMap.set(this.#map, old, id);
+			return id;
+		});
+	}
+	has(old) {
+		return MutableHashMap.has(this.#map, old);
+	}
+	#next() {
+		return `${this.prefix}${this.#counter++}`;
+	}
+};
+// src/jsonld/internal/context.ts
+/**
+* Context processing and IRI expansion (JSON-LD 1.1 API §4.1, §4.2, §5.2).
+*
+* @internal
+*/
+/** @internal */
+var NeedDocument = class {
+	url;
+	constructor(url) {
+		this.url = url;
+	}
+};
+/** @internal */
+const initialContext = (base) => ({
+	base,
+	originalBase: base,
+	terms: MutableHashMap.empty()
+});
+/**
+* The definition of `term` in the active context.
+*
+* @internal
+*/
+const termOf = (active, term) => Option.fromUndefinedOr(active.terms.backing.get(term));
+/**
+* The definition of `term`, when it carries a scoped context.
+*
+* @internal
+*/
+const scopedTermOf = (active, term) => Option.filter(termOf(active, term), (def) => def.hasContext);
+const cloneContext = (ctx) => {
+	const out = {
+		base: ctx.base,
+		originalBase: ctx.originalBase,
+		terms: MutableHashMap.fromIterable(ctx.terms)
+	};
+	if (ctx.vocab !== void 0) out.vocab = ctx.vocab;
+	if (ctx.language !== void 0) out.language = ctx.language;
+	if (ctx.direction !== void 0) out.direction = ctx.direction;
+	if (ctx.previous !== void 0) out.previous = ctx.previous;
+	return out;
+};
+const MAX_REMOTE_CONTEXTS = 32;
+/** Loads a remote context document, failing with `loading remote context failed`. */
+const loadContextDocument = (env, url) => mapJsonLdError(() => env.load(url, "http://www.w3.org/ns/json-ld#context"), (e) => fail("loading remote context failed", `${url}: ${e.message}`));
+/**
+* Applies the type-scoped context of each term (in the given order) that
+* defines one, as expansion step 11 and compaction step 11 do.
+*
+* @internal
+*/
+const applyTypeScopedContexts = (env, active, typeScoped, terms) => terms.reduce((result, term) => Option.match(scopedTermOf(typeScoped, term), {
+	onNone: () => result,
+	onSome: (def) => processContext(env, result, def.context, def.baseUrl ?? null, [], false, false)
+}), active);
+/** Loads a remote context (once per run), failing with `invalid remote context`. */
+const remoteContext = (env, url) => Option.getOrElse(MutableHashMap.get(env.contextCache, url), () => {
+	const doc = loadContextDocument(env, url);
+	if (!isObject(doc.document) || !("@context" in doc.document)) fail("invalid remote context", url);
+	const loaded = {
+		context: doc.document["@context"],
+		documentUrl: doc.documentUrl
+	};
+	MutableHashMap.set(env.contextCache, url, loaded);
+	return loaded;
+});
+/**
+* Context Processing Algorithm.
+*
+* @internal
+*/
+const processContext = (env, active, localContext, baseUrl, remoteContexts = [], overrideProtected = false, propagate = true, validateScoped = true) => {
+	let result = cloneContext(active);
+	if (isObject(localContext) && "@propagate" in localContext) {
+		if (!Predicate.isBoolean(localContext["@propagate"])) fail("invalid @propagate value");
+		propagate = localContext["@propagate"];
+	}
+	if (!propagate && result.previous === void 0) result.previous = active;
+	(Array.isArray(localContext) ? localContext : [localContext]).forEach((context) => {
+		if (context === null) {
+			result = nullified(active, result, overrideProtected, propagate);
+			return;
+		}
+		if (isString$1(context)) {
+			const url = resolveIri(context, baseUrl);
+			if (!validateScoped && remoteContexts.includes(url)) return;
+			if (remoteContexts.length > MAX_REMOTE_CONTEXTS) fail("context overflow");
+			const loaded = remoteContext(env, url);
+			result = processContext(env, result, loaded.context, loaded.documentUrl, [...remoteContexts, url], overrideProtected, true, validateScoped);
+			return;
+		}
+		processLocalContext(env, result, context, baseUrl, remoteContexts, overrideProtected, validateScoped);
+	});
+	return result;
+};
+/** Context processing step 5.1: a `null` context resets the active context. */
+const nullified = (active, result, overrideProtected, propagate) => {
+	if (!overrideProtected && Iterable.some(MutableHashMap.values(result.terms), (def) => def.protected)) fail("invalid context nullification");
+	const reset = initialContext(active.originalBase);
+	if (!propagate) reset.previous = result;
+	return reset;
+};
+/** Steps 5.3 - 5.13: a context definition (an object) updates `result` in place. */
+const processLocalContext = (env, result, definition, baseUrl, remoteContexts, overrideProtected, validateScoped) => {
+	if (!isObject(definition)) fail("invalid local context");
+	checkVersion(env, definition);
+	const context = withImport(env, definition, baseUrl);
+	if ("@base" in context && Arr.isReadonlyArrayEmpty(remoteContexts)) setBase(result, context["@base"]);
+	if ("@vocab" in context) setVocab(env, result, context["@vocab"]);
+	setLanguageAndDirection(env, result, context);
+	checkFlags(env, context);
+	const state = {
+		defined: MutableHashMap.empty(),
+		baseUrl,
+		protected: context["@protected"] === true,
+		overrideProtected,
+		remoteContexts,
+		validateScoped
+	};
+	Record.keys(context).forEach((key) => {
+		if (!isContextKeyword(key)) createTermDefinition(env, result, context, key, state);
+	});
+};
+/** Step 5.5: `@version`. */
+const checkVersion = (env, context) => {
+	if (!("@version" in context)) return;
+	if (context["@version"] !== 1.1) fail("invalid @version value");
+	if (env.processingMode === "json-ld-1.0") fail("processing mode conflict");
+};
+/** Step 5.6: the context merged over the one its `@import` names. */
+const withImport = (env, context, baseUrl) => {
+	if (!("@import" in context)) return context;
+	if (env.processingMode === "json-ld-1.0") fail("invalid context entry");
+	const imp = context["@import"];
+	if (!isString$1(imp)) fail("invalid @import value");
+	const url = resolveIri(imp, baseUrl);
+	const doc = loadContextDocument(env, url);
+	if (!isObject(doc.document) || !isObject(doc.document["@context"])) fail("invalid remote context", url);
+	const importContext = doc.document["@context"];
+	if ("@import" in importContext) fail("invalid context entry");
+	return {
+		...importContext,
+		...context
+	};
+};
+/** Step 5.7: `@base`. */
+const setBase = (result, value) => {
+	if (value === null) result.base = null;
+	else if (!isString$1(value)) fail("invalid base IRI");
+	else if (isAbsoluteIri(value)) result.base = value;
+	else if (result.base !== null) result.base = resolveIri(value, result.base);
+	else fail("invalid base IRI");
+};
+/** Step 5.8: `@vocab`. */
+const setVocab = (env, result, value) => {
+	if (value === null) {
+		delete result.vocab;
+		return;
+	}
+	if (!isString$1(value)) fail("invalid vocab mapping");
+	if (env.processingMode === "json-ld-1.0" && !isAbsoluteIri(value) && !isBlankNodeId(value)) fail("invalid vocab mapping");
+	const expanded = expandIri(env, result, value, true, true);
+	if (expanded === null || isKeyword(expanded)) fail("invalid vocab mapping");
+	result.vocab = expanded;
+};
+/** Steps 5.9 and 5.10: `@language` and `@direction`. */
+const setLanguageAndDirection = (env, result, context) => {
+	if ("@language" in context) {
+		const value = context["@language"];
+		if (value === null) delete result.language;
+		else if (!isString$1(value)) fail("invalid default language");
+		else result.language = value;
+	}
+	if ("@direction" in context) {
+		if (env.processingMode === "json-ld-1.0") fail("invalid context entry");
+		const value = context["@direction"];
+		if (value === null) delete result.direction;
+		else if (value !== "ltr" && value !== "rtl") fail("invalid base direction");
+		else result.direction = value;
+	}
+};
+/** Step 5.11, and the `@protected` flag. */
+const checkFlags = (env, context) => {
+	if ("@propagate" in context) {
+		if (env.processingMode === "json-ld-1.0") fail("invalid context entry");
+		if (!Predicate.isBoolean(context["@propagate"])) fail("invalid @propagate value");
+	}
+	if ("@protected" in context && !Predicate.isBoolean(context["@protected"])) fail("invalid @protected value");
+};
+const isContextKeyword = stringSet([
+	"@base",
+	"@direction",
+	"@import",
+	"@language",
+	"@propagate",
+	"@protected",
+	"@version",
+	"@vocab"
+]);
+const isTermKey = stringSet([
+	"@id",
+	"@reverse",
+	"@container",
+	"@context",
+	"@direction",
+	"@index",
+	"@language",
+	"@nest",
+	"@prefix",
+	"@protected",
+	"@type"
+]);
+const GEN_DELIMS = /[:/?#[\]@]$/;
+const isContainerKeyword = stringSet([
+	"@graph",
+	"@id",
+	"@index",
+	"@language",
+	"@list",
+	"@set",
+	"@type"
+]);
+const validContainer = (env, value) => {
+	if (env.processingMode === "json-ld-1.0") return isString$1(value) && [
+		"@list",
+		"@set",
+		"@index",
+		"@language"
+	].includes(value);
+	const c = Array.isArray(value) ? value : [value];
+	if (Arr.isReadonlyArrayEmpty(c)) return false;
+	if (!c.every((x) => isString$1(x) && isContainerKeyword(x))) return false;
+	if (c.some((x, i) => c.indexOf(x) !== i)) return false;
+	if (c.includes("@list")) return c.length === 1;
+	if (c.includes("@graph")) {
+		if (c.includes("@id") && c.includes("@index")) return false;
+		return c.every((x) => x === "@graph" || x === "@id" || x === "@index" || x === "@set");
+	}
+	if (c.length === 1) return true;
+	return c.length === 2 && c.includes("@set");
+};
+/**
+* Create Term Definition algorithm.
+*
+* @internal
+*/
+const createTermDefinition = (env, active, local, term, state) => {
+	const { defined, baseUrl, overrideProtected, remoteContexts } = state;
+	const status = MutableHashMap.get(defined, term);
+	if (Option.isSome(status)) {
+		if (status.value) return;
+		fail("cyclic IRI mapping", term);
+	}
+	if (term === "") fail("invalid term definition", "empty term");
+	MutableHashMap.set(defined, term, false);
+	let value = local[term];
+	if (term === "@type" && env.processingMode !== "json-ld-1.0" && isObject(value)) {
+		const keys = Record.keys(value);
+		if (Arr.isReadonlyArrayEmpty(keys) || keys.some((k) => k !== "@container" && k !== "@protected") || "@container" in value && value["@container"] !== "@set") fail("keyword redefinition", term);
+	} else if (isKeyword(term)) fail("keyword redefinition", term);
+	else if (hasKeywordForm(term)) {
+		MutableHashMap.set(defined, term, true);
+		return;
+	}
+	const previous = termOf(active, term);
+	MutableHashMap.remove(active.terms, term);
+	let simpleTerm = false;
+	if (value === null) value = { "@id": null };
+	else if (isString$1(value)) {
+		value = { "@id": value };
+		simpleTerm = true;
+	} else if (!isObject(value)) fail("invalid term definition", term);
+	const def = {
+		iri: null,
+		reverse: false,
+		hasContext: false,
+		container: [],
+		prefix: false,
+		protected: state.protected,
+		hasColon: term.indexOf(":", 1) !== -1
+	};
+	if ("@protected" in value) {
+		if (env.processingMode === "json-ld-1.0") fail("invalid term definition");
+		if (!Predicate.isBoolean(value["@protected"])) fail("invalid @protected value");
+		def.protected = value["@protected"];
+	}
+	if ("@type" in value) {
+		const type = value["@type"];
+		if (!isString$1(type)) fail("invalid type mapping");
+		const expanded = expandIri(env, active, type, true, false, local, state);
+		if (expanded === "@json" || expanded === "@none") {
+			if (env.processingMode === "json-ld-1.0") fail("invalid type mapping");
+		} else if (expanded === null || expanded !== "@id" && expanded !== "@vocab" && !isAbsoluteIri(expanded) || isBlankNodeId(expanded)) fail("invalid type mapping", type);
+		def.type = expanded;
+	}
+	if ("@reverse" in value) {
+		if ("@id" in value || "@nest" in value) fail("invalid reverse property");
+		const rev = value["@reverse"];
+		if (!isString$1(rev)) fail("invalid IRI mapping");
+		if (hasKeywordForm(rev)) {
+			MutableHashMap.set(defined, term, true);
+			return;
+		}
+		const iri = expandIri(env, active, rev, true, false, local, state);
+		if (iri === null || !isAbsoluteIri(iri) && !isBlankNodeId(iri)) fail("invalid IRI mapping");
+		def.iri = iri;
+		if ("@container" in value) {
+			const c = value["@container"];
+			if (c !== null && c !== "@set" && c !== "@index") fail("invalid reverse property");
+			if (c !== null) def.container = [c];
+		}
+		def.reverse = true;
+	} else if ("@id" in value && value["@id"] !== term) {
+		const id = value["@id"];
+		if (id === null) def.iri = null;
+		else {
+			if (!isString$1(id)) fail("invalid IRI mapping");
+			if (!isKeyword(id) && hasKeywordForm(id)) {
+				MutableHashMap.set(defined, term, true);
+				return;
+			}
+			const iri = expandIri(env, active, id, true, false, local, state);
+			if (iri === null || !isKeyword(iri) && !isAbsoluteIri(iri) && !isBlankNodeId(iri)) fail("invalid IRI mapping", id);
+			if (iri === "@context") fail("invalid keyword alias");
+			def.iri = iri;
+			if (term.slice(1, -1).includes(":") || term.includes("/")) {
+				MutableHashMap.set(defined, term, true);
+				if (expandIri(env, active, term, true, false, local, state) !== iri) fail("invalid IRI mapping", term);
+			}
+			if (!term.includes(":") && !term.includes("/") && simpleTerm) {
+				if (GEN_DELIMS.test(iri) || isBlankNodeId(iri)) def.prefix = true;
+			}
+		}
+	} else if (term.indexOf(":", 1) !== -1) {
+		const i = term.indexOf(":");
+		const prefix = term.slice(0, i);
+		const suffix = term.slice(i + 1);
+		if (prefix !== "_" && !suffix.startsWith("//") && hasOwn(local, prefix)) createTermDefinition(env, active, local, prefix, state);
+		const prefixIri = prefix === "_" ? null : Option.getOrNull(Option.map(termOf(active, prefix), (d) => d.iri));
+		def.iri = prefixIri === null ? term : prefixIri + suffix;
+	} else if (term.includes("/")) {
+		const iri = expandIri(env, active, term, true);
+		if (iri === null || !isAbsoluteIri(iri)) fail("invalid IRI mapping", term);
+		def.iri = iri;
+	} else if (term === "@type") def.iri = "@type";
+	else if (active.vocab !== void 0) def.iri = active.vocab + term;
+	else fail("invalid IRI mapping", term);
+	if ("@container" in value && !def.reverse) {
+		const c = value["@container"];
+		if (!validContainer(env, c)) fail("invalid container mapping");
+		def.container = Array.isArray(c) ? [...c] : [c];
+		if (def.container.includes("@type")) {
+			if (def.type === void 0) def.type = "@id";
+			if (def.type !== "@id" && def.type !== "@vocab") fail("invalid type mapping");
+		}
+	}
+	if ("@index" in value) {
+		if (env.processingMode === "json-ld-1.0" || !def.container.includes("@index")) fail("invalid term definition");
+		const index = value["@index"];
+		if (!isString$1(index)) fail("invalid term definition");
+		const expanded = expandIri(env, active, index, true, false, local, state);
+		if (expanded === null || isKeyword(expanded) || !isAbsoluteIri(expanded)) fail("invalid term definition");
+		def.index = index;
+	}
+	if ("@context" in value) {
+		if (env.processingMode === "json-ld-1.0") fail("invalid term definition");
+		const ctx = value["@context"];
+		mapJsonLdError(() => processContext(env, active, ctx, baseUrl, remoteContexts, true, true, false), (e) => fail("invalid scoped context", e.message));
+		def.context = ctx;
+		def.hasContext = true;
+		def.baseUrl = baseUrl;
+	}
+	if ("@language" in value && !("@type" in value)) {
+		const lang = value["@language"];
+		if (lang !== null && !isString$1(lang)) fail("invalid language mapping");
+		def.language = lang;
+	}
+	if ("@direction" in value && !("@type" in value)) {
+		const dir = value["@direction"];
+		if (dir !== null && dir !== "ltr" && dir !== "rtl") fail("invalid base direction");
+		def.direction = dir;
+	}
+	if ("@nest" in value) {
+		if (env.processingMode === "json-ld-1.0") fail("invalid term definition");
+		const nest = value["@nest"];
+		if (!isString$1(nest) || isKeyword(nest) && nest !== "@nest") fail("invalid @nest value");
+		def.nest = nest;
+	}
+	if ("@prefix" in value) {
+		if (env.processingMode === "json-ld-1.0" || term.includes(":") || term.includes("/")) fail("invalid term definition");
+		const p = value["@prefix"];
+		if (!Predicate.isBoolean(p)) fail("invalid @prefix value");
+		def.prefix = p;
+		if (p && def.iri !== null && isKeyword(def.iri)) fail("invalid term definition");
+	}
+	checkTermKeys(value);
+	finishDefinition(active, term, def, previous, overrideProtected, defined);
+};
+const checkTermKeys = (value) => {
+	Record.keys(value).forEach((k) => {
+		if (!isTermKey(k)) fail("invalid term definition", k);
+	});
+};
+const finishDefinition = (active, term, def, previous, overrideProtected, defined) => {
+	const kept = Option.filter(previous, (p) => !overrideProtected && p.protected);
+	if (Option.isSome(kept) && !sameDefinition(def, kept.value)) fail("protected term redefinition", term);
+	MutableHashMap.set(active.terms, term, Option.getOrElse(kept, () => def));
+	MutableHashMap.set(defined, term, true);
+};
+/** Whether the definition of `term` is still to be created from `local` (§4.2, step 3). */
+const isPending = (local, state, term) => hasOwn(local, term) && !Option.getOrElse(MutableHashMap.get(state.defined, term), () => false);
+const sameDefinition = (a, b) => a.iri === b.iri && a.reverse === b.reverse && a.type === b.type && a.language === b.language && "language" in a === "language" in b && a.direction === b.direction && "direction" in a === "direction" in b && a.hasContext === b.hasContext && deepEqual(a.context, b.context) && a.container.length === b.container.length && a.container.every((c) => b.container.includes(c)) && a.index === b.index && a.nest === b.nest && a.prefix === b.prefix;
+/**
+* IRI Expansion algorithm.
+*
+* @internal
+*/
+const expandIri = (env, active, value, vocab = false, documentRelative = false, local, state) => {
+	if (value === null || isKeyword(value)) return value;
+	if (hasKeywordForm(value)) return null;
+	if (local !== void 0 && state !== void 0 && isPending(local, state, value)) createTermDefinition(env, active, local, value, state);
+	const def = termOf(active, value);
+	if (Option.isSome(def)) {
+		const iri = def.value.iri;
+		if (iri !== null && isKeyword(iri)) return iri;
+		if (vocab) return iri;
+	}
+	const colon = value.indexOf(":", 1);
+	if (colon !== -1) {
+		const prefix = value.slice(0, colon);
+		const suffix = value.slice(colon + 1);
+		if (prefix === "_" || suffix.startsWith("//")) return value;
+		if (local !== void 0 && state !== void 0 && isPending(local, state, prefix)) createTermDefinition(env, active, local, prefix, state);
+		const prefixDef = termOf(active, prefix);
+		if (Option.isSome(prefixDef) && prefixDef.value.iri !== null && prefixDef.value.prefix) return prefixDef.value.iri + suffix;
+		if (isAbsoluteIri(value)) return value;
+	}
+	if (vocab && active.vocab !== void 0) return active.vocab + value;
+	if (documentRelative) return resolveIri(value, active.base);
+	return value;
+};
+// src/jsonld/internal/compact.ts
+/**
+* Compaction Algorithms (JSON-LD 1.1 API §6).
+*
+* @internal
+*/
+/** The definition of `term`, read where a missing definition reads as its defaults. */
+const definitionOf = (active, term) => active.terms.backing.get(term);
+/**
+* Compaction Algorithm.
+*
+* @internal
+*/
+const compactElement = (env, active, activeProperty, element, options) => {
+	const typeScoped = active;
+	if (isScalar(element) || element === null) return element;
+	if (Array.isArray(element)) {
+		const result = [];
+		element.forEach((item) => {
+			const compacted = compactElement(env, active, activeProperty, item, options);
+			if (compacted !== null) result.push(compacted);
+		});
+		const container = activeContainer(active, activeProperty);
+		if (result.length !== 1 || !options.compactArrays || isProperty(activeProperty, "@graph") || isProperty(activeProperty, "@set") || container.includes("@list") || container.includes("@set")) return result;
+		return result[0];
+	}
+	const propDef = activeDefinition(active, activeProperty);
+	if (active.previous !== void 0) {
+		const keys = Record.keys(element);
+		if (!("@value" in element) && !(keys.length === 1 && keys[0] === "@id")) active = active.previous;
+	}
+	if (propDef?.hasContext === true) active = processContext(env, active, propDef.context, propDef.baseUrl ?? null, [], true);
+	if ("@value" in element || "@id" in element) {
+		const compacted = compactValue(env, active, activeProperty, element, options);
+		if (isScalar(compacted) || compacted === null || propDef?.type === "@json") {
+			if (isScalar(compacted) || propDef?.type === "@json") return compacted;
+		}
+	}
+	if (isListObject(element) && activeContainer(active, activeProperty).includes("@list")) return compactElement(env, active, activeProperty, element["@list"], options);
+	const insideReverse = isProperty(activeProperty, "@reverse");
+	const result = {};
+	if ("@type" in element) {
+		const compactedTypes = Arr.sort(asArray(element["@type"]).map((t) => compactIri(env, typeScoped, t, null, true, false, options)), compareStrings);
+		active = applyTypeScopedContexts(env, active, typeScoped, compactedTypes);
+	}
+	const scope = {
+		env,
+		active,
+		typeScoped,
+		activeProperty,
+		options,
+		result,
+		insideReverse
+	};
+	(options.ordered ? Arr.sort(Record.keys(element), compareStrings) : Record.keys(element)).forEach((expandedProperty) => {
+		const expandedValue = element[expandedProperty];
+		if (!compactKeywordEntry(scope, expandedProperty, expandedValue)) compactPropertyEntry(scope, expandedProperty, expandedValue);
+	});
+	return result;
+};
+/** The IRI compaction of a keyword (as a vocabulary term) in the active context. */
+const aliasOf = (scope, keyword) => compactIri(scope.env, scope.active, keyword, null, true, false, scope.options);
+/** Steps 12.1 - 12.6: a keyword entry. Returns false for an entry they leave to 12.7. */
+const compactKeywordEntry = (scope, expandedProperty, expandedValue) => {
+	const { env, active, activeProperty, options, result } = scope;
+	if (expandedProperty === "@id") result[aliasOf(scope, "@id")] = isString$1(expandedValue) ? compactIri(env, active, expandedValue, null, false, false, options) : expandedValue;
+	else if (expandedProperty === "@type") compactTypeEntry(scope, expandedValue);
+	else if (expandedProperty === "@reverse") compactReverseEntry(scope, expandedValue);
+	else if (expandedProperty === "@preserve") {
+		const compactedValue = compactElement(env, active, activeProperty, expandedValue, options);
+		if (!(Array.isArray(expandedValue) && Arr.isReadonlyArrayEmpty(expandedValue))) result["@preserve"] = compactedValue;
+	} else if (expandedProperty === "@index") {
+		if (!activeContainer(active, activeProperty).includes("@index")) result[aliasOf(scope, expandedProperty)] = expandedValue;
+	} else if (expandedProperty === "@direction" || expandedProperty === "@language" || expandedProperty === "@value") result[aliasOf(scope, expandedProperty)] = expandedValue;
+	else return false;
+	return true;
+};
+/** Step 12.2: `@type`. */
+const compactTypeEntry = (scope, expandedValue) => {
+	const { env, active, typeScoped, options, result } = scope;
+	const types = isString$1(expandedValue) ? [] : expandedValue;
+	const compactedValue = isString$1(expandedValue) ? compactIri(env, typeScoped, expandedValue, null, true, false, options) : types.map((t) => compactIri(env, typeScoped, t, null, true, false, options));
+	const alias = aliasOf(scope, "@type");
+	const asArr = env.processingMode !== "json-ld-1.0" && containerOf(active, alias).includes("@set") || !options.compactArrays;
+	addValue(result, alias, compactedValue, asArr);
+	if (!asArr && Array.isArray(result[alias]) && result[alias].length === 1) result[alias] = result[alias][0];
+};
+/** Step 12.3: `@reverse`. */
+const compactReverseEntry = (scope, expandedValue) => {
+	const { env, active, options, result } = scope;
+	const compactedValue = compactElement(env, active, REVERSE_PROPERTY, expandedValue, options);
+	Record.keys(compactedValue).forEach((property) => {
+		const def = definitionOf(active, property);
+		if (def?.reverse === true) {
+			const asArr = def.container.includes("@set") || !options.compactArrays;
+			addValue(result, property, compactedValue[property], asArr);
+			delete compactedValue[property];
+		}
+	});
+	if (Arr.isReadonlyArrayNonEmpty(Record.keys(compactedValue))) result[aliasOf(scope, "@reverse")] = compactedValue;
+};
+/** Steps 12.7 and 12.8: a property entry. */
+const compactPropertyEntry = (scope, expandedProperty, expandedValue) => {
+	const { env, active, options, result, insideReverse } = scope;
+	if (Array.isArray(expandedValue) && Arr.isReadonlyArrayEmpty(expandedValue)) {
+		const itemActiveProperty = compactIri(env, active, expandedProperty, expandedValue, true, insideReverse, options);
+		const nestResult = nestResultFor(env, active, result, itemActiveProperty, options);
+		addValue(nestResult, itemActiveProperty, [], true);
+	}
+	asArray(expandedValue).forEach((expandedItem) => compactPropertyItem(scope, expandedProperty, expandedItem));
+};
+/** Step 12.8: one item of a property entry. */
+const compactPropertyItem = (scope, expandedProperty, expandedItem) => {
+	const { env, active, options, result, insideReverse } = scope;
+	const property = compactIri(env, active, expandedProperty, expandedItem, true, insideReverse, options);
+	const container = containerOf(active, property);
+	const target = {
+		property,
+		nestResult: nestResultFor(env, active, result, property, options),
+		container,
+		asArr: container.includes("@set") || property === "@graph" || property === "@list" || !options.compactArrays
+	};
+	const inner = isListObject(expandedItem) ? expandedItem["@list"] : isGraphObject(expandedItem) ? expandedItem["@graph"] : expandedItem;
+	const compactedItem = compactElement(env, active, Option.some(property), inner, options);
+	if (isListObject(expandedItem)) compactListItem(scope, target, expandedItem, compactedItem);
+	else if (isGraphObject(expandedItem)) compactGraphItem(scope, target, expandedItem, compactedItem);
+	else if ((container.includes("@language") || container.includes("@index") || container.includes("@id") || container.includes("@type")) && !container.includes("@graph")) compactMapItem(scope, target, expandedItem, compactedItem);
+	else addValue(target.nestResult, property, compactedItem, target.asArr);
+};
+/** Step 12.8.7: a list object. */
+const compactListItem = (scope, target, expandedItem, compacted) => {
+	const items = asArray(compacted);
+	if (target.container.includes("@list")) {
+		target.nestResult[target.property] = items;
+		return;
+	}
+	const compactedItem = { [aliasOf(scope, "@list")]: items };
+	if ("@index" in expandedItem) compactedItem[aliasOf(scope, "@index")] = expandedItem["@index"];
+	addValue(target.nestResult, target.property, compactedItem, target.asArr);
+};
+/** Step 12.8.8: a graph object. */
+const compactGraphItem = (scope, target, expandedItem, compactedItem) => {
+	const { env, active, options } = scope;
+	const { container, nestResult, property, asArr } = target;
+	if (container.includes("@graph") && container.includes("@id")) {
+		const mapObject = getOrInit(nestResult, property, () => ({}));
+		const mapKey = "@id" in expandedItem ? compactIri(env, active, expandedItem["@id"], null, false, false, options) : aliasOf(scope, "@none");
+		addValue(mapObject, mapKey, compactedItem, asArr);
+	} else if (container.includes("@graph") && container.includes("@index") && isSimpleGraphObject(expandedItem)) {
+		const mapObject = getOrInit(nestResult, property, () => ({}));
+		const mapKey = "@index" in expandedItem ? expandedItem["@index"] : aliasOf(scope, "@none");
+		addValue(mapObject, mapKey, compactedItem, asArr);
+	} else if (container.includes("@graph") && isSimpleGraphObject(expandedItem)) {
+		const value = Array.isArray(compactedItem) && compactedItem.length > 1 ? { [aliasOf(scope, "@included")]: compactedItem } : compactedItem;
+		addValue(nestResult, property, value, asArr);
+	} else {
+		const value = { [aliasOf(scope, "@graph")]: compactedItem };
+		if ("@id" in expandedItem) value[aliasOf(scope, "@id")] = compactIri(env, active, expandedItem["@id"], null, false, false, options);
+		if ("@index" in expandedItem) value[aliasOf(scope, "@index")] = expandedItem["@index"];
+		addValue(nestResult, property, value, asArr);
+	}
+};
+/** Step 12.8.9: an item of a language, index, id or type map. */
+const compactMapItem = (scope, target, expandedItem, compactedItem) => {
+	const { container, nestResult, property, asArr } = target;
+	const mapObject = getOrInit(nestResult, property, () => ({}));
+	const indexKey = definitionOf(scope.active, property)?.index ?? "@index";
+	let entry;
+	if (container.includes("@language") && "@value" in expandedItem) entry = {
+		key: expandedItem["@language"],
+		value: expandedItem["@value"]
+	};
+	else if (container.includes("@language")) entry = typeMapEntry(scope, target, expandedItem, compactedItem, "@language");
+	else if (container.includes("@index") && indexKey === "@index") entry = {
+		key: expandedItem["@index"],
+		value: compactedItem
+	};
+	else if (container.includes("@index")) entry = indexPropertyEntry(scope, indexKey, compactedItem);
+	else if (container.includes("@id")) {
+		const idKey = aliasOf(scope, "@id");
+		entry = {
+			key: compactedItem[idKey],
+			value: compactedItem
+		};
+		delete compactedItem[idKey];
+	} else entry = typeMapEntry(scope, target, expandedItem, compactedItem, "@type");
+	const key = entry.key === void 0 || entry.key === null ? aliasOf(scope, "@none") : entry.key;
+	addValue(mapObject, key, entry.value, asArr);
+};
+/** Step 12.8.9.8: an index map on a property (`@index` names a property). */
+const indexPropertyEntry = (scope, indexKey, compactedItem) => {
+	const { env, active } = scope;
+	const containerKey = isObject(compactedItem) && hasOwn(compactedItem, indexKey) ? indexKey : aliasOf(scope, expandIri(env, active, indexKey, true) ?? indexKey);
+	const values = isObject(compactedItem) ? asArray(compactedItem[containerKey] ?? []) : [];
+	const key = Arr.isReadonlyArrayNonEmpty(values) && isString$1(values[0]) ? values[0] : void 0;
+	if (key !== void 0) {
+		const rest = values.slice(1);
+		delete compactedItem[containerKey];
+		if (Arr.isReadonlyArrayNonEmpty(rest)) addValue(compactedItem, containerKey, rest, false);
+	}
+	return {
+		key,
+		value: compactedItem
+	};
+};
+/** Step 12.8.9.10: a type map (the map's keys are the values of `keyword`). */
+const typeMapEntry = (scope, target, expandedItem, compactedItem, keyword) => {
+	const { env, active, options } = scope;
+	const containerKey = aliasOf(scope, keyword);
+	const values = asArray(compactedItem[containerKey] ?? []);
+	const rest = values.slice(1);
+	delete compactedItem[containerKey];
+	if (Arr.isReadonlyArrayNonEmpty(rest)) addValue(compactedItem, containerKey, rest, false);
+	if (rest.length === 1 && Array.isArray(compactedItem[containerKey])) compactedItem[containerKey] = compactedItem[containerKey][0];
+	const remaining = Record.keys(compactedItem);
+	const [only] = remaining;
+	const onlyId = remaining.length === 1 && only !== void 0 && expandIri(env, active, only, true) === "@id" && "@id" in expandedItem;
+	return {
+		key: values[0],
+		value: onlyId ? compactElement(env, active, Option.some(target.property), { "@id": expandedItem["@id"] }, options) : compactedItem
+	};
+};
+const nestResultFor = (env, active, result, itemActiveProperty, options) => {
+	const nestTerm = definitionOf(active, itemActiveProperty)?.nest;
+	if (nestTerm === void 0) return result;
+	if (nestTerm !== "@nest" && expandIri(env, active, nestTerm, true) !== "@nest") fail("invalid @nest value");
+	if (!isObject(result[nestTerm])) result[nestTerm] = {};
+	return result[nestTerm];
+};
+/** @internal */
+const containerOf = (active, term) => definitionOf(active, term)?.container ?? [];
+/** The definition of the active property (none at the top level). */
+const activeDefinition = (active, activeProperty) => Option.isNone(activeProperty) ? void 0 : definitionOf(active, activeProperty.value);
+/** The container mapping of the active property (none at the top level). */
+const activeContainer = (active, activeProperty) => activeDefinition(active, activeProperty)?.container ?? [];
+/** Term definitions ordered by their term: shortest first, then lexicographically. */
+const shortestTermFirst = Order.mapInput(Order.combine(Order.mapInput(Order.Number, (term) => term.length), compareStrings), ([term]) => term);
+const emptyEntry = (term) => {
+	return {
+		"@language": Object.create(null),
+		"@type": Object.create(null),
+		"@any": { "@none": term }
+	};
+};
+/**
+* Inverse Context Creation algorithm.
+*
+* @internal
+*/
+const inverseContext = (active) => {
+	if (active.inverse !== void 0) return active.inverse;
+	const result = MutableHashMap.empty();
+	const defaultLanguage = active.language !== void 0 ? active.language.toLowerCase() : "@none";
+	Arr.sort(active.terms, shortestTermFirst).forEach(([term, def]) => {
+		const iri = def.iri;
+		if (iri === null) return;
+		const container = Arr.isReadonlyArrayEmpty(def.container) ? "@none" : Arr.sort(def.container, Order.String).join("");
+		const containerMap = Option.getOrElse(MutableHashMap.get(result, iri), () => {
+			const created = Object.create(null);
+			MutableHashMap.set(result, iri, created);
+			return created;
+		});
+		const entry = containerMap[container] ?? emptyEntry(term);
+		containerMap[container] = entry;
+		const typeMap = entry["@type"];
+		const languageMap = entry["@language"];
+		if (def.reverse) typeMap["@reverse"] ??= term;
+		else if (def.type === "@none") {
+			languageMap["@any"] ??= term;
+			typeMap["@any"] ??= term;
+		} else if (def.type !== void 0) typeMap[def.type] ??= term;
+		else if ("language" in def && "direction" in def) {
+			let langDir;
+			if (def.language != null && def.direction != null) langDir = `${def.language}_${def.direction}`.toLowerCase();
+			else if (def.language != null) langDir = def.language.toLowerCase();
+			else if (def.direction != null) langDir = `_${def.direction}`;
+			else langDir = "@null";
+			languageMap[langDir] ??= term;
+		} else if ("language" in def) {
+			const language = def.language == null ? "@null" : def.language.toLowerCase();
+			languageMap[language] ??= term;
+		} else if ("direction" in def) {
+			const direction = def.direction == null ? "@none" : `_${def.direction}`;
+			languageMap[direction] ??= term;
+		} else if (active.direction !== void 0) {
+			const langDir = active.language !== void 0 ? `${active.language}_${active.direction}`.toLowerCase() : `_${active.direction}`;
+			languageMap[langDir] ??= term;
+			languageMap["@none"] ??= term;
+			typeMap["@none"] ??= term;
+		} else {
+			languageMap[defaultLanguage] ??= term;
+			languageMap["@none"] ??= term;
+			typeMap["@none"] ??= term;
+		}
+	});
+	active.inverse = result;
+	return result;
+};
+const selectTerm = (containerMap, containers, typeLanguage, preferredValues) => Arr.findFirst(containers, (container) => {
+	const entry = containerMap[container];
+	if (entry === void 0) return Option.none();
+	const valueMap = entry[typeLanguage];
+	return Arr.findFirst(preferredValues, (item) => Option.fromUndefinedOr(valueMap[item]));
+});
+/** The `_direction` suffix of a preferred language value (none without one). */
+const directionSuffix = (pv) => {
+	const i = pv.indexOf("_");
+	return i === -1 ? [] : [pv.slice(i)];
+};
+/** A compact IRI candidate is chosen when it is shorter (or as short and earlier) than the best. */
+const isBetterCompactIri = (candidate, best) => Option.isNone(best) || candidate.length < best.value.length || candidate.length === best.value.length && candidate < best.value;
+/**
+* IRI Compaction algorithm.
+*
+* @internal
+*/
+const compactIri = (env, active, iri, value = null, vocab = false, reverse = false, options) => {
+	if (iri === null) return iri;
+	const inverse = inverseContext(active);
+	const containerMap = vocab ? MutableHashMap.get(inverse, iri) : Option.none();
+	if (Option.isSome(containerMap)) {
+		const defaultLanguage = active.direction !== void 0 ? `${active.language ?? ""}_${active.direction}`.toLowerCase() : active.language !== void 0 ? active.language.toLowerCase() : "@none";
+		if (isObject(value) && "@preserve" in value) value = asArray(value["@preserve"])[0];
+		const containers = [];
+		let typeLanguage = "@language";
+		let typeLanguageValue = "@null";
+		if (isObject(value) && "@index" in value && !isGraphObject(value)) containers.push("@index", "@index@set");
+		if (reverse) {
+			typeLanguage = "@type";
+			typeLanguageValue = "@reverse";
+			containers.push("@set");
+		} else if (isListObject(value)) {
+			if (!("@index" in value)) containers.push("@list");
+			const list = value["@list"];
+			let commonType = "@none";
+			let commonLanguage = defaultLanguage;
+			list.every((item, i) => {
+				let itemLanguage = "@none";
+				let itemType = "@none";
+				if (isValueObject(item)) {
+					if ("@direction" in item) itemLanguage = `${item["@language"] ?? ""}_${item["@direction"]}`.toLowerCase();
+					else if ("@language" in item) itemLanguage = String(item["@language"]).toLowerCase();
+					else if ("@type" in item) itemType = item["@type"];
+					else itemLanguage = "@null";
+				} else itemType = "@id";
+				if (i === 0) {
+					commonLanguage = itemLanguage;
+					commonType = itemType;
+				} else {
+					if (itemLanguage !== commonLanguage && isValueObject(item)) commonLanguage = "@none";
+					if (itemType !== commonType) commonType = "@none";
+				}
+				return !(commonLanguage === "@none" && commonType === "@none");
+			});
+			if (commonType !== "@none") {
+				typeLanguage = "@type";
+				typeLanguageValue = commonType;
+			} else typeLanguageValue = commonLanguage;
+		} else if (isGraphObject(value)) {
+			if ("@index" in value) containers.push("@graph@index", "@graph@index@set");
+			if ("@id" in value) containers.push("@graph@id", "@graph@id@set");
+			containers.push("@graph", "@graph@set", "@set");
+			if (!("@index" in value)) containers.push("@graph@index", "@graph@index@set");
+			if (!("@id" in value)) containers.push("@graph@id", "@graph@id@set");
+			containers.push("@index", "@index@set");
+			typeLanguage = "@type";
+			typeLanguageValue = "@id";
+		} else {
+			if (isValueObject(value)) {
+				if ("@direction" in value && !("@index" in value)) {
+					typeLanguageValue = `${value["@language"] ?? ""}_${value["@direction"]}`.toLowerCase();
+					containers.push("@language", "@language@set");
+				} else if ("@language" in value && !("@index" in value)) {
+					typeLanguageValue = String(value["@language"]).toLowerCase();
+					containers.push("@language", "@language@set");
+				} else if ("@type" in value) {
+					typeLanguageValue = value["@type"] ?? "@null";
+					typeLanguage = "@type";
+				}
+			} else {
+				typeLanguage = "@type";
+				typeLanguageValue = "@id";
+				containers.push("@id", "@id@set", "@type", "@set@type");
+			}
+			containers.push("@set");
+		}
+		containers.push("@none");
+		if (env.processingMode !== "json-ld-1.0" && (!isObject(value) || !("@index" in value))) containers.push("@index", "@index@set");
+		if (env.processingMode !== "json-ld-1.0" && isObject(value) && Record.keys(value).length === 1 && "@value" in value) containers.push("@language", "@language@set");
+		const preferredValues = [];
+		if (typeLanguageValue === "@reverse") preferredValues.push("@reverse");
+		if ((typeLanguageValue === "@id" || typeLanguageValue === "@reverse") && isObject(value) && "@id" in value) {
+			const compactedId = compactIri(env, active, value["@id"], null, true, false, options);
+			if (definitionOf(active, compactedId)?.iri === value["@id"]) preferredValues.push("@vocab", "@id", "@none");
+			else preferredValues.push("@id", "@vocab", "@none");
+		} else {
+			preferredValues.push(typeLanguageValue, "@none");
+			if (isListObject(value) && Arr.isReadonlyArrayEmpty(value["@list"])) typeLanguage = "@any";
+		}
+		preferredValues.push("@any");
+		pushAll(preferredValues, preferredValues.flatMap(directionSuffix));
+		const term = selectTerm(containerMap.value, containers, typeLanguage, preferredValues);
+		if (Option.isSome(term)) return term.value;
+	}
+	if (vocab && active.vocab !== void 0) {
+		if (iri.startsWith(active.vocab) && iri.length > active.vocab.length) {
+			const suffix = iri.slice(active.vocab.length);
+			if (!MutableHashMap.has(active.terms, suffix)) return suffix;
+		}
+	}
+	let compactIriResult = Option.none();
+	MutableHashMap.forEach(active.terms, (def, term) => {
+		const prefixIri = def.iri;
+		if (prefixIri === null || prefixIri === iri || !iri.startsWith(prefixIri) || !def.prefix) return;
+		const candidate = `${term}:${iri.slice(prefixIri.length)}`;
+		const candidateDef = definitionOf(active, candidate);
+		if (isBetterCompactIri(candidate, compactIriResult) && (candidateDef === void 0 || candidateDef.iri === iri && value === null)) compactIriResult = Option.some(candidate);
+	});
+	if (Option.isSome(compactIriResult)) return compactIriResult.value;
+	const colon = iri.indexOf(":");
+	if (colon > 0) {
+		const scheme = iri.slice(0, colon);
+		const def = definitionOf(active, scheme);
+		if (def !== void 0 && def.prefix && !iri.slice(colon + 1).startsWith("//")) fail("IRI confused with prefix", iri);
+	}
+	if (!vocab && (options?.compactToRelative ?? true)) return removeBase(active.base, iri);
+	return iri;
+};
+/**
+* Value Compaction algorithm.
+*
+* @internal
+*/
+const compactValue = (env, active, activeProperty, value, options) => {
+	const def = activeDefinition(active, activeProperty);
+	const container = def?.container ?? [];
+	const typeMapping = def?.type;
+	const language = def !== void 0 && "language" in def ? def.language : active.language;
+	const direction = def !== void 0 && "direction" in def ? def.direction : active.direction;
+	const keys = Record.keys(value);
+	if ("@id" in value) {
+		if (keys.every((k) => k === "@id" || k === "@index")) {
+			const indexOk = !("@index" in value) || container.includes("@index");
+			if (indexOk && typeMapping === "@id") return compactIri(env, active, value["@id"], null, false, false, options);
+			if (indexOk && typeMapping === "@vocab") return compactIri(env, active, value["@id"], null, true, false, options);
+		}
+		return value;
+	}
+	const preserveIndex = "@index" in value && !container.includes("@index");
+	if (!preserveIndex) {
+		if ("@type" in value && value["@type"] === typeMapping) return value["@value"];
+		if (typeMapping === "@none" || "@type" in value) {} else if (!isString$1(value["@value"])) {
+			if (!("@language" in value) && !("@direction" in value)) return value["@value"];
+		} else {
+			const langMatch = "@language" in value ? language != null && String(value["@language"]).toLowerCase() === language.toLowerCase() : language == null;
+			const dirMatch = "@direction" in value ? value["@direction"] === direction : direction == null;
+			if (langMatch && dirMatch) return value["@value"];
+		}
+	}
+	const result = {};
+	keys.forEach((key) => {
+		if (key === "@index" && !preserveIndex) return;
+		const alias = compactIri(env, active, key, null, true, false, options);
+		result[alias] = key === "@type" ? compactIri(env, active, value[key], null, true, false, options) : value[key];
+	});
+	return result;
+};
+// src/jsonld/internal/expand.ts
+/**
+* Expansion Algorithm (JSON-LD 1.1 API §5.1).
+*
+* @internal
+*/
+/** A frame-expansion `@language` / `@direction` value: `{}` or an array of strings. */
+const isFrameStringValue = (value) => isEmptyObject(value) || Array.isArray(value) && value.every(isString$1);
+/** @internal */
+const expandElement = (env, active, activeProperty, element, baseUrl, options, fromMap = false) => {
+	if (element === null || element === void 0) return null;
+	if (isProperty(activeProperty, "@default")) options = {
+		...options,
+		frameExpansion: false
+	};
+	const propDef = Option.isNone(activeProperty) ? Option.none() : termOf(active, activeProperty.value);
+	const propertyScoped = Option.filter(propDef, (def) => def.hasContext);
+	if (isScalar(element)) {
+		if (Option.isNone(activeProperty) || activeProperty.value === "@graph") return null;
+		if (Option.isSome(propertyScoped)) {
+			const def = propertyScoped.value;
+			active = processContext(env, active, def.context, def.baseUrl ?? null);
+		}
+		return expandValue(env, active, activeProperty.value, element);
+	}
+	if (Array.isArray(element)) {
+		const result = [];
+		const isList = Option.isSome(propDef) && propDef.value.container.includes("@list");
+		element.forEach((item) => {
+			const expanded = expandElement(env, active, activeProperty, item, baseUrl, options, fromMap);
+			if (Array.isArray(expanded)) {
+				if (isList) result.push({ "@list": expanded });
+				else pushAll(result, expanded);
+			} else if (expanded !== null) result.push(expanded);
+		});
+		return result;
+	}
+	if (!isObject(element)) fail("invalid local context");
+	if (active.previous !== void 0 && !fromMap) {
+		const keys = Record.keys(element);
+		if (!keys.some((key) => {
+			const exp = expandIri(env, active, key, true);
+			return exp === "@value" || keys.length === 1 && exp === "@id";
+		})) active = active.previous;
+	}
+	if (Option.isSome(propertyScoped)) {
+		const def = propertyScoped.value;
+		active = processContext(env, active, def.context, def.baseUrl ?? null, [], true);
+	}
+	if ("@context" in element) active = processContext(env, active, element["@context"], baseUrl);
+	const typeScoped = active;
+	const keys = Arr.sort(Record.keys(element), compareStrings);
+	keys.forEach((key) => {
+		if (expandIri(env, active, key, true) !== "@type") return;
+		const values = asArray(element[key]);
+		active = applyTypeScopedContexts(env, active, typeScoped, Arr.sort(Arr.filter(values, isString$1), compareStrings));
+	});
+	const typeKey = keys.find((key) => expandIri(env, active, key, true) === "@type");
+	const lastType = typeKey === void 0 ? void 0 : asArray(element[typeKey]).at(-1);
+	const inputIsJson = isString$1(lastType) && expandIri(env, active, lastType, true) === "@json";
+	const result = {};
+	expandObject(env, active, typeScoped, activeProperty, element, result, inputIsJson, baseUrl, options);
+	if ("@value" in result) {
+		const extra = Record.keys(result).find((k) => k !== "@direction" && k !== "@index" && k !== "@language" && k !== "@type" && k !== "@value");
+		if (extra !== void 0) fail("invalid value object", extra);
+		if ("@type" in result && ("@language" in result || "@direction" in result)) fail("invalid value object");
+		const type = result["@type"];
+		if (type === "@json") {} else {
+			const v = result["@value"];
+			if (v === null || Array.isArray(v) && Arr.isReadonlyArrayEmpty(v)) return null;
+			if (!isString$1(v) && "@language" in result) {
+				if (!options.frameExpansion) fail("invalid language-tagged value");
+			}
+			if ("@type" in result) {
+				if (options.frameExpansion) {} else if (!isString$1(type) || !isAbsoluteIri(type) || isBlankNodeId(type)) fail("invalid typed value");
+			}
+		}
+	} else if ("@type" in result) {
+		if (!Array.isArray(result["@type"])) result["@type"] = [result["@type"]];
+	} else if ("@set" in result || "@list" in result) {
+		const n = Record.keys(result).length;
+		if (n > 2 || n === 2 && !("@index" in result)) fail("invalid set or list object");
+		if ("@set" in result) {
+			const set = result["@set"];
+			return finalize(set, activeProperty, options);
+		}
+	}
+	return finalize(result, activeProperty, options);
+};
+const finalize = (result, activeProperty, options) => {
+	if (isObject(result)) {
+		const keys = Record.keys(result);
+		if (keys.length === 1 && keys[0] === "@language") return null;
+		if (!options.frameExpansion && isTopLevel(activeProperty)) {
+			if (Arr.isReadonlyArrayEmpty(keys) || "@value" in result || "@list" in result) return null;
+			if (keys.length === 1 && keys[0] === "@id") return null;
+		}
+	}
+	return result;
+};
+const expandKeyword = Match.fn((expandedProperty, _key, _value, _kw) => expandedProperty).pipe(Match.withReturnType(), Match.when("@id", (_p, _ep, _key, value, kw) => {
+	if (isString$1(value)) return expandIri(kw.env, kw.active, value, false, true);
+	if (kw.options.frameExpansion && isEmptyObject(value)) return [value];
+	if (kw.options.frameExpansion && Array.isArray(value) && value.every(isString$1)) return value.map((v) => expandIri(kw.env, kw.active, v, false, true));
+	return fail("invalid @id value", stringifyJson(value));
+}), Match.when("@type", (_p, _ep, _key, value, kw) => {
+	let expandedValue = void 0;
+	if (kw.options.frameExpansion && isEmptyObject(value)) expandedValue = value;
+	else if (kw.options.frameExpansion && isObject(value) && "@default" in value && Record.keys(value).length === 1) expandedValue = { "@default": expandIri(kw.env, kw.typeScoped, value["@default"], true, true) };
+	else if (isString$1(value)) expandedValue = expandIri(kw.env, kw.typeScoped, value, true, true);
+	else if (Array.isArray(value) && value.every(isString$1)) expandedValue = value.map((v) => expandIri(kw.env, kw.typeScoped, v, true, true));
+	else fail("invalid type value", stringifyJson(value));
+	if ("@type" in kw.result) expandedValue = [...asArray(kw.result["@type"]), ...asArray(expandedValue)];
+	return expandedValue;
+}), Match.when("@graph", (_p, _ep, _key, value, kw) => asArray(expandElement(kw.env, kw.active, GRAPH_PROPERTY, value, kw.baseUrl, kw.options))), Match.when("@included", (_p, _ep, _key, value, kw) => {
+	if (kw.env.processingMode === "json-ld-1.0") return void 0;
+	const expandedValue = asArray(expandElement(kw.env, kw.active, kw.activeProperty, value, kw.baseUrl, kw.options));
+	if (expandedValue.some((v) => !isObject(v) || "@value" in v || "@list" in v || "@set" in v)) fail("invalid @included value");
+	return "@included" in kw.result ? [...kw.result["@included"], ...expandedValue] : expandedValue;
+}), Match.when("@value", (_p, _ep, _key, value, kw) => {
+	let expandedValue = void 0;
+	if (kw.inputIsJson) {
+		if (kw.env.processingMode === "json-ld-1.0") fail("invalid value object value");
+		expandedValue = value;
+	} else if (value === null || isScalar(value)) expandedValue = value;
+	else if (kw.options.frameExpansion && (isEmptyObject(value) || Array.isArray(value) && value.every(isScalar))) expandedValue = value;
+	else fail("invalid value object value");
+	if (expandedValue === null) {
+		kw.result["@value"] = null;
+		return;
+	}
+	return expandedValue;
+}), Match.when("@language", (_p, _ep, _key, value, kw) => {
+	if (isString$1(value)) return value;
+	if (kw.options.frameExpansion && isFrameStringValue(value)) return value;
+	return fail("invalid language-tagged string");
+}), Match.when("@direction", (_p, _ep, _key, value, kw) => {
+	if (kw.env.processingMode === "json-ld-1.0") return void 0;
+	if (value === "ltr" || value === "rtl") return value;
+	if (kw.options.frameExpansion && isFrameStringValue(value)) return value;
+	return fail("invalid base direction");
+}), Match.when("@index", (_p, _ep, _key, value) => {
+	if (!isString$1(value)) fail("invalid @index value");
+	return value;
+}), Match.when("@list", (_p, _ep, _key, value, kw) => {
+	if (isTopLevel(kw.activeProperty)) return void 0;
+	const expandedValue = asArray(expandElement(kw.env, kw.active, kw.activeProperty, value, kw.baseUrl, kw.options));
+	if (kw.env.processingMode === "json-ld-1.0" && expandedValue.some(isListObject)) fail("list of lists");
+	return expandedValue;
+}), Match.when("@set", (_p, _ep, _key, value, kw) => expandElement(kw.env, kw.active, kw.activeProperty, value, kw.baseUrl, kw.options)), Match.when("@reverse", (_p, _ep, _key, value, kw) => {
+	if (!isObject(value)) fail("invalid @reverse value");
+	const ev = expandElement(kw.env, kw.active, REVERSE_PROPERTY, value, kw.baseUrl, kw.options);
+	if (isObject(ev)) {
+		if ("@reverse" in ev) {
+			const reversed = ev["@reverse"];
+			Record.keys(reversed).forEach((property) => {
+				if (!hasOwn(kw.result, property)) kw.result[property] = [];
+				pushAll(kw.result[property], asArray(reversed[property]));
+			});
+		}
+		const others = Record.keys(ev).filter((k) => k !== "@reverse");
+		if (Arr.isReadonlyArrayNonEmpty(others)) {
+			const reverseMap = getOrInit(kw.result, "@reverse", () => ({}));
+			others.forEach((property) => asArray(ev[property]).forEach((item) => {
+				if (isValueObject(item) || isListObject(item)) fail("invalid reverse property value");
+				getOrInit(reverseMap, property, () => []).push(item);
+			}));
+		}
+	}
+}), Match.when("@nest", (_p, _ep, key, _value, kw) => {
+	kw.nests.push(key);
+}), Match.when("@default", (_p, _ep, _key, value, kw) => kw.options.frameExpansion ? expandElement(kw.env, kw.active, kw.activeProperty, value, kw.baseUrl, kw.options) : void 0), Match.when(Match.is("@embed", "@explicit", "@omitDefault", "@requireAll"), (_p, _ep, _key, value, kw) => kw.options.frameExpansion ? asArray(value) : void 0), Match.orElse(() => void 0));
+const expandObject = (env, active, typeScoped, activeProperty, element, result, inputIsJson, baseUrl, options) => {
+	const nests = [];
+	const scope = {
+		env,
+		active,
+		typeScoped,
+		activeProperty,
+		result,
+		inputIsJson,
+		baseUrl,
+		options,
+		nests
+	};
+	(options.ordered ? Arr.sort(Record.keys(element), compareStrings) : Record.keys(element)).forEach((key) => {
+		const value = element[key];
+		if (key === "@context") return;
+		const expandedProperty = expandIri(env, active, key, true);
+		if (expandedProperty === null || !expandedProperty.includes(":") && !isKeyword(expandedProperty)) return;
+		if (isKeyword(expandedProperty)) {
+			if (isProperty(activeProperty, "@reverse")) fail("invalid reverse property map");
+			if (hasOwn(result, expandedProperty) && expandedProperty !== "@included" && expandedProperty !== "@type") fail("colliding keywords", expandedProperty);
+			if (expandedProperty in result && expandedProperty === "@type" && env.processingMode === "json-ld-1.0") fail("colliding keywords", expandedProperty);
+			const expandedValue = expandKeyword(expandedProperty, key, value, scope);
+			if (expandedValue !== void 0) result[expandedProperty] = expandedValue;
+			return;
+		}
+		const def = termOf(active, key);
+		const container = Option.isSome(def) ? def.value.container : [];
+		let expandedValue;
+		if (Option.isSome(def) && def.value.type === "@json") expandedValue = {
+			"@value": value,
+			"@type": "@json"
+		};
+		else if (container.includes("@language") && isObject(value)) {
+			const values = [];
+			expandedValue = values;
+			const direction = Option.isSome(def) && "direction" in def.value ? def.value.direction : active.direction;
+			(options.ordered ? Arr.sort(Record.keys(value), compareStrings) : Record.keys(value)).forEach((language) => asArray(value[language]).forEach((item) => {
+				if (item === null) return;
+				if (!isString$1(item)) fail("invalid language map value");
+				const v = {
+					"@value": item,
+					"@language": language
+				};
+				if (language === "@none" || expandIri(env, active, language, true) === "@none") delete v["@language"];
+				if (direction !== null && direction !== void 0) v["@direction"] = direction;
+				values.push(v);
+			}));
+		} else if ((container.includes("@index") || container.includes("@type") || container.includes("@id")) && isObject(value)) {
+			const values = [];
+			expandedValue = values;
+			const indexKey = Option.isSome(def) ? def.value.index ?? "@index" : "@index";
+			(options.ordered ? Arr.sort(Record.keys(value), compareStrings) : Record.keys(value)).forEach((index) => {
+				let mapContext = active;
+				if (container.includes("@type")) {
+					mapContext = active.previous ?? active;
+					const indexDef = scopedTermOf(mapContext, index);
+					if (Option.isSome(indexDef)) mapContext = processContext(env, mapContext, indexDef.value.context, indexDef.value.baseUrl ?? null);
+				}
+				const expandedIndex = expandIri(env, active, index, true);
+				asArray(expandElement(env, mapContext, Option.some(key), asArray(value[index]), baseUrl, options, true)).forEach((expandedItem) => {
+					const item = container.includes("@graph") && !isGraphObject(expandedItem) ? { "@graph": asArray(expandedItem) } : expandedItem;
+					if (container.includes("@index") && indexKey !== "@index" && expandedIndex !== "@none") {
+						const reExpanded = expandValue(env, active, indexKey, index);
+						const expandedIndexKey = expandIri(env, active, indexKey, true) ?? indexKey;
+						item[expandedIndexKey] = [reExpanded, ...hasOwn(item, expandedIndexKey) ? asArray(item[expandedIndexKey]) : []];
+						if (isValueObject(item) && Record.keys(item).length > 1) fail("invalid value object");
+					} else if (container.includes("@index") && !("@index" in item) && expandedIndex !== "@none") item["@index"] = index;
+					else if (container.includes("@id") && !("@id" in item) && expandedIndex !== "@none") item["@id"] = expandIri(env, active, index, false, true);
+					else if (container.includes("@type") && expandedIndex !== "@none") item["@type"] = [expandedIndex, ...item["@type"] ? asArray(item["@type"]) : []];
+					values.push(item);
+				});
+			});
+		} else expandedValue = expandElement(env, active, Option.some(key), value, baseUrl, options);
+		if (expandedValue === null) return;
+		if (container.includes("@list") && !isListObject(expandedValue)) expandedValue = { "@list": asArray(expandedValue) };
+		if (container.includes("@graph") && !container.includes("@id") && !container.includes("@index")) expandedValue = asArray(expandedValue).map((ev) => ({ "@graph": asArray(ev) }));
+		if (Option.isSome(def) && def.value.reverse) {
+			const reverseMap = getOrInit(result, "@reverse", () => ({}));
+			asArray(expandedValue).forEach((item) => {
+				if (isValueObject(item) || isListObject(item)) fail("invalid reverse property value");
+				getOrInit(reverseMap, expandedProperty, () => []).push(item);
+			});
+		} else pushAll(getOrInit(result, expandedProperty, () => []), asArray(expandedValue));
+	});
+	(options.ordered ? Arr.sort(nests, compareStrings) : nests).forEach((nestKey) => asArray(element[nestKey]).forEach((nested) => {
+		if (!isObject(nested)) fail("invalid @nest value");
+		if (Record.keys(nested).some((k) => expandIri(env, active, k, true) === "@value")) fail("invalid @nest value");
+		const nestContext = Option.match(scopedTermOf(active, nestKey), {
+			onNone: () => active,
+			onSome: (nestDef) => processContext(env, active, nestDef.context, nestDef.baseUrl ?? null, [], true)
+		});
+		expandObject(env, nestContext, typeScoped, activeProperty, nested, result, inputIsJson, baseUrl, options);
+	}));
+};
+/**
+* Value Expansion algorithm.
+*
+* @internal
+*/
+const expandValue = (env, active, activeProperty, value) => {
+	const def = Option.getOrNull(termOf(active, activeProperty));
+	const type = def === null ? void 0 : def.type;
+	if (type === "@id" && isString$1(value)) return { "@id": expandIri(env, active, value, false, true) };
+	if (type === "@vocab" && isString$1(value)) return { "@id": expandIri(env, active, value, true, true) };
+	const result = { "@value": value };
+	if (type !== void 0 && type !== "@id" && type !== "@vocab" && type !== "@none") result["@type"] = type;
+	else if (isString$1(value)) {
+		const language = def !== null && "language" in def ? def.language : active.language;
+		const direction = def !== null && "direction" in def ? def.direction : active.direction;
+		if (language !== null && language !== void 0) result["@language"] = language;
+		if (direction !== null && direction !== void 0) result["@direction"] = direction;
+	}
+	return result;
+};
+// src/jsonld/internal/flatten.ts
+/**
+* Node Map Generation and Flattening (JSON-LD 1.1 API §7).
+*
+* @internal
+*/
+/**
+* Adds `item` to the active list or, outside a list, to the active property
+* of the active subject (once, when `unique`).
+*/
+const addToTarget = (graph, activeSubject, activeProperty, list, item, unique) => {
+	if (Option.isSome(list)) {
+		list.value["@list"].push(item);
+		return;
+	}
+	if (Option.isNone(activeSubject) || Option.isNone(activeProperty)) return;
+	const subject = activeSubject.value;
+	if (isObject(subject)) return;
+	const values = getOrInit(graph[subject] ?? {}, activeProperty.value, () => []);
+	if (unique) addUnique(values, item);
+	else values.push(item);
+};
+/**
+* Node Map Generation algorithm.
+*
+* @internal
+*/
+const generateNodeMap = (element, nodeMap, issuer, activeGraph = "@default", activeSubject = Option.none(), activeProperty = Option.none(), list = Option.none()) => {
+	if (Array.isArray(element)) {
+		element.forEach((item) => generateNodeMap(item, nodeMap, issuer, activeGraph, activeSubject, activeProperty, list));
+		return;
+	}
+	const graph = getOrInit(nodeMap, activeGraph, () => ({}));
+	if ("@type" in element) {
+		const type = element["@type"];
+		element["@type"] = Array.isArray(type) ? type.map((t) => isBlankNodeId(t) ? issuer.issue(t) : t) : isBlankNodeId(type) ? issuer.issue(type) : type;
+	}
+	if (isValueObject(element)) {
+		addToTarget(graph, activeSubject, activeProperty, list, element, true);
+		return;
+	}
+	if (isListObject(element)) {
+		const result = { "@list": [] };
+		generateNodeMap(element["@list"], nodeMap, issuer, activeGraph, activeSubject, activeProperty, Option.some(result));
+		addToTarget(graph, activeSubject, activeProperty, list, result, false);
+		return;
+	}
+	let id;
+	if ("@id" in element) {
+		id = element["@id"];
+		if (id === null) return;
+		if (isBlankNodeId(id)) id = issuer.issue(id);
+	} else id = issuer.issue();
+	const node = getOrInit(graph, id, () => ({ "@id": id }));
+	if (Option.isSome(activeSubject) && isObject(activeSubject.value)) {
+		if (Option.isSome(activeProperty)) {
+			const values = getOrInit(node, activeProperty.value, () => []);
+			addUnique(values, activeSubject.value);
+		}
+	} else if (Option.isSome(activeProperty)) addToTarget(graph, activeSubject, activeProperty, list, { "@id": id }, true);
+	if ("@type" in element) {
+		const types = getOrInit(node, "@type", () => []);
+		asArray(element["@type"]).forEach((t) => {
+			if (!types.includes(t)) types.push(t);
+		});
+	}
+	if ("@index" in element) {
+		if ("@index" in node && node["@index"] !== element["@index"]) fail("conflicting indexes");
+		node["@index"] = element["@index"];
+	}
+	if ("@reverse" in element) {
+		const referenced = Option.some({ "@id": id });
+		const reverseMap = element["@reverse"];
+		Record.keys(reverseMap).forEach((property) => {
+			const reverseProperty = Option.some(property);
+			asArray(reverseMap[property]).forEach((value) => generateNodeMap(value, nodeMap, issuer, activeGraph, referenced, reverseProperty));
+		});
+	}
+	if ("@graph" in element) generateNodeMap(element["@graph"], nodeMap, issuer, id);
+	if ("@included" in element) generateNodeMap(element["@included"], nodeMap, issuer, activeGraph);
+	const subject = Option.some(id);
+	Arr.sort(Record.keys(element), compareStrings).forEach((key) => {
+		if (key === "@id" || key === "@type" || key === "@index" || key === "@reverse" || key === "@graph" || key === "@included") return;
+		const property = isBlankNodeId(key) ? issuer.issue(key) : key;
+		if (!hasOwn(node, property)) node[property] = [];
+		generateNodeMap(element[key], nodeMap, issuer, activeGraph, subject, Option.some(property));
+	});
+};
+/** The nodes of a graph that say more than their `@id`, in key order (sorted when `ordered`). */
+const nodesOf = (graph, ordered) => {
+	const ids = ordered ? Arr.sort(Record.keys(graph), compareStrings) : Record.keys(graph);
+	const nodes = [];
+	ids.forEach((id) => {
+		const node = graph[id];
+		if (node !== void 0 && !isOnlyId$1(node)) nodes.push(node);
+	});
+	return nodes;
+};
+/**
+* Flattening algorithm (without the final compaction).
+*
+* @internal
+*/
+const flattenExpanded = (expanded, ordered) => {
+	const defaultGraph = {};
+	const nodeMap = { "@default": defaultGraph };
+	generateNodeMap(expanded, nodeMap, new IdIssuer());
+	const named = Record.keys(nodeMap).filter((g) => g !== "@default");
+	(ordered ? Arr.sort(named, compareStrings) : named).forEach((graphName) => {
+		const entry = getOrInit(defaultGraph, graphName, () => ({ "@id": graphName }));
+		entry["@graph"] = nodesOf(nodeMap[graphName] ?? {}, ordered);
+	});
+	return nodesOf(defaultGraph, ordered);
+};
+const isOnlyId$1 = (node) => {
+	const keys = Record.keys(node);
+	return keys.length === 1 && keys[0] === "@id";
+};
+/** @internal */
+const mergeNodeMaps = (graphs) => {
+	const merged = {};
+	Arr.sort(Record.keys(graphs), compareStrings).forEach((graphName) => {
+		const graph = graphs[graphName] ?? {};
+		Arr.sort(Record.keys(graph), compareStrings).forEach((id) => {
+			const node = graph[id] ?? {};
+			const mergedNode = getOrInit(merged, id, () => ({ "@id": id }));
+			Arr.sort(Record.keys(node), compareStrings).forEach((property) => {
+				if (property === "@id") return;
+				if (property === "@type") {
+					const types = getOrInit(mergedNode, "@type", () => []);
+					asArray(node["@type"]).forEach((t) => {
+						if (!types.includes(t)) types.push(t);
+					});
+					return;
+				}
+				if (property.startsWith("@")) {
+					mergedNode[property] = structuredClone(node[property]);
+					return;
+				}
+				const values = getOrInit(mergedNode, property, () => []);
+				asArray(node[property]).forEach((v) => {
+					if (!values.some((x) => deepEqual(x, v))) values.push(structuredClone(v));
+				});
+			});
+		});
+	});
+	return merged;
+};
+// src/jsonld/internal/frame.ts
+/**
+* Framing Algorithm (JSON-LD 1.1 Framing §4).
+*
+* @internal
+*/
+/**
+* Frames expanded input with an expanded frame. Returns the framed nodes
+* (expanded form) and the blank node identifiers that are referenced only
+* once and can therefore be pruned.
+*
+* @internal
+*/
+const frame$1 = (expanded, expandedFrame, options) => {
+	const graphMap = { "@default": {} };
+	generateNodeMap(expanded, graphMap, new IdIssuer());
+	let graph = "@default";
+	if (options.merged) {
+		graphMap["@merged"] = mergeNodeMaps(graphMap);
+		graph = "@merged";
+	}
+	const state = {
+		options,
+		graphMap,
+		subjects: graphMap[graph] ?? {},
+		graph,
+		embedded: false,
+		subjectStack: [],
+		link: {},
+		bnodeMap: {},
+		uniqueEmbeds: {}
+	};
+	const framed = [];
+	frameSubjects(state, Arr.sort(Record.keys(state.subjects), compareStrings), asArray(expandedFrame), framed, Option.none());
+	const bnodesToClear = MutableHashSet.fromIterable(options.is11 ? Record.keys(state.bnodeMap).filter((id) => state.bnodeMap[id]?.length === 1) : []);
+	return cleanupPreserve(framed, bnodesToClear, /* @__PURE__ */ new WeakSet());
+};
+const getFlag = (pattern, options, name) => {
+	const flag = `@${name}`;
+	let value = hasOwn(pattern, flag) ? asArray(pattern[flag])[0] : options[name];
+	if (isValueObject(value)) value = value["@value"];
+	if (name === "embed") {
+		if (value === true) value = "@once";
+		else if (value === false) value = "@never";
+		else if (![
+			"@always",
+			"@never",
+			"@link",
+			"@first",
+			"@last",
+			"@once"
+		].includes(value)) fail("invalid @embed value", String(value));
+	} else if (Predicate.isString(value)) value = value === "true";
+	return value;
+};
+const validateFrame = (frameValue) => {
+	if (!Array.isArray(frameValue) || frameValue.length !== 1 || !isObject(frameValue[0])) fail("invalid frame", "a frame must be a single object");
+	const f = frameValue[0];
+	if (hasOwn(f, "@id")) asArray(f["@id"]).forEach((id) => {
+		if (!(isObject(id) || isString$1(id) && isAbsoluteIri(id)) || isBlankNodeId(id)) fail("invalid frame", `invalid @id ${stringifyJson(id)}`);
+	});
+	if (hasOwn(f, "@type")) asArray(f["@type"]).forEach((type) => {
+		if (!(isObject(type) || isString$1(type) && isAbsoluteIri(type) || type === "@json") || isBlankNodeId(type)) fail("invalid frame", `invalid @type ${stringifyJson(type)}`);
+	});
+};
+const createImplicitFrame = (flags) => [{
+	"@embed": [flags.embed],
+	"@explicit": [flags.explicit],
+	"@requireAll": [flags.requireAll]
+}];
+const createsCircularReference = (subject, graph, stack) => stack.some((entry) => entry.graph === graph && entry.subject["@id"] === subject["@id"]);
+const addFrameOutput = (parent, property, output) => {
+	if (isObject(parent)) {
+		if (Option.isSome(property)) addValue(parent, property.value, output, true);
+	} else parent.push(output);
+};
+const isSubjectReference = (v) => isObject(v) && Record.keys(v).length === 1 && hasOwn(v, "@id");
+const frameSubjects = (state, subjects, frameValue, parent, property) => {
+	validateFrame(frameValue);
+	const pattern = frameValue[0];
+	const options = state.options;
+	const flags = {
+		embed: getFlag(pattern, options, "embed"),
+		explicit: getFlag(pattern, options, "explicit"),
+		requireAll: getFlag(pattern, options, "requireAll")
+	};
+	const link = getOrInit(state.link, state.graph, () => ({}));
+	const matches = filterSubjects(state, subjects, pattern, flags);
+	Arr.sort(Record.keys(matches), compareStrings).forEach((id) => {
+		const subject = matches[id];
+		if (subject === void 0) return;
+		if (Option.isNone(property)) state.uniqueEmbeds = { [state.graph]: {} };
+		const uniqueEmbeds = getOrInit(state.uniqueEmbeds, state.graph, () => ({}));
+		const output = { "@id": id };
+		if (isBlankNodeId(id)) addValue(state.bnodeMap, id, output, true);
+		link[id] = output;
+		if ((flags.embed === "@first" || flags.embed === "@last") && options.is11) fail("invalid @embed value", flags.embed);
+		if (!state.embedded && hasOwn(uniqueEmbeds, id)) return;
+		if (state.embedded && (flags.embed === "@never" || createsCircularReference(subject, state.graph, state.subjectStack))) {
+			addFrameOutput(parent, property, output);
+			return;
+		}
+		if (state.embedded && (flags.embed === "@first" || flags.embed === "@once") && hasOwn(uniqueEmbeds, id)) {
+			addFrameOutput(parent, property, output);
+			return;
+		}
+		if (flags.embed === "@last" && hasOwn(uniqueEmbeds, id)) removeEmbed(state, id);
+		uniqueEmbeds[id] = {
+			parent,
+			property
+		};
+		state.subjectStack.push({
+			subject,
+			graph: state.graph
+		});
+		const namedGraph = state.graphMap[id];
+		if (hasOwn(state.graphMap, id) && namedGraph !== void 0) {
+			let recurse;
+			let subframe;
+			if (!hasOwn(pattern, "@graph")) {
+				recurse = state.graph !== "@merged";
+				subframe = {};
+			} else {
+				subframe = asArray(pattern["@graph"])[0];
+				recurse = !(id === "@merged" || id === "@default");
+				if (!isObject(subframe)) subframe = {};
+			}
+			if (recurse) frameSubjects({
+				...state,
+				graph: id,
+				subjects: namedGraph,
+				embedded: false
+			}, Arr.sort(Record.keys(namedGraph), compareStrings), [subframe], output, Option.some("@graph"));
+		}
+		if (hasOwn(pattern, "@included")) frameSubjects({
+			...state,
+			embedded: false
+		}, subjects, pattern["@included"], output, Option.some("@included"));
+		Arr.sort(Record.keys(subject), compareStrings).forEach((prop) => {
+			if (isKeyword(prop)) {
+				output[prop] = clone(subject[prop]);
+				if (prop === "@type") asArray(subject["@type"]).forEach((type) => {
+					if (isBlankNodeId(type)) addValue(state.bnodeMap, type, output, true);
+				});
+				return;
+			}
+			if (flags.explicit && !hasOwn(pattern, prop)) return;
+			const underProp = Option.some(prop);
+			subject[prop].forEach((o) => {
+				const subframe = hasOwn(pattern, prop) ? pattern[prop] : createImplicitFrame(flags);
+				if (isListObject(o)) {
+					const first = hasOwn(pattern, prop) ? asArray(pattern[prop])[0] : void 0;
+					const listFrame = isObject(first) && hasOwn(first, "@list") ? first["@list"] : createImplicitFrame(flags);
+					const list = { "@list": [] };
+					addFrameOutput(output, underProp, list);
+					const listProperty = Option.some("@list");
+					asArray(o["@list"]).forEach((oo) => {
+						if (isSubjectReference(oo)) frameSubjects({
+							...state,
+							embedded: true
+						}, [oo["@id"]], listFrame, list, listProperty);
+						else addFrameOutput(list, listProperty, clone(oo));
+					});
+				} else if (isSubjectReference(o)) frameSubjects({
+					...state,
+					embedded: true
+				}, [o["@id"]], subframe, output, underProp);
+				else if (valueMatch(asArray(subframe)[0], o)) addFrameOutput(output, underProp, clone(o));
+			});
+		});
+		Arr.sort(Record.keys(pattern), compareStrings).forEach((prop) => {
+			if (prop === "@type") {
+				const first = asArray(pattern[prop])[0];
+				if (!isObject(first) || !hasOwn(first, "@default")) return;
+			} else if (isKeyword(prop)) return;
+			const next = asArray(pattern[prop])[0] ?? {};
+			if (!getFlag(next, options, "omitDefault") && !hasOwn(output, prop)) {
+				let preserve = "@null";
+				if (hasOwn(next, "@default")) preserve = clone(next["@default"]);
+				output[prop] = [{ "@preserve": asArray(preserve) }];
+			}
+		});
+		if (isObject(pattern["@reverse"])) {
+			const reversePattern = pattern["@reverse"];
+			Arr.sort(Record.keys(reversePattern), compareStrings).forEach((reverseProp) => {
+				const subframe = reversePattern[reverseProp];
+				Record.keys(state.subjects).forEach((s) => {
+					if (asArray(state.subjects[s]?.[reverseProp] ?? []).some((v) => isObject(v) && v["@id"] === id)) {
+						const reverse = output["@reverse"] ??= {};
+						addValue(reverse, reverseProp, [], true);
+						frameSubjects({
+							...state,
+							embedded: true
+						}, [s], subframe, reverse[reverseProp], property);
+					}
+				});
+			});
+		}
+		addFrameOutput(parent, property, output);
+		state.subjectStack.pop();
+	});
+};
+const removeEmbed = (state, id) => {
+	const embeds = state.uniqueEmbeds[state.graph];
+	const embed = embeds?.[id];
+	if (embeds === void 0 || embed === void 0) return;
+	const parent = embed.parent;
+	const subject = { "@id": id };
+	if (Array.isArray(parent)) parent.forEach((v, i) => {
+		if (isObject(v) && v["@id"] === id) parent[i] = subject;
+	});
+	else if (isObject(parent) && Option.isSome(embed.property)) {
+		const property = embed.property.value;
+		parent[property] = asArray(parent[property]).map((v) => isObject(v) && v["@id"] === id ? subject : v);
+	}
+	const removeDependents = (parentId) => {
+		Record.keys(embeds).forEach((next) => {
+			const e = embeds[next];
+			if (e !== void 0 && isObject(e.parent) && e.parent["@id"] === parentId) {
+				delete embeds[next];
+				removeDependents(next);
+			}
+		});
+	};
+	removeDependents(id);
+};
+const filterSubjects = (state, subjects, pattern, flags) => {
+	const result = {};
+	const graph = state.graphMap[state.graph];
+	subjects.forEach((id) => {
+		const subject = graph?.[id];
+		if (subject !== void 0 && filterSubject(state, subject, pattern, flags)) result[id] = subject;
+	});
+	return result;
+};
+const filterSubject = (state, subject, pattern, flags) => {
+	let wildcard = true;
+	let matchesSome = false;
+	let decided = Option.none();
+	const decide = (verdict) => {
+		decided = Option.some(verdict);
+		return true;
+	};
+	Record.keys(pattern).some((key) => {
+		let matchThis = false;
+		const nodeValues = hasOwn(subject, key) ? asArray(subject[key]) : [];
+		const frameValues = asArray(pattern[key]);
+		const isEmpty = Arr.isReadonlyArrayEmpty(frameValues);
+		if (key === "@id") {
+			if (Arr.isReadonlyArrayEmpty(frameValues) || isObject(frameValues[0])) matchThis = true;
+			else matchThis = frameValues.includes(nodeValues[0]);
+			if (!flags.requireAll) return decide(matchThis);
+		} else if (key === "@type") {
+			wildcard = false;
+			if (isEmpty) {
+				if (Arr.isReadonlyArrayNonEmpty(nodeValues)) return decide(false);
+				matchThis = true;
+			} else if (frameValues.length === 1 && isEmptyObject(frameValues[0])) matchThis = Arr.isReadonlyArrayNonEmpty(nodeValues);
+			else {
+				frameValues.forEach((type) => {
+					if (isObject(type) && hasOwn(type, "@default")) matchThis = true;
+					else matchThis = matchThis || nodeValues.some((t) => t === type);
+				});
+				if (!flags.requireAll) return decide(matchThis);
+			}
+		} else if (isKeyword(key)) return false;
+		else {
+			const thisFrame = frameValues[0];
+			let hasDefault = false;
+			if (thisFrame !== void 0) {
+				validateFrame([thisFrame]);
+				hasDefault = hasOwn(thisFrame, "@default");
+			}
+			wildcard = false;
+			if (Arr.isReadonlyArrayEmpty(nodeValues) && hasDefault) return false;
+			if (Arr.isReadonlyArrayNonEmpty(nodeValues) && isEmpty) return decide(false);
+			if (thisFrame === void 0) {
+				if (Arr.isReadonlyArrayNonEmpty(nodeValues)) return decide(false);
+				matchThis = true;
+			} else if (isListObject(thisFrame)) {
+				const listValue = asArray(thisFrame["@list"])[0];
+				if (isListObject(nodeValues[0])) {
+					const nodeListValues = nodeValues[0]["@list"];
+					if (isValueObject(listValue)) matchThis = nodeListValues.some((lv) => valueMatch(listValue, lv));
+					else if (isObject(listValue)) matchThis = nodeListValues.some((lv) => nodeMatch(state, listValue, lv, flags));
+				}
+			} else if (isValueObject(thisFrame)) matchThis = nodeValues.some((nv) => valueMatch(thisFrame, nv));
+			else if (isSubjectReference(thisFrame)) matchThis = nodeValues.some((nv) => nodeMatch(state, thisFrame, nv, flags));
+			else if (isObject(thisFrame)) matchThis = Arr.isReadonlyArrayNonEmpty(nodeValues);
+		}
+		if (!matchThis && flags.requireAll) return decide(false);
+		matchesSome = matchesSome || matchThis;
+		return false;
+	});
+	return Option.getOrElse(decided, () => wildcard || matchesSome);
+};
+const nodeMatch = (state, pattern, value, flags) => {
+	if (!isObject(value) || !hasOwn(value, "@id")) return false;
+	const node = state.subjects[value["@id"]];
+	return node !== void 0 && filterSubject(state, node, pattern, flags);
+};
+const lowerIfString = (s) => isString$1(s) ? s.toLowerCase() : s;
+const valueMatch = (pattern, value) => {
+	if (!isObject(pattern)) return true;
+	const v1 = value["@value"];
+	const t1 = value["@type"];
+	const l1 = value["@language"];
+	const v2 = hasOwn(pattern, "@value") ? asArray(pattern["@value"]) : [];
+	const t2 = hasOwn(pattern, "@type") ? asArray(pattern["@type"]) : [];
+	const l2 = hasOwn(pattern, "@language") ? asArray(pattern["@language"]) : [];
+	if (Arr.isReadonlyArrayEmpty(v2) && Arr.isReadonlyArrayEmpty(t2) && Arr.isReadonlyArrayEmpty(l2)) return true;
+	if (!(v2.includes(v1) || isEmptyObject(v2[0]))) return false;
+	if (!(t1 === void 0 && Arr.isReadonlyArrayEmpty(t2) || t2.includes(t1) || t1 !== void 0 && isEmptyObject(t2[0]))) return false;
+	if (!(l1 === void 0 && Arr.isReadonlyArrayEmpty(l2) || l2.map(lowerIfString).includes(lowerIfString(l1)) || l1 !== void 0 && isEmptyObject(l2[0]))) return false;
+	return true;
+};
+const cleanupPreserve = (input, bnodesToClear, seen) => {
+	if (Array.isArray(input)) return input.map((v) => cleanupPreserve(v, bnodesToClear, seen));
+	if (isObject(input)) {
+		if (hasOwn(input, "@preserve")) return input["@preserve"][0];
+		if (isValueObject(input)) return input;
+		if (isListObject(input)) {
+			input["@list"] = cleanupPreserve(input["@list"], bnodesToClear, seen);
+			return input;
+		}
+		if (seen.has(input)) return input;
+		seen.add(input);
+		Record.keys(input).forEach((prop) => {
+			if (prop === "@id" && MutableHashSet.has(bnodesToClear, input[prop])) {
+				delete input["@id"];
+				return;
+			}
+			input[prop] = cleanupPreserve(input[prop], bnodesToClear, seen);
+		});
+	}
+	return input;
+};
+/**
+* Replaces `@null` placeholders (from frame defaults) by `null`, dropping
+* them from arrays.
+*
+* @internal
+*/
+const cleanupNull = (input, seen = /* @__PURE__ */ new WeakSet()) => {
+	if (Array.isArray(input)) return input.map((v) => cleanupNull(v, seen)).filter((v) => v !== null);
+	if (input === "@null") return null;
+	if (isObject(input)) {
+		if (seen.has(input)) return input;
+		seen.add(input);
+		Record.keys(input).forEach((key) => {
+			input[key] = cleanupNull(input[key], seen);
+		});
+	}
+	return input;
+};
+// src/jsonld/internal/rdf.ts
+/**
+* RDF conversion: Deserialize JSON-LD to RDF and Serialize RDF as JSON-LD
+* (JSON-LD 1.1 API §8).
+*
+* @internal
+*/
+const blankNode = (id) => blankNode$1(id.slice(2));
+/**
+* The nodes of the IRIs seen by the current `toRdf` (none for an IRI that
+* is not well-formed), so that an IRI that recurs (a property, a type, a
+* datatype, a node) is validated and made into a node once. `toRdf` runs
+* synchronously, and empties it before and after.
+*/
+const iriNodes = MutableHashMap.empty();
+/** The node of an IRI, if it is well-formed. */
+const iriNode = (iri) => {
+	const cached = MutableHashMap.get(iriNodes, iri);
+	if (Option.isSome(cached)) return cached.value;
+	const node = isWellFormedIri(iri) ? Option.some(namedNode(iri)) : Option.none();
+	MutableHashMap.set(iriNodes, iri, node);
+	return node;
+};
+const toResource = (id) => isBlankNodeId(id) ? Option.some(blankNode(id)) : iriNode(id);
+/**
+* Converts expanded JSON-LD to quads.
+*
+* @internal
+*/
+const toRdf$1 = (expanded, options) => {
+	const issuer = new IdIssuer();
+	MutableHashMap.clear(iriNodes);
+	const rdfType = namedNode(RDF_TYPE);
+	const nodeMap = { "@default": {} };
+	generateNodeMap(expanded, nodeMap, issuer);
+	const quads = [];
+	Arr.sort(Record.keys(nodeMap), compareStrings).forEach((graphName) => {
+		const graphTerm = graphName === "@default" ? Option.some(defaultGraph) : toResource(graphName);
+		const graph = nodeMap[graphName];
+		if (Option.isNone(graphTerm) || graph === void 0) return;
+		const g = graphTerm.value;
+		Arr.sort(Record.keys(graph), compareStrings).forEach((subject) => {
+			const s = toResource(subject);
+			const node = graph[subject];
+			if (Option.isNone(s) || node === void 0) return;
+			Arr.sort(Record.keys(node), compareStrings).forEach((property) => {
+				const values = node[property];
+				if (property === "@type") {
+					values.forEach((type) => {
+						const o = toResource(type);
+						if (Option.isSome(o)) quads.push(quad(s.value, rdfType, o.value, g));
+					});
+					return;
+				}
+				if (property.startsWith("@")) return;
+				const p = isBlankNodeId(property) ? Option.none() : iriNode(property);
+				if (Option.isNone(p)) return;
+				values.forEach((item) => {
+					const listTriples = [];
+					const o = objectToRdf(item, listTriples, issuer, options);
+					if (Option.isSome(o)) quads.push(quad(s.value, p.value, o.value, g));
+					listTriples.forEach(([ls, lp, lo]) => quads.push(quad(ls, lp, lo, g)));
+				});
+			});
+		});
+	});
+	MutableHashMap.clear(iriNodes);
+	return quads;
+};
+const toDoubleString = (n) => n.toExponential(15).replace(/(\d)0*e\+?/, "$1E");
+const objectToRdf = (item, triples, issuer, options) => {
+	if (!isValueObject(item) && !isListObject(item)) return toResource(item["@id"]);
+	if (isListObject(item)) return Option.some(listToRdf(item["@list"], triples, issuer, options));
+	let value = item["@value"];
+	const type = item["@type"];
+	const typed = type !== void 0 && type !== null;
+	if (typed && type !== "@json" && Option.isNone(iriNode(type))) return Option.none();
+	if ("@language" in item && !isWellFormedLanguage(item["@language"])) return Option.none();
+	let datatype;
+	if (type === "@json") {
+		value = canonicalJson(value);
+		datatype = RDF_JSON;
+	} else if (Predicate.isBoolean(value)) {
+		value = value ? "true" : "false";
+		datatype = typed ? type : XSD_BOOLEAN;
+	} else if (Predicate.isNumber(value) && (!Number.isInteger(value) || Math.abs(value) >= 1e21 || type === "http://www.w3.org/2001/XMLSchema#double")) {
+		value = toDoubleString(value);
+		datatype = typed ? type : XSD_DOUBLE;
+	} else if (Predicate.isNumber(value)) {
+		value = value.toFixed(0);
+		datatype = typed ? type : XSD_INTEGER;
+	} else datatype = typed ? type : "@language" in item ? RDF_LANG_STRING : XSD_STRING;
+	if ("@direction" in item && Option.isSome(options.rdfDirection)) {
+		const language = "@language" in item ? String(item["@language"]).toLowerCase() : "";
+		if (options.rdfDirection.value === "i18n-datatype") return Option.some(literal(String(value), namedNode(`${I18N}${language}_${item["@direction"]}`)));
+		const literal$1 = blankNode(issuer.issue());
+		triples.push([
+			literal$1,
+			namedNode(RDF_VALUE),
+			literal(String(value))
+		]);
+		if ("@language" in item) triples.push([
+			literal$1,
+			namedNode(RDF_LANGUAGE),
+			literal(language)
+		]);
+		triples.push([
+			literal$1,
+			namedNode(RDF_DIRECTION),
+			literal(item["@direction"])
+		]);
+		return Option.some(literal$1);
+	}
+	if ("@language" in item) return Option.some(literal(String(value), String(item["@language"])));
+	return Option.some(literal(String(value), Option.getOrElse(iriNode(datatype), () => namedNode(datatype))));
+};
+const listToRdf = (list, triples, issuer, options) => {
+	const nil = namedNode(RDF_NIL);
+	const bnodes = list.map(() => blankNode(issuer.issue()));
+	const first = namedNode(RDF_FIRST);
+	const rest = namedNode(RDF_REST);
+	bnodes.forEach((subject, i) => {
+		const embedded = [];
+		const o = objectToRdf(list[i], embedded, issuer, options);
+		if (Option.isSome(o)) triples.push([
+			subject,
+			first,
+			o.value
+		]);
+		triples.push([
+			subject,
+			rest,
+			bnodes[i + 1] ?? nil
+		]);
+		embedded.forEach((triple) => triples.push(triple));
+	});
+	return bnodes[0] ?? nil;
+};
+const termId = (t) => isBlankNode(t) ? `_:${t.value}` : isNamedNode(t) ? t.value : isDefaultGraph(t) ? "@default" : t.key;
+const DOUBLE_RE = /^(\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)?$|^(\+|-)?INF$|^NaN$/;
+/**
+* Serialize RDF as JSON-LD algorithm.
+*
+* @internal
+*/
+const fromRdf$1 = (quads, options) => {
+	const defaultGraph = {};
+	const graphMap = {};
+	graphMap["@default"] = defaultGraph;
+	const referencedOnce = {};
+	const compoundLiteralSubjects = {};
+	const nilUsages = {};
+	const seen = MutableHashSet.empty();
+	const compoundLiterals = Option.isSome(options.rdfDirection) && options.rdfDirection.value === "compound-literal";
+	Iterable.forEach(quads, (q) => {
+		const before = MutableHashSet.size(seen);
+		if (MutableHashSet.size(MutableHashSet.add(seen, q.key)) === before) return;
+		const name = termId(q.graph);
+		const nodeMap = getOrInit(graphMap, name, () => ({}));
+		const compoundMap = getOrInit(compoundLiteralSubjects, name, () => MutableHashSet.empty());
+		const usages = getOrInit(nilUsages, name, () => []);
+		if (name !== "@default" && !hasOwn(defaultGraph, name)) defaultGraph[name] = { "@id": name };
+		const subject = termId(q.subject);
+		const predicate = q.predicate.value;
+		const object = q.object;
+		const node = getOrInit(nodeMap, subject, () => ({ "@id": subject }));
+		if (compoundLiterals && predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#direction") MutableHashSet.add(compoundMap, subject);
+		const isBlank = isBlankNode(object);
+		const isResource = isBlank || isNamedNode(object);
+		const objectId = isResource ? termId(object) : "";
+		if (isResource && !hasOwn(nodeMap, objectId)) nodeMap[objectId] = { "@id": objectId };
+		if (predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" && isResource && !options.useRdfType) {
+			const types = getOrInit(node, "@type", () => []);
+			if (!types.includes(objectId)) types.push(objectId);
+			return;
+		}
+		const value = rdfToObject(object, options);
+		const values = getOrInit(node, predicate, () => []);
+		let stored = value;
+		const existing = values.find((v) => deepEqual(v, value));
+		if (existing === void 0) values.push(value);
+		else stored = existing;
+		if (isResource && objectId === "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil") usages.push({
+			node,
+			property: predicate,
+			value: stored
+		});
+		else if (isResource && hasOwn(referencedOnce, objectId)) referencedOnce[objectId] = false;
+		else if (isBlank) referencedOnce[objectId] = {
+			node,
+			property: predicate,
+			value: stored
+		};
+	});
+	Record.keys(graphMap).forEach((name) => {
+		const graphObject = graphMap[name];
+		if (graphObject === void 0) return;
+		Iterable.forEach(compoundLiteralSubjects[name] ?? [], (cl) => {
+			const clEntry = referencedOnce[cl];
+			if (!clEntry) return;
+			const { node, property } = clEntry;
+			const clNode = graphObject[cl];
+			delete graphObject[cl];
+			if (clNode === void 0) return;
+			node[property].forEach((clReference) => {
+				if (clReference["@id"] !== cl) return;
+				delete clReference["@id"];
+				clReference["@value"] = clNode[RDF_VALUE]?.[0]?.["@value"];
+				if ("http://www.w3.org/1999/02/22-rdf-syntax-ns#language" in clNode) {
+					const lang = clNode[RDF_LANGUAGE][0]["@value"];
+					if (!Predicate.isString(lang) || !isWellFormedLanguage(lang)) fail("invalid language-tagged string");
+					clReference["@language"] = lang;
+				}
+				if ("http://www.w3.org/1999/02/22-rdf-syntax-ns#direction" in clNode) {
+					const dir = clNode[RDF_DIRECTION][0]["@value"];
+					if (dir !== "ltr" && dir !== "rtl") fail("invalid base direction");
+					clReference["@direction"] = dir;
+				}
+			});
+		});
+		if (!("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil" in graphObject)) return;
+		(nilUsages[name] ?? []).forEach((usage) => {
+			const list = [];
+			const listNodes = [];
+			const { head } = loop({
+				node: usage.node,
+				property: usage.property,
+				head: usage.value,
+				done: false
+			}, (walk) => {
+				const { node } = walk;
+				if (walk.done || walk.property !== "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest") return Option.none();
+				if (!isWellFormedListNode(node, referencedOnce)) return Option.none();
+				const nodeUsage = referencedOnce[node["@id"]];
+				if (!nodeUsage) return Option.none();
+				list.push(node[RDF_FIRST][0]);
+				listNodes.push(node["@id"]);
+				return Option.some({
+					node: nodeUsage.node,
+					property: nodeUsage.property,
+					head: nodeUsage.value,
+					done: !isBlankNodeId(nodeUsage.node["@id"])
+				});
+			});
+			delete head["@id"];
+			list.reverse();
+			head["@list"] = list;
+			listNodes.forEach((id) => {
+				delete graphObject[id];
+			});
+		});
+	});
+	const result = [];
+	(options.ordered ? Arr.sort(Record.keys(defaultGraph), compareStrings) : Record.keys(defaultGraph)).forEach((subject) => {
+		const node = defaultGraph[subject];
+		if (node === void 0) return;
+		const graph = graphMap[subject];
+		if (hasOwn(graphMap, subject) && subject !== "@default" && graph !== void 0) {
+			const nodes = node["@graph"] = [];
+			(options.ordered ? Arr.sort(Record.keys(graph), compareStrings) : Record.keys(graph)).forEach((k) => {
+				const n = graph[k];
+				if (n !== void 0 && !isOnlyId(n)) nodes.push(n);
+			});
+		}
+		if (!isOnlyId(node)) result.push(node);
+	});
+	return result;
+};
+const isOnlyId = (n) => Record.keys(n).length === 1 && "@id" in n;
+const isWellFormedListNode = (node, referencedOnce) => {
+	const id = node["@id"];
+	if (!isBlankNodeId(id)) return false;
+	if (!isObject(referencedOnce[id])) return false;
+	const first = node[RDF_FIRST];
+	const rest = node[RDF_REST];
+	if (!Array.isArray(first) || first.length !== 1) return false;
+	if (!Array.isArray(rest) || rest.length !== 1) return false;
+	return Record.keys(node).every((k) => {
+		if (k === "@id" || k === "http://www.w3.org/1999/02/22-rdf-syntax-ns#first" || k === "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest") return true;
+		const t = node["@type"];
+		return k === "@type" && Array.isArray(t) && t.length === 1 && t[0] === "http://www.w3.org/1999/02/22-rdf-syntax-ns#List";
+	});
+};
+const rdfToObject = (object, options) => {
+	if (!isLiteral(object)) return { "@id": termId(object) };
+	const result = {};
+	let converted = object.value;
+	let type = Option.none();
+	const datatype = object.datatype.value;
+	const isJson = options.processingMode !== "json-ld-1.0" && datatype === "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON";
+	if (isJson) {
+		converted = Result.getOrElse(parseJson(converted), () => fail("invalid JSON literal"));
+		type = Option.some("@json");
+	} else if (options.useNativeTypes) {
+		if (datatype === "http://www.w3.org/2001/XMLSchema#string") {} else if (datatype === "http://www.w3.org/2001/XMLSchema#boolean") {
+			if (converted === "true" || converted === "1") converted = true;
+			else if (converted === "false" || converted === "0") converted = false;
+			else type = Option.some(datatype);
+		} else if (datatype === "http://www.w3.org/2001/XMLSchema#integer" && /^[+-]?[0-9]+$/.test(converted)) {
+			const n = Number(converted);
+			if (Number.isSafeInteger(n)) converted = n;
+			else type = Option.some(datatype);
+		} else if (datatype === "http://www.w3.org/2001/XMLSchema#double" && DOUBLE_RE.test(converted)) {
+			const n = Number(converted.replace(/INF$/, "Infinity"));
+			if (Number.isFinite(n)) converted = n;
+			else type = Option.some(datatype);
+		} else if (object.language === "") type = Option.some(datatype);
+	}
+	if (isJson) {} else if (datatype.startsWith("https://www.w3.org/ns/i18n#") && Option.isSome(options.rdfDirection) && options.rdfDirection.value === "i18n-datatype") {
+		const fragment = datatype.slice(27);
+		const i = fragment.indexOf("_");
+		const language = i === -1 ? fragment : fragment.slice(0, i);
+		if (language !== "") result["@language"] = language;
+		if (i !== -1) result["@direction"] = fragment.slice(i + 1);
+		type = Option.none();
+	} else if (object.language !== "") {
+		result["@language"] = object.language;
+		if (object.direction !== void 0) result["@direction"] = object.direction;
+		type = Option.none();
+	} else if (!options.useNativeTypes && datatype !== "http://www.w3.org/2001/XMLSchema#string" && Option.isNone(type)) type = Option.some(datatype);
+	result["@value"] = converted;
+	if (Option.isSome(type)) result["@type"] = type.value;
+	return result;
+};
+// src/jsonld/JsonLd.ts
+/**
+* The JSON-LD 1.1 processor: expansion, compaction, flattening, framing and
+* conversion to and from RDF, plus a `Serialization.Codec` for the
+* `application/ld+json` media type.
+*
+* Remote documents and contexts are loaded through the `DocumentLoader`
+* service when it is provided (or through `options.documentLoader`); without
+* one, any remote reference fails with `loading remote context failed` /
+* `loading document failed`.
+*
+* @since 0.1.0
+*/
+var JsonLd_exports = /* @__PURE__ */ __exportAll({
+	codec: () => codec,
+	compact: () => compact,
+	expand: () => expand,
+	flatten: () => flatten,
+	format: () => format,
+	frame: () => frame,
+	fromRdf: () => fromRdf,
+	parse: () => parse,
+	parser: () => parser,
+	serialize: () => serialize,
+	serializer: () => serializer,
+	toQuads: () => toQuads,
+	toRdf: () => toRdf
+});
+/** An empty context (`{}` or `[]`), which compaction leaves out of the output. */
+const isEmptyContext = (context) => isEmptyObject(context) || Array.isArray(context) && Arr.isReadonlyArrayEmpty(context);
+const getLoader = (options) => options?.documentLoader !== void 0 ? Effect.succeed(options.documentLoader) : Effect.map(Effect.serviceOption(DocumentLoader), (o) => Option.getOrElse(o, () => none));
+/**
+* The environment of one algorithm run: documents come from `docs`, and a
+* document not loaded yet aborts the run with `NeedDocument`.
+*/
+const makeEnv = (docs, options) => ({
+	processingMode: options?.processingMode ?? "json-ld-1.1",
+	contextCache: MutableHashMap.empty(),
+	load: (url) => {
+		const hit = MutableHashMap.get(docs, url);
+		if (Option.isNone(hit)) throw new NeedDocument(url);
+		if (Result.isFailure(hit.value)) throw hit.value.failure;
+		return hit.value.success;
+	}
+});
+/**
+* Runs the algorithm once. A `NeedDocument` or `JsonLdError` it throws is the
+* failure; anything else is a bug and propagates (a defect in `run`).
+*/
+const attempt = (f, env) => Result.try({
+	try: () => f(env),
+	catch: (e) => {
+		if (e instanceof NeedDocument || isJsonLdError(e)) return e;
+		throw e;
+	}
+});
+/**
+* Runs a pure algorithm, loading documents on demand: when the algorithm
+* needs a document that has not been loaded yet it aborts with
+* `NeedDocument`, the document is loaded, and the algorithm is restarted.
+*/
+const run = (f, options) => Effect.gen(function* () {
+	const loader = yield* getLoader(options);
+	const docs = MutableHashMap.empty();
+	const env = makeEnv(docs, options);
+	const go = Effect.suspend(() => {
+		const step = attempt(f, env);
+		if (Result.isSuccess(step)) return Effect.succeed(step.success);
+		const failure = step.failure;
+		if (!(failure instanceof NeedDocument)) return Effect.fail(failure);
+		return Effect.flatMap(Effect.result(loader.load(failure.url, { profile: "http://www.w3.org/ns/json-ld#context" })), (r) => {
+			MutableHashMap.set(docs, failure.url, r);
+			return go;
+		});
+	});
+	return yield* go;
+});
+const isRemoteDocument = (u) => isObject(u) && Predicate.isString(u["documentUrl"]) && "document" in u;
+/** Resolves an input (an `Input`, or a frame, which is any JSON-LD input). */
+const resolveInput = (input, options) => Effect.gen(function* () {
+	if (isString$1(input)) {
+		const doc = yield* (yield* getLoader(options)).load(input, { extractAllScripts: options?.extractAllScripts }).pipe(Effect.mapError((e) => e.code === "loading document failed" || e.code === "multiple context link headers" ? e : make$1("loading document failed", e.message)));
+		return {
+			document: doc.document,
+			documentUrl: doc.documentUrl,
+			contextUrl: Option.fromUndefinedOr(doc.contextUrl)
+		};
+	}
+	if (isRemoteDocument(input)) return {
+		document: input.document,
+		documentUrl: input.documentUrl,
+		contextUrl: Option.fromUndefinedOr(input.contextUrl)
+	};
+	return {
+		document: input,
+		documentUrl: null,
+		contextUrl: Option.none()
+	};
+});
+const expandSync = (env, input, frameExpansion, options) => {
+	const base = options?.base !== void 0 ? options.base : input.documentUrl;
+	let active = initialContext(base);
+	if (options?.expandContext !== void 0 && options.expandContext !== null) {
+		let ctx = options.expandContext;
+		if (isObject(ctx) && "@context" in ctx) ctx = ctx["@context"];
+		active = processContext(env, active, ctx, active.originalBase);
+	}
+	if (Option.isSome(input.contextUrl)) {
+		const contextUrl = input.contextUrl.value;
+		active = processContext(env, active, contextUrl, contextUrl);
+	}
+	let expanded = expandElement(env, active, Option.none(), input.document, input.documentUrl ?? base, {
+		frameExpansion,
+		ordered: options?.ordered ?? false
+	});
+	if (isObject(expanded) && Record.keys(expanded).length === 1 && "@graph" in expanded) expanded = expanded["@graph"];
+	if (expanded === null || expanded === void 0) expanded = [];
+	if (!Array.isArray(expanded)) expanded = [expanded];
+	return expanded;
+};
+const compactSync = (env, expanded, context, documentUrl, options) => {
+	if (isObject(context) && "@context" in context) context = context["@context"];
+	const compactToRelative = options?.compactToRelative ?? true;
+	const base = options?.base !== void 0 && options.base !== null ? options.base : compactToRelative ? documentUrl : null;
+	const contextBase = isString$1(context) ? context : options?.base ?? documentUrl ?? null;
+	let active = initialContext(base);
+	active = processContext(env, active, context ?? null, contextBase);
+	const compactOptions = {
+		compactArrays: options?.compactArrays ?? true,
+		ordered: options?.ordered ?? false,
+		compactToRelative
+	};
+	let compacted = compactElement(env, active, Option.none(), expanded, compactOptions);
+	if (Array.isArray(compacted)) compacted = Arr.isReadonlyArrayEmpty(compacted) ? {} : { [compactIri(env, active, "@graph", null, true, false, compactOptions)]: compacted };
+	if (compacted === null || compacted === void 0) compacted = {};
+	if (context !== null && context !== void 0 && !isEmptyContext(context)) compacted = {
+		"@context": context,
+		...compacted
+	};
+	return compacted;
+};
+/**
+* Expands a JSON-LD document (JSON-LD 1.1 API, Expansion Algorithm).
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const expand = (input, options) => Effect.flatMap(resolveInput(input, options), (resolved) => run((env) => expandSync(env, resolved, false, options), options));
+/**
+* Compacts a JSON-LD document against a context (JSON-LD 1.1 API,
+* Compaction Algorithm). The context may be a context definition, an array
+* of contexts, an IRI, or a document with an `@context` entry.
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const compact = (input, context, options) => Effect.flatMap(resolveInput(input, options), (resolved) => run((env) => {
+	const expanded = expandSync(env, resolved, false, {
+		...options,
+		ordered: false
+	});
+	return compactSync(env, expanded, context, resolved.documentUrl, options);
+}, options));
+/**
+* Flattens a JSON-LD document (JSON-LD 1.1 API, Flattening Algorithm),
+* optionally compacting the result.
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const flatten = (input, context, options) => Effect.flatMap(resolveInput(input, options), (resolved) => run((env) => {
+	const expanded = expandSync(env, resolved, false, options);
+	const flattened = flattenExpanded(expanded, options?.ordered ?? false);
+	if (context === void 0 || context === null) return flattened;
+	return compactSync(env, flattened, context, resolved.documentUrl, options);
+}, options));
+/**
+* Frames a JSON-LD document (JSON-LD 1.1 Framing).
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const frame = (input, frameInput, options) => Effect.gen(function* () {
+	const resolved = yield* resolveInput(input, options);
+	const resolvedFrame = yield* resolveInput(frameInput, options);
+	return yield* run((env) => frameSync(env, resolved, resolvedFrame, options), options);
+});
+/** The `@context` entry of a document (`null` when it has none). */
+const contextOf = (document) => document["@context"] ?? null;
+const frameSync = (env, resolved, resolvedFrame, options) => {
+	const frameDocument = resolvedFrame.document;
+	if (!isObject(frameDocument) && !Array.isArray(frameDocument)) return fail("invalid frame", "a frame must be a JSON object");
+	const context = isObject(frameDocument) ? contextOf(frameDocument) : null;
+	const base = options?.base !== void 0 ? options.base : resolved.documentUrl;
+	const frameBase = resolvedFrame.documentUrl ?? base;
+	const frameContext = processContext(env, initialContext(frameBase), context, frameBase);
+	const merged = !(isObject(frameDocument) && Record.keys(frameDocument).some((k) => expandIri(env, frameContext, k, true) === "@graph"));
+	const expanded = expandSync(env, resolved, false, {
+		...options,
+		ordered: false
+	});
+	const expandedFrame = expandSync(env, resolvedFrame, true, {
+		...options,
+		ordered: false
+	});
+	const is11 = env.processingMode !== "json-ld-1.0";
+	const framed = frame$1(expanded, expandedFrame, {
+		embed: options?.embed ?? "@once",
+		explicit: options?.explicit ?? false,
+		omitDefault: options?.omitDefault ?? false,
+		requireAll: options?.requireAll ?? false,
+		ordered: options?.ordered ?? false,
+		merged,
+		is11
+	});
+	const compactToRelative = options?.compactToRelative ?? true;
+	let active = initialContext(options?.base != null ? options.base : compactToRelative ? resolved.documentUrl : null);
+	active = processContext(env, active, context, frameBase);
+	const compactOptions = {
+		compactArrays: options?.compactArrays ?? true,
+		ordered: options?.ordered ?? false,
+		compactToRelative
+	};
+	const omitGraph = options?.omitGraph ?? is11;
+	let compacted = compactElement(env, active, Option.none(), framed, compactOptions);
+	if (omitGraph && Array.isArray(compacted)) {
+		if (compacted.length === 1 && compactOptions.compactArrays) compacted = compacted[0];
+	} else if (!omitGraph && isObject(compacted)) compacted = [compacted];
+	if (Array.isArray(compacted)) compacted = { [compactIri(env, active, "@graph", null, true, false, compactOptions)]: compacted };
+	if (compacted === null || compacted === void 0) compacted = {};
+	if (context !== null && !isEmptyContext(context)) compacted = {
+		"@context": context,
+		...compacted
+	};
+	return cleanupNull(compacted);
+};
+/**
+* Converts a JSON-LD document to an RDF dataset (Deserialize JSON-LD to RDF
+* Algorithm).
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const toRdf = (input, options) => Effect.map(toQuads(input, options), fromIterable);
+/**
+* Like `toRdf`, but returns the quads in document order.
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const toQuads = (input, options) => quadsOf(input, options);
+/** `toQuads` over any parsed JSON document. */
+const quadsOf = (input, options) => Effect.flatMap(resolveInput(input, options), (resolved) => run((env) => {
+	const expanded = expandSync(env, resolved, false, options);
+	return toRdf$1(expanded, {
+		produceGeneralizedRdf: options?.produceGeneralizedRdf ?? false,
+		rdfDirection: Option.fromNullishOr(options?.rdfDirection)
+	});
+}, options));
+/**
+* Converts RDF quads to expanded JSON-LD (Serialize RDF as JSON-LD
+* Algorithm).
+*
+* @since 0.1.0
+* @category algorithms
+*/
+const fromRdf = (quads, options) => Effect.try({
+	try: () => fromRdf$1(quads, {
+		rdfDirection: Option.fromNullishOr(options?.rdfDirection),
+		useNativeTypes: options?.useNativeTypes ?? false,
+		useRdfType: options?.useRdfType ?? false,
+		ordered: options?.ordered ?? false,
+		processingMode: options?.processingMode ?? "json-ld-1.1"
+	}),
+	catch: (e) => isJsonLdError(e) ? e : make$1("invalid JSON literal", String(e))
+});
+/**
+* The JSON-LD format.
+*
+* @since 0.1.0
+* @category formats
+*/
+const format = makeFormat({
+	name: "JSON-LD",
+	mediaType: "application/ld+json",
+	extensions: ["jsonld"],
+	datasets: true
+});
+const trace = {
+	module: "JsonLd",
+	format
+};
+const JSON_WS = /[ \t\n\r]*/y;
+/** Finds the offset of the first JSON syntax error in `input`. */
+const jsonErrorOffset = (input) => {
+	let i = 0;
+	const scan = (re) => {
+		re.lastIndex = i;
+		re.exec(input);
+		i = re.lastIndex;
+	};
+	const ws = () => scan(JSON_WS);
+	const stop = () => {
+		throw i;
+	};
+	const literal = (word) => {
+		if (input.startsWith(word, i)) i += word.length;
+		else stop();
+	};
+	const string = () => {
+		i++;
+		loop(true, () => {
+			if (i >= input.length || input[i] === "\"") return Option.none();
+			if (input[i] === "\\") i++;
+			else if (input.charCodeAt(i) < 32) stop();
+			i++;
+			return Option.some(true);
+		});
+		if (i >= input.length) stop();
+		i++;
+	};
+	const value = () => {
+		ws();
+		const c = input[i];
+		if (c === "{" || c === "[") {
+			const close = c === "{" ? "}" : "]";
+			i++;
+			ws();
+			if (input[i] === close) {
+				i++;
+				return;
+			}
+			loop(true, () => {
+				if (c === "{") {
+					ws();
+					if (input[i] !== "\"") stop();
+					string();
+					ws();
+					if (input[i] !== ":") stop();
+					i++;
+				}
+				value();
+				ws();
+				if (input[i] === ",") {
+					i++;
+					return Option.some(true);
+				}
+				if (input[i] !== close) stop();
+				i++;
+				return Option.none();
+			});
+		} else if (c === "\"") string();
+		else if (c === "t") literal("true");
+		else if (c === "f") literal("false");
+		else if (c === "n") literal("null");
+		else {
+			const m = /^-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/.exec(input.slice(i));
+			if (m === null || m[0] === "") return stop();
+			i += m[0].length;
+		}
+	};
+	return Result.merge(Result.try({
+		try: () => {
+			value();
+			ws();
+			return i;
+		},
+		catch: () => i
+	}));
+};
+const positionOf = (input) => {
+	const pos = jsonErrorOffset(input);
+	const before = input.slice(0, pos);
+	return {
+		line: before.split("\n").length,
+		column: pos - before.lastIndexOf("\n")
+	};
+};
+/**
+* Parses a JSON-LD document into RDF.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parse = (input, options) => Effect.gen(function* () {
+	const json = yield* Effect.fromResult(parseJson(input)).pipe(Effect.mapError((e) => new RdfParseError({
+		format: format.name,
+		message: `invalid JSON: ${String(e)}`,
+		...positionOf(input)
+	})));
+	const base = options?.base !== void 0 ? options.base : options?.baseIri ?? null;
+	const quads = yield* quadsOf(json, {
+		...options,
+		base
+	}).pipe(Effect.mapError((e) => new RdfParseError({
+		format: format.name,
+		message: e.message
+	})));
+	const prefix = options?.blankNodePrefix ?? freshBlankNodePrefix();
+	const graph = options?.graph;
+	const relabel = (t) => isBlankNode(t) ? blankNode$1(`${prefix}${t.value}`) : t;
+	return {
+		dataset: fromIterable(quads.map((q) => {
+			const relabelled = mapTerms(q, relabel);
+			return graph !== void 0 && isDefaultGraph(relabelled.graph) ? quad(relabelled.subject, relabelled.predicate, relabelled.object, graph) : relabelled;
+		})),
+		prefixes: prefixesOf(json),
+		baseIri: base ?? void 0
+	};
+}).pipe(withParseSpan(trace, input));
+const prefixesOf = (json) => {
+	const entries = [];
+	const visit = (ctx) => {
+		if (Array.isArray(ctx)) ctx.forEach(visit);
+		else if (isObject(ctx)) Record.keys(ctx).forEach((k) => {
+			if (k.startsWith("@") || k.includes(":")) return;
+			const v = ctx[k];
+			const iri = isString$1(v) ? v : isObject(v) && isString$1(v["@id"]) ? v["@id"] : void 0;
+			if (iri !== void 0 && /[/#:]$/.test(iri) && /^[a-z][a-z0-9+.-]*:/i.test(iri)) entries.push([k, iri]);
+		});
+	};
+	if (isObject(json)) visit(json["@context"]);
+	return make(entries);
+};
+/**
+* Serialises quads as a JSON-LD document. Without a context (and without
+* prefixes) the output is expanded JSON-LD; otherwise it is compacted with
+* the given context, extended with one term per prefix.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serialize = (quads, options) => Effect.gen(function* () {
+	const expanded = yield* fromRdf(quads, options);
+	let context = options?.context ?? null;
+	if (isObject(context) && "@context" in context) context = context["@context"];
+	if (options?.prefixes !== void 0 && options.prefixes.prefixes.size > 0) {
+		const prefixContext = {};
+		options.prefixes.prefixes.forEach((namespace, prefix) => {
+			prefixContext[prefix] = namespace;
+		});
+		if (options.baseIri !== void 0) prefixContext["@base"] = options.baseIri;
+		context = context === null ? prefixContext : Array.isArray(context) ? [prefixContext, ...context] : [prefixContext, context];
+	}
+	const output = context === null ? expanded : yield* compact(expanded, context, {
+		base: options?.baseIri ?? null,
+		compactArrays: options?.compactArrays,
+		processingMode: options?.processingMode,
+		documentLoader: options?.documentLoader
+	});
+	return yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown, { space: options?.indent ?? 2 }))(output);
+}).pipe(Effect.mapError((e) => new RdfSerializeError({
+	format: format.name,
+	message: e.message
+})), withSerializeSpan(trace));
+/**
+* The JSON-LD parser.
+*
+* @since 0.1.0
+* @category parsing
+*/
+const parser = makeParser({
+	format,
+	parse
+});
+/**
+* The JSON-LD serializer.
+*
+* @since 0.1.0
+* @category serializing
+*/
+const serializer = makeSerializer({
+	format,
+	serialize
+});
+/**
+* The JSON-LD codec.
+*
+* @since 0.1.0
+* @category codecs
+*/
+const codec = makeCodec(parser, serializer);
+export { flatten as a, fromRdf as c, serialize as d, serializer as f, expand as i, parse as l, toRdf as m, codec as n, format as o, toQuads as p, compact as r, frame as s, JsonLd_exports as t, parser as u };
+
+//# sourceMappingURL=JsonLd-DOwS2FHg.mjs.map