solid-ui 3.1.3-0 → 3.1.3-10

package/dist/chunks/jsonld-B61R4iOL.js

@@ -0,0 +1,4156 @@
+import { t as e } from "./rolldown-runtime-B1bRi_D7.js";
+//#region node_modules/rdf-canonize/lib/IdentifierIssuer.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	t.exports = class e {
+		constructor(e, t = /* @__PURE__ */ new Map(), n = 0) {
+			this.prefix = e, this._existing = t, this.counter = n;
+		}
+		clone() {
+			let { prefix: t, _existing: n, counter: r } = this;
+			return new e(t, new Map(n), r);
+		}
+		getId(e) {
+			let t = e && this._existing.get(e);
+			if (t) return t;
+			let n = this.prefix + this.counter;
+			return this.counter++, e && this._existing.set(e, n), n;
+		}
+		hasId(e) {
+			return this._existing.has(e);
+		}
+		getOldIds() {
+			return [...this._existing.keys()];
+		}
+	};
+})), n = /* @__PURE__ */ e((() => {
+	(function(e, t) {
+		if (e.setImmediate) return;
+		var n = 1, r = {}, i = !1, a = e.document, o;
+		function s(e) {
+			typeof e != "function" && (e = Function("" + e));
+			for (var t = Array(arguments.length - 1), i = 0; i < t.length; i++) t[i] = arguments[i + 1];
+			return r[n] = {
+				callback: e,
+				args: t
+			}, o(n), n++;
+		}
+		function c(e) {
+			delete r[e];
+		}
+		function l(e) {
+			var n = e.callback, r = e.args;
+			switch (r.length) {
+				case 0:
+					n();
+					break;
+				case 1:
+					n(r[0]);
+					break;
+				case 2:
+					n(r[0], r[1]);
+					break;
+				case 3:
+					n(r[0], r[1], r[2]);
+					break;
+				default:
+					n.apply(t, r);
+					break;
+			}
+		}
+		function u(e) {
+			if (i) setTimeout(u, 0, e);
+			else {
+				var t = r[e];
+				if (t) {
+					i = !0;
+					try {
+						l(t);
+					} finally {
+						c(e), i = !1;
+					}
+				}
+			}
+		}
+		function d() {
+			o = function(e) {
+				process.nextTick(function() {
+					u(e);
+				});
+			};
+		}
+		function f() {
+			if (e.postMessage && !e.importScripts) {
+				var t = !0, n = e.onmessage;
+				return e.onmessage = function() {
+					t = !1;
+				}, e.postMessage("", "*"), e.onmessage = n, t;
+			}
+		}
+		function p() {
+			var t = "setImmediate$" + Math.random() + "$", n = function(n) {
+				n.source === e && typeof n.data == "string" && n.data.indexOf(t) === 0 && u(+n.data.slice(t.length));
+			};
+			e.addEventListener ? e.addEventListener("message", n, !1) : e.attachEvent("onmessage", n), o = function(n) {
+				e.postMessage(t + n, "*");
+			};
+		}
+		function m() {
+			var e = new MessageChannel();
+			e.port1.onmessage = function(e) {
+				var t = e.data;
+				u(t);
+			}, o = function(t) {
+				e.port2.postMessage(t);
+			};
+		}
+		function h() {
+			var e = a.documentElement;
+			o = function(t) {
+				var n = a.createElement("script");
+				n.onreadystatechange = function() {
+					u(t), n.onreadystatechange = null, e.removeChild(n), n = null;
+				}, e.appendChild(n);
+			};
+		}
+		function g() {
+			o = function(e) {
+				setTimeout(u, 0, e);
+			};
+		}
+		var _ = Object.getPrototypeOf && Object.getPrototypeOf(e);
+		_ = _ && _.setTimeout ? _ : e, {}.toString.call(e.process) === "[object process]" ? d() : f() ? p() : e.MessageChannel ? m() : a && "onreadystatechange" in a.createElement("script") ? h() : g(), _.setImmediate = s, _.clearImmediate = c;
+	})(typeof self > "u" ? typeof global > "u" ? void 0 : global : self);
+})), r = /* @__PURE__ */ e(((e) => {
+	n(), e.setImmediate = setImmediate, e.crypto = globalThis.crypto;
+	var t = [];
+	for (let e = 0; e <= 255; ++e) t.push(e.toString(16).padStart(2, "0"));
+	e.bufferToHex = function(e) {
+		let n = "", r = new Uint8Array(e);
+		for (let e = 0; e < r.length; ++e) n += t[r[e]];
+		return n;
+	};
+})), i = /* @__PURE__ */ e(((e, t) => {
+	var { bufferToHex: n, crypto: i } = r(), a = /* @__PURE__ */ new Map([
+		["sha256", "SHA-256"],
+		["SHA256", "SHA-256"],
+		["SHA-256", "SHA-256"],
+		["sha384", "SHA-384"],
+		["SHA384", "SHA-384"],
+		["SHA-384", "SHA-384"],
+		["sha512", "SHA-512"],
+		["SHA512", "SHA-512"],
+		["SHA-512", "SHA-512"]
+	]);
+	t.exports = class {
+		constructor(e) {
+			if (!(i && i.subtle)) throw Error("crypto.subtle not found.");
+			if (!a.has(e)) throw Error(`Unsupported algorithm "${e}".`);
+			this.algorithm = a.get(e), this._content = "";
+		}
+		update(e) {
+			this._content += e;
+		}
+		async digest() {
+			let e = new TextEncoder().encode(this._content);
+			return n(await i.subtle.digest(this.algorithm, e));
+		}
+	};
+})), a = /* @__PURE__ */ e(((e, t) => {
+	t.exports = class {
+		constructor(e) {
+			this.current = e.sort(), this.done = !1, this.dir = /* @__PURE__ */ new Map();
+			for (let t = 0; t < e.length; ++t) this.dir.set(e[t], !0);
+		}
+		hasNext() {
+			return !this.done;
+		}
+		next() {
+			let { current: e, dir: t } = this, n = e.slice(), r = null, i = 0, a = e.length;
+			for (let n = 0; n < a; ++n) {
+				let o = e[n], s = t.get(o);
+				(r === null || o > r) && (s && n > 0 && o > e[n - 1] || !s && n < a - 1 && o > e[n + 1]) && (r = o, i = n);
+			}
+			if (r === null) this.done = !0;
+			else {
+				let n = t.get(r) ? i - 1 : i + 1;
+				e[i] = e[n], e[n] = r;
+				for (let n of e) n > r && t.set(n, !t.get(n));
+			}
+			return n;
+		}
+	};
+})), o = /* @__PURE__ */ e(((e, t) => {
+	var n = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString", r = "http://www.w3.org/2001/XMLSchema#string", i = "NamedNode", a = "BlankNode", o = "Literal", s = {};
+	s.eoln = /(?:\r\n)|(?:\n)|(?:\r)/g, s.empty = /* @__PURE__ */ RegExp("^[ \\t]*$"), s.quad = /* @__PURE__ */ RegExp("^[ \\t]*(?:(?:<((?:[^\0- <>\"{}|^`\\\\]|\\\\u[0-9A-Fa-f]{4}|\\\\U[0-9A-Fa-f]{8})*)>)|_:((?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9])(?:(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀.])*(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀]))?))[ \\t]+(?:<((?:[^\0- <>\"{}|^`\\\\]|\\\\u[0-9A-Fa-f]{4}|\\\\U[0-9A-Fa-f]{8})*)>)[ \\t]+(?:(?:<((?:[^\0- <>\"{}|^`\\\\]|\\\\u[0-9A-Fa-f]{4}|\\\\U[0-9A-Fa-f]{8})*)>)|_:((?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9])(?:(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀.])*(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀]))?)|(?:\"([^\"\\\\]*(?:\\\\.[^\"\\\\]*)*)\"(?:(?:\\^\\^(?:<((?:[^\0- <>\"{}|^`\\\\]|\\\\u[0-9A-Fa-f]{4}|\\\\U[0-9A-Fa-f]{8})*)>))|(?:@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)))?))[ \\t]*(?:\\.|(?:(?:(?:<((?:[^\0- <>\"{}|^`\\\\]|\\\\u[0-9A-Fa-f]{4}|\\\\U[0-9A-Fa-f]{8})*)>)|_:((?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9])(?:(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀.])*(?:[A-Za-zÀ-ÖØ-öø-˿Ͱ-ͽͿ-῿‌-‍⁰-↏Ⰰ-⿯、-퟿豈-﷏ﷰ-�_0-9-·̀-ͯ‿-⁀]))?))[ \\t]*\\.))[ \\t]*$"), t.exports = class e {
+		static parse(e) {
+			let t = [], l = {}, u = e.split(s.eoln), d = 0;
+			for (let e of u) {
+				if (d++, s.empty.test(e)) continue;
+				let u = e.match(s.quad);
+				if (u === null) throw Error("N-Quads parse error on line " + d + ".");
+				let f = {
+					subject: null,
+					predicate: null,
+					object: null,
+					graph: null
+				};
+				if (u[1] === void 0 ? f.subject = {
+					termType: a,
+					value: u[2]
+				} : f.subject = {
+					termType: i,
+					value: v(u[1])
+				}, f.predicate = {
+					termType: i,
+					value: v(u[3])
+				}, u[4] === void 0 ? u[5] === void 0 ? (f.object = {
+					termType: o,
+					value: void 0,
+					datatype: { termType: i }
+				}, u[7] === void 0 ? u[8] === void 0 ? f.object.datatype.value = r : (f.object.datatype.value = n, f.object.language = u[8]) : f.object.datatype.value = v(u[7]), f.object.value = p(u[6])) : f.object = {
+					termType: a,
+					value: u[5]
+				} : f.object = {
+					termType: i,
+					value: v(u[4])
+				}, u[9] === void 0 ? u[10] === void 0 ? f.graph = {
+					termType: "DefaultGraph",
+					value: ""
+				} : f.graph = {
+					termType: a,
+					value: u[10]
+				} : f.graph = {
+					termType: i,
+					value: v(u[9])
+				}, !(f.graph.value in l)) l[f.graph.value] = [f], t.push(f);
+				else {
+					let e = !0, n = l[f.graph.value];
+					for (let t of n) if (c(t, f)) {
+						e = !1;
+						break;
+					}
+					e && (n.push(f), t.push(f));
+				}
+			}
+			return t;
+		}
+		static serialize(t) {
+			let n = [];
+			for (let r of t) n.push(e.serializeQuad(r));
+			return n.sort().join("");
+		}
+		static serializeQuadComponents(e, t, o, s) {
+			let c = "";
+			return e.termType === i ? c += `<${g(e.value)}>` : c += `_:${e.value}`, t.termType === i ? c += ` <${g(t.value)}> ` : c += ` _:${t.value} `, o.termType === i ? c += `<${g(o.value)}>` : o.termType === a ? c += `_:${o.value}` : (c += `"${d(o.value)}"`, o.datatype.value === n ? o.language && (c += `@${o.language}`) : o.datatype.value !== r && (c += `^^<${g(o.datatype.value)}>`)), s.termType === i ? c += ` <${g(s.value)}>` : s.termType === a && (c += ` _:${s.value}`), c += " .\n", c;
+		}
+		static serializeQuad(t) {
+			return e.serializeQuadComponents(t.subject, t.predicate, t.object, t.graph);
+		}
+	};
+	function c(e, t) {
+		return !(e.subject.termType === t.subject.termType && e.object.termType === t.object.termType) || !(e.subject.value === t.subject.value && e.predicate.value === t.predicate.value && e.object.value === t.object.value) ? !1 : e.object.termType !== o || e.object.datatype.termType === t.object.datatype.termType && e.object.language === t.object.language && e.object.datatype.value === t.object.datatype.value;
+	}
+	var l = /[\u0000-\u001F\u007F"\\]/g, u = [];
+	for (let e = 0; e <= 127; ++e) l.test(String.fromCharCode(e)) && (u[e] = "\\u" + e.toString(16).toUpperCase().padStart(4, "0"), l.lastIndex = 0);
+	u["\b".codePointAt(0)] = "\\b", u["	".codePointAt(0)] = "\\t", u["\n".codePointAt(0)] = "\\n", u["\f".codePointAt(0)] = "\\f", u["\r".codePointAt(0)] = "\\r", u["\"".codePointAt(0)] = "\\\"", u["\\".codePointAt(0)] = "\\\\";
+	function d(e) {
+		return l.test(e) ? e.replace(l, function(e) {
+			return u[e.codePointAt(0)];
+		}) : e;
+	}
+	var f = /(?:\\([btnfr"'\\]))|(?:\\u([0-9A-Fa-f]{4}))|(?:\\U([0-9A-Fa-f]{8}))/g;
+	function p(e) {
+		return f.test(e) ? e.replace(f, function(e, t, n, r) {
+			if (t) switch (t) {
+				case "b": return "\b";
+				case "t": return "	";
+				case "n": return "\n";
+				case "f": return "\f";
+				case "r": return "\r";
+				case "\"": return "\"";
+				case "'": return "'";
+				case "\\": return "\\";
+			}
+			if (n) return String.fromCharCode(parseInt(n, 16));
+			if (r) return String.fromCodePoint(parseInt(r, 16));
+		}) : e;
+	}
+	var m = /[\u0000-\u0020<>"{}|^`\\]/g, h = [];
+	for (let e = 0; e <= 127; ++e) m.test(String.fromCharCode(e)) && (h[e] = "\\u" + e.toString(16).toUpperCase().padStart(4, "0"), m.lastIndex = 0);
+	function g(e) {
+		return m.test(e) ? e.replace(m, function(e) {
+			return h[e.codePointAt(0)];
+		}) : e;
+	}
+	var _ = /(?:\\u([0-9A-Fa-f]{4}))|(?:\\U([0-9A-Fa-f]{8}))/g;
+	function v(e) {
+		return _.test(e) ? e.replace(_, function(e, t, n) {
+			if (t) return String.fromCharCode(parseInt(t, 16));
+			if (n) return String.fromCodePoint(parseInt(n, 16));
+		}) : e;
+	}
+})), s = /* @__PURE__ */ e(((e, n) => {
+	var s = t(), c = i(), l = a(), u = o(), { setImmediate: d } = r();
+	n.exports = class {
+		constructor({ createMessageDigest: e = null, messageDigestAlgorithm: t = "sha256", canonicalIdMap: n = /* @__PURE__ */ new Map(), maxWorkFactor: r = 1, maxDeepIterations: i = -1, signal: a = null } = {}) {
+			this.name = "RDFC-1.0", this.blankNodeInfo = /* @__PURE__ */ new Map(), this.canonicalIssuer = new s("c14n", n), this.createMessageDigest = e || (() => new c(t)), this.maxWorkFactor = r, this.maxDeepIterations = i, this.remainingDeepIterations = 0, this.signal = a, this.quads = null;
+		}
+		async main(e) {
+			this.quads = e;
+			for (let t of e) this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.subject
+			}), this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.object
+			}), this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.graph
+			});
+			let t = /* @__PURE__ */ new Map(), n = [...this.blankNodeInfo.keys()], r = 0;
+			for (let e of n) ++r % 100 == 0 && await this._yield(), await this._hashAndTrackBlankNode({
+				id: e,
+				hashToBlankNodes: t
+			});
+			let i = [...t.keys()].sort(), a = [];
+			for (let e of i) {
+				let n = t.get(e);
+				if (n.length > 1) {
+					a.push(n);
+					continue;
+				}
+				let r = n[0];
+				this.canonicalIssuer.getId(r);
+			}
+			if (this.maxDeepIterations < 0) if (this.maxWorkFactor === 0) this.maxDeepIterations = 0;
+			else if (this.maxWorkFactor === Infinity) this.maxDeepIterations = Infinity;
+			else {
+				let e = a.reduce((e, t) => e + t.length, 0);
+				this.maxDeepIterations = e ** this.maxWorkFactor;
+			}
+			this.maxDeepIterations > 2 ** 53 - 1 && (this.maxDeepIterations = Infinity), this.remainingDeepIterations = this.maxDeepIterations;
+			for (let e of a) {
+				let t = [];
+				for (let n of e) {
+					if (this.canonicalIssuer.hasId(n)) continue;
+					let e = new s("b");
+					e.getId(n);
+					let r = await this.hashNDegreeQuads(n, e);
+					t.push(r);
+				}
+				t.sort(f);
+				for (let e of t) {
+					let t = e.issuer.getOldIds();
+					for (let e of t) this.canonicalIssuer.getId(e);
+				}
+			}
+			let o = [];
+			for (let e of this.quads) {
+				let t = u.serializeQuadComponents(this._componentWithCanonicalId(e.subject), e.predicate, this._componentWithCanonicalId(e.object), this._componentWithCanonicalId(e.graph));
+				o.push(t);
+			}
+			return o.sort(), o.join("");
+		}
+		async hashFirstDegreeQuads(e) {
+			let t = [], n = this.blankNodeInfo.get(e), r = n.quads;
+			for (let n of r) t.push(u.serializeQuadComponents(this.modifyFirstDegreeComponent(e, n.subject, "subject"), n.predicate, this.modifyFirstDegreeComponent(e, n.object, "object"), this.modifyFirstDegreeComponent(e, n.graph, "graph")));
+			t.sort();
+			let i = this.createMessageDigest();
+			for (let e of t) i.update(e);
+			return n.hash = await i.digest(), n.hash;
+		}
+		async hashRelatedBlankNode(e, t, n, r) {
+			let i = this.createMessageDigest();
+			i.update(r), r !== "g" && i.update(this.getRelatedPredicate(t));
+			let a;
+			return a = this.canonicalIssuer.hasId(e) ? "_:" + this.canonicalIssuer.getId(e) : n.hasId(e) ? "_:" + n.getId(e) : this.blankNodeInfo.get(e).hash, i.update(a), i.digest();
+		}
+		async hashNDegreeQuads(e, t) {
+			if (this.remainingDeepIterations === 0) throw Error(`Maximum deep iterations exceeded (${this.maxDeepIterations}).`);
+			this.remainingDeepIterations--;
+			let n = this.createMessageDigest(), r = await this.createHashToRelated(e, t), i = [...r.keys()].sort();
+			for (let e of i) {
+				n.update(e);
+				let i = "", a, o = new l(r.get(e)), s = 0;
+				for (; o.hasNext();) {
+					let e = o.next();
+					if (++s % 3 == 0) {
+						if (this.signal && this.signal.aborted) throw Error(`Abort signal received: "${this.signal.reason}".`);
+						await this._yield();
+					}
+					let n = t.clone(), r = "", c = [], l = !1;
+					for (let t of e) if (this.canonicalIssuer.hasId(t) ? r += "_:" + this.canonicalIssuer.getId(t) : (n.hasId(t) || c.push(t), r += "_:" + n.getId(t)), i.length !== 0 && r > i) {
+						l = !0;
+						break;
+					}
+					if (!l) {
+						for (let e of c) {
+							let t = await this.hashNDegreeQuads(e, n);
+							if (r += "_:" + n.getId(e), r += `<${t.hash}>`, n = t.issuer, i.length !== 0 && r > i) {
+								l = !0;
+								break;
+							}
+						}
+						l || (i.length === 0 || r < i) && (i = r, a = n);
+					}
+				}
+				n.update(i), t = a;
+			}
+			return {
+				hash: await n.digest(),
+				issuer: t
+			};
+		}
+		modifyFirstDegreeComponent(e, t) {
+			return t.termType === "BlankNode" ? {
+				termType: "BlankNode",
+				value: t.value === e ? "a" : "z"
+			} : t;
+		}
+		getRelatedPredicate(e) {
+			return `<${e.predicate.value}>`;
+		}
+		async createHashToRelated(e, t) {
+			let n = /* @__PURE__ */ new Map(), r = this.blankNodeInfo.get(e).quads, i = 0;
+			for (let a of r) ++i % 100 == 0 && await this._yield(), await Promise.all([
+				this._addRelatedBlankNodeHash({
+					quad: a,
+					component: a.subject,
+					position: "s",
+					id: e,
+					issuer: t,
+					hashToRelated: n
+				}),
+				this._addRelatedBlankNodeHash({
+					quad: a,
+					component: a.object,
+					position: "o",
+					id: e,
+					issuer: t,
+					hashToRelated: n
+				}),
+				this._addRelatedBlankNodeHash({
+					quad: a,
+					component: a.graph,
+					position: "g",
+					id: e,
+					issuer: t,
+					hashToRelated: n
+				})
+			]);
+			return n;
+		}
+		async _hashAndTrackBlankNode({ id: e, hashToBlankNodes: t }) {
+			let n = await this.hashFirstDegreeQuads(e), r = t.get(n);
+			r ? r.push(e) : t.set(n, [e]);
+		}
+		_addBlankNodeQuadInfo({ quad: e, component: t }) {
+			if (t.termType !== "BlankNode") return;
+			let n = t.value, r = this.blankNodeInfo.get(n);
+			r ? r.quads.add(e) : this.blankNodeInfo.set(n, {
+				quads: /* @__PURE__ */ new Set([e]),
+				hash: null
+			});
+		}
+		async _addRelatedBlankNodeHash({ quad: e, component: t, position: n, id: r, issuer: i, hashToRelated: a }) {
+			if (!(t.termType === "BlankNode" && t.value !== r)) return;
+			let o = t.value, s = await this.hashRelatedBlankNode(o, e, i, n), c = a.get(s);
+			c ? c.push(o) : a.set(s, [o]);
+		}
+		_componentWithCanonicalId(e) {
+			return e.termType === "BlankNode" && !e.value.startsWith(this.canonicalIssuer.prefix) ? {
+				termType: "BlankNode",
+				value: this.canonicalIssuer.getId(e.value)
+			} : e;
+		}
+		async _yield() {
+			return new Promise((e) => d(e));
+		}
+	};
+	function f(e, t) {
+		return e.hash < t.hash ? -1 : +(e.hash > t.hash);
+	}
+})), c = /* @__PURE__ */ e(((e, n) => {
+	var r = t(), s = i(), c = a(), l = o();
+	n.exports = class {
+		constructor({ createMessageDigest: e = null, messageDigestAlgorithm: t = "sha256", canonicalIdMap: n = /* @__PURE__ */ new Map(), maxWorkFactor: i = 1, maxDeepIterations: a = -1, timeout: o = 0 } = {}) {
+			this.name = "RDFC-1.0", this.blankNodeInfo = /* @__PURE__ */ new Map(), this.canonicalIssuer = new r("c14n", n), this.createMessageDigest = e || (() => new s(t)), this.maxWorkFactor = i, this.maxDeepIterations = a, this.remainingDeepIterations = 0, this.timeout = o, o > 0 && (this.startTime = Date.now()), this.quads = null;
+		}
+		main(e) {
+			this.quads = e;
+			for (let t of e) this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.subject
+			}), this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.object
+			}), this._addBlankNodeQuadInfo({
+				quad: t,
+				component: t.graph
+			});
+			let t = /* @__PURE__ */ new Map(), n = [...this.blankNodeInfo.keys()];
+			for (let e of n) this._hashAndTrackBlankNode({
+				id: e,
+				hashToBlankNodes: t
+			});
+			let i = [...t.keys()].sort(), a = [];
+			for (let e of i) {
+				let n = t.get(e);
+				if (n.length > 1) {
+					a.push(n);
+					continue;
+				}
+				let r = n[0];
+				this.canonicalIssuer.getId(r);
+			}
+			if (this.maxDeepIterations < 0) if (this.maxWorkFactor === 0) this.maxDeepIterations = 0;
+			else if (this.maxWorkFactor === Infinity) this.maxDeepIterations = Infinity;
+			else {
+				let e = a.reduce((e, t) => e + t.length, 0);
+				this.maxDeepIterations = e ** this.maxWorkFactor;
+			}
+			this.maxDeepIterations > 2 ** 53 - 1 && (this.maxDeepIterations = Infinity), this.remainingDeepIterations = this.maxDeepIterations;
+			for (let e of a) {
+				let t = [];
+				for (let n of e) {
+					if (this.canonicalIssuer.hasId(n)) continue;
+					let e = new r("b");
+					e.getId(n);
+					let i = this.hashNDegreeQuads(n, e);
+					t.push(i);
+				}
+				t.sort(u);
+				for (let e of t) {
+					let t = e.issuer.getOldIds();
+					for (let e of t) this.canonicalIssuer.getId(e);
+				}
+			}
+			let o = [];
+			for (let e of this.quads) {
+				let t = l.serializeQuadComponents(this._componentWithCanonicalId(e.subject), e.predicate, this._componentWithCanonicalId(e.object), this._componentWithCanonicalId(e.graph));
+				o.push(t);
+			}
+			return o.sort(), o.join("");
+		}
+		hashFirstDegreeQuads(e) {
+			let t = [], n = this.blankNodeInfo.get(e), r = n.quads;
+			for (let n of r) t.push(l.serializeQuadComponents(this.modifyFirstDegreeComponent(e, n.subject, "subject"), n.predicate, this.modifyFirstDegreeComponent(e, n.object, "object"), this.modifyFirstDegreeComponent(e, n.graph, "graph")));
+			t.sort();
+			let i = this.createMessageDigest();
+			for (let e of t) i.update(e);
+			return n.hash = i.digest(), n.hash;
+		}
+		hashRelatedBlankNode(e, t, n, r) {
+			let i = this.createMessageDigest();
+			i.update(r), r !== "g" && i.update(this.getRelatedPredicate(t));
+			let a;
+			return a = this.canonicalIssuer.hasId(e) ? "_:" + this.canonicalIssuer.getId(e) : n.hasId(e) ? "_:" + n.getId(e) : this.blankNodeInfo.get(e).hash, i.update(a), i.digest();
+		}
+		hashNDegreeQuads(e, t) {
+			if (this.remainingDeepIterations === 0) throw Error(`Maximum deep iterations exceeded (${this.maxDeepIterations}).`);
+			this.remainingDeepIterations--;
+			let n = this.createMessageDigest(), r = this.createHashToRelated(e, t), i = [...r.keys()].sort();
+			for (let e of i) {
+				n.update(e);
+				let i = "", a, o = new c(r.get(e)), s = 0;
+				for (; o.hasNext();) {
+					let e = o.next();
+					if (++s % 3 == 0 && this.timeout > 0 && Date.now() - this.startTime > this.timeout) throw Error("Canonize timeout.");
+					let n = t.clone(), r = "", c = [], l = !1;
+					for (let t of e) if (this.canonicalIssuer.hasId(t) ? r += "_:" + this.canonicalIssuer.getId(t) : (n.hasId(t) || c.push(t), r += "_:" + n.getId(t)), i.length !== 0 && r > i) {
+						l = !0;
+						break;
+					}
+					if (!l) {
+						for (let e of c) {
+							let t = this.hashNDegreeQuads(e, n);
+							if (r += "_:" + n.getId(e), r += `<${t.hash}>`, n = t.issuer, i.length !== 0 && r > i) {
+								l = !0;
+								break;
+							}
+						}
+						l || (i.length === 0 || r < i) && (i = r, a = n);
+					}
+				}
+				n.update(i), t = a;
+			}
+			return {
+				hash: n.digest(),
+				issuer: t
+			};
+		}
+		modifyFirstDegreeComponent(e, t) {
+			return t.termType === "BlankNode" ? {
+				termType: "BlankNode",
+				value: t.value === e ? "a" : "z"
+			} : t;
+		}
+		getRelatedPredicate(e) {
+			return `<${e.predicate.value}>`;
+		}
+		createHashToRelated(e, t) {
+			let n = /* @__PURE__ */ new Map(), r = this.blankNodeInfo.get(e).quads;
+			for (let i of r) this._addRelatedBlankNodeHash({
+				quad: i,
+				component: i.subject,
+				position: "s",
+				id: e,
+				issuer: t,
+				hashToRelated: n
+			}), this._addRelatedBlankNodeHash({
+				quad: i,
+				component: i.object,
+				position: "o",
+				id: e,
+				issuer: t,
+				hashToRelated: n
+			}), this._addRelatedBlankNodeHash({
+				quad: i,
+				component: i.graph,
+				position: "g",
+				id: e,
+				issuer: t,
+				hashToRelated: n
+			});
+			return n;
+		}
+		_hashAndTrackBlankNode({ id: e, hashToBlankNodes: t }) {
+			let n = this.hashFirstDegreeQuads(e), r = t.get(n);
+			r ? r.push(e) : t.set(n, [e]);
+		}
+		_addBlankNodeQuadInfo({ quad: e, component: t }) {
+			if (t.termType !== "BlankNode") return;
+			let n = t.value, r = this.blankNodeInfo.get(n);
+			r ? r.quads.add(e) : this.blankNodeInfo.set(n, {
+				quads: /* @__PURE__ */ new Set([e]),
+				hash: null
+			});
+		}
+		_addRelatedBlankNodeHash({ quad: e, component: t, position: n, id: r, issuer: i, hashToRelated: a }) {
+			if (!(t.termType === "BlankNode" && t.value !== r)) return;
+			let o = t.value, s = this.hashRelatedBlankNode(o, e, i, n), c = a.get(s);
+			c ? c.push(o) : a.set(s, [o]);
+		}
+		_componentWithCanonicalId(e) {
+			return e.termType === "BlankNode" && !e.value.startsWith(this.canonicalIssuer.prefix) ? {
+				termType: "BlankNode",
+				value: this.canonicalIssuer.getId(e.value)
+			} : e;
+		}
+	};
+	function u(e, t) {
+		return e.hash < t.hash ? -1 : +(e.hash > t.hash);
+	}
+})), l = /* @__PURE__ */ e(((e) => {
+	var n = s(), r = c();
+	function i(t, n) {
+		if (n.inputFormat) {
+			if (n.inputFormat === "application/n-quads") {
+				if (typeof t != "string") throw Error("N-Quads input must be a string.");
+				return e.NQuads.parse(t);
+			}
+			throw Error(`Unknown canonicalization input format: "${n.inputFormat}".`);
+		}
+		return t;
+	}
+	function a(e) {
+		if (e.format && e.format !== "application/n-quads") throw Error(`Unknown canonicalization output format: "${e.format}".`);
+	}
+	function l() {
+		globalThis.RDF_CANONIZE_TRACE_URDNA2015 && console.trace("[rdf-canonize] URDNA2015 is deprecated, use RDFC-1.0");
+	}
+	e.NQuads = o(), e.IdentifierIssuer = t(), e.canonize = async function(e, t = {}) {
+		let r = i(e, t);
+		if (a(t), !("algorithm" in t)) throw Error("No RDF Dataset Canonicalization algorithm specified.");
+		if (t.algorithm === "RDFC-1.0") return new n(t).main(r);
+		if (t.algorithm === "URDNA2015" && !t.rejectURDNA2015) return l(), new n(t).main(r);
+		throw Error("Invalid RDF Dataset Canonicalization algorithm: " + t.algorithm);
+	}, e._canonizeSync = function(e, t = {}) {
+		let n = i(e, t);
+		if (a(t), !("algorithm" in t)) throw Error("No RDF Dataset Canonicalization algorithm specified.");
+		if (t.algorithm === "RDFC-1.0") return new r(t).main(n);
+		if (t.algorithm === "URDNA2015" && !t.rejectURDNA2015) return l(), new r(t).main(n);
+		throw Error("Invalid RDF Dataset Canonicalization algorithm: " + t.algorithm);
+	};
+})), u = /* @__PURE__ */ e(((e, t) => {
+	t.exports = l();
+})), d = /* @__PURE__ */ e(((e, t) => {
+	var n = {};
+	t.exports = n, n.isArray = Array.isArray, n.isBoolean = (e) => typeof e == "boolean" || Object.prototype.toString.call(e) === "[object Boolean]", n.isDouble = (e) => n.isNumber(e) && (String(e).indexOf(".") !== -1 || Math.abs(e) >= 1e21), n.isEmptyObject = (e) => n.isObject(e) && Object.keys(e).length === 0, n.isNumber = (e) => typeof e == "number" || Object.prototype.toString.call(e) === "[object Number]", n.isNumeric = (e) => !isNaN(parseFloat(e)) && isFinite(e), n.isObject = (e) => Object.prototype.toString.call(e) === "[object Object]", n.isString = (e) => typeof e == "string" || Object.prototype.toString.call(e) === "[object String]", n.isUndefined = (e) => e === void 0;
+})), f = /* @__PURE__ */ e(((e, t) => {
+	var n = d(), r = {};
+	t.exports = r, r.isSubject = (e) => n.isObject(e) && !("@value" in e || "@set" in e || "@list" in e) ? Object.keys(e).length > 1 || !("@id" in e) : !1, r.isSubjectReference = (e) => n.isObject(e) && Object.keys(e).length === 1 && "@id" in e, r.isValue = (e) => n.isObject(e) && "@value" in e, r.isList = (e) => n.isObject(e) && "@list" in e, r.isGraph = (e) => n.isObject(e) && "@graph" in e && Object.keys(e).filter((e) => e !== "@id" && e !== "@index").length === 1, r.isSimpleGraph = (e) => r.isGraph(e) && !("@id" in e), r.isBlankNode = (e) => {
+		if (n.isObject(e)) {
+			if ("@id" in e) {
+				let t = e["@id"];
+				return !n.isString(t) || t.indexOf("_:") === 0;
+			}
+			return Object.keys(e).length === 0 || !("@value" in e || "@set" in e || "@list" in e);
+		}
+		return !1;
+	};
+})), p = /* @__PURE__ */ e(((e, t) => {
+	t.exports = class extends Error {
+		constructor(e = "An unspecified JSON-LD error occurred.", t = "jsonld.Error", n = {}) {
+			super(e), this.name = t, this.message = e, this.details = n;
+		}
+	};
+})), m = /* @__PURE__ */ e(((e, t) => {
+	var n = f(), r = d(), i = u().IdentifierIssuer, a = p(), o = /^[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*$/, s = /(?:<[^>]*?>|"[^"]*?"|[^,])+/g, c = /\s*<([^>]*?)>\s*(?:;\s*(.*))?/, l = /(.*?)=(?:(?:"([^"]*?)")|([^"]*?))\s*(?:(?:;\s*)|$)/g, m = /^@[a-zA-Z]+$/, h = { headers: { accept: "application/ld+json, application/json" } }, g = {};
+	t.exports = g, g.IdentifierIssuer = i, g.REGEX_BCP47 = o, g.REGEX_KEYWORD = m, g.clone = function(e) {
+		if (e && typeof e == "object") {
+			let t;
+			if (r.isArray(e)) {
+				t = [];
+				for (let n = 0; n < e.length; ++n) t[n] = g.clone(e[n]);
+			} else if (e instanceof Map) {
+				t = /* @__PURE__ */ new Map();
+				for (let [n, r] of e) t.set(n, g.clone(r));
+			} else if (e instanceof Set) {
+				t = /* @__PURE__ */ new Set();
+				for (let n of e) t.add(g.clone(n));
+			} else if (r.isObject(e)) {
+				t = {};
+				for (let n in e) t[n] = g.clone(e[n]);
+			} else t = e.toString();
+			return t;
+		}
+		return e;
+	}, g.asArray = function(e) {
+		return Array.isArray(e) ? e : [e];
+	}, g.buildHeaders = (e = {}) => {
+		if (Object.keys(e).some((e) => e.toLowerCase() === "accept")) throw RangeError("Accept header may not be specified; only \"" + h.headers.accept + "\" is supported.");
+		return Object.assign({ Accept: h.headers.accept }, e);
+	}, g.parseLinkHeader = (e) => {
+		let t = {}, n = e.match(s);
+		for (let e = 0; e < n.length; ++e) {
+			let r = n[e].match(c);
+			if (!r) continue;
+			let i = { target: r[1] }, a = r[2];
+			for (; r = l.exec(a);) i[r[1]] = r[2] === void 0 ? r[3] : r[2];
+			let o = i.rel || "";
+			Array.isArray(t[o]) ? t[o].push(i) : t.hasOwnProperty(o) ? t[o] = [t[o], i] : t[o] = i;
+		}
+		return t;
+	}, g.validateTypeValue = (e, t) => {
+		if (!r.isString(e) && !(r.isArray(e) && e.every((e) => r.isString(e)))) {
+			if (t && r.isObject(e)) switch (Object.keys(e).length) {
+				case 0: return;
+				case 1: if ("@default" in e && g.asArray(e["@default"]).every((e) => r.isString(e))) return;
+			}
+			throw new a("Invalid JSON-LD syntax; \"@type\" value must a string, an array of strings, an empty object, or a default object.", "jsonld.SyntaxError", {
+				code: "invalid type value",
+				value: e
+			});
+		}
+	}, g.hasProperty = (e, t) => {
+		if (e.hasOwnProperty(t)) {
+			let n = e[t];
+			return !r.isArray(n) || n.length > 0;
+		}
+		return !1;
+	}, g.hasValue = (e, t, i) => {
+		if (g.hasProperty(e, t)) {
+			let a = e[t], o = n.isList(a);
+			if (r.isArray(a) || o) {
+				o && (a = a["@list"]);
+				for (let e = 0; e < a.length; ++e) if (g.compareValues(i, a[e])) return !0;
+			} else if (!r.isArray(i)) return g.compareValues(i, a);
+		}
+		return !1;
+	}, g.addValue = (e, t, n, i) => {
+		if (i ||= {}, "propertyIsArray" in i || (i.propertyIsArray = !1), "valueIsArray" in i || (i.valueIsArray = !1), "allowDuplicate" in i || (i.allowDuplicate = !0), "prependValue" in i || (i.prependValue = !1), i.valueIsArray) e[t] = n;
+		else if (r.isArray(n)) {
+			n.length === 0 && i.propertyIsArray && !e.hasOwnProperty(t) && (e[t] = []), i.prependValue && (n = n.concat(e[t]), e[t] = []);
+			for (let r = 0; r < n.length; ++r) g.addValue(e, t, n[r], i);
+		} else if (e.hasOwnProperty(t)) {
+			let a = !i.allowDuplicate && g.hasValue(e, t, n);
+			!r.isArray(e[t]) && (!a || i.propertyIsArray) && (e[t] = [e[t]]), a || (i.prependValue ? e[t].unshift(n) : e[t].push(n));
+		} else e[t] = i.propertyIsArray ? [n] : n;
+	}, g.getValues = (e, t) => [].concat(e[t] || []), g.removeProperty = (e, t) => {
+		delete e[t];
+	}, g.removeValue = (e, t, n, r) => {
+		r ||= {}, "propertyIsArray" in r || (r.propertyIsArray = !1);
+		let i = g.getValues(e, t).filter((e) => !g.compareValues(e, n));
+		i.length === 0 ? g.removeProperty(e, t) : i.length === 1 && !r.propertyIsArray ? e[t] = i[0] : e[t] = i;
+	}, g.relabelBlankNodes = (e, t) => (t ||= {}, _(t.issuer || new i("_:b"), e)), g.compareValues = (e, t) => e === t || n.isValue(e) && n.isValue(t) && e["@value"] === t["@value"] && e["@type"] === t["@type"] && e["@language"] === t["@language"] && e["@index"] === t["@index"] ? !0 : r.isObject(e) && "@id" in e && r.isObject(t) && "@id" in t ? e["@id"] === t["@id"] : !1, g.compareShortestLeast = (e, t) => e.length < t.length ? -1 : t.length < e.length ? 1 : e === t ? 0 : e < t ? -1 : 1;
+	function _(e, t) {
+		if (r.isArray(t)) for (let n = 0; n < t.length; ++n) t[n] = _(e, t[n]);
+		else if (n.isList(t)) t["@list"] = _(e, t["@list"]);
+		else if (r.isObject(t)) {
+			n.isBlankNode(t) && (t["@id"] = e.getId(t["@id"]));
+			let r = Object.keys(t).sort();
+			for (let n = 0; n < r.length; ++n) {
+				let i = r[n];
+				i !== "@id" && (t[i] = _(e, t[i]));
+			}
+		}
+		return t;
+	}
+})), h = /* @__PURE__ */ e(((e, t) => {
+	t.exports = {
+		LINK_HEADER_REL: "http://www.w3.org/ns/json-ld#context",
+		LINK_HEADER_CONTEXT: "http://www.w3.org/ns/json-ld#context",
+		RDF: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+		RDF_LIST: "http://www.w3.org/1999/02/22-rdf-syntax-ns#List",
+		RDF_FIRST: "http://www.w3.org/1999/02/22-rdf-syntax-ns#first",
+		RDF_REST: "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest",
+		RDF_NIL: "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil",
+		RDF_TYPE: "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+		RDF_PLAIN_LITERAL: "http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral",
+		RDF_XML_LITERAL: "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+		RDF_JSON_LITERAL: "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON",
+		RDF_OBJECT: "http://www.w3.org/1999/02/22-rdf-syntax-ns#object",
+		RDF_LANGSTRING: "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString",
+		XSD: "http://www.w3.org/2001/XMLSchema#",
+		XSD_BOOLEAN: "http://www.w3.org/2001/XMLSchema#boolean",
+		XSD_DOUBLE: "http://www.w3.org/2001/XMLSchema#double",
+		XSD_INTEGER: "http://www.w3.org/2001/XMLSchema#integer",
+		XSD_STRING: "http://www.w3.org/2001/XMLSchema#string"
+	};
+})), g = /* @__PURE__ */ e(((e, t) => {
+	t.exports = class {
+		constructor() {
+			this._requests = {};
+		}
+		wrapLoader(e) {
+			let t = this;
+			return t._loader = e, function() {
+				return t.add.apply(t, arguments);
+			};
+		}
+		async add(e) {
+			let t = this._requests[e];
+			if (t) return Promise.resolve(t);
+			t = this._requests[e] = this._loader(e);
+			try {
+				return await t;
+			} finally {
+				delete this._requests[e];
+			}
+		}
+	};
+})), _ = /* @__PURE__ */ e(((e, t) => {
+	var n = d(), r = {};
+	t.exports = r, r.parsers = {
+		simple: {
+			keys: [
+				"href",
+				"scheme",
+				"authority",
+				"path",
+				"query",
+				"fragment"
+			],
+			regex: /^(?:([^:\/?#]+):)?(?:\/\/([^\/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/
+		},
+		full: {
+			keys: [
+				"href",
+				"protocol",
+				"scheme",
+				"authority",
+				"auth",
+				"user",
+				"password",
+				"hostname",
+				"port",
+				"path",
+				"directory",
+				"file",
+				"query",
+				"fragment"
+			],
+			regex: /^(([a-zA-Z][a-zA-Z0-9+-.]*):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?(?:(((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/
+		}
+	}, r.parse = (e, t) => {
+		let n = {}, i = r.parsers[t || "full"], a = i.regex.exec(e), o = i.keys.length;
+		for (; o--;) n[i.keys[o]] = a[o] === void 0 ? null : a[o];
+		return (n.scheme === "https" && n.port === "443" || n.scheme === "http" && n.port === "80") && (n.href = n.href.replace(":" + n.port, ""), n.authority = n.authority.replace(":" + n.port, ""), n.port = null), n.normalizedPath = r.removeDotSegments(n.path), n;
+	}, r.prependBase = (e, t) => {
+		if (e === null || r.isAbsolute(t)) return t;
+		(!e || n.isString(e)) && (e = r.parse(e || ""));
+		let i = r.parse(t), a = { protocol: e.protocol || "" };
+		if (i.authority !== null) a.authority = i.authority, a.path = i.path, a.query = i.query;
+		else if (a.authority = e.authority, i.path === "") a.path = e.path, i.query === null ? a.query = e.query : a.query = i.query;
+		else {
+			if (i.path.indexOf("/") === 0) a.path = i.path;
+			else {
+				let t = e.path;
+				t = t.substr(0, t.lastIndexOf("/") + 1), (t.length > 0 || e.authority) && t.substr(-1) !== "/" && (t += "/"), t += i.path, a.path = t;
+			}
+			a.query = i.query;
+		}
+		i.path !== "" && (a.path = r.removeDotSegments(a.path));
+		let o = a.protocol;
+		return a.authority !== null && (o += "//" + a.authority), o += a.path, a.query !== null && (o += "?" + a.query), i.fragment !== null && (o += "#" + i.fragment), o === "" && (o = "./"), o;
+	}, r.removeBase = (e, t) => {
+		if (e === null) return t;
+		(!e || n.isString(e)) && (e = r.parse(e || ""));
+		let i = "";
+		if (e.href === "" ? t.indexOf("//") && (i += "//") : i += (e.protocol || "") + "//" + (e.authority || ""), t.indexOf(i) !== 0) return t;
+		let a = r.parse(t.substr(i.length)), o = e.normalizedPath.split("/"), s = a.normalizedPath.split("/"), c = a.fragment || a.query ? 0 : 1;
+		for (; o.length > 0 && s.length > c && o[0] === s[0];) o.shift(), s.shift();
+		let l = "";
+		if (o.length > 0) {
+			o.pop();
+			for (let e = 0; e < o.length; ++e) l += "../";
+		}
+		return l += s.join("/"), a.query !== null && (l += "?" + a.query), a.fragment !== null && (l += "#" + a.fragment), l === "" && (l = "./"), l;
+	}, r.removeDotSegments = (e) => {
+		if (e.length === 0) return "";
+		let t = e.split("/"), n = [];
+		for (; t.length > 0;) {
+			let e = t.shift(), r = t.length === 0;
+			if (e === ".") {
+				r && n.push("");
+				continue;
+			}
+			if (e === "..") {
+				n.pop(), r && n.push("");
+				continue;
+			}
+			n.push(e);
+		}
+		return e[0] === "/" && n.length > 0 && n[0] !== "" && n.unshift(""), n.length === 1 && n[0] === "" ? "/" : n.join("/");
+	};
+	var i = /^([A-Za-z][A-Za-z0-9+-.]*|_):[^\s]*$/;
+	r.isAbsolute = (e) => n.isString(e) && i.test(e), r.isRelative = (e) => n.isString(e);
+})), v = /* @__PURE__ */ e(((e, t) => {
+	var { parseLinkHeader: n, buildHeaders: r } = m(), { LINK_HEADER_CONTEXT: i } = h(), a = p(), o = g(), { prependBase: s } = _(), c = /(^|(\r\n))link:/i;
+	t.exports = ({ secure: e, headers: t = {}, xhr: u } = { headers: {} }) => {
+		return t = r(t), new o().wrapLoader(d);
+		async function d(r) {
+			if (r.indexOf("http:") !== 0 && r.indexOf("https:") !== 0) throw new a("URL could not be dereferenced; only \"http\" and \"https\" URLs are supported.", "jsonld.InvalidUrl", {
+				code: "loading document failed",
+				url: r
+			});
+			if (e && r.indexOf("https") !== 0) throw new a("URL could not be dereferenced; secure mode is enabled and the URL's scheme is not \"https\".", "jsonld.InvalidUrl", {
+				code: "loading document failed",
+				url: r
+			});
+			let o;
+			try {
+				o = await l(u, r, t);
+			} catch (e) {
+				throw new a("URL could not be dereferenced, an error occurred.", "jsonld.LoadDocumentError", {
+					code: "loading document failed",
+					url: r,
+					cause: e
+				});
+			}
+			if (o.status >= 400) throw new a("URL could not be dereferenced: " + o.statusText, "jsonld.LoadDocumentError", {
+				code: "loading document failed",
+				url: r,
+				httpStatusCode: o.status
+			});
+			let f = {
+				contextUrl: null,
+				documentUrl: r,
+				document: o.response
+			}, p = null, m = o.getResponseHeader("Content-Type"), h;
+			if (c.test(o.getAllResponseHeaders()) && (h = o.getResponseHeader("Link")), h && m !== "application/ld+json") {
+				let e = n(h), t = e[i];
+				if (Array.isArray(t)) throw new a("URL could not be dereferenced, it has more than one associated HTTP Link Header.", "jsonld.InvalidUrl", {
+					code: "multiple context link headers",
+					url: r
+				});
+				t && (f.contextUrl = t.target), p = e.alternate, p && p.type == "application/ld+json" && !(m || "").match(/^application\/(\w*\+)?json$/) && (f = await d(s(r, p.target)));
+			}
+			return f;
+		}
+	};
+	function l(e, t, n) {
+		e ||= XMLHttpRequest;
+		let r = new e();
+		return new Promise((e, i) => {
+			r.onload = () => e(r), r.onerror = (e) => i(e), r.open("GET", t, !0);
+			for (let e in n) r.setRequestHeader(e, n[e]);
+			r.send();
+		});
+	}
+})), y = /* @__PURE__ */ e(((e, t) => {
+	var n = v(), r = {};
+	t.exports = r, r.setupDocumentLoaders = function(e) {
+		typeof XMLHttpRequest < "u" && (e.documentLoaders.xhr = n, e.useDocumentLoader("xhr"));
+	}, r.setupGlobals = function(e) {
+		globalThis.JsonLdProcessor === void 0 && Object.defineProperty(globalThis, "JsonLdProcessor", {
+			writable: !0,
+			enumerable: !1,
+			configurable: !0,
+			value: e.JsonLdProcessor
+		});
+	};
+})), b = /* @__PURE__ */ e(((e, t) => {
+	t.exports = function(e) {
+		e.prototype[Symbol.iterator] = function* () {
+			for (let e = this.head; e; e = e.next) yield e.value;
+		};
+	};
+})), x = /* @__PURE__ */ e(((e, t) => {
+	t.exports = n, n.Node = o, n.create = n;
+	function n(e) {
+		var t = this;
+		if (t instanceof n || (t = new n()), t.tail = null, t.head = null, t.length = 0, e && typeof e.forEach == "function") e.forEach(function(e) {
+			t.push(e);
+		});
+		else if (arguments.length > 0) for (var r = 0, i = arguments.length; r < i; r++) t.push(arguments[r]);
+		return t;
+	}
+	n.prototype.removeNode = function(e) {
+		if (e.list !== this) throw Error("removing node which does not belong to this list");
+		var t = e.next, n = e.prev;
+		return t && (t.prev = n), n && (n.next = t), e === this.head && (this.head = t), e === this.tail && (this.tail = n), e.list.length--, e.next = null, e.prev = null, e.list = null, t;
+	}, n.prototype.unshiftNode = function(e) {
+		if (e !== this.head) {
+			e.list && e.list.removeNode(e);
+			var t = this.head;
+			e.list = this, e.next = t, t && (t.prev = e), this.head = e, this.tail ||= e, this.length++;
+		}
+	}, n.prototype.pushNode = function(e) {
+		if (e !== this.tail) {
+			e.list && e.list.removeNode(e);
+			var t = this.tail;
+			e.list = this, e.prev = t, t && (t.next = e), this.tail = e, this.head ||= e, this.length++;
+		}
+	}, n.prototype.push = function() {
+		for (var e = 0, t = arguments.length; e < t; e++) i(this, arguments[e]);
+		return this.length;
+	}, n.prototype.unshift = function() {
+		for (var e = 0, t = arguments.length; e < t; e++) a(this, arguments[e]);
+		return this.length;
+	}, n.prototype.pop = function() {
+		if (this.tail) {
+			var e = this.tail.value;
+			return this.tail = this.tail.prev, this.tail ? this.tail.next = null : this.head = null, this.length--, e;
+		}
+	}, n.prototype.shift = function() {
+		if (this.head) {
+			var e = this.head.value;
+			return this.head = this.head.next, this.head ? this.head.prev = null : this.tail = null, this.length--, e;
+		}
+	}, n.prototype.forEach = function(e, t) {
+		t ||= this;
+		for (var n = this.head, r = 0; n !== null; r++) e.call(t, n.value, r, this), n = n.next;
+	}, n.prototype.forEachReverse = function(e, t) {
+		t ||= this;
+		for (var n = this.tail, r = this.length - 1; n !== null; r--) e.call(t, n.value, r, this), n = n.prev;
+	}, n.prototype.get = function(e) {
+		for (var t = 0, n = this.head; n !== null && t < e; t++) n = n.next;
+		if (t === e && n !== null) return n.value;
+	}, n.prototype.getReverse = function(e) {
+		for (var t = 0, n = this.tail; n !== null && t < e; t++) n = n.prev;
+		if (t === e && n !== null) return n.value;
+	}, n.prototype.map = function(e, t) {
+		t ||= this;
+		for (var r = new n(), i = this.head; i !== null;) r.push(e.call(t, i.value, this)), i = i.next;
+		return r;
+	}, n.prototype.mapReverse = function(e, t) {
+		t ||= this;
+		for (var r = new n(), i = this.tail; i !== null;) r.push(e.call(t, i.value, this)), i = i.prev;
+		return r;
+	}, n.prototype.reduce = function(e, t) {
+		var n, r = this.head;
+		if (arguments.length > 1) n = t;
+		else if (this.head) r = this.head.next, n = this.head.value;
+		else throw TypeError("Reduce of empty list with no initial value");
+		for (var i = 0; r !== null; i++) n = e(n, r.value, i), r = r.next;
+		return n;
+	}, n.prototype.reduceReverse = function(e, t) {
+		var n, r = this.tail;
+		if (arguments.length > 1) n = t;
+		else if (this.tail) r = this.tail.prev, n = this.tail.value;
+		else throw TypeError("Reduce of empty list with no initial value");
+		for (var i = this.length - 1; r !== null; i--) n = e(n, r.value, i), r = r.prev;
+		return n;
+	}, n.prototype.toArray = function() {
+		for (var e = Array(this.length), t = 0, n = this.head; n !== null; t++) e[t] = n.value, n = n.next;
+		return e;
+	}, n.prototype.toArrayReverse = function() {
+		for (var e = Array(this.length), t = 0, n = this.tail; n !== null; t++) e[t] = n.value, n = n.prev;
+		return e;
+	}, n.prototype.slice = function(e, t) {
+		t ||= this.length, t < 0 && (t += this.length), e ||= 0, e < 0 && (e += this.length);
+		var r = new n();
+		if (t < e || t < 0) return r;
+		e < 0 && (e = 0), t > this.length && (t = this.length);
+		for (var i = 0, a = this.head; a !== null && i < e; i++) a = a.next;
+		for (; a !== null && i < t; i++, a = a.next) r.push(a.value);
+		return r;
+	}, n.prototype.sliceReverse = function(e, t) {
+		t ||= this.length, t < 0 && (t += this.length), e ||= 0, e < 0 && (e += this.length);
+		var r = new n();
+		if (t < e || t < 0) return r;
+		e < 0 && (e = 0), t > this.length && (t = this.length);
+		for (var i = this.length, a = this.tail; a !== null && i > t; i--) a = a.prev;
+		for (; a !== null && i > e; i--, a = a.prev) r.push(a.value);
+		return r;
+	}, n.prototype.splice = function(e, t, ...n) {
+		e > this.length && (e = this.length - 1), e < 0 && (e = this.length + e);
+		for (var i = 0, a = this.head; a !== null && i < e; i++) a = a.next;
+		for (var o = [], i = 0; a && i < t; i++) o.push(a.value), a = this.removeNode(a);
+		a === null && (a = this.tail), a !== this.head && a !== this.tail && (a = a.prev);
+		for (var i = 0; i < n.length; i++) a = r(this, a, n[i]);
+		return o;
+	}, n.prototype.reverse = function() {
+		for (var e = this.head, t = this.tail, n = e; n !== null; n = n.prev) {
+			var r = n.prev;
+			n.prev = n.next, n.next = r;
+		}
+		return this.head = t, this.tail = e, this;
+	};
+	function r(e, t, n) {
+		var r = t === e.head ? new o(n, null, t, e) : new o(n, t, t.next, e);
+		return r.next === null && (e.tail = r), r.prev === null && (e.head = r), e.length++, r;
+	}
+	function i(e, t) {
+		e.tail = new o(t, e.tail, null, e), e.head ||= e.tail, e.length++;
+	}
+	function a(e, t) {
+		e.head = new o(t, null, e.head, e), e.tail ||= e.head, e.length++;
+	}
+	function o(e, t, n, r) {
+		if (!(this instanceof o)) return new o(e, t, n, r);
+		this.list = r, this.value = e, t ? (t.next = this, this.prev = t) : this.prev = null, n ? (n.prev = this, this.next = n) : this.next = null;
+	}
+	try {
+		b()(n);
+	} catch {}
+})), S = /* @__PURE__ */ e(((e, t) => {
+	var n = x(), r = Symbol("max"), i = Symbol("length"), a = Symbol("lengthCalculator"), o = Symbol("allowStale"), s = Symbol("maxAge"), c = Symbol("dispose"), l = Symbol("noDisposeOnSet"), u = Symbol("lruList"), d = Symbol("cache"), f = Symbol("updateAgeOnGet"), p = () => 1, m = class {
+		constructor(e) {
+			if (typeof e == "number" && (e = { max: e }), e ||= {}, e.max && (typeof e.max != "number" || e.max < 0)) throw TypeError("max must be a non-negative number");
+			this[r] = e.max || Infinity;
+			let t = e.length || p;
+			if (this[a] = typeof t == "function" ? t : p, this[o] = e.stale || !1, e.maxAge && typeof e.maxAge != "number") throw TypeError("maxAge must be a number");
+			this[s] = e.maxAge || 0, this[c] = e.dispose, this[l] = e.noDisposeOnSet || !1, this[f] = e.updateAgeOnGet || !1, this.reset();
+		}
+		set max(e) {
+			if (typeof e != "number" || e < 0) throw TypeError("max must be a non-negative number");
+			this[r] = e || Infinity, _(this);
+		}
+		get max() {
+			return this[r];
+		}
+		set allowStale(e) {
+			this[o] = !!e;
+		}
+		get allowStale() {
+			return this[o];
+		}
+		set maxAge(e) {
+			if (typeof e != "number") throw TypeError("maxAge must be a non-negative number");
+			this[s] = e, _(this);
+		}
+		get maxAge() {
+			return this[s];
+		}
+		set lengthCalculator(e) {
+			typeof e != "function" && (e = p), e !== this[a] && (this[a] = e, this[i] = 0, this[u].forEach((e) => {
+				e.length = this[a](e.value, e.key), this[i] += e.length;
+			})), _(this);
+		}
+		get lengthCalculator() {
+			return this[a];
+		}
+		get length() {
+			return this[i];
+		}
+		get itemCount() {
+			return this[u].length;
+		}
+		rforEach(e, t) {
+			t ||= this;
+			for (let n = this[u].tail; n !== null;) {
+				let r = n.prev;
+				b(this, e, n, t), n = r;
+			}
+		}
+		forEach(e, t) {
+			t ||= this;
+			for (let n = this[u].head; n !== null;) {
+				let r = n.next;
+				b(this, e, n, t), n = r;
+			}
+		}
+		keys() {
+			return this[u].toArray().map((e) => e.key);
+		}
+		values() {
+			return this[u].toArray().map((e) => e.value);
+		}
+		reset() {
+			this[c] && this[u] && this[u].length && this[u].forEach((e) => this[c](e.key, e.value)), this[d] = /* @__PURE__ */ new Map(), this[u] = new n(), this[i] = 0;
+		}
+		dump() {
+			return this[u].map((e) => !g(this, e) && {
+				k: e.key,
+				v: e.value,
+				e: e.now + (e.maxAge || 0)
+			}).toArray().filter((e) => e);
+		}
+		dumpLru() {
+			return this[u];
+		}
+		set(e, t, n) {
+			if (n ||= this[s], n && typeof n != "number") throw TypeError("maxAge must be a number");
+			let o = n ? Date.now() : 0, f = this[a](t, e);
+			if (this[d].has(e)) {
+				if (f > this[r]) return v(this, this[d].get(e)), !1;
+				let a = this[d].get(e).value;
+				return this[c] && (this[l] || this[c](e, a.value)), a.now = o, a.maxAge = n, a.value = t, this[i] += f - a.length, a.length = f, this.get(e), _(this), !0;
+			}
+			let p = new y(e, t, f, o, n);
+			return p.length > this[r] ? (this[c] && this[c](e, t), !1) : (this[i] += p.length, this[u].unshift(p), this[d].set(e, this[u].head), _(this), !0);
+		}
+		has(e) {
+			if (!this[d].has(e)) return !1;
+			let t = this[d].get(e).value;
+			return !g(this, t);
+		}
+		get(e) {
+			return h(this, e, !0);
+		}
+		peek(e) {
+			return h(this, e, !1);
+		}
+		pop() {
+			let e = this[u].tail;
+			return e ? (v(this, e), e.value) : null;
+		}
+		del(e) {
+			v(this, this[d].get(e));
+		}
+		load(e) {
+			this.reset();
+			let t = Date.now();
+			for (let n = e.length - 1; n >= 0; n--) {
+				let r = e[n], i = r.e || 0;
+				if (i === 0) this.set(r.k, r.v);
+				else {
+					let e = i - t;
+					e > 0 && this.set(r.k, r.v, e);
+				}
+			}
+		}
+		prune() {
+			this[d].forEach((e, t) => h(this, t, !1));
+		}
+	}, h = (e, t, n) => {
+		let r = e[d].get(t);
+		if (r) {
+			let t = r.value;
+			if (g(e, t)) {
+				if (v(e, r), !e[o]) return;
+			} else n && (e[f] && (r.value.now = Date.now()), e[u].unshiftNode(r));
+			return t.value;
+		}
+	}, g = (e, t) => {
+		if (!t || !t.maxAge && !e[s]) return !1;
+		let n = Date.now() - t.now;
+		return t.maxAge ? n > t.maxAge : e[s] && n > e[s];
+	}, _ = (e) => {
+		if (e[i] > e[r]) for (let t = e[u].tail; e[i] > e[r] && t !== null;) {
+			let n = t.prev;
+			v(e, t), t = n;
+		}
+	}, v = (e, t) => {
+		if (t) {
+			let n = t.value;
+			e[c] && e[c](n.key, n.value), e[i] -= n.length, e[d].delete(n.key), e[u].removeNode(t);
+		}
+	}, y = class {
+		constructor(e, t, n, r, i) {
+			this.key = e, this.value = t, this.length = n, this.now = r, this.maxAge = i || 0;
+		}
+	}, b = (e, t, n, r) => {
+		let i = n.value;
+		g(e, i) && (v(e, n), e[o] || (i = void 0)), i && t.call(r, i.value, i.key, e);
+	};
+	t.exports = m;
+})), C = /* @__PURE__ */ e(((e, t) => {
+	var n = S(), r = 10;
+	t.exports = class {
+		constructor({ document: e }) {
+			this.document = e, this.cache = new n({ max: r });
+		}
+		getProcessed(e) {
+			return this.cache.get(e);
+		}
+		setProcessed(e, t) {
+			this.cache.set(e, t);
+		}
+	};
+})), w = /* @__PURE__ */ e(((e, t) => {
+	var { isArray: n, isObject: r, isString: i } = d(), { asArray: a } = m(), { prependBase: o } = _(), s = p(), c = C(), l = 10;
+	t.exports = class {
+		constructor({ sharedCache: e }) {
+			this.perOpCache = /* @__PURE__ */ new Map(), this.sharedCache = e;
+		}
+		async resolve({ activeCtx: e, context: t, documentLoader: o, base: s, cycles: l = /* @__PURE__ */ new Set() }) {
+			t && r(t) && t["@context"] && (t = t["@context"]), t = a(t);
+			let d = [];
+			for (let a of t) {
+				if (i(a)) {
+					let t = this._get(a);
+					t ||= await this._resolveRemoteContext({
+						activeCtx: e,
+						url: a,
+						documentLoader: o,
+						base: s,
+						cycles: l
+					}), n(t) ? d.push(...t) : d.push(t);
+					continue;
+				}
+				if (a === null) {
+					d.push(new c({ document: null }));
+					continue;
+				}
+				r(a) || u(t);
+				let f = JSON.stringify(a), p = this._get(f);
+				p || (p = new c({ document: a }), this._cacheResolvedContext({
+					key: f,
+					resolved: p,
+					tag: "static"
+				})), d.push(p);
+			}
+			return d;
+		}
+		_get(e) {
+			let t = this.perOpCache.get(e);
+			if (!t) {
+				let n = this.sharedCache.get(e);
+				n && (t = n.get("static"), t && this.perOpCache.set(e, t));
+			}
+			return t;
+		}
+		_cacheResolvedContext({ key: e, resolved: t, tag: n }) {
+			if (this.perOpCache.set(e, t), n !== void 0) {
+				let r = this.sharedCache.get(e);
+				r || (r = /* @__PURE__ */ new Map(), this.sharedCache.set(e, r)), r.set(n, t);
+			}
+			return t;
+		}
+		async _resolveRemoteContext({ activeCtx: e, url: t, documentLoader: n, base: r, cycles: i }) {
+			t = o(r, t);
+			let { context: a, remoteDoc: s } = await this._fetchContext({
+				activeCtx: e,
+				url: t,
+				documentLoader: n,
+				cycles: i
+			});
+			r = s.documentUrl || t, f({
+				context: a,
+				base: r
+			});
+			let c = await this.resolve({
+				activeCtx: e,
+				context: a,
+				documentLoader: n,
+				base: r,
+				cycles: i
+			});
+			return this._cacheResolvedContext({
+				key: t,
+				resolved: c,
+				tag: s.tag
+			}), c;
+		}
+		async _fetchContext({ activeCtx: e, url: t, documentLoader: a, cycles: o }) {
+			if (o.size > l) throw new s("Maximum number of @context URLs exceeded.", "jsonld.ContextUrlError", {
+				code: e.processingMode === "json-ld-1.0" ? "loading remote context failed" : "context overflow",
+				max: l
+			});
+			if (o.has(t)) throw new s("Cyclical @context URLs detected.", "jsonld.ContextUrlError", {
+				code: e.processingMode === "json-ld-1.0" ? "recursive context inclusion" : "context overflow",
+				url: t
+			});
+			o.add(t);
+			let c, u;
+			try {
+				u = await a(t), c = u.document || null, i(c) && (c = JSON.parse(c));
+			} catch (e) {
+				throw new s(`Dereferencing a URL did not result in a valid JSON-LD object. Possible causes are an inaccessible URL perhaps due to a same-origin policy (ensure the server uses CORS if you are using client-side JavaScript), too many redirects, a non-JSON response, or more than one HTTP Link Header was provided for a remote context. URL: "${t}".`, "jsonld.InvalidUrl", {
+					code: "loading remote context failed",
+					url: t,
+					cause: e
+				});
+			}
+			if (!r(c)) throw new s(`Dereferencing a URL did not result in a JSON object. The response was valid JSON, but it was not a JSON object. URL: "${t}".`, "jsonld.InvalidUrl", {
+				code: "invalid remote context",
+				url: t
+			});
+			return c = "@context" in c ? { "@context": c["@context"] } : { "@context": {} }, u.contextUrl && (n(c["@context"]) || (c["@context"] = [c["@context"]]), c["@context"].push(u.contextUrl)), {
+				context: c,
+				remoteDoc: u
+			};
+		}
+	};
+	function u(e) {
+		throw new s("Invalid JSON-LD syntax; @context must be an object.", "jsonld.SyntaxError", {
+			code: "invalid local context",
+			context: e
+		});
+	}
+	function f({ context: e, base: t }) {
+		if (!e) return;
+		let a = e["@context"];
+		if (i(a)) {
+			e["@context"] = o(t, a);
+			return;
+		}
+		if (n(a)) {
+			for (let e = 0; e < a.length; ++e) {
+				let n = a[e];
+				if (i(n)) {
+					a[e] = o(t, n);
+					continue;
+				}
+				r(n) && f({
+					context: { "@context": n },
+					base: t
+				});
+			}
+			return;
+		}
+		if (r(a)) for (let e in a) f({
+			context: a[e],
+			base: t
+		});
+	}
+})), T = /* @__PURE__ */ e(((e, t) => {
+	t.exports = u().NQuads;
+})), E = /* @__PURE__ */ e(((e, t) => {
+	var n = p(), { isArray: r } = d(), { asArray: i } = m(), a = {};
+	t.exports = a, a.defaultEventHandler = null, a.setupEventHandler = ({ options: e = {} }) => {
+		let t = [].concat(e.safe ? a.safeEventHandler : [], e.eventHandler ? i(e.eventHandler) : [], a.defaultEventHandler ? a.defaultEventHandler : []);
+		return t.length === 0 ? null : t;
+	}, a.handleEvent = ({ event: e, options: t }) => {
+		o({
+			event: e,
+			handlers: t.eventHandler
+		});
+	};
+	function o({ event: e, handlers: t }) {
+		let i = !0;
+		for (let a = 0; i && a < t.length; ++a) {
+			i = !1;
+			let s = t[a];
+			if (r(s)) i = o({
+				event: e,
+				handlers: s
+			});
+			else if (typeof s == "function") s({
+				event: e,
+				next: () => {
+					i = !0;
+				}
+			});
+			else if (typeof s == "object") e.code in s ? s[e.code]({
+				event: e,
+				next: () => {
+					i = !0;
+				}
+			}) : i = !0;
+			else throw new n("Invalid event handler.", "jsonld.InvalidEventHandler", { event: e });
+		}
+		return i;
+	}
+	var s = /* @__PURE__ */ new Set([
+		"empty object",
+		"free-floating scalar",
+		"invalid @language value",
+		"invalid property",
+		"null @id value",
+		"null @value value",
+		"object with only @id",
+		"object with only @language",
+		"object with only @list",
+		"object with only @value",
+		"relative @id reference",
+		"relative @type reference",
+		"relative @vocab reference",
+		"reserved @id value",
+		"reserved @reverse value",
+		"reserved term",
+		"blank node predicate",
+		"relative graph reference",
+		"relative object reference",
+		"relative predicate reference",
+		"relative subject reference",
+		"rdfDirection not set"
+	]);
+	a.safeEventHandler = function({ event: e, next: t }) {
+		if (e.level === "warning" && s.has(e.code)) throw new n("Safe mode validation error.", "jsonld.ValidationError", { event: e });
+		t();
+	}, a.logEventHandler = function({ event: e, next: t }) {
+		console.log(`EVENT: ${e.message}`, { event: e }), t();
+	}, a.logWarningEventHandler = function({ event: e, next: t }) {
+		e.level === "warning" && console.warn(`WARNING: ${e.message}`, { event: e }), t();
+	}, a.unhandledEventHandler = function({ event: e }) {
+		throw new n("No handler for event.", "jsonld.UnhandledEvent", { event: e });
+	}, a.setDefaultEventHandler = function({ eventHandler: e } = {}) {
+		a.defaultEventHandler = e ? i(e) : null;
+	};
+})), D = /* @__PURE__ */ e(((e, t) => {
+	var n = m(), r = p(), { isArray: i, isObject: a, isString: o, isUndefined: s } = d(), { isAbsolute: c, isRelative: l, prependBase: u } = _(), { handleEvent: f } = E(), { REGEX_BCP47: h, REGEX_KEYWORD: g, asArray: v, compareShortestLeast: y } = m(), b = /* @__PURE__ */ new Map(), x = 1e4, S = {};
+	t.exports = S, S.process = async ({ activeCtx: e, localCtx: t, options: n, propagate: s = !0, overrideProtected: d = !1, cycles: p = /* @__PURE__ */ new Set() }) => {
+		if (a(t) && "@context" in t && i(t["@context"]) && (t = t["@context"]), v(t).length === 0) return e;
+		let m = [], g = [({ event: e, next: t }) => {
+			m.push(e), t();
+		}];
+		n.eventHandler && g.push(n.eventHandler);
+		let _ = n;
+		n = {
+			...n,
+			eventHandler: g
+		};
+		let y = await n.contextResolver.resolve({
+			activeCtx: e,
+			context: t,
+			documentLoader: n.documentLoader,
+			base: n.base
+		});
+		a(y[0].document) && typeof y[0].document["@propagate"] == "boolean" && (s = y[0].document["@propagate"]);
+		let b = e;
+		!s && !b.previousContext && (b = b.clone(), b.previousContext = e);
+		for (let i of y) {
+			let { document: s } = i;
+			if (e = b, s === null) {
+				if (!d && Object.keys(e.protected).length !== 0) throw new r("Tried to nullify a context with protected terms outside of a term definition.", "jsonld.SyntaxError", { code: "invalid context nullification" });
+				b = e = S.getInitialContext(n).clone();
+				continue;
+			}
+			let g = i.getProcessed(e);
+			if (g) {
+				if (_.eventHandler) for (let e of g.events) f({
+					event: e,
+					options: _
+				});
+				b = e = g.context;
+				continue;
+			}
+			if (a(s) && "@context" in s && (s = s["@context"]), !a(s)) throw new r("Invalid JSON-LD syntax; @context must be an object.", "jsonld.SyntaxError", {
+				code: "invalid local context",
+				context: s
+			});
+			b = b.clone();
+			let v = /* @__PURE__ */ new Map();
+			if ("@version" in s) {
+				if (s["@version"] !== 1.1) throw new r("Unsupported JSON-LD version: " + s["@version"], "jsonld.UnsupportedVersion", {
+					code: "invalid @version value",
+					context: s
+				});
+				if (e.processingMode && e.processingMode === "json-ld-1.0") throw new r("@version: " + s["@version"] + " not compatible with " + e.processingMode, "jsonld.ProcessingModeConflict", {
+					code: "processing mode conflict",
+					context: s
+				});
+				b.processingMode = "json-ld-1.1", b["@version"] = s["@version"], v.set("@version", !0);
+			}
+			if (b.processingMode = b.processingMode || e.processingMode, "@base" in s) {
+				let e = s["@base"];
+				if (!(e === null || c(e))) if (l(e)) e = u(b["@base"], e);
+				else throw new r("Invalid JSON-LD syntax; the value of \"@base\" in a @context must be an absolute IRI, a relative IRI, or null.", "jsonld.SyntaxError", {
+					code: "invalid base IRI",
+					context: s
+				});
+				b["@base"] = e, v.set("@base", !0);
+			}
+			if ("@vocab" in s) {
+				let e = s["@vocab"];
+				if (e === null) delete b["@vocab"];
+				else if (!o(e)) throw new r("Invalid JSON-LD syntax; the value of \"@vocab\" in a @context must be a string or null.", "jsonld.SyntaxError", {
+					code: "invalid vocab mapping",
+					context: s
+				});
+				else if (!c(e) && S.processingMode(b, 1)) throw new r("Invalid JSON-LD syntax; the value of \"@vocab\" in a @context must be an absolute IRI.", "jsonld.SyntaxError", {
+					code: "invalid vocab mapping",
+					context: s
+				});
+				else {
+					let t = C(b, e, {
+						vocab: !0,
+						base: !0
+					}, void 0, void 0, n);
+					c(t) || n.eventHandler && f({
+						event: {
+							type: ["JsonLdEvent"],
+							code: "relative @vocab reference",
+							level: "warning",
+							message: "Relative @vocab reference found.",
+							details: { vocab: t }
+						},
+						options: n
+					}), b["@vocab"] = t;
+				}
+				v.set("@vocab", !0);
+			}
+			if ("@language" in s) {
+				let e = s["@language"];
+				if (e === null) delete b["@language"];
+				else if (o(e)) e.match(h) || n.eventHandler && f({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "invalid @language value",
+						level: "warning",
+						message: "@language value must be valid BCP47.",
+						details: { language: e }
+					},
+					options: n
+				}), b["@language"] = e.toLowerCase();
+				else throw new r("Invalid JSON-LD syntax; the value of \"@language\" in a @context must be a string or null.", "jsonld.SyntaxError", {
+					code: "invalid default language",
+					context: s
+				});
+				v.set("@language", !0);
+			}
+			if ("@direction" in s) {
+				let t = s["@direction"];
+				if (e.processingMode === "json-ld-1.0") throw new r("Invalid JSON-LD syntax; @direction not compatible with " + e.processingMode, "jsonld.SyntaxError", {
+					code: "invalid context member",
+					context: s
+				});
+				if (t === null) delete b["@direction"];
+				else if (t !== "ltr" && t !== "rtl") throw new r("Invalid JSON-LD syntax; the value of \"@direction\" in a @context must be null, \"ltr\", or \"rtl\".", "jsonld.SyntaxError", {
+					code: "invalid base direction",
+					context: s
+				});
+				else b["@direction"] = t;
+				v.set("@direction", !0);
+			}
+			if ("@propagate" in s) {
+				let n = s["@propagate"];
+				if (e.processingMode === "json-ld-1.0") throw new r("Invalid JSON-LD syntax; @propagate not compatible with " + e.processingMode, "jsonld.SyntaxError", {
+					code: "invalid context entry",
+					context: s
+				});
+				if (typeof n != "boolean") throw new r("Invalid JSON-LD syntax; @propagate value must be a boolean.", "jsonld.SyntaxError", {
+					code: "invalid @propagate value",
+					context: t
+				});
+				v.set("@propagate", !0);
+			}
+			if ("@import" in s) {
+				let i = s["@import"];
+				if (e.processingMode === "json-ld-1.0") throw new r("Invalid JSON-LD syntax; @import not compatible with " + e.processingMode, "jsonld.SyntaxError", {
+					code: "invalid context entry",
+					context: s
+				});
+				if (!o(i)) throw new r("Invalid JSON-LD syntax; @import must be a string.", "jsonld.SyntaxError", {
+					code: "invalid @import value",
+					context: t
+				});
+				let a = await n.contextResolver.resolve({
+					activeCtx: e,
+					context: i,
+					documentLoader: n.documentLoader,
+					base: n.base
+				});
+				if (a.length !== 1) throw new r("Invalid JSON-LD syntax; @import must reference a single context.", "jsonld.SyntaxError", {
+					code: "invalid remote context",
+					context: t
+				});
+				let c = a[0].getProcessed(e);
+				if (c) s = c;
+				else {
+					let n = a[0].document;
+					if ("@import" in n) throw new r("Invalid JSON-LD syntax: imported context must not include @import.", "jsonld.SyntaxError", {
+						code: "invalid context entry",
+						context: t
+					});
+					for (let e in n) s.hasOwnProperty(e) || (s[e] = n[e]);
+					a[0].setProcessed(e, s);
+				}
+				v.set("@import", !0);
+			}
+			v.set("@protected", s["@protected"] || !1);
+			for (let e in s) if (S.createTermDefinition({
+				activeCtx: b,
+				localCtx: s,
+				term: e,
+				defined: v,
+				options: n,
+				overrideProtected: d
+			}), a(s[e]) && "@context" in s[e]) {
+				let t = s[e]["@context"], i = !0;
+				if (o(t)) {
+					let e = u(n.base, t);
+					p.has(e) ? i = !1 : p.add(e);
+				}
+				if (i) try {
+					await S.process({
+						activeCtx: b.clone(),
+						localCtx: s[e]["@context"],
+						overrideProtected: !0,
+						options: n,
+						cycles: p
+					});
+				} catch {
+					throw new r("Invalid JSON-LD syntax; invalid scoped context.", "jsonld.SyntaxError", {
+						code: "invalid scoped context",
+						context: s[e]["@context"],
+						term: e
+					});
+				}
+			}
+			i.setProcessed(e, {
+				context: b,
+				events: m
+			});
+		}
+		return b;
+	}, S.createTermDefinition = ({ activeCtx: e, localCtx: t, term: n, defined: s, options: l, overrideProtected: u = !1 }) => {
+		if (s.has(n)) {
+			if (s.get(n)) return;
+			throw new r("Cyclical context definition detected.", "jsonld.CyclicalContext", {
+				code: "cyclic IRI mapping",
+				context: t,
+				term: n
+			});
+		}
+		s.set(n, !1);
+		let d;
+		if (t.hasOwnProperty(n) && (d = t[n]), n === "@type" && a(d) && (d["@container"] || "@set") === "@set" && S.processingMode(e, 1.1)) {
+			let e = [
+				"@container",
+				"@id",
+				"@protected"
+			], i = Object.keys(d);
+			if (i.length === 0 || i.some((t) => !e.includes(t))) throw new r("Invalid JSON-LD syntax; keywords cannot be overridden.", "jsonld.SyntaxError", {
+				code: "keyword redefinition",
+				context: t,
+				term: n
+			});
+		} else if (S.isKeyword(n)) throw new r("Invalid JSON-LD syntax; keywords cannot be overridden.", "jsonld.SyntaxError", {
+			code: "keyword redefinition",
+			context: t,
+			term: n
+		});
+		else if (n.match(g)) {
+			l.eventHandler && f({
+				event: {
+					type: ["JsonLdEvent"],
+					code: "reserved term",
+					level: "warning",
+					message: "Terms beginning with \"@\" are reserved for future use and dropped.",
+					details: { term: n }
+				},
+				options: l
+			});
+			return;
+		} else if (n === "") throw new r("Invalid JSON-LD syntax; a term cannot be an empty string.", "jsonld.SyntaxError", {
+			code: "invalid term definition",
+			context: t
+		});
+		let p = e.mappings.get(n);
+		e.mappings.has(n) && e.mappings.delete(n);
+		let m = !1;
+		if ((o(d) || d === null) && (m = !0, d = { "@id": d }), !a(d)) throw new r("Invalid JSON-LD syntax; @context term values must be strings or objects.", "jsonld.SyntaxError", {
+			code: "invalid term definition",
+			context: t
+		});
+		let h = {};
+		e.mappings.set(n, h), h.reverse = !1;
+		let _ = [
+			"@container",
+			"@id",
+			"@language",
+			"@reverse",
+			"@type"
+		];
+		S.processingMode(e, 1.1) && _.push("@context", "@direction", "@index", "@nest", "@prefix", "@protected");
+		for (let e in d) if (!_.includes(e)) throw new r("Invalid JSON-LD syntax; a term definition must not contain " + e, "jsonld.SyntaxError", {
+			code: "invalid term definition",
+			context: t
+		});
+		let v = n.indexOf(":");
+		if (h._termHasColon = v > 0, "@reverse" in d) {
+			if ("@id" in d) throw new r("Invalid JSON-LD syntax; a @reverse term definition must not contain @id.", "jsonld.SyntaxError", {
+				code: "invalid reverse property",
+				context: t
+			});
+			if ("@nest" in d) throw new r("Invalid JSON-LD syntax; a @reverse term definition must not contain @nest.", "jsonld.SyntaxError", {
+				code: "invalid reverse property",
+				context: t
+			});
+			let i = d["@reverse"];
+			if (!o(i)) throw new r("Invalid JSON-LD syntax; a @context @reverse value must be a string.", "jsonld.SyntaxError", {
+				code: "invalid IRI mapping",
+				context: t
+			});
+			if (i.match(g)) {
+				l.eventHandler && f({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "reserved @reverse value",
+						level: "warning",
+						message: "@reverse values beginning with \"@\" are reserved for future use and dropped.",
+						details: { reverse: i }
+					},
+					options: l
+				}), p ? e.mappings.set(n, p) : e.mappings.delete(n);
+				return;
+			}
+			let a = C(e, i, {
+				vocab: !0,
+				base: !1
+			}, t, s, l);
+			if (!c(a)) throw new r("Invalid JSON-LD syntax; a @context @reverse value must be an absolute IRI or a blank node identifier.", "jsonld.SyntaxError", {
+				code: "invalid IRI mapping",
+				context: t
+			});
+			h["@id"] = a, h.reverse = !0;
+		} else if ("@id" in d) {
+			let i = d["@id"];
+			if (i && !o(i)) throw new r("Invalid JSON-LD syntax; a @context @id value must be an array of strings or a string.", "jsonld.SyntaxError", {
+				code: "invalid IRI mapping",
+				context: t
+			});
+			if (i === null) h["@id"] = null;
+			else if (!S.isKeyword(i) && i.match(g)) {
+				l.eventHandler && f({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "reserved @id value",
+						level: "warning",
+						message: "@id values beginning with \"@\" are reserved for future use and dropped.",
+						details: { id: i }
+					},
+					options: l
+				}), p ? e.mappings.set(n, p) : e.mappings.delete(n);
+				return;
+			} else if (i !== n) {
+				if (i = C(e, i, {
+					vocab: !0,
+					base: !1
+				}, t, s, l), !c(i) && !S.isKeyword(i)) throw new r("Invalid JSON-LD syntax; a @context @id value must be an absolute IRI, a blank node identifier, or a keyword.", "jsonld.SyntaxError", {
+					code: "invalid IRI mapping",
+					context: t
+				});
+				if (n.match(/(?::[^:])|\//) && C(e, n, {
+					vocab: !0,
+					base: !1
+				}, t, new Map(s).set(n, !0), l) !== i) throw new r("Invalid JSON-LD syntax; term in form of IRI must expand to definition.", "jsonld.SyntaxError", {
+					code: "invalid IRI mapping",
+					context: t
+				});
+				h["@id"] = i, h._prefix = m && !h._termHasColon && i.match(/[:\/\?#\[\]@]$/) !== null;
+			}
+		}
+		if (!("@id" in h)) if (h._termHasColon) {
+			let r = n.substr(0, v);
+			if (t.hasOwnProperty(r) && S.createTermDefinition({
+				activeCtx: e,
+				localCtx: t,
+				term: r,
+				defined: s,
+				options: l
+			}), e.mappings.has(r)) {
+				let t = n.substr(v + 1);
+				h["@id"] = e.mappings.get(r)["@id"] + t;
+			} else h["@id"] = n;
+		} else if (n === "@type") h["@id"] = n;
+		else {
+			if (!("@vocab" in e)) throw new r("Invalid JSON-LD syntax; @context terms must define an @id.", "jsonld.SyntaxError", {
+				code: "invalid IRI mapping",
+				context: t,
+				term: n
+			});
+			h["@id"] = e["@vocab"] + n;
+		}
+		if ((d["@protected"] === !0 || s.get("@protected") === !0 && d["@protected"] !== !1) && (e.protected[n] = !0, h.protected = !0), s.set(n, !0), "@type" in d) {
+			let n = d["@type"];
+			if (!o(n)) throw new r("Invalid JSON-LD syntax; an @context @type value must be a string.", "jsonld.SyntaxError", {
+				code: "invalid type mapping",
+				context: t
+			});
+			if (n === "@json" || n === "@none") {
+				if (S.processingMode(e, 1)) throw new r(`Invalid JSON-LD syntax; an @context @type value must not be "${n}" in JSON-LD 1.0 mode.`, "jsonld.SyntaxError", {
+					code: "invalid type mapping",
+					context: t
+				});
+			} else if (n !== "@id" && n !== "@vocab") {
+				if (n = C(e, n, {
+					vocab: !0,
+					base: !1
+				}, t, s, l), !c(n)) throw new r("Invalid JSON-LD syntax; an @context @type value must be an absolute IRI.", "jsonld.SyntaxError", {
+					code: "invalid type mapping",
+					context: t
+				});
+				if (n.indexOf("_:") === 0) throw new r("Invalid JSON-LD syntax; an @context @type value must be an IRI, not a blank node identifier.", "jsonld.SyntaxError", {
+					code: "invalid type mapping",
+					context: t
+				});
+			}
+			h["@type"] = n;
+		}
+		if ("@container" in d) {
+			let n = o(d["@container"]) ? [d["@container"]] : d["@container"] || [], a = [
+				"@list",
+				"@set",
+				"@index",
+				"@language"
+			], s = !0, c = n.includes("@set");
+			if (S.processingMode(e, 1.1)) {
+				if (a.push("@graph", "@id", "@type"), n.includes("@list")) {
+					if (n.length !== 1) throw new r("Invalid JSON-LD syntax; @context @container with @list must have no other values", "jsonld.SyntaxError", {
+						code: "invalid container mapping",
+						context: t
+					});
+				} else if (n.includes("@graph")) {
+					if (n.some((e) => e !== "@graph" && e !== "@id" && e !== "@index" && e !== "@set")) throw new r("Invalid JSON-LD syntax; @context @container with @graph must have no other values other than @id, @index, and @set", "jsonld.SyntaxError", {
+						code: "invalid container mapping",
+						context: t
+					});
+				} else s &= n.length <= (c ? 2 : 1);
+				if (n.includes("@type") && (h["@type"] = h["@type"] || "@id", !["@id", "@vocab"].includes(h["@type"]))) throw new r("Invalid JSON-LD syntax; container: @type requires @type to be @id or @vocab.", "jsonld.SyntaxError", {
+					code: "invalid type mapping",
+					context: t
+				});
+			} else s &= !i(d["@container"]), s &= n.length <= 1;
+			if (s &= n.every((e) => a.includes(e)), s &= !(c && n.includes("@list")), !s) throw new r("Invalid JSON-LD syntax; @context @container value must be one of the following: " + a.join(", "), "jsonld.SyntaxError", {
+				code: "invalid container mapping",
+				context: t
+			});
+			if (h.reverse && !n.every((e) => ["@index", "@set"].includes(e))) throw new r("Invalid JSON-LD syntax; @context @container value for a @reverse type definition must be @index or @set.", "jsonld.SyntaxError", {
+				code: "invalid reverse property",
+				context: t
+			});
+			h["@container"] = n;
+		}
+		if ("@index" in d) {
+			if (!("@container" in d) || !h["@container"].includes("@index")) throw new r(`Invalid JSON-LD syntax; @index without @index in @container: "${d["@index"]}" on term "${n}".`, "jsonld.SyntaxError", {
+				code: "invalid term definition",
+				context: t
+			});
+			if (!o(d["@index"]) || d["@index"].indexOf("@") === 0) throw new r(`Invalid JSON-LD syntax; @index must expand to an IRI: "${d["@index"]}" on term "${n}".`, "jsonld.SyntaxError", {
+				code: "invalid term definition",
+				context: t
+			});
+			h["@index"] = d["@index"];
+		}
+		if ("@context" in d && (h["@context"] = d["@context"]), "@language" in d && !("@type" in d)) {
+			let e = d["@language"];
+			if (e !== null && !o(e)) throw new r("Invalid JSON-LD syntax; @context @language value must be a string or null.", "jsonld.SyntaxError", {
+				code: "invalid language mapping",
+				context: t
+			});
+			e !== null && (e = e.toLowerCase()), h["@language"] = e;
+		}
+		if ("@prefix" in d) {
+			if (n.match(/:|\//)) throw new r("Invalid JSON-LD syntax; @context @prefix used on a compact IRI term", "jsonld.SyntaxError", {
+				code: "invalid term definition",
+				context: t
+			});
+			if (S.isKeyword(h["@id"])) throw new r("Invalid JSON-LD syntax; keywords may not be used as prefixes", "jsonld.SyntaxError", {
+				code: "invalid term definition",
+				context: t
+			});
+			if (typeof d["@prefix"] == "boolean") h._prefix = d["@prefix"] === !0;
+			else throw new r("Invalid JSON-LD syntax; @context value for @prefix must be boolean", "jsonld.SyntaxError", {
+				code: "invalid @prefix value",
+				context: t
+			});
+		}
+		if ("@direction" in d) {
+			let e = d["@direction"];
+			if (e !== null && e !== "ltr" && e !== "rtl") throw new r("Invalid JSON-LD syntax; @direction value must be null, \"ltr\", or \"rtl\".", "jsonld.SyntaxError", {
+				code: "invalid base direction",
+				context: t
+			});
+			h["@direction"] = e;
+		}
+		if ("@nest" in d) {
+			let e = d["@nest"];
+			if (!o(e) || e !== "@nest" && e.indexOf("@") === 0) throw new r("Invalid JSON-LD syntax; @context @nest value must be a string which is not a keyword other than @nest.", "jsonld.SyntaxError", {
+				code: "invalid @nest value",
+				context: t
+			});
+			h["@nest"] = e;
+		}
+		let y = h["@id"];
+		if (y === "@context" || y === "@preserve") throw new r("Invalid JSON-LD syntax; @context and @preserve cannot be aliased.", "jsonld.SyntaxError", {
+			code: "invalid keyword alias",
+			context: t
+		});
+		if (p && p.protected && !u && (e.protected[n] = !0, h.protected = !0, !w(p, h))) throw new r("Invalid JSON-LD syntax; tried to redefine a protected term.", "jsonld.SyntaxError", {
+			code: "protected term redefinition",
+			context: t,
+			term: n
+		});
+	}, S.expandIri = (e, t, n, r) => C(e, t, n, void 0, void 0, r);
+	function C(e, t, n, r, i, s) {
+		if (t === null || !o(t) || S.isKeyword(t)) return t;
+		if (t.match(g)) return null;
+		if (r && r.hasOwnProperty(t) && i.get(t) !== !0 && S.createTermDefinition({
+			activeCtx: e,
+			localCtx: r,
+			term: t,
+			defined: i,
+			options: s
+		}), n ||= {}, n.vocab) {
+			let n = e.mappings.get(t);
+			if (n === null) return null;
+			if (a(n) && "@id" in n) return n["@id"];
+		}
+		let l = t.indexOf(":");
+		if (l > 0) {
+			let n = t.substr(0, l), a = t.substr(l + 1);
+			if (n === "_" || a.indexOf("//") === 0) return t;
+			r && r.hasOwnProperty(n) && S.createTermDefinition({
+				activeCtx: e,
+				localCtx: r,
+				term: n,
+				defined: i,
+				options: s
+			});
+			let o = e.mappings.get(n);
+			if (o && o._prefix) return o["@id"] + a;
+			if (c(t)) return t;
+		}
+		if (n.vocab && "@vocab" in e) t = e["@vocab"] + t;
+		else if (n.base) {
+			let n, r;
+			"@base" in e ? e["@base"] ? (r = u(s.base, e["@base"]), n = u(r, t)) : (r = e["@base"], n = t) : (r = s.base, n = u(s.base, t)), t = n;
+		}
+		return t;
+	}
+	S.getInitialContext = (e) => {
+		let t = JSON.stringify({ processingMode: e.processingMode }), r = b.get(t);
+		if (r) return r;
+		let i = {
+			processingMode: e.processingMode,
+			mappings: /* @__PURE__ */ new Map(),
+			inverse: null,
+			getInverse: a,
+			clone: c,
+			revertToPreviousContext: l,
+			protected: {}
+		};
+		return b.size === x && b.clear(), b.set(t, i), i;
+		function a() {
+			let e = this;
+			if (e.inverse) return e.inverse;
+			let t = e.inverse = {}, n = e.fastCurieMap = {}, r = {}, i = (e["@language"] || "@none").toLowerCase(), a = e["@direction"], c = e.mappings, l = [...c.keys()].sort(y);
+			for (let e of l) {
+				let o = c.get(e);
+				if (o === null) continue;
+				let l = o["@container"] || "@none";
+				if (l = [].concat(l).sort().join(""), o["@id"] === null) continue;
+				let u = v(o["@id"]);
+				for (let c of u) {
+					let u = t[c], d = S.isKeyword(c);
+					if (u) !d && !o._termHasColon && r[c].push(e);
+					else if (t[c] = u = {}, !d && !o._termHasColon) {
+						r[c] = [e];
+						let t = {
+							iri: c,
+							terms: r[c]
+						};
+						c[0] in n ? n[c[0]].push(t) : n[c[0]] = [t];
+					}
+					if (u[l] || (u[l] = {
+						"@language": {},
+						"@type": {},
+						"@any": {}
+					}), u = u[l], s(e, u["@any"], "@none"), o.reverse) s(e, u["@type"], "@reverse");
+					else if (o["@type"] === "@none") s(e, u["@any"], "@none"), s(e, u["@language"], "@none"), s(e, u["@type"], "@none");
+					else if ("@type" in o) s(e, u["@type"], o["@type"]);
+					else if ("@language" in o && "@direction" in o) {
+						let t = o["@language"], n = o["@direction"];
+						t && n ? s(e, u["@language"], `${t}_${n}`.toLowerCase()) : t ? s(e, u["@language"], t.toLowerCase()) : n ? s(e, u["@language"], `_${n}`) : s(e, u["@language"], "@null");
+					} else "@language" in o ? s(e, u["@language"], (o["@language"] || "@null").toLowerCase()) : "@direction" in o ? o["@direction"] ? s(e, u["@language"], `_${o["@direction"]}`) : s(e, u["@language"], "@none") : a ? (s(e, u["@language"], `_${a}`), s(e, u["@language"], "@none"), s(e, u["@type"], "@none")) : (s(e, u["@language"], i), s(e, u["@language"], "@none"), s(e, u["@type"], "@none"));
+				}
+			}
+			for (let e in n) o(n, e, 1);
+			return t;
+		}
+		function o(e, t, n) {
+			let r = e[t], i = e[t] = {}, a, s;
+			for (let e of r) a = e.iri, s = n >= a.length ? "" : a[n], s in i ? i[s].push(e) : i[s] = [e];
+			for (let e in i) e !== "" && o(i, e, n + 1);
+		}
+		function s(e, t, n) {
+			t.hasOwnProperty(n) || (t[n] = e);
+		}
+		function c() {
+			let e = {};
+			return e.mappings = n.clone(this.mappings), e.clone = this.clone, e.inverse = null, e.getInverse = this.getInverse, e.protected = n.clone(this.protected), this.previousContext && (e.previousContext = this.previousContext.clone()), e.revertToPreviousContext = this.revertToPreviousContext, "@base" in this && (e["@base"] = this["@base"]), "@language" in this && (e["@language"] = this["@language"]), "@vocab" in this && (e["@vocab"] = this["@vocab"]), e;
+		}
+		function l() {
+			return this.previousContext ? this.previousContext.clone() : this;
+		}
+	}, S.getContextValue = (e, t, n) => {
+		if (t === null) return n === "@context" ? void 0 : null;
+		if (e.mappings.has(t)) {
+			let r = e.mappings.get(t);
+			if (s(n)) return r;
+			if (r.hasOwnProperty(n)) return r[n];
+		}
+		if (n === "@language" && n in e || n === "@direction" && n in e) return e[n];
+		if (n !== "@context") return null;
+	}, S.processingMode = (e, t) => t.toString() >= "1.1" ? !e.processingMode || e.processingMode >= "json-ld-" + t.toString() : e.processingMode === "json-ld-1.0", S.isKeyword = (e) => {
+		if (!o(e) || e[0] !== "@") return !1;
+		switch (e) {
+			case "@base":
+			case "@container":
+			case "@context":
+			case "@default":
+			case "@direction":
+			case "@embed":
+			case "@explicit":
+			case "@graph":
+			case "@id":
+			case "@included":
+			case "@index":
+			case "@json":
+			case "@language":
+			case "@list":
+			case "@nest":
+			case "@none":
+			case "@omitDefault":
+			case "@prefix":
+			case "@preserve":
+			case "@protected":
+			case "@requireAll":
+			case "@reverse":
+			case "@set":
+			case "@type":
+			case "@value":
+			case "@version":
+			case "@vocab": return !0;
+		}
+		return !1;
+	};
+	function w(e, t) {
+		if (!(e && typeof e == "object") || !(t && typeof t == "object")) return e === t;
+		let n = Array.isArray(e);
+		if (n !== Array.isArray(t)) return !1;
+		if (n) {
+			if (e.length !== t.length) return !1;
+			for (let n = 0; n < e.length; ++n) if (!w(e[n], t[n])) return !1;
+			return !0;
+		}
+		let r = Object.keys(e), i = Object.keys(t);
+		if (r.length !== i.length) return !1;
+		for (let n in e) {
+			let r = e[n], i = t[n];
+			if (n === "@container" && Array.isArray(r) && Array.isArray(i) && (r = r.slice().sort(), i = i.slice().sort()), !w(r, i)) return !1;
+		}
+		return !0;
+	}
+})), O = /* @__PURE__ */ e(((e, t) => {
+	var n = p(), { isArray: r, isObject: i, isEmptyObject: a, isString: o, isUndefined: s } = d(), { isList: c, isValue: l, isGraph: u, isSubject: h } = f(), { expandIri: g, getContextValue: v, isKeyword: y, process: b, processingMode: x } = D(), { isAbsolute: S } = _(), { REGEX_BCP47: C, REGEX_KEYWORD: w, addValue: T, asArray: O, getValues: k, validateTypeValue: A } = m(), { handleEvent: j } = E(), M = {};
+	t.exports = M, M.expand = async ({ activeCtx: e, activeProperty: t = null, element: c, options: l = {}, insideList: u = !1, insideIndex: d = !1, typeScopedContext: f = null }) => {
+		if (c == null) return null;
+		if (t === "@default" && (l = Object.assign({}, l, { isFrame: !1 })), !r(c) && !i(c)) return !u && (t === null || g(e, t, { vocab: !0 }, l) === "@graph") ? (l.eventHandler && j({
+			event: {
+				type: ["JsonLdEvent"],
+				code: "free-floating scalar",
+				level: "warning",
+				message: "Dropping free-floating scalar not in a list.",
+				details: { value: c }
+			},
+			options: l
+		}), null) : F({
+			activeCtx: e,
+			activeProperty: t,
+			value: c,
+			options: l
+		});
+		if (r(c)) {
+			let n = [], i = v(e, t, "@container") || [];
+			u ||= i.includes("@list");
+			for (let i = 0; i < c.length; ++i) {
+				let a = await M.expand({
+					activeCtx: e,
+					activeProperty: t,
+					element: c[i],
+					options: l,
+					insideIndex: d,
+					typeScopedContext: f
+				});
+				u && r(a) && (a = { "@list": a }), a !== null && (r(a) ? n = n.concat(a) : n.push(a));
+			}
+			return n;
+		}
+		let p = g(e, t, { vocab: !0 }, l), m = v(e, t, "@context");
+		f ||= e.previousContext ? e : null;
+		let h = Object.keys(c).sort(), _ = !d;
+		if (_ && f && h.length <= 2 && !h.includes("@context")) for (let t of h) {
+			let n = g(f, t, { vocab: !0 }, l);
+			if (n === "@value") {
+				_ = !1, e = f;
+				break;
+			}
+			if (n === "@id" && h.length === 1) {
+				_ = !1;
+				break;
+			}
+		}
+		_ && (e = e.revertToPreviousContext()), s(m) || (e = await b({
+			activeCtx: e,
+			localCtx: m,
+			propagate: !0,
+			overrideProtected: !0,
+			options: l
+		})), "@context" in c && (e = await b({
+			activeCtx: e,
+			localCtx: c["@context"],
+			options: l
+		})), f = e;
+		let y = null;
+		for (let t of h) if (g(e, t, { vocab: !0 }, l) === "@type") {
+			y ||= t;
+			let n = c[t], r = Array.isArray(n) ? n.length > 1 ? n.slice().sort() : n : [n];
+			for (let t of r) {
+				let n = v(f, t, "@context");
+				s(n) || (e = await b({
+					activeCtx: e,
+					localCtx: n,
+					options: l,
+					propagate: !1
+				}));
+			}
+		}
+		let C = {};
+		await P({
+			activeCtx: e,
+			activeProperty: t,
+			expandedActiveProperty: p,
+			element: c,
+			expandedParent: C,
+			options: l,
+			insideList: u,
+			typeKey: y,
+			typeScopedContext: f
+		}), h = Object.keys(C);
+		let w = h.length;
+		if ("@value" in C) {
+			if ("@type" in C && ("@language" in C || "@direction" in C)) throw new n("Invalid JSON-LD syntax; an element containing \"@value\" may not contain both \"@type\" and either \"@language\" or \"@direction\".", "jsonld.SyntaxError", {
+				code: "invalid value object",
+				element: C
+			});
+			let t = w - 1;
+			if ("@type" in C && --t, "@index" in C && --t, "@language" in C && --t, "@direction" in C && --t, t !== 0) throw new n("Invalid JSON-LD syntax; an element containing \"@value\" may only have an \"@index\" property and either \"@type\" or either or both \"@language\" or \"@direction\".", "jsonld.SyntaxError", {
+				code: "invalid value object",
+				element: C
+			});
+			let r = C["@value"] === null ? [] : O(C["@value"]), i = k(C, "@type");
+			if (!(x(e, 1.1) && i.includes("@json") && i.length === 1)) {
+				if (r.length === 0) l.eventHandler && j({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "null @value value",
+						level: "warning",
+						message: "Dropping null @value value.",
+						details: { value: C }
+					},
+					options: l
+				}), C = null;
+				else if (!r.every((e) => o(e) || a(e)) && "@language" in C) throw new n("Invalid JSON-LD syntax; only strings may be language-tagged.", "jsonld.SyntaxError", {
+					code: "invalid language-tagged value",
+					element: C
+				});
+				else if (!i.every((e) => S(e) && !(o(e) && e.indexOf("_:") === 0) || a(e))) throw new n("Invalid JSON-LD syntax; an element containing \"@value\" and \"@type\" must have an absolute IRI for the value of \"@type\".", "jsonld.SyntaxError", {
+					code: "invalid typed value",
+					element: C
+				});
+			}
+		} else if ("@type" in C && !r(C["@type"])) C["@type"] = [C["@type"]];
+		else if ("@set" in C || "@list" in C) {
+			if (w > 1 && !(w === 2 && "@index" in C)) throw new n("Invalid JSON-LD syntax; if an element has the property \"@set\" or \"@list\", then it can have at most one other property that is \"@index\".", "jsonld.SyntaxError", {
+				code: "invalid set or list object",
+				element: C
+			});
+			"@set" in C && (C = C["@set"], h = Object.keys(C), w = h.length);
+		} else w === 1 && "@language" in C && (l.eventHandler && j({
+			event: {
+				type: ["JsonLdEvent"],
+				code: "object with only @language",
+				level: "warning",
+				message: "Dropping object with only @language.",
+				details: { value: C }
+			},
+			options: l
+		}), C = null);
+		return i(C) && !l.keepFreeFloatingNodes && !u && (t === null || p === "@graph" || (v(e, t, "@container") || []).includes("@graph")) && (C = N({
+			value: C,
+			count: w,
+			options: l
+		})), C;
+	};
+	function N({ value: e, count: t, options: n }) {
+		if (t === 0 || "@value" in e || "@list" in e || t === 1 && "@id" in e) {
+			if (n.eventHandler) {
+				let r, i;
+				t === 0 ? (r = "empty object", i = "Dropping empty object.") : "@value" in e ? (r = "object with only @value", i = "Dropping object with only @value.") : "@list" in e ? (r = "object with only @list", i = "Dropping object with only @list.") : t === 1 && "@id" in e && (r = "object with only @id", i = "Dropping object with only @id."), j({
+					event: {
+						type: ["JsonLdEvent"],
+						code: r,
+						level: "warning",
+						message: i,
+						details: { value: e }
+					},
+					options: n
+				});
+			}
+			return null;
+		}
+		return e;
+	}
+	async function P({ activeCtx: e, activeProperty: t, expandedActiveProperty: u, element: d, expandedParent: f, options: p = {}, insideList: m, typeKey: _, typeScopedContext: w }) {
+		let E = Object.keys(d).sort(), D = [], k, F = d[_] && g(e, r(d[_]) ? d[_][0] : d[_], { vocab: !0 }, {
+			...p,
+			typeExpansion: !0
+		}) === "@json";
+		for (let m of E) {
+			let _ = d[m], E;
+			if (m === "@context") continue;
+			let P = g(e, m, { vocab: !0 }, p);
+			if (P === null || !(S(P) || y(P))) {
+				p.eventHandler && j({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "invalid property",
+						level: "warning",
+						message: "Dropping property that did not expand into an absolute IRI or keyword.",
+						details: {
+							property: m,
+							expandedProperty: P
+						}
+					},
+					options: p
+				});
+				continue;
+			}
+			if (y(P)) {
+				if (u === "@reverse") throw new n("Invalid JSON-LD syntax; a keyword cannot be used as a @reverse property.", "jsonld.SyntaxError", {
+					code: "invalid reverse property map",
+					value: _
+				});
+				if (P in f && P !== "@included" && P !== "@type") throw new n("Invalid JSON-LD syntax; colliding keywords detected.", "jsonld.SyntaxError", {
+					code: "colliding keywords",
+					keyword: P
+				});
+			}
+			if (P === "@id") {
+				if (!o(_)) {
+					if (!p.isFrame) throw new n("Invalid JSON-LD syntax; \"@id\" value must a string.", "jsonld.SyntaxError", {
+						code: "invalid @id value",
+						value: _
+					});
+					if (i(_)) {
+						if (!a(_)) throw new n("Invalid JSON-LD syntax; \"@id\" value an empty object or array of strings, if framing", "jsonld.SyntaxError", {
+							code: "invalid @id value",
+							value: _
+						});
+					} else if (r(_)) {
+						if (!_.every((e) => o(e))) throw new n("Invalid JSON-LD syntax; \"@id\" value an empty object or array of strings, if framing", "jsonld.SyntaxError", {
+							code: "invalid @id value",
+							value: _
+						});
+					} else throw new n("Invalid JSON-LD syntax; \"@id\" value an empty object or array of strings, if framing", "jsonld.SyntaxError", {
+						code: "invalid @id value",
+						value: _
+					});
+				}
+				T(f, "@id", O(_).map((t) => {
+					if (o(t)) {
+						let n = g(e, t, { base: !0 }, p);
+						return p.eventHandler && (n === null ? j(t === null ? {
+							event: {
+								type: ["JsonLdEvent"],
+								code: "null @id value",
+								level: "warning",
+								message: "Null @id found.",
+								details: { id: t }
+							},
+							options: p
+						} : {
+							event: {
+								type: ["JsonLdEvent"],
+								code: "reserved @id value",
+								level: "warning",
+								message: "Reserved @id found.",
+								details: { id: t }
+							},
+							options: p
+						}) : S(n) || j({
+							event: {
+								type: ["JsonLdEvent"],
+								code: "relative @id reference",
+								level: "warning",
+								message: "Relative @id reference found.",
+								details: {
+									id: t,
+									expandedId: n
+								}
+							},
+							options: p
+						})), n;
+					}
+					return t;
+				}), { propertyIsArray: p.isFrame });
+				continue;
+			}
+			if (P === "@type") {
+				i(_) && (_ = Object.fromEntries(Object.entries(_).map(([e, t]) => [g(w, e, { vocab: !0 }), O(t).map((e) => g(w, e, {
+					base: !0,
+					vocab: !0
+				}, {
+					...p,
+					typeExpansion: !0
+				}))]))), A(_, p.isFrame), T(f, "@type", O(_).map((e) => {
+					if (o(e)) {
+						let t = g(w, e, {
+							base: !0,
+							vocab: !0
+						}, {
+							...p,
+							typeExpansion: !0
+						});
+						return t !== "@json" && !S(t) && p.eventHandler && j({
+							event: {
+								type: ["JsonLdEvent"],
+								code: "relative @type reference",
+								level: "warning",
+								message: "Relative @type reference found.",
+								details: { type: e }
+							},
+							options: p
+						}), t;
+					}
+					return e;
+				}), { propertyIsArray: !!p.isFrame });
+				continue;
+			}
+			if (P === "@included" && x(e, 1.1)) {
+				let r = O(await M.expand({
+					activeCtx: e,
+					activeProperty: t,
+					element: _,
+					options: p
+				}));
+				if (!r.every((e) => h(e))) throw new n("Invalid JSON-LD syntax; values of @included must expand to node objects.", "jsonld.SyntaxError", {
+					code: "invalid @included value",
+					value: _
+				});
+				T(f, "@included", r, { propertyIsArray: !0 });
+				continue;
+			}
+			if (P === "@graph" && !(i(_) || r(_))) throw new n("Invalid JSON-LD syntax; \"@graph\" value must not be an object or an array.", "jsonld.SyntaxError", {
+				code: "invalid @graph value",
+				value: _
+			});
+			if (P === "@value") {
+				k = _, F && x(e, 1.1) ? f["@value"] = _ : T(f, "@value", _, { propertyIsArray: p.isFrame });
+				continue;
+			}
+			if (P === "@language") {
+				if (_ === null) continue;
+				if (!o(_) && !p.isFrame) throw new n("Invalid JSON-LD syntax; \"@language\" value must be a string.", "jsonld.SyntaxError", {
+					code: "invalid language-tagged string",
+					value: _
+				});
+				_ = O(_).map((e) => o(e) ? e.toLowerCase() : e);
+				for (let e of _) o(e) && !e.match(C) && p.eventHandler && j({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "invalid @language value",
+						level: "warning",
+						message: "@language value must be valid BCP47.",
+						details: { language: e }
+					},
+					options: p
+				});
+				T(f, "@language", _, { propertyIsArray: p.isFrame });
+				continue;
+			}
+			if (P === "@direction") {
+				if (!o(_) && !p.isFrame) throw new n("Invalid JSON-LD syntax; \"@direction\" value must be a string.", "jsonld.SyntaxError", {
+					code: "invalid base direction",
+					value: _
+				});
+				_ = O(_);
+				for (let e of _) if (o(e) && e !== "ltr" && e !== "rtl") throw new n("Invalid JSON-LD syntax; \"@direction\" must be \"ltr\" or \"rtl\".", "jsonld.SyntaxError", {
+					code: "invalid base direction",
+					value: _
+				});
+				T(f, "@direction", _, { propertyIsArray: p.isFrame });
+				continue;
+			}
+			if (P === "@index") {
+				if (!o(_)) throw new n("Invalid JSON-LD syntax; \"@index\" value must be a string.", "jsonld.SyntaxError", {
+					code: "invalid @index value",
+					value: _
+				});
+				T(f, "@index", _);
+				continue;
+			}
+			if (P === "@reverse") {
+				if (!i(_)) throw new n("Invalid JSON-LD syntax; \"@reverse\" value must be an object.", "jsonld.SyntaxError", {
+					code: "invalid @reverse value",
+					value: _
+				});
+				if (E = await M.expand({
+					activeCtx: e,
+					activeProperty: "@reverse",
+					element: _,
+					options: p
+				}), "@reverse" in E) for (let e in E["@reverse"]) T(f, e, E["@reverse"][e], { propertyIsArray: !0 });
+				let t = f["@reverse"] || null;
+				for (let e in E) {
+					if (e === "@reverse") continue;
+					t === null && (t = f["@reverse"] = {}), T(t, e, [], { propertyIsArray: !0 });
+					let r = E[e];
+					for (let i = 0; i < r.length; ++i) {
+						let a = r[i];
+						if (l(a) || c(a)) throw new n("Invalid JSON-LD syntax; \"@reverse\" value must not be a @value or an @list.", "jsonld.SyntaxError", {
+							code: "invalid reverse property value",
+							value: E
+						});
+						T(t, e, a, { propertyIsArray: !0 });
+					}
+				}
+				continue;
+			}
+			if (P === "@nest") {
+				D.push(m);
+				continue;
+			}
+			let R = e, z = v(e, m, "@context");
+			s(z) || (R = await b({
+				activeCtx: e,
+				localCtx: z,
+				propagate: !0,
+				overrideProtected: !0,
+				options: p
+			}));
+			let B = v(e, m, "@container") || [];
+			if (B.includes("@language") && i(_)) {
+				let e = v(R, m, "@direction");
+				E = I(R, _, e, p);
+			} else if (B.includes("@index") && i(_)) {
+				let t = B.includes("@graph"), n = v(R, m, "@index") || "@index", r = n !== "@index" && g(e, n, { vocab: !0 }, p);
+				E = await L({
+					activeCtx: R,
+					options: p,
+					activeProperty: m,
+					value: _,
+					asGraph: t,
+					indexKey: n,
+					propertyIndex: r
+				});
+			} else if (B.includes("@id") && i(_)) {
+				let e = B.includes("@graph");
+				E = await L({
+					activeCtx: R,
+					options: p,
+					activeProperty: m,
+					value: _,
+					asGraph: e,
+					indexKey: "@id"
+				});
+			} else if (B.includes("@type") && i(_)) E = await L({
+				activeCtx: R.revertToPreviousContext(),
+				options: p,
+				activeProperty: m,
+				value: _,
+				asGraph: !1,
+				indexKey: "@type"
+			});
+			else {
+				let n = P === "@list";
+				if (n || P === "@set") {
+					let e = t;
+					n && u === "@graph" && (e = null), E = await M.expand({
+						activeCtx: R,
+						activeProperty: e,
+						element: _,
+						options: p,
+						insideList: n
+					});
+				} else E = v(e, m, "@type") === "@json" ? {
+					"@type": "@json",
+					"@value": _
+				} : await M.expand({
+					activeCtx: R,
+					activeProperty: m,
+					element: _,
+					options: p,
+					insideList: !1
+				});
+			}
+			if (!(E === null && P !== "@value")) {
+				if (P !== "@list" && !c(E) && B.includes("@list") && (E = { "@list": O(E) }), B.includes("@graph") && !B.some((e) => e === "@id" || e === "@index")) {
+					if (E = O(E), p.isFrame || (E = E.filter((e) => {
+						let t = Object.keys(e).length;
+						return N({
+							value: e,
+							count: t,
+							options: p
+						}) !== null;
+					})), E.length === 0) continue;
+					E = E.map((e) => ({ "@graph": O(e) }));
+				}
+				if (R.mappings.has(m) && R.mappings.get(m).reverse) {
+					let e = f["@reverse"] = f["@reverse"] || {};
+					E = O(E);
+					for (let t = 0; t < E.length; ++t) {
+						let r = E[t];
+						if (l(r) || c(r)) throw new n("Invalid JSON-LD syntax; \"@reverse\" value must not be a @value or an @list.", "jsonld.SyntaxError", {
+							code: "invalid reverse property value",
+							value: E
+						});
+						T(e, P, r, { propertyIsArray: !0 });
+					}
+					continue;
+				}
+				T(f, P, E, { propertyIsArray: !0 });
+			}
+		}
+		if ("@value" in f && !(f["@type"] === "@json" && x(e, 1.1)) && (i(k) || r(k)) && !p.isFrame) throw new n("Invalid JSON-LD syntax; \"@value\" value must not be an object or an array.", "jsonld.SyntaxError", {
+			code: "invalid value object value",
+			value: k
+		});
+		for (let a of D) {
+			let o = r(d[a]) ? d[a] : [d[a]];
+			for (let r of o) {
+				if (!i(r) || Object.keys(r).some((t) => g(e, t, { vocab: !0 }, p) === "@value")) throw new n("Invalid JSON-LD syntax; nested value must be a node object.", "jsonld.SyntaxError", {
+					code: "invalid @nest value",
+					value: r
+				});
+				await P({
+					activeCtx: e,
+					activeProperty: t,
+					expandedActiveProperty: u,
+					element: r,
+					expandedParent: f,
+					options: p,
+					insideList: m,
+					typeScopedContext: w,
+					typeKey: _
+				});
+			}
+		}
+	}
+	function F({ activeCtx: e, activeProperty: t, value: n, options: r }) {
+		if (n == null) return null;
+		let i = g(e, t, { vocab: !0 }, r);
+		if (i === "@id") return g(e, n, { base: !0 }, r);
+		if (i === "@type") return g(e, n, {
+			vocab: !0,
+			base: !0
+		}, {
+			...r,
+			typeExpansion: !0
+		});
+		let a = v(e, t, "@type");
+		if ((a === "@id" || i === "@graph") && o(n)) {
+			let i = g(e, n, { base: !0 }, r);
+			return i === null && n.match(w) && r.eventHandler && j({
+				event: {
+					type: ["JsonLdEvent"],
+					code: "reserved @id value",
+					level: "warning",
+					message: "Reserved @id found.",
+					details: { id: t }
+				},
+				options: r
+			}), { "@id": i };
+		}
+		if (a === "@vocab" && o(n)) return { "@id": g(e, n, {
+			vocab: !0,
+			base: !0
+		}, r) };
+		if (y(i)) return n;
+		let s = {};
+		if (a && ![
+			"@id",
+			"@vocab",
+			"@none"
+		].includes(a)) s["@type"] = a;
+		else if (o(n)) {
+			let n = v(e, t, "@language");
+			n !== null && (s["@language"] = n);
+			let r = v(e, t, "@direction");
+			r !== null && (s["@direction"] = r);
+		}
+		return [
+			"boolean",
+			"number",
+			"string"
+		].includes(typeof n) || (n = n.toString()), s["@value"] = n, s;
+	}
+	function I(e, t, i, a) {
+		let s = [], c = Object.keys(t).sort();
+		for (let l of c) {
+			let c = g(e, l, { vocab: !0 }, a), u = t[l];
+			r(u) || (u = [u]);
+			for (let e of u) {
+				if (e === null) continue;
+				if (!o(e)) throw new n("Invalid JSON-LD syntax; language map values must be strings.", "jsonld.SyntaxError", {
+					code: "invalid language map value",
+					languageMap: t
+				});
+				let r = { "@value": e };
+				c !== "@none" && (l.match(C) || a.eventHandler && j({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "invalid @language value",
+						level: "warning",
+						message: "@language value must be valid BCP47.",
+						details: { language: l }
+					},
+					options: a
+				}), r["@language"] = l.toLowerCase()), i && (r["@direction"] = i), s.push(r);
+			}
+		}
+		return s;
+	}
+	async function L({ activeCtx: e, options: t, activeProperty: i, value: a, asGraph: o, indexKey: c, propertyIndex: d }) {
+		let f = [], p = Object.keys(a).sort(), m = c === "@type";
+		for (let h of p) {
+			if (m) {
+				let n = v(e, h, "@context");
+				s(n) || (e = await b({
+					activeCtx: e,
+					localCtx: n,
+					propagate: !1,
+					options: t
+				}));
+			}
+			let p = a[h];
+			r(p) || (p = [p]), p = await M.expand({
+				activeCtx: e,
+				activeProperty: i,
+				element: p,
+				options: t,
+				insideList: !1,
+				insideIndex: !0
+			});
+			let _;
+			_ = d ? h === "@none" ? "@none" : F({
+				activeCtx: e,
+				activeProperty: c,
+				value: h,
+				options: t
+			}) : g(e, h, { vocab: !0 }, t), c === "@id" ? h = g(e, h, { base: !0 }, t) : m && (h = _);
+			for (let e of p) {
+				if (o && !u(e) && (e = { "@graph": [e] }), c === "@type") _ === "@none" || (e["@type"] ? e["@type"] = [h].concat(e["@type"]) : e["@type"] = [h]);
+				else if (l(e) && ![
+					"@language",
+					"@type",
+					"@index"
+				].includes(c)) throw new n(`Invalid JSON-LD syntax; Attempt to add illegal key to value object: "${c}".`, "jsonld.SyntaxError", {
+					code: "invalid value object",
+					value: e
+				});
+				else d ? _ !== "@none" && T(e, d, _, {
+					propertyIsArray: !0,
+					prependValue: !0
+				}) : _ !== "@none" && !(c in e) && (e[c] = h);
+				f.push(e);
+			}
+		}
+		return f;
+	}
+})), k = /* @__PURE__ */ e(((e, t) => {
+	var { isKeyword: n } = D(), r = f(), i = d(), a = m(), o = p(), s = {};
+	t.exports = s, s.createMergedNodeMap = (e, t) => {
+		t ||= {};
+		let n = t.issuer || new a.IdentifierIssuer("_:b"), r = { "@default": {} };
+		return s.createNodeMap(e, r, "@default", n), s.mergeNodeMaps(r);
+	}, s.createNodeMap = (e, t, c, l, u, d) => {
+		if (i.isArray(e)) {
+			for (let n of e) s.createNodeMap(n, t, c, l, void 0, d);
+			return;
+		}
+		if (!i.isObject(e)) {
+			d && d.push(e);
+			return;
+		}
+		if (r.isValue(e)) {
+			if ("@type" in e) {
+				let t = e["@type"];
+				t.indexOf("_:") === 0 && (e["@type"] = t = l.getId(t));
+			}
+			d && d.push(e);
+			return;
+		} else if (d && r.isList(e)) {
+			let n = [];
+			s.createNodeMap(e["@list"], t, c, l, u, n), d.push({ "@list": n });
+			return;
+		}
+		if ("@type" in e) {
+			let t = e["@type"];
+			for (let e of t) e.indexOf("_:") === 0 && l.getId(e);
+		}
+		i.isUndefined(u) && (u = r.isBlankNode(e) ? l.getId(e["@id"]) : e["@id"]), d && d.push({ "@id": u });
+		let f = t[c], p = f[u] = f[u] || {};
+		p["@id"] = u;
+		let m = Object.keys(e).sort();
+		for (let i of m) {
+			if (i === "@id") continue;
+			if (i === "@reverse") {
+				let n = { "@id": u }, i = e["@reverse"];
+				for (let e in i) {
+					let o = i[e];
+					for (let i of o) {
+						let o = i["@id"];
+						r.isBlankNode(i) && (o = l.getId(o)), s.createNodeMap(i, t, c, l, o), a.addValue(f[o], e, n, {
+							propertyIsArray: !0,
+							allowDuplicate: !1
+						});
+					}
+				}
+				continue;
+			}
+			if (i === "@graph") {
+				u in t || (t[u] = {}), s.createNodeMap(e[i], t, u, l);
+				continue;
+			}
+			if (i === "@included") {
+				s.createNodeMap(e[i], t, c, l);
+				continue;
+			}
+			if (i !== "@type" && n(i)) {
+				if (i === "@index" && i in p && (e[i] !== p[i] || e[i]["@id"] !== p[i]["@id"])) throw new o("Invalid JSON-LD syntax; conflicting @index property detected.", "jsonld.SyntaxError", {
+					code: "conflicting indexes",
+					subject: p
+				});
+				p[i] = e[i];
+				continue;
+			}
+			let d = e[i];
+			if (i.indexOf("_:") === 0 && (i = l.getId(i)), d.length === 0) {
+				a.addValue(p, i, [], { propertyIsArray: !0 });
+				continue;
+			}
+			for (let e of d) if (i === "@type" && (e = e.indexOf("_:") === 0 ? l.getId(e) : e), r.isSubject(e) || r.isSubjectReference(e)) {
+				if ("@id" in e && !e["@id"]) continue;
+				let n = r.isBlankNode(e) ? l.getId(e["@id"]) : e["@id"];
+				a.addValue(p, i, { "@id": n }, {
+					propertyIsArray: !0,
+					allowDuplicate: !1
+				}), s.createNodeMap(e, t, c, l, n);
+			} else if (r.isValue(e)) a.addValue(p, i, e, {
+				propertyIsArray: !0,
+				allowDuplicate: !1
+			});
+			else if (r.isList(e)) {
+				let n = [];
+				s.createNodeMap(e["@list"], t, c, l, u, n), e = { "@list": n }, a.addValue(p, i, e, {
+					propertyIsArray: !0,
+					allowDuplicate: !1
+				});
+			} else s.createNodeMap(e, t, c, l, u), a.addValue(p, i, e, {
+				propertyIsArray: !0,
+				allowDuplicate: !1
+			});
+		}
+	}, s.mergeNodeMapGraphs = (e) => {
+		let t = {};
+		for (let r of Object.keys(e).sort()) for (let i of Object.keys(e[r]).sort()) {
+			let o = e[r][i];
+			i in t || (t[i] = { "@id": i });
+			let s = t[i];
+			for (let e of Object.keys(o).sort()) if (n(e) && e !== "@type") s[e] = a.clone(o[e]);
+			else for (let t of o[e]) a.addValue(s, e, a.clone(t), {
+				propertyIsArray: !0,
+				allowDuplicate: !1
+			});
+		}
+		return t;
+	}, s.mergeNodeMaps = (e) => {
+		let t = e["@default"], n = Object.keys(e).sort();
+		for (let i of n) {
+			if (i === "@default") continue;
+			let n = e[i], a = t[i];
+			a ? "@graph" in a || (a["@graph"] = []) : t[i] = a = {
+				"@id": i,
+				"@graph": []
+			};
+			let o = a["@graph"];
+			for (let e of Object.keys(n).sort()) {
+				let t = n[e];
+				r.isSubjectReference(t) || o.push(t);
+			}
+		}
+		return t;
+	};
+})), A = /* @__PURE__ */ e(((e, t) => {
+	var { isSubjectReference: n } = f(), { createMergedNodeMap: r } = k(), i = {};
+	t.exports = i, i.flatten = (e) => {
+		let t = r(e), i = [], a = Object.keys(t).sort();
+		for (let e = 0; e < a.length; ++e) {
+			let r = t[a[e]];
+			n(r) || i.push(r);
+		}
+		return i;
+	};
+})), j = /* @__PURE__ */ e(((e, t) => {
+	var n = p(), r = f(), i = d(), { REGEX_BCP47: a, addValue: o } = m(), { handleEvent: s } = E(), { RDF_LIST: c, RDF_FIRST: l, RDF_REST: u, RDF_NIL: g, RDF_TYPE: _, RDF_JSON_LITERAL: v, XSD_BOOLEAN: y, XSD_DOUBLE: b, XSD_INTEGER: x, XSD_STRING: S } = h(), C = {};
+	t.exports = C, C.fromRDF = async (e, t) => {
+		let { useRdfType: a = !1, useNativeTypes: s = !1, rdfDirection: d = null } = t, f = {}, p = { "@default": f }, m = {};
+		if (d) {
+			if (d === "compound-literal") throw new n("Unsupported rdfDirection value.", "jsonld.InvalidRdfDirection", { value: d });
+			if (d !== "i18n-datatype") throw new n("Unknown rdfDirection value.", "jsonld.InvalidRdfDirection", { value: d });
+		}
+		for (let n of e) {
+			let e = n.graph.termType === "DefaultGraph" ? "@default" : n.graph.value;
+			e in p || (p[e] = {}), e !== "@default" && !(e in f) && (f[e] = { "@id": e });
+			let r = p[e], i = T(n.subject), c = n.predicate.value, l = n.object;
+			i in r || (r[i] = { "@id": i });
+			let u = r[i], h = T(l), v = !!h;
+			if (v && !(h in r) && (r[h] = { "@id": h }), c === _ && !a && v) {
+				o(u, "@type", h, { propertyIsArray: !0 });
+				continue;
+			}
+			let y = w(l, s, d, t);
+			if (o(u, c, y, { propertyIsArray: !0 }), v) if (h === g) {
+				let e = r[h];
+				"usages" in e || (e.usages = []), e.usages.push({
+					node: u,
+					property: c,
+					value: y
+				});
+			} else h in m ? m[h] = !1 : m[h] = {
+				node: u,
+				property: c,
+				value: y
+			};
+		}
+		for (let e in p) {
+			let t = p[e];
+			if (!(g in t)) continue;
+			let n = t[g];
+			if (n.usages) {
+				for (let e of n.usages) {
+					let n = e.node, a = e.property, o = e.value, s = [], d = [], f = Object.keys(n).length;
+					for (; a === u && i.isObject(m[n["@id"]]) && i.isArray(n[l]) && n[l].length === 1 && i.isArray(n[u]) && n[u].length === 1 && (f === 3 || f === 4 && i.isArray(n["@type"]) && n["@type"].length === 1 && n["@type"][0] === c) && (s.push(n[l][0]), d.push(n["@id"]), e = m[n["@id"]], n = e.node, a = e.property, o = e.value, f = Object.keys(n).length, r.isBlankNode(n)););
+					delete o["@id"], o["@list"] = s.reverse();
+					for (let e of d) delete t[e];
+				}
+				delete n.usages;
+			}
+		}
+		let h = [], v = Object.keys(f).sort();
+		for (let e of v) {
+			let t = f[e];
+			if (e in p) {
+				let n = t["@graph"] = [], i = p[e], a = Object.keys(i).sort();
+				for (let e of a) {
+					let t = i[e];
+					r.isSubjectReference(t) || n.push(t);
+				}
+			}
+			r.isSubjectReference(t) || h.push(t);
+		}
+		return h;
+	};
+	function w(e, t, r, o) {
+		let c = T(e);
+		if (c) return { "@id": c };
+		let l = { "@value": e.value };
+		if (e.language) e.language.match(a) || o.eventHandler && s({
+			event: {
+				type: ["JsonLdEvent"],
+				code: "invalid @language value",
+				level: "warning",
+				message: "@language value must be valid BCP47.",
+				details: { language: e.language }
+			},
+			options: o
+		}), l["@language"] = e.language;
+		else {
+			let c = e.datatype.value;
+			if (c ||= S, c === v) {
+				c = "@json";
+				try {
+					l["@value"] = JSON.parse(l["@value"]);
+				} catch (e) {
+					throw new n("JSON literal could not be parsed.", "jsonld.InvalidJsonLiteral", {
+						code: "invalid JSON literal",
+						value: l["@value"],
+						cause: e
+					});
+				}
+			}
+			if (t) if (c === y) l["@value"] === "true" || l["@value"] === "1" ? l["@value"] = !0 : l["@value"] === "false" || l["@value"] === "0" ? l["@value"] = !1 : l["@type"] = c;
+			else if (c === x) if (i.isNumeric(l["@value"])) {
+				let e = parseInt(l["@value"], 10);
+				e.toFixed(0) === l["@value"] && (l["@value"] = e);
+			} else l["@type"] = c;
+			else c === b && i.isNumeric(l["@value"]) ? l["@value"] = parseFloat(l["@value"]) : l["@type"] = c;
+			else if (r === "i18n-datatype" && c.startsWith("https://www.w3.org/ns/i18n#")) {
+				let [, e, t] = c.split(/[#_]/);
+				e.length > 0 && (l["@language"] = e, e.match(a) || o.eventHandler && s({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "invalid @language value",
+						level: "warning",
+						message: "@language value must be valid BCP47.",
+						details: { language: e }
+					},
+					options: o
+				})), l["@direction"] = t;
+			} else c !== S && (l["@type"] = c);
+		}
+		return l;
+	}
+	function T(e) {
+		return e.termType === "NamedNode" ? e.value : e.termType === "BlankNode" ? "_:" + e.value : null;
+	}
+})), M = /* @__PURE__ */ e(((e, t) => {
+	t.exports = function e(t) {
+		if (typeof t == "number" && isNaN(t)) throw Error("NaN is not allowed");
+		if (typeof t == "number" && !isFinite(t)) throw Error("Infinity is not allowed");
+		return typeof t != "object" || !t ? JSON.stringify(t) : t.toJSON instanceof Function ? e(t.toJSON()) : Array.isArray(t) ? `[${t.reduce((t, n, r) => `${t}${r === 0 ? "" : ","}${e(n === void 0 || typeof n == "symbol" ? null : n)}`, "")}]` : `{${Object.keys(t).sort().reduce((n, r) => t[r] === void 0 || typeof t[r] == "symbol" ? n : `${n}${n.length === 0 ? "" : ","}${e(r)}:${e(t[r])}`, "")}}`;
+	};
+})), N = /* @__PURE__ */ e(((e, t) => {
+	var { createNodeMap: n } = k(), { isKeyword: r } = D(), i = f(), a = M(), o = p(), s = d(), c = m(), { handleEvent: l } = E(), { RDF_FIRST: u, RDF_REST: g, RDF_NIL: v, RDF_TYPE: y, RDF_JSON_LITERAL: b, RDF_LANGSTRING: x, XSD_BOOLEAN: S, XSD_DOUBLE: C, XSD_INTEGER: w, XSD_STRING: T } = h(), { isAbsolute: O } = _(), A = {};
+	t.exports = A, A.toRDF = (e, t) => {
+		let r = new c.IdentifierIssuer("_:b"), i = { "@default": {} };
+		n(e, i, "@default", r);
+		let a = [], o = Object.keys(i).sort();
+		for (let e of o) {
+			let n;
+			if (e === "@default") n = {
+				termType: "DefaultGraph",
+				value: ""
+			};
+			else if (O(e)) n = F(e);
+			else {
+				t.eventHandler && l({
+					event: {
+						type: ["JsonLdEvent"],
+						code: "relative graph reference",
+						level: "warning",
+						message: "Relative graph reference found.",
+						details: { graph: e }
+					},
+					options: t
+				});
+				continue;
+			}
+			j(a, i[e], n, r, t);
+		}
+		return a;
+	};
+	function j(e, t, n, i, a) {
+		let o = Object.keys(t).sort();
+		for (let s of o) {
+			let o = t[s], c = Object.keys(o).sort();
+			for (let t of c) {
+				let c = o[t];
+				if (t === "@type") t = y;
+				else if (r(t)) continue;
+				for (let r of c) {
+					let o = F(s);
+					if (!O(s)) {
+						a.eventHandler && l({
+							event: {
+								type: ["JsonLdEvent"],
+								code: "relative subject reference",
+								level: "warning",
+								message: "Relative subject reference found.",
+								details: { subject: s }
+							},
+							options: a
+						});
+						continue;
+					}
+					let c = F(t);
+					if (!O(t)) {
+						a.eventHandler && l({
+							event: {
+								type: ["JsonLdEvent"],
+								code: "relative predicate reference",
+								level: "warning",
+								message: "Relative predicate reference found.",
+								details: { predicate: t }
+							},
+							options: a
+						});
+						continue;
+					}
+					if (c.termType === "BlankNode" && !a.produceGeneralizedRdf) {
+						a.eventHandler && l({
+							event: {
+								type: ["JsonLdEvent"],
+								code: "blank node predicate",
+								level: "warning",
+								message: "Dropping blank node predicate.",
+								details: { property: i.getOldIds().find((e) => i.getId(e) === t) }
+							},
+							options: a
+						});
+						continue;
+					}
+					let u = P(r, i, e, n, a.rdfDirection, a);
+					u && e.push({
+						subject: o,
+						predicate: c,
+						object: u,
+						graph: n
+					});
+				}
+			}
+		}
+	}
+	function N(e, t, n, r, i, a) {
+		let o = {
+			termType: "NamedNode",
+			value: u
+		}, s = {
+			termType: "NamedNode",
+			value: g
+		}, c = {
+			termType: "NamedNode",
+			value: v
+		}, l = e.pop(), d = l ? {
+			termType: "BlankNode",
+			value: t.getId().slice(2)
+		} : c, f = d;
+		for (let c of e) {
+			let e = P(c, t, n, r, i, a), l = {
+				termType: "BlankNode",
+				value: t.getId().slice(2)
+			};
+			n.push({
+				subject: f,
+				predicate: o,
+				object: e,
+				graph: r
+			}), n.push({
+				subject: f,
+				predicate: s,
+				object: l,
+				graph: r
+			}), f = l;
+		}
+		if (l) {
+			let e = P(l, t, n, r, i, a);
+			n.push({
+				subject: f,
+				predicate: o,
+				object: e,
+				graph: r
+			}), n.push({
+				subject: f,
+				predicate: s,
+				object: c,
+				graph: r
+			});
+		}
+		return d;
+	}
+	function P(e, t, n, r, c, u) {
+		let d;
+		if (i.isValue(e)) {
+			d = {
+				termType: "Literal",
+				value: void 0,
+				datatype: { termType: "NamedNode" }
+			};
+			let t = e["@value"], n = e["@type"] || null;
+			if (n === "@json") d.value = a(t), d.datatype.value = b;
+			else if (s.isBoolean(t)) d.value = t.toString(), d.datatype.value = n || S;
+			else if (s.isDouble(t) || n === C) s.isDouble(t) || (t = parseFloat(t)), d.value = t.toExponential(15).replace(/(\d)0*e\+?/, "$1E"), d.datatype.value = n || C;
+			else if (s.isNumber(t)) d.value = t.toFixed(0), d.datatype.value = n || w;
+			else if ("@direction" in e && c === "i18n-datatype") {
+				let n = `https://www.w3.org/ns/i18n#${(e["@language"] || "").toLowerCase()}_${e["@direction"]}`;
+				d.datatype.value = n, d.value = t;
+			} else if ("@direction" in e && c === "compound-literal") throw new o("Unsupported rdfDirection value.", "jsonld.InvalidRdfDirection", { value: c });
+			else if ("@direction" in e && c) throw new o("Unknown rdfDirection value.", "jsonld.InvalidRdfDirection", { value: c });
+			else "@language" in e ? ("@direction" in e && !c && u.eventHandler && l({
+				event: {
+					type: ["JsonLdEvent"],
+					code: "rdfDirection not set",
+					level: "warning",
+					message: "rdfDirection not set for @direction.",
+					details: { object: d.value }
+				},
+				options: u
+			}), d.value = t, d.datatype.value = n || x, d.language = e["@language"]) : ("@direction" in e && !c && u.eventHandler && l({
+				event: {
+					type: ["JsonLdEvent"],
+					code: "rdfDirection not set",
+					level: "warning",
+					message: "rdfDirection not set for @direction.",
+					details: { object: d.value }
+				},
+				options: u
+			}), d.value = t, d.datatype.value = n || T);
+		} else if (i.isList(e)) {
+			let i = N(e["@list"], t, n, r, c, u);
+			d = {
+				termType: i.termType,
+				value: i.value
+			};
+		} else d = F(s.isObject(e) ? e["@id"] : e);
+		return d.termType === "NamedNode" && !O(d.value) ? (u.eventHandler && l({
+			event: {
+				type: ["JsonLdEvent"],
+				code: "relative object reference",
+				level: "warning",
+				message: "Relative object reference found.",
+				details: { object: d.value }
+			},
+			options: u
+		}), null) : d;
+	}
+	function F(e) {
+		return e.startsWith("_:") ? {
+			termType: "BlankNode",
+			value: e.slice(2)
+		} : {
+			termType: "NamedNode",
+			value: e
+		};
+	}
+})), P = /* @__PURE__ */ e(((e, t) => {
+	var { isKeyword: n } = D(), r = f(), i = d(), a = m(), o = _(), s = p(), { createNodeMap: c, mergeNodeMapGraphs: l } = k(), u = {};
+	t.exports = u, u.frameMergedOrDefault = (e, t, n) => {
+		let r = {
+			options: n,
+			embedded: !1,
+			graph: "@default",
+			graphMap: { "@default": {} },
+			subjectStack: [],
+			link: {},
+			bnodeMap: {}
+		}, i = new a.IdentifierIssuer("_:b");
+		c(e, r.graphMap, "@default", i), n.merged && (r.graphMap["@merged"] = l(r.graphMap), r.graph = "@merged"), r.subjects = r.graphMap[r.graph];
+		let o = [];
+		return u.frame(r, Object.keys(r.subjects).sort(), t, o), n.pruneBlankNodeIdentifiers && (n.bnodesToClear = Object.keys(r.bnodeMap).filter((e) => r.bnodeMap[e].length === 1)), n.link = {}, C(o, n);
+	}, u.frame = (e, t, o, c, l = null) => {
+		y(o), o = o[0];
+		let d = e.options, f = {
+			embed: v(o, d, "embed"),
+			explicit: v(o, d, "explicit"),
+			requireAll: v(o, d, "requireAll")
+		};
+		e.link.hasOwnProperty(e.graph) || (e.link[e.graph] = {});
+		let p = e.link[e.graph], m = b(e, t, o, f), _ = Object.keys(m).sort();
+		for (let y of _) {
+			let _ = m[y];
+			if (l === null ? e.uniqueEmbeds = { [e.graph]: {} } : e.uniqueEmbeds[e.graph] = e.uniqueEmbeds[e.graph] || {}, f.embed === "@link" && y in p) {
+				w(c, l, p[y]);
+				continue;
+			}
+			let b = { "@id": y };
+			if (y.indexOf("_:") === 0 && a.addValue(e.bnodeMap, y, b, { propertyIsArray: !0 }), p[y] = b, (f.embed === "@first" || f.embed === "@last") && e.is11) throw new s("Invalid JSON-LD syntax; invalid value of @embed.", "jsonld.SyntaxError", {
+				code: "invalid @embed value",
+				frame: o
+			});
+			if (!(!e.embedded && e.uniqueEmbeds[e.graph].hasOwnProperty(y))) {
+				if (e.embedded && (f.embed === "@never" || g(_, e.graph, e.subjectStack))) {
+					w(c, l, b);
+					continue;
+				}
+				if (e.embedded && (f.embed == "@first" || f.embed == "@once") && e.uniqueEmbeds[e.graph].hasOwnProperty(y)) {
+					w(c, l, b);
+					continue;
+				}
+				if (f.embed === "@last" && y in e.uniqueEmbeds[e.graph] && S(e, y), e.uniqueEmbeds[e.graph][y] = {
+					parent: c,
+					property: l
+				}, e.subjectStack.push({
+					subject: _,
+					graph: e.graph
+				}), y in e.graphMap) {
+					let t = !1, n = null;
+					"@graph" in o ? (n = o["@graph"][0], t = !(y === "@merged" || y === "@default"), i.isObject(n) || (n = {})) : (t = e.graph !== "@merged", n = {}), t && u.frame({
+						...e,
+						graph: y,
+						embedded: !1
+					}, Object.keys(e.graphMap[y]).sort(), [n], b, "@graph");
+				}
+				"@included" in o && u.frame({
+					...e,
+					embedded: !1
+				}, t, o["@included"], b, "@included");
+				for (let t of Object.keys(_).sort()) {
+					if (n(t)) {
+						if (b[t] = a.clone(_[t]), t === "@type") for (let t of _["@type"]) t.indexOf("_:") === 0 && a.addValue(e.bnodeMap, t, b, { propertyIsArray: !0 });
+						continue;
+					}
+					if (!(f.explicit && !(t in o))) for (let n of _[t]) {
+						let i = t in o ? o[t] : h(f);
+						if (r.isList(n)) {
+							let i = o[t] && o[t][0] && o[t][0]["@list"] ? o[t][0]["@list"] : h(f), s = { "@list": [] };
+							w(b, t, s);
+							let c = n["@list"];
+							for (let t of c) r.isSubjectReference(t) ? u.frame({
+								...e,
+								embedded: !0
+							}, [t["@id"]], i, s, "@list") : w(s, "@list", a.clone(t));
+						} else r.isSubjectReference(n) ? u.frame({
+							...e,
+							embedded: !0
+						}, [n["@id"]], i, b, t) : E(i[0], n) && w(b, t, a.clone(n));
+					}
+				}
+				for (let e of Object.keys(o).sort()) {
+					if (e === "@type") {
+						if (!i.isObject(o[e][0]) || !("@default" in o[e][0])) continue;
+					} else if (n(e)) continue;
+					let t = o[e][0] || {};
+					if (!v(t, d, "omitDefault") && !(e in b)) {
+						let n = "@null";
+						"@default" in t && (n = a.clone(t["@default"])), i.isArray(n) || (n = [n]), b[e] = [{ "@preserve": n }];
+					}
+				}
+				for (let t of Object.keys(o["@reverse"] || {}).sort()) {
+					let n = o["@reverse"][t];
+					for (let r of Object.keys(e.subjects)) a.getValues(e.subjects[r], t).some((e) => e["@id"] === y) && (b["@reverse"] = b["@reverse"] || {}, a.addValue(b["@reverse"], t, [], { propertyIsArray: !0 }), u.frame({
+						...e,
+						embedded: !0
+					}, [r], n, b["@reverse"][t], l));
+				}
+				w(c, l, b), e.subjectStack.pop();
+			}
+		}
+	}, u.cleanupNull = (e, t) => {
+		if (i.isArray(e)) return e.map((e) => u.cleanupNull(e, t)).filter((e) => e);
+		if (e === "@null") return null;
+		if (i.isObject(e)) {
+			if ("@id" in e) {
+				let n = e["@id"];
+				if (t.link.hasOwnProperty(n)) {
+					let r = t.link[n].indexOf(e);
+					if (r !== -1) return t.link[n][r];
+					t.link[n].push(e);
+				} else t.link[n] = [e];
+			}
+			for (let n in e) e[n] = u.cleanupNull(e[n], t);
+		}
+		return e;
+	};
+	function h(e) {
+		let t = {};
+		for (let n in e) e[n] !== void 0 && (t["@" + n] = [e[n]]);
+		return [t];
+	}
+	function g(e, t, n) {
+		for (let r = n.length - 1; r >= 0; --r) {
+			let i = n[r];
+			if (i.graph === t && i.subject["@id"] === e["@id"]) return !0;
+		}
+		return !1;
+	}
+	function v(e, t, n) {
+		let r = "@" + n, i = r in e ? e[r][0] : t[n];
+		if (n === "embed") {
+			if (i === !0) i = "@once";
+			else if (i === !1) i = "@never";
+			else if (i !== "@always" && i !== "@never" && i !== "@link" && i !== "@first" && i !== "@last" && i !== "@once") throw new s("Invalid JSON-LD syntax; invalid value of @embed.", "jsonld.SyntaxError", {
+				code: "invalid @embed value",
+				frame: e
+			});
+		}
+		return i;
+	}
+	function y(e) {
+		if (!i.isArray(e) || e.length !== 1 || !i.isObject(e[0])) throw new s("Invalid JSON-LD syntax; a JSON-LD frame must be a single object.", "jsonld.SyntaxError", { frame: e });
+		if ("@id" in e[0]) {
+			for (let t of a.asArray(e[0]["@id"])) if (!(i.isObject(t) || o.isAbsolute(t)) || i.isString(t) && t.indexOf("_:") === 0) throw new s("Invalid JSON-LD syntax; invalid @id in frame.", "jsonld.SyntaxError", {
+				code: "invalid frame",
+				frame: e
+			});
+		}
+		if ("@type" in e[0]) {
+			for (let t of a.asArray(e[0]["@type"])) if (!(i.isObject(t) || o.isAbsolute(t) || t === "@json") || i.isString(t) && t.indexOf("_:") === 0) throw new s("Invalid JSON-LD syntax; invalid @type in frame.", "jsonld.SyntaxError", {
+				code: "invalid frame",
+				frame: e
+			});
+		}
+	}
+	function b(e, t, n, r) {
+		let i = {};
+		for (let a of t) {
+			let t = e.graphMap[e.graph][a];
+			x(e, t, n, r) && (i[a] = t);
+		}
+		return i;
+	}
+	function x(e, t, o, s) {
+		let c = !0, l = !1;
+		for (let u in o) {
+			let d = !1, f = a.getValues(t, u), p = a.getValues(o, u).length === 0;
+			if (u === "@id") {
+				if (i.isEmptyObject(o["@id"][0] || {}) ? d = !0 : o["@id"].length >= 0 && (d = o["@id"].includes(f[0])), !s.requireAll) return d;
+			} else if (u === "@type") {
+				if (c = !1, p) {
+					if (f.length > 0) return !1;
+					d = !0;
+				} else if (o["@type"].length === 1 && i.isEmptyObject(o["@type"][0])) d = f.length > 0;
+				else for (let e of o["@type"]) i.isObject(e) && "@default" in e ? d = !0 : d ||= f.some((t) => t === e);
+				if (!s.requireAll) return d;
+			} else if (n(u)) continue;
+			else {
+				let t = a.getValues(o, u)[0], n = !1;
+				if (t && (y([t]), n = "@default" in t), c = !1, f.length === 0 && n) continue;
+				if (f.length > 0 && p) return !1;
+				if (t === void 0) {
+					if (f.length > 0) return !1;
+					d = !0;
+				} else if (r.isList(t)) {
+					let n = t["@list"][0];
+					if (r.isList(f[0])) {
+						let t = f[0]["@list"];
+						r.isValue(n) ? d = t.some((e) => E(n, e)) : (r.isSubject(n) || r.isSubjectReference(n)) && (d = t.some((t) => T(e, n, t, s)));
+					}
+				} else d = r.isValue(t) ? f.some((e) => E(t, e)) : r.isSubjectReference(t) ? f.some((n) => T(e, t, n, s)) : i.isObject(t) ? f.length > 0 : !1;
+			}
+			if (!d && s.requireAll) return !1;
+			l ||= d;
+		}
+		return c || l;
+	}
+	function S(e, t) {
+		let n = e.uniqueEmbeds[e.graph], r = n[t], o = r.parent, s = r.property, c = { "@id": t };
+		if (i.isArray(o)) {
+			for (let e = 0; e < o.length; ++e) if (a.compareValues(o[e], c)) {
+				o[e] = c;
+				break;
+			}
+		} else {
+			let e = i.isArray(o[s]);
+			a.removeValue(o, s, c, { propertyIsArray: e }), a.addValue(o, s, c, { propertyIsArray: e });
+		}
+		let l = (e) => {
+			let t = Object.keys(n);
+			for (let r of t) r in n && i.isObject(n[r].parent) && n[r].parent["@id"] === e && (delete n[r], l(r));
+		};
+		l(t);
+	}
+	function C(e, t) {
+		if (i.isArray(e)) return e.map((e) => C(e, t));
+		if (i.isObject(e)) {
+			if ("@preserve" in e) return e["@preserve"][0];
+			if (r.isValue(e)) return e;
+			if (r.isList(e)) return e["@list"] = C(e["@list"], t), e;
+			if ("@id" in e) {
+				let n = e["@id"];
+				if (t.link.hasOwnProperty(n)) {
+					let r = t.link[n].indexOf(e);
+					if (r !== -1) return t.link[n][r];
+					t.link[n].push(e);
+				} else t.link[n] = [e];
+			}
+			for (let n in e) {
+				if (n === "@id" && t.bnodesToClear.includes(e[n])) {
+					delete e["@id"];
+					continue;
+				}
+				e[n] = C(e[n], t);
+			}
+		}
+		return e;
+	}
+	function w(e, t, n) {
+		i.isObject(e) ? a.addValue(e, t, n, { propertyIsArray: !0 }) : e.push(n);
+	}
+	function T(e, t, n, r) {
+		if (!("@id" in n)) return !1;
+		let i = e.subjects[n["@id"]];
+		return i && x(e, i, t, r);
+	}
+	function E(e, t) {
+		let n = t["@value"], r = t["@type"], a = t["@language"], o = e["@value"] ? i.isArray(e["@value"]) ? e["@value"] : [e["@value"]] : [], s = e["@type"] ? i.isArray(e["@type"]) ? e["@type"] : [e["@type"]] : [], c = e["@language"] ? i.isArray(e["@language"]) ? e["@language"] : [e["@language"]] : [];
+		return o.length === 0 && s.length === 0 && c.length === 0 || !(!(o.includes(n) || i.isEmptyObject(o[0])) || !(!r && s.length === 0 || s.includes(r) || r && i.isEmptyObject(s[0])) || !(!a && c.length === 0 || c.includes(a) || a && i.isEmptyObject(c[0])));
+	}
+})), F = /* @__PURE__ */ e(((e, t) => {
+	var n = p(), { isArray: r, isObject: i, isString: a, isUndefined: o } = d(), { isList: s, isValue: c, isGraph: l, isSimpleGraph: u, isSubjectReference: h } = f(), { expandIri: g, getContextValue: v, isKeyword: y, process: b, processingMode: x } = D(), { removeBase: S, prependBase: C } = _(), { REGEX_KEYWORD: w, addValue: T, asArray: E, compareShortestLeast: O } = m(), k = {};
+	t.exports = k, k.compact = async ({ activeCtx: e, activeProperty: t = null, element: d, options: f = {} }) => {
+		if (r(d)) {
+			let n = [];
+			for (let r = 0; r < d.length; ++r) {
+				let i = await k.compact({
+					activeCtx: e,
+					activeProperty: t,
+					element: d[r],
+					options: f
+				});
+				i !== null && n.push(i);
+			}
+			return f.compactArrays && n.length === 1 && (v(e, t, "@container") || []).length === 0 && (n = n[0]), n;
+		}
+		let p = v(e, t, "@context");
+		if (o(p) || (e = await b({
+			activeCtx: e,
+			localCtx: p,
+			propagate: !0,
+			overrideProtected: !0,
+			options: f
+		})), i(d)) {
+			if (f.link && "@id" in d && f.link.hasOwnProperty(d["@id"])) {
+				let e = f.link[d["@id"]];
+				for (let t = 0; t < e.length; ++t) if (e[t].expanded === d) return e[t].compacted;
+			}
+			if (c(d) || h(d)) {
+				let n = k.compactValue({
+					activeCtx: e,
+					activeProperty: t,
+					value: d,
+					options: f
+				});
+				return f.link && h(d) && (f.link.hasOwnProperty(d["@id"]) || (f.link[d["@id"]] = []), f.link[d["@id"]].push({
+					expanded: d,
+					compacted: n
+				})), n;
+			}
+			if (s(d) && (v(e, t, "@container") || []).includes("@list")) return k.compact({
+				activeCtx: e,
+				activeProperty: t,
+				element: d["@list"],
+				options: f
+			});
+			let p = t === "@reverse", m = {}, g = e;
+			!c(d) && !h(d) && (e = e.revertToPreviousContext());
+			let _ = v(g, t, "@context");
+			o(_) || (e = await b({
+				activeCtx: e,
+				localCtx: _,
+				propagate: !0,
+				overrideProtected: !0,
+				options: f
+			})), f.link && "@id" in d && (f.link.hasOwnProperty(d["@id"]) || (f.link[d["@id"]] = []), f.link[d["@id"]].push({
+				expanded: d,
+				compacted: m
+			}));
+			let S = d["@type"] || [];
+			S.length > 1 && (S = Array.from(S).sort());
+			let C = e;
+			for (let t of S) {
+				let n = v(g, k.compactIri({
+					activeCtx: C,
+					iri: t,
+					relativeTo: { vocab: !0 }
+				}), "@context");
+				o(n) || (e = await b({
+					activeCtx: e,
+					localCtx: n,
+					options: f,
+					propagate: !1
+				}));
+			}
+			let w = Object.keys(d).sort();
+			for (let o of w) {
+				let h = d[o];
+				if (o === "@id") {
+					let t = E(h).map((t) => k.compactIri({
+						activeCtx: e,
+						iri: t,
+						relativeTo: { vocab: !1 },
+						base: f.base
+					}));
+					t.length === 1 && (t = t[0]);
+					let n = k.compactIri({
+						activeCtx: e,
+						iri: "@id",
+						relativeTo: { vocab: !0 }
+					});
+					m[n] = t;
+					continue;
+				}
+				if (o === "@type") {
+					let t = E(h).map((e) => k.compactIri({
+						activeCtx: g,
+						iri: e,
+						relativeTo: { vocab: !0 }
+					}));
+					t.length === 1 && (t = t[0]);
+					let n = k.compactIri({
+						activeCtx: e,
+						iri: "@type",
+						relativeTo: { vocab: !0 }
+					}), i = (v(e, n, "@container") || []).includes("@set") && x(e, 1.1) || r(t) && h.length === 0;
+					T(m, n, t, { propertyIsArray: i });
+					continue;
+				}
+				if (o === "@reverse") {
+					let t = await k.compact({
+						activeCtx: e,
+						activeProperty: "@reverse",
+						element: h,
+						options: f
+					});
+					for (let n in t) if (e.mappings.has(n) && e.mappings.get(n).reverse) {
+						let r = t[n];
+						T(m, n, r, { propertyIsArray: (v(e, n, "@container") || []).includes("@set") || !f.compactArrays }), delete t[n];
+					}
+					Object.keys(t).length > 0 && T(m, k.compactIri({
+						activeCtx: e,
+						iri: o,
+						relativeTo: { vocab: !0 }
+					}), t);
+					continue;
+				}
+				if (o === "@preserve") {
+					let n = await k.compact({
+						activeCtx: e,
+						activeProperty: t,
+						element: h,
+						options: f
+					});
+					r(n) && n.length === 0 || T(m, o, n);
+					continue;
+				}
+				if (o === "@index") {
+					if ((v(e, t, "@container") || []).includes("@index")) continue;
+					T(m, k.compactIri({
+						activeCtx: e,
+						iri: o,
+						relativeTo: { vocab: !0 }
+					}), h);
+					continue;
+				}
+				if (o !== "@graph" && o !== "@list" && o !== "@included" && y(o)) {
+					T(m, k.compactIri({
+						activeCtx: e,
+						iri: o,
+						relativeTo: { vocab: !0 }
+					}), h);
+					continue;
+				}
+				if (!r(h)) throw new n("JSON-LD expansion error; expanded value must be an array.", "jsonld.SyntaxError");
+				if (h.length === 0) {
+					let t = k.compactIri({
+						activeCtx: e,
+						iri: o,
+						value: h,
+						relativeTo: { vocab: !0 },
+						reverse: p
+					}), n = e.mappings.has(t) ? e.mappings.get(t)["@nest"] : null, r = m;
+					n && (j(e, n, f), i(m[n]) || (m[n] = {}), r = m[n]), T(r, t, h, { propertyIsArray: !0 });
+				}
+				for (let t of h) {
+					let n = k.compactIri({
+						activeCtx: e,
+						iri: o,
+						value: t,
+						relativeTo: { vocab: !0 },
+						reverse: p
+					}), d = e.mappings.has(n) ? e.mappings.get(n)["@nest"] : null, h = m;
+					d && (j(e, d, f), i(m[d]) || (m[d] = {}), h = m[d]);
+					let g = v(e, n, "@container") || [], _ = l(t), y = s(t), b;
+					y ? b = t["@list"] : _ && (b = t["@graph"]);
+					let x = await k.compact({
+						activeCtx: e,
+						activeProperty: n,
+						element: y || _ ? b : t,
+						options: f
+					});
+					if (y) if (r(x) || (x = [x]), !g.includes("@list")) x = { [k.compactIri({
+						activeCtx: e,
+						iri: "@list",
+						relativeTo: { vocab: !0 }
+					})]: x }, "@index" in t && (x[k.compactIri({
+						activeCtx: e,
+						iri: "@index",
+						relativeTo: { vocab: !0 }
+					})] = t["@index"]);
+					else {
+						T(h, n, x, {
+							valueIsArray: !0,
+							allowDuplicate: !0
+						});
+						continue;
+					}
+					if (_) if (g.includes("@graph") && (g.includes("@id") || g.includes("@index") && u(t))) {
+						let r;
+						h.hasOwnProperty(n) ? r = h[n] : h[n] = r = {};
+						let i = (g.includes("@id") ? t["@id"] : t["@index"]) || k.compactIri({
+							activeCtx: e,
+							iri: "@none",
+							relativeTo: { vocab: !0 }
+						});
+						T(r, i, x, { propertyIsArray: !f.compactArrays || g.includes("@set") });
+					} else g.includes("@graph") && u(t) ? (r(x) && x.length > 1 && (x = { "@included": x }), T(h, n, x, { propertyIsArray: !f.compactArrays || g.includes("@set") })) : (r(x) && x.length === 1 && f.compactArrays && (x = x[0]), x = { [k.compactIri({
+						activeCtx: e,
+						iri: "@graph",
+						relativeTo: { vocab: !0 }
+					})]: x }, "@id" in t && (x[k.compactIri({
+						activeCtx: e,
+						iri: "@id",
+						relativeTo: { vocab: !0 }
+					})] = t["@id"]), "@index" in t && (x[k.compactIri({
+						activeCtx: e,
+						iri: "@index",
+						relativeTo: { vocab: !0 }
+					})] = t["@index"]), T(h, n, x, { propertyIsArray: !f.compactArrays || g.includes("@set") }));
+					else if (g.includes("@language") || g.includes("@index") || g.includes("@id") || g.includes("@type")) {
+						let r;
+						h.hasOwnProperty(n) ? r = h[n] : h[n] = r = {};
+						let i;
+						if (g.includes("@language")) c(x) && (x = x["@value"]), i = t["@language"];
+						else if (g.includes("@index")) {
+							let r = v(e, n, "@index") || "@index", o = k.compactIri({
+								activeCtx: e,
+								iri: r,
+								relativeTo: { vocab: !0 }
+							});
+							if (r === "@index") i = t["@index"], delete x[o];
+							else {
+								let e;
+								if ([i, ...e] = E(x[r] || []), !a(i)) i = null;
+								else switch (e.length) {
+									case 0:
+										delete x[r];
+										break;
+									case 1:
+										x[r] = e[0];
+										break;
+									default:
+										x[r] = e;
+										break;
+								}
+							}
+						} else if (g.includes("@id")) {
+							let t = k.compactIri({
+								activeCtx: e,
+								iri: "@id",
+								relativeTo: { vocab: !0 }
+							});
+							i = x[t], delete x[t];
+						} else if (g.includes("@type")) {
+							let r = k.compactIri({
+								activeCtx: e,
+								iri: "@type",
+								relativeTo: { vocab: !0 }
+							}), a;
+							switch ([i, ...a] = E(x[r] || []), a.length) {
+								case 0:
+									delete x[r];
+									break;
+								case 1:
+									x[r] = a[0];
+									break;
+								default:
+									x[r] = a;
+									break;
+							}
+							Object.keys(x).length === 1 && "@id" in t && (x = await k.compact({
+								activeCtx: e,
+								activeProperty: n,
+								element: { "@id": t["@id"] },
+								options: f
+							}));
+						}
+						i ||= k.compactIri({
+							activeCtx: e,
+							iri: "@none",
+							relativeTo: { vocab: !0 }
+						}), T(r, i, x, { propertyIsArray: g.includes("@set") });
+					} else {
+						let e = !f.compactArrays || g.includes("@set") || g.includes("@list") || r(x) && x.length === 0 || o === "@list" || o === "@graph";
+						T(h, n, x, { propertyIsArray: e });
+					}
+				}
+			}
+			return m;
+		}
+		return d;
+	}, k.compactIri = ({ activeCtx: e, iri: t, value: r = null, relativeTo: a = { vocab: !1 }, reverse: o = !1, base: u = null }) => {
+		if (t === null) return t;
+		e.isPropertyTermScoped && e.previousContext && (e = e.previousContext);
+		let d = e.getInverse();
+		if (y(t) && t in d && "@none" in d[t] && "@type" in d[t]["@none"] && "@none" in d[t]["@none"]["@type"]) return d[t]["@none"]["@type"]["@none"];
+		if (a.vocab && t in d) {
+			let n = e["@language"] || "@none", a = [];
+			i(r) && "@index" in r && !("@graph" in r) && a.push("@index", "@index@set"), i(r) && "@preserve" in r && (r = r["@preserve"][0]), l(r) ? ("@index" in r && a.push("@graph@index", "@graph@index@set", "@index", "@index@set"), "@id" in r && a.push("@graph@id", "@graph@id@set"), a.push("@graph", "@graph@set", "@set"), "@index" in r || a.push("@graph@index", "@graph@index@set", "@index", "@index@set"), "@id" in r || a.push("@graph@id", "@graph@id@set")) : i(r) && !c(r) && a.push("@id", "@id@set", "@type", "@set@type");
+			let u = "@language", d = "@null";
+			if (o) u = "@type", d = "@reverse", a.push("@set");
+			else if (s(r)) {
+				"@index" in r || a.push("@list");
+				let e = r["@list"];
+				if (e.length === 0) u = "@any", d = "@none";
+				else {
+					let t = e.length === 0 ? n : null, r = null;
+					for (let n = 0; n < e.length; ++n) {
+						let i = e[n], a = "@none", o = "@none";
+						if (c(i) ? "@direction" in i ? a = `${(i["@language"] || "").toLowerCase()}_${i["@direction"]}` : "@language" in i ? a = i["@language"].toLowerCase() : "@type" in i ? o = i["@type"] : a = "@null" : o = "@id", t === null ? t = a : a !== t && c(i) && (t = "@none"), r === null ? r = o : o !== r && (r = "@none"), t === "@none" && r === "@none") break;
+					}
+					t ||= "@none", r ||= "@none", r === "@none" ? d = t : (u = "@type", d = r);
+				}
+			} else {
+				if (c(r)) if ("@language" in r && !("@index" in r)) {
+					a.push("@language", "@language@set"), d = r["@language"];
+					let e = r["@direction"];
+					e && (d = `${d}_${e}`);
+				} else "@direction" in r && !("@index" in r) ? d = `_${r["@direction"]}` : "@type" in r && (u = "@type", d = r["@type"]);
+				else u = "@type", d = "@id";
+				a.push("@set");
+			}
+			a.push("@none"), i(r) && !("@index" in r) && a.push("@index", "@index@set"), c(r) && Object.keys(r).length === 1 && a.push("@language", "@language@set");
+			let f = A(e, t, r, a, u, d);
+			if (f !== null) return f;
+		}
+		if (a.vocab && "@vocab" in e) {
+			let n = e["@vocab"];
+			if (t.indexOf(n) === 0 && t !== n) {
+				let r = t.substr(n.length);
+				if (!e.mappings.has(r)) return r;
+			}
+		}
+		let f = null, p = [], m = e.fastCurieMap, h = t.length - 1;
+		for (let e = 0; e < h && t[e] in m; ++e) m = m[t[e]], "" in m && p.push(m[""][0]);
+		for (let n = p.length - 1; n >= 0; --n) {
+			let i = p[n], a = i.terms;
+			for (let n of a) {
+				let a = n + ":" + t.substr(i.iri.length);
+				e.mappings.get(n)._prefix && (!e.mappings.has(a) || r === null && e.mappings.get(a)["@id"] === t) && (f === null || O(a, f) < 0) && (f = a);
+			}
+		}
+		if (f !== null) return f;
+		for (let [r, i] of e.mappings) if (i && i._prefix && t.startsWith(r + ":")) throw new n(`Absolute IRI "${t}" confused with prefix "${r}".`, "jsonld.SyntaxError", {
+			code: "IRI confused with prefix",
+			context: e
+		});
+		if (!a.vocab) if ("@base" in e) if (e["@base"]) {
+			let n = S(C(u, e["@base"]), t);
+			return w.test(n) ? `./${n}` : n;
+		} else return t;
+		else return S(u, t);
+		return t;
+	}, k.compactValue = ({ activeCtx: e, activeProperty: t, value: n, options: r }) => {
+		if (c(n)) {
+			let r = v(e, t, "@type"), i = v(e, t, "@language"), o = v(e, t, "@direction"), s = v(e, t, "@container") || [], c = "@index" in n && !s.includes("@index");
+			if (!c && r !== "@none" && (n["@type"] === r || "@language" in n && n["@language"] === i && "@direction" in n && n["@direction"] === o || "@language" in n && n["@language"] === i || "@direction" in n && n["@direction"] === o)) return n["@value"];
+			let l = Object.keys(n).length, u = l === 1 || l === 2 && "@index" in n && !c, d = "@language" in e, f = a(n["@value"]), p = e.mappings.has(t) && e.mappings.get(t)["@language"] === null;
+			if (u && r !== "@none" && (!d || !f || p)) return n["@value"];
+			let m = {};
+			return c && (m[k.compactIri({
+				activeCtx: e,
+				iri: "@index",
+				relativeTo: { vocab: !0 }
+			})] = n["@index"]), "@type" in n ? m[k.compactIri({
+				activeCtx: e,
+				iri: "@type",
+				relativeTo: { vocab: !0 }
+			})] = k.compactIri({
+				activeCtx: e,
+				iri: n["@type"],
+				relativeTo: { vocab: !0 }
+			}) : "@language" in n && (m[k.compactIri({
+				activeCtx: e,
+				iri: "@language",
+				relativeTo: { vocab: !0 }
+			})] = n["@language"]), "@direction" in n && (m[k.compactIri({
+				activeCtx: e,
+				iri: "@direction",
+				relativeTo: { vocab: !0 }
+			})] = n["@direction"]), m[k.compactIri({
+				activeCtx: e,
+				iri: "@value",
+				relativeTo: { vocab: !0 }
+			})] = n["@value"], m;
+		}
+		let i = g(e, t, { vocab: !0 }, r), o = v(e, t, "@type"), s = k.compactIri({
+			activeCtx: e,
+			iri: n["@id"],
+			relativeTo: { vocab: o === "@vocab" },
+			base: r.base
+		});
+		return o === "@id" || o === "@vocab" || i === "@graph" ? s : { [k.compactIri({
+			activeCtx: e,
+			iri: "@id",
+			relativeTo: { vocab: !0 }
+		})]: s };
+	};
+	function A(e, t, n, r, a, o) {
+		o === null && (o = "@null");
+		let s = [];
+		if ((o === "@id" || o === "@reverse") && i(n) && "@id" in n) {
+			o === "@reverse" && s.push("@reverse");
+			let t = k.compactIri({
+				activeCtx: e,
+				iri: n["@id"],
+				relativeTo: { vocab: !0 }
+			});
+			e.mappings.has(t) && e.mappings.get(t) && e.mappings.get(t)["@id"] === n["@id"] ? s.push.apply(s, ["@vocab", "@id"]) : s.push.apply(s, ["@id", "@vocab"]);
+		} else {
+			s.push(o);
+			let e = s.find((e) => e.includes("_"));
+			e && s.push(e.replace(/^[^_]+_/, "_"));
+		}
+		s.push("@none");
+		let c = e.inverse[t];
+		for (let e of r) {
+			if (!(e in c)) continue;
+			let t = c[e][a];
+			for (let e of s) if (e in t) return t[e];
+		}
+		return null;
+	}
+	function j(e, t, r) {
+		if (g(e, t, { vocab: !0 }, r) !== "@nest") throw new n("JSON-LD compact error; nested property must have an @nest value resolving to @nest.", "jsonld.SyntaxError", { code: "invalid @nest value" });
+	}
+})), I = /* @__PURE__ */ e(((e, t) => {
+	t.exports = (e) => {
+		class t {
+			toString() {
+				return "[object JsonLdProcessor]";
+			}
+		}
+		return Object.defineProperty(t, "prototype", {
+			writable: !1,
+			enumerable: !1
+		}), Object.defineProperty(t.prototype, "constructor", {
+			writable: !0,
+			enumerable: !1,
+			configurable: !0,
+			value: t
+		}), t.compact = function(t, n) {
+			return arguments.length < 2 ? Promise.reject(/* @__PURE__ */ TypeError("Could not compact, too few arguments.")) : e.compact(t, n);
+		}, t.expand = function(t) {
+			return arguments.length < 1 ? Promise.reject(/* @__PURE__ */ TypeError("Could not expand, too few arguments.")) : e.expand(t);
+		}, t.flatten = function(t) {
+			return arguments.length < 1 ? Promise.reject(/* @__PURE__ */ TypeError("Could not flatten, too few arguments.")) : e.flatten(t);
+		}, t;
+	};
+})), L = /* @__PURE__ */ e(((e, t) => {
+	var n = u(), r = y(), i = m(), a = w(), o = i.IdentifierIssuer, s = p(), c = S(), l = T(), { expand: h } = O(), { flatten: v } = A(), { fromRDF: b } = j(), { toRDF: x } = N(), { frameMergedOrDefault: C, cleanupNull: M } = P(), { isArray: L, isObject: R, isString: z } = d(), { isSubjectReference: B } = f(), { expandIri: V, getInitialContext: H, process: U, processingMode: W } = D(), { compact: G, compactIri: K } = F(), { createNodeMap: q, createMergedNodeMap: J, mergeNodeMaps: Y } = k(), { logEventHandler: X, logWarningEventHandler: Z, safeEventHandler: ee, setDefaultEventHandler: te, setupEventHandler: ne, strictEventHandler: re, unhandledEventHandler: ie } = E(), Q = function(e) {
+		let t = {}, u = new c({ max: 100 });
+		e.compact = async function(t, n, r) {
+			if (arguments.length < 2) throw TypeError("Could not compact, too few arguments.");
+			if (n === null) throw new s("The compaction context must not be null.", "jsonld.CompactError", { code: "invalid local context" });
+			if (t === null) return null;
+			r = d(r, {
+				base: z(t) ? t : "",
+				compactArrays: !0,
+				compactToRelative: !0,
+				graph: !1,
+				skipExpansion: !1,
+				link: !1,
+				issuer: new o("_:b"),
+				contextResolver: new a({ sharedCache: u })
+			}), r.link && (r.skipExpansion = !0), r.compactToRelative || delete r.base;
+			let c;
+			c = r.skipExpansion ? t : await e.expand(t, r);
+			let l = await e.processContext(H(r), n, r), f = await G({
+				activeCtx: l,
+				element: c,
+				options: r
+			});
+			r.compactArrays && !r.graph && L(f) ? f.length === 1 ? f = f[0] : f.length === 0 && (f = {}) : r.graph && R(f) && (f = [f]), R(n) && "@context" in n && (n = n["@context"]), n = i.clone(n), L(n) || (n = [n]);
+			let p = n;
+			n = [];
+			for (let e = 0; e < p.length; ++e) (!R(p[e]) || Object.keys(p[e]).length > 0) && n.push(p[e]);
+			let m = n.length > 0;
+			if (n.length === 1 && (n = n[0]), L(f)) {
+				let e = K({
+					activeCtx: l,
+					iri: "@graph",
+					relativeTo: { vocab: !0 }
+				}), t = f;
+				f = {}, m && (f["@context"] = n), f[e] = t;
+			} else if (R(f) && m) {
+				let e = f;
+				f = { "@context": n };
+				for (let t in e) f[t] = e[t];
+			}
+			return f;
+		}, e.expand = async function(t, n) {
+			if (arguments.length < 1) throw TypeError("Could not expand, too few arguments.");
+			n = d(n, {
+				keepFreeFloatingNodes: !1,
+				contextResolver: new a({ sharedCache: u })
+			});
+			let r = {}, o = [];
+			if ("expandContext" in n) {
+				let e = i.clone(n.expandContext);
+				R(e) && "@context" in e ? r.expandContext = e : r.expandContext = { "@context": e }, o.push(r.expandContext);
+			}
+			let s;
+			if (!z(t)) r.input = i.clone(t);
+			else {
+				let i = await e.get(t, n);
+				s = i.documentUrl, r.input = i.document, i.contextUrl && (r.remoteContext = { "@context": i.contextUrl }, o.push(r.remoteContext));
+			}
+			"base" in n || (n.base = s || "");
+			let c = H(n);
+			for (let e of o) c = await U({
+				activeCtx: c,
+				localCtx: e,
+				options: n
+			});
+			let l = await h({
+				activeCtx: c,
+				element: r.input,
+				options: n
+			});
+			return R(l) && "@graph" in l && Object.keys(l).length === 1 ? l = l["@graph"] : l === null && (l = []), L(l) || (l = [l]), l;
+		}, e.flatten = async function(t, n, r) {
+			if (arguments.length < 1) return /* @__PURE__ */ TypeError("Could not flatten, too few arguments.");
+			typeof n == "function" ? n = null : n ||= null, r = d(r, {
+				base: z(t) ? t : "",
+				contextResolver: new a({ sharedCache: u })
+			});
+			let i = v(await e.expand(t, r));
+			return n === null ? i : (r.graph = !0, r.skipExpansion = !0, await e.compact(i, n, r));
+		}, e.frame = async function(t, n, r) {
+			if (arguments.length < 2) throw TypeError("Could not frame, too few arguments.");
+			if (r = d(r, {
+				base: z(t) ? t : "",
+				embed: "@once",
+				explicit: !1,
+				requireAll: !1,
+				omitDefault: !1,
+				bnodesToClear: [],
+				contextResolver: new a({ sharedCache: u })
+			}), z(n)) {
+				let t = await e.get(n, r);
+				if (n = t.document, t.contextUrl) {
+					let e = n["@context"];
+					e ? L(e) ? e.push(t.contextUrl) : e = [e, t.contextUrl] : e = t.contextUrl, n["@context"] = e;
+				}
+			}
+			let i = n && n["@context"] || {}, o = await e.processContext(H(r), i, r);
+			r.hasOwnProperty("omitGraph") || (r.omitGraph = W(o, 1.1)), r.hasOwnProperty("pruneBlankNodeIdentifiers") || (r.pruneBlankNodeIdentifiers = W(o, 1.1));
+			let s = await e.expand(t, r), c = { ...r };
+			c.isFrame = !0, c.keepFreeFloatingNodes = !0;
+			let l = await e.expand(n, c);
+			c.merged = !Object.keys(n).map((e) => V(o, e, { vocab: !0 })).includes("@graph"), c.is11 = W(o, 1.1);
+			let f = C(s, l, c);
+			c.graph = !r.omitGraph, c.skipExpansion = !0, c.link = {}, c.framing = !0;
+			let p = await e.compact(f, i, c);
+			return c.link = {}, p = M(p, c), p;
+		}, e.link = async function(t, n, r) {
+			let i = {};
+			return n && (i["@context"] = n), i["@embed"] = "@link", e.frame(t, i, r);
+		}, e.normalize = e.canonize = async function(t, r) {
+			if (arguments.length < 1) throw TypeError("Could not canonize, too few arguments.");
+			r = d(r, {
+				skipExpansion: !1,
+				safe: !0,
+				contextResolver: new a({ sharedCache: u })
+			});
+			let i = Object.assign({}, { algorithm: "RDFC-1.0" }, r.canonizeOptions || null);
+			if ("inputFormat" in r) {
+				if (r.inputFormat !== "application/n-quads") throw new s("Unknown canonicalization input format.", "jsonld.CanonizeError");
+				let e = l.parse(t);
+				return n.canonize(e, i);
+			}
+			let o = { ...r };
+			delete o.format, delete o.canonizeOptions, o.produceGeneralizedRdf = !1;
+			let c = await e.toRDF(t, o);
+			return n.canonize(c, i);
+		}, e.fromRDF = async function(e, n) {
+			if (arguments.length < 1) throw TypeError("Could not convert from RDF, too few arguments.");
+			n = d(n, { format: z(e) ? "application/n-quads" : void 0 });
+			let { format: r } = n, { rdfParser: i } = n;
+			if (r) {
+				if (i ||= t[r], !i) throw new s("Unknown input format.", "jsonld.UnknownFormat", { format: r });
+			} else i = () => e;
+			return b(await i(e), n);
+		}, e.toRDF = async function(t, n) {
+			if (arguments.length < 1) throw TypeError("Could not convert to RDF, too few arguments.");
+			n = d(n, {
+				skipExpansion: !1,
+				contextResolver: new a({ sharedCache: u })
+			});
+			let r;
+			r = n.skipExpansion ? t : await e.expand(t, n);
+			let i = x(r, n);
+			if (n.format) {
+				if (n.format === "application/n-quads") return l.serialize(i);
+				throw new s("Unknown output format.", "jsonld.UnknownFormat", { format: n.format });
+			}
+			return i;
+		}, e.createNodeMap = async function(t, n) {
+			if (arguments.length < 1) throw TypeError("Could not create node map, too few arguments.");
+			return n = d(n, {
+				base: z(t) ? t : "",
+				contextResolver: new a({ sharedCache: u })
+			}), J(await e.expand(t, n), n);
+		}, e.merge = async function(t, n, r) {
+			if (arguments.length < 1) throw TypeError("Could not merge, too few arguments.");
+			if (!L(t)) throw TypeError("Could not merge, \"docs\" must be an array.");
+			typeof n == "function" ? n = null : n ||= null, r = d(r, { contextResolver: new a({ sharedCache: u }) });
+			let s = await Promise.all(t.map((t) => {
+				let n = { ...r };
+				return e.expand(t, n);
+			})), c = !0;
+			"mergeNodes" in r && (c = r.mergeNodes);
+			let l = r.issuer || new o("_:b"), f = { "@default": {} };
+			for (let e = 0; e < s.length; ++e) {
+				let t = i.relabelBlankNodes(s[e], { issuer: new o("_:b" + e + "-") }), n = c || e === 0 ? f : { "@default": {} };
+				if (q(t, n, "@default", l), n !== f) for (let e in n) {
+					let t = n[e];
+					if (!(e in f)) {
+						f[e] = t;
+						continue;
+					}
+					let r = f[e];
+					for (let e in t) e in r || (r[e] = t[e]);
+				}
+			}
+			let p = Y(f), m = [], h = Object.keys(p).sort();
+			for (let e = 0; e < h.length; ++e) {
+				let t = p[h[e]];
+				B(t) || m.push(t);
+			}
+			return n === null ? m : (r.graph = !0, r.skipExpansion = !0, await e.compact(m, n, r));
+		}, Object.defineProperty(e, "documentLoader", {
+			get: () => e._documentLoader,
+			set: (t) => e._documentLoader = t
+		}), e.documentLoader = async (e) => {
+			throw new s("Could not retrieve a JSON-LD document from the URL. URL dereferencing not implemented.", "jsonld.LoadDocumentError", {
+				code: "loading document failed",
+				url: e
+			});
+		}, e.get = async function(t, n) {
+			let r;
+			r = typeof n.documentLoader == "function" ? n.documentLoader : e.documentLoader;
+			let i = await r(t);
+			try {
+				if (!i.document) throw new s("No remote document found at the given URL.", "jsonld.NullRemoteDocument");
+				z(i.document) && (i.document = JSON.parse(i.document));
+			} catch (e) {
+				throw new s("Could not retrieve a JSON-LD document from the URL.", "jsonld.LoadDocumentError", {
+					code: "loading document failed",
+					cause: e,
+					remoteDoc: i
+				});
+			}
+			return i;
+		}, e.processContext = async function(e, t, n) {
+			return n = d(n, {
+				base: "",
+				contextResolver: new a({ sharedCache: u })
+			}), t === null ? H(n) : (t = i.clone(t), R(t) && "@context" in t || (t = { "@context": t }), U({
+				activeCtx: e,
+				localCtx: t,
+				options: n
+			}));
+		}, e.getContextValue = D().getContextValue, e.documentLoaders = {}, e.useDocumentLoader = function(t) {
+			if (!(t in e.documentLoaders)) throw new s("Unknown document loader type: \"" + t + "\"", "jsonld.UnknownDocumentLoader", { type: t });
+			e.documentLoader = e.documentLoaders[t].apply(e, Array.prototype.slice.call(arguments, 1));
+		}, e.registerRDFParser = function(e, n) {
+			t[e] = n;
+		}, e.unregisterRDFParser = function(e) {
+			delete t[e];
+		}, e.registerRDFParser("application/n-quads", l.parse), e.url = _(), e.logEventHandler = X, e.logWarningEventHandler = Z, e.safeEventHandler = ee, e.setDefaultEventHandler = te, e.strictEventHandler = re, e.unhandledEventHandler = ie, e.util = i, Object.assign(e, i), e.promises = e, e.RequestQueue = g(), e.JsonLdProcessor = I()(e), r.setupGlobals(e), r.setupDocumentLoaders(e);
+		function d(t, { documentLoader: n = e.documentLoader, ...r }) {
+			if (t && "compactionMap" in t) throw new s("\"compactionMap\" not supported.", "jsonld.OptionsError");
+			if (t && "expansionMap" in t) throw new s("\"expansionMap\" not supported.", "jsonld.OptionsError");
+			return Object.assign({}, { documentLoader: n }, r, t, { eventHandler: ne({ options: t }) });
+		}
+		return e;
+	}, $ = function() {
+		return Q(function() {
+			return $();
+		});
+	};
+	Q($), t.exports = $;
+}));
+//#endregion
+export default L();
+
+//# sourceMappingURL=jsonld-B61R4iOL.js.map