@fedify/vocab-runtime 2.4.0-dev.2122 → 2.4.0-dev.2129

package/dist/tests/internal/portable-dereference.test.cjs

@@ -1,6 +1,6 @@
 const require_contexts = require("../contexts-Ch3v2Cgu.cjs");
 const require_url = require("../url-BqlldzT8.cjs");
-require("../jsonld-CmDhHNTx.cjs");
+const require_jsonld_cache = require("../jsonld-cache-9jap4yM0.cjs");
 let node_assert_strict = require("node:assert/strict");
 let node_test = require("node:test");
 let _logtape_logtape = require("@logtape/logtape");
@@ -98,8 +98,8 @@ function parseGatewayOrigin(gateway) {
 * part of the public API contract.  This is not considered public API for
 * Semantic Versioning decisions.
 */
-function createSnapshotContextLoader(contextLoader) {
-	for (let wrapped = snapshotLoaders.get(contextLoader); wrapped?.released; wrapped = snapshotLoaders.get(contextLoader)) contextLoader = wrapped.base;
+function createSnapshotContextLoader(contextLoader, suppressError) {
+	contextLoader = require_jsonld_cache.unwrapReleasedDocumentLoader(contextLoader);
 	const cache = /* @__PURE__ */ new Map();
 	let released = false;
 	const release = () => {
@@ -117,7 +117,10 @@ function createSnapshotContextLoader(contextLoader) {
 		};
 		let promise = cache.get(key);
 		if (promise == null) {
-			const loading = contextLoader(url, options).then((document) => structuredClone(document));
+			const loading = contextLoader(url, suppressError ? {
+				...options,
+				suppressError: true
+			} : options).then((document) => structuredClone(document));
 			promise = loading;
 			cache.set(key, loading);
 			loading.catch(() => {
@@ -130,13 +133,12 @@ function createSnapshotContextLoader(contextLoader) {
 		base: contextLoader,
 		released: false
 	};
-	snapshotLoaders.set(loader, state);
+	require_jsonld_cache.registerDocumentLoaderWrapper(loader, state);
 	return {
 		loader,
 		release
 	};
 }
-const snapshotLoaders = /* @__PURE__ */ new WeakMap();
 //#endregion
 //#region src/internal/portable-dereference.test.ts
 const hrefs = (urls) => urls.map((url) => url.href);
@@ -207,4 +209,63 @@ const hrefs = (urls) => urls.map((url) => url.href);
 	inner.release();
 	outer.release();
 });
+(0, node_test.test)("context loaders unwrap mixed released wrappers", async () => {
+	const calls = [];
+	const base = (url) => {
+		calls.push(url);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": {} }
+		});
+	};
+	for (const snapshotFirst of [false, true]) {
+		let loader = base;
+		for (let i = 0; i < 1e4; i++) {
+			const wrapper = i % 2 === 0 === snapshotFirst ? createSnapshotContextLoader(loader, true) : require_jsonld_cache.createScopedContextLoader(loader, true);
+			wrapper.release();
+			loader = wrapper.loader;
+		}
+		const unwrapped = require_jsonld_cache.createScopedContextLoader(loader, false).loader;
+		(0, node_assert_strict.deepStrictEqual)(unwrapped, base);
+		await unwrapped("https://example.com/context");
+	}
+	(0, node_assert_strict.deepStrictEqual)(calls, ["https://example.com/context", "https://example.com/context"]);
+});
+(0, node_test.test)("mixed context wrappers preserve active suppression and snapshots", async () => {
+	for (const activeSnapshot of [false, true]) {
+		const calls = [];
+		const base = (url, options) => {
+			calls.push(options);
+			return Promise.resolve({
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": {} }
+			});
+		};
+		const active = activeSnapshot ? createSnapshotContextLoader(base, true) : require_jsonld_cache.createScopedContextLoader(base, true);
+		let loader = active.loader;
+		for (let i = 0; i < 4; i++) {
+			const wrapper = i % 2 === 0 ? require_jsonld_cache.createScopedContextLoader(loader, true) : createSnapshotContextLoader(loader, true);
+			wrapper.release();
+			loader = wrapper.loader;
+		}
+		const unwrapped = require_jsonld_cache.createScopedContextLoader(loader, false).loader;
+		(0, node_assert_strict.deepStrictEqual)(unwrapped, active.loader);
+		const options = { signal: new AbortController().signal };
+		const first = await unwrapped("https://example.com/context", options);
+		(0, node_assert_strict.ok)(first.document != null && typeof first.document === "object");
+		Reflect.set(first.document, "changed", true);
+		(0, node_assert_strict.deepStrictEqual)((await unwrapped("https://example.com/context", options)).document, { "@context": {} });
+		(0, node_assert_strict.deepStrictEqual)(calls.length, activeSnapshot ? 1 : 2);
+		for (const call of calls) (0, node_assert_strict.deepStrictEqual)(call, {
+			...options,
+			suppressError: true
+		});
+		active.release();
+		(0, node_assert_strict.deepStrictEqual)(require_jsonld_cache.createScopedContextLoader(loader, false).loader, base);
+		await unwrapped("https://example.com/context", options);
+		(0, node_assert_strict.deepStrictEqual)(calls.at(-1), options);
+	}
+});
 //#endregion

package/dist/tests/internal/portable-dereference.test.mjs

@@ -1,6 +1,6 @@
 import { t as preloadedContexts } from "../contexts-BBX_qhBL.mjs";
 import { a as formatIri, m as parseIri } from "../url-DgJM9WJn.mjs";
-import "../jsonld-DweIJ07b.mjs";
+import { n as createScopedContextLoader, o as registerDocumentLoaderWrapper, s as unwrapReleasedDocumentLoader } from "../jsonld-cache-DnZS0z1G.mjs";
 import { deepStrictEqual, ok, throws } from "node:assert/strict";
 import { test } from "node:test";
 import { getLogger } from "@logtape/logtape";
@@ -98,8 +98,8 @@ function parseGatewayOrigin(gateway) {
 * part of the public API contract.  This is not considered public API for
 * Semantic Versioning decisions.
 */
-function createSnapshotContextLoader(contextLoader) {
-	for (let wrapped = snapshotLoaders.get(contextLoader); wrapped?.released; wrapped = snapshotLoaders.get(contextLoader)) contextLoader = wrapped.base;
+function createSnapshotContextLoader(contextLoader, suppressError) {
+	contextLoader = unwrapReleasedDocumentLoader(contextLoader);
 	const cache = /* @__PURE__ */ new Map();
 	let released = false;
 	const release = () => {
@@ -117,7 +117,10 @@ function createSnapshotContextLoader(contextLoader) {
 		};
 		let promise = cache.get(key);
 		if (promise == null) {
-			const loading = contextLoader(url, options).then((document) => structuredClone(document));
+			const loading = contextLoader(url, suppressError ? {
+				...options,
+				suppressError: true
+			} : options).then((document) => structuredClone(document));
 			promise = loading;
 			cache.set(key, loading);
 			loading.catch(() => {
@@ -130,13 +133,12 @@ function createSnapshotContextLoader(contextLoader) {
 		base: contextLoader,
 		released: false
 	};
-	snapshotLoaders.set(loader, state);
+	registerDocumentLoaderWrapper(loader, state);
 	return {
 		loader,
 		release
 	};
 }
-const snapshotLoaders = /* @__PURE__ */ new WeakMap();
 //#endregion
 //#region src/internal/portable-dereference.test.ts
 const hrefs = (urls) => urls.map((url) => url.href);
@@ -207,5 +209,64 @@ test("createSnapshotContextLoader() does not nest released snapshots", async ()
 	inner.release();
 	outer.release();
 });
+test("context loaders unwrap mixed released wrappers", async () => {
+	const calls = [];
+	const base = (url) => {
+		calls.push(url);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": {} }
+		});
+	};
+	for (const snapshotFirst of [false, true]) {
+		let loader = base;
+		for (let i = 0; i < 1e4; i++) {
+			const wrapper = i % 2 === 0 === snapshotFirst ? createSnapshotContextLoader(loader, true) : createScopedContextLoader(loader, true);
+			wrapper.release();
+			loader = wrapper.loader;
+		}
+		const unwrapped = createScopedContextLoader(loader, false).loader;
+		deepStrictEqual(unwrapped, base);
+		await unwrapped("https://example.com/context");
+	}
+	deepStrictEqual(calls, ["https://example.com/context", "https://example.com/context"]);
+});
+test("mixed context wrappers preserve active suppression and snapshots", async () => {
+	for (const activeSnapshot of [false, true]) {
+		const calls = [];
+		const base = (url, options) => {
+			calls.push(options);
+			return Promise.resolve({
+				contextUrl: null,
+				documentUrl: url,
+				document: { "@context": {} }
+			});
+		};
+		const active = activeSnapshot ? createSnapshotContextLoader(base, true) : createScopedContextLoader(base, true);
+		let loader = active.loader;
+		for (let i = 0; i < 4; i++) {
+			const wrapper = i % 2 === 0 ? createScopedContextLoader(loader, true) : createSnapshotContextLoader(loader, true);
+			wrapper.release();
+			loader = wrapper.loader;
+		}
+		const unwrapped = createScopedContextLoader(loader, false).loader;
+		deepStrictEqual(unwrapped, active.loader);
+		const options = { signal: new AbortController().signal };
+		const first = await unwrapped("https://example.com/context", options);
+		ok(first.document != null && typeof first.document === "object");
+		Reflect.set(first.document, "changed", true);
+		deepStrictEqual((await unwrapped("https://example.com/context", options)).document, { "@context": {} });
+		deepStrictEqual(calls.length, activeSnapshot ? 1 : 2);
+		for (const call of calls) deepStrictEqual(call, {
+			...options,
+			suppressError: true
+		});
+		active.release();
+		deepStrictEqual(createScopedContextLoader(loader, false).loader, base);
+		await unwrapped("https://example.com/context", options);
+		deepStrictEqual(calls.at(-1), options);
+	}
+});
 //#endregion
 export {};

package/dist/tests/jsonld-cache-9jap4yM0.cjs

@@ -0,0 +1,373 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
+const require_url = require("./url-BqlldzT8.cjs");
+let jsonld_dist_jsonld_esm_js = require("jsonld/dist/jsonld.esm.js");
+jsonld_dist_jsonld_esm_js = require_rolldown_runtime.__toESM(jsonld_dist_jsonld_esm_js, 1);
+//#region src/jsonld.ts
+var jsonld_default = jsonld_dist_jsonld_esm_js.default;
+//#endregion
+//#region src/internal/jsonld-cache.ts
+const noJsonLdContext = Symbol("noJsonLdContext");
+const documentLoaderWrappers = /* @__PURE__ */ new WeakMap();
+/**
+* Registers a loader wrapper with the shared released-wrapper registry.
+* Both suppression and snapshot wrappers must use this registry so mixed
+* chains can be unwrapped.  The caller updates the state on release.
+* @internal Not a public API.
+*/
+function registerDocumentLoaderWrapper(loader, state) {
+	documentLoaderWrappers.set(loader, state);
+}
+/**
+* Removes released loader wrappers, stopping at the first active wrapper.
+* Active wrappers retain their operation's suppression or snapshot cache.
+* @internal Not a public API.
+*/
+function unwrapReleasedDocumentLoader(base) {
+	for (let state = documentLoaderWrappers.get(base); state?.released; state = documentLoaderWrappers.get(base)) base = state.base;
+	return base;
+}
+/**
+* Lowers context loading failure logs for one accessor operation.  Parsed
+* objects retain the loader, so release it before returning to the caller.
+* Released wrappers are unwrapped to avoid accumulating loader chains.
+* @internal Used by generated vocabulary accessors; not a public API.
+*/
+function createScopedContextLoader(base, suppressError) {
+	base = unwrapReleasedDocumentLoader(base);
+	if (!suppressError) return {
+		loader: base,
+		release: () => {}
+	};
+	const state = {
+		base,
+		released: false
+	};
+	const loader = (url, options) => base(url, state.released ? options : {
+		...options,
+		suppressError: true
+	});
+	registerDocumentLoaderWrapper(loader, state);
+	return {
+		loader,
+		release: () => {
+			state.released = true;
+		}
+	};
+}
+/**
+* Checks whether an IRI is trusted relative to another IRI.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function isTrustedIriOrigin(options, left, right) {
+	return options.crossOrigin === "trust" || left == null || right != null && (require_url.haveSameIriOrigin(left, right) || require_url.haveSameFe34Origin(left, right));
+}
+/**
+* Normalizes portable IRIs in JSON-LD cache data.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function normalizeJsonLdIris(value, iriKeys, iriPattern = /^ap(?:\+ef61)?:\/\//i) {
+	return normalize(value, void 0, 0, void 0);
+	function isIriPosition(key, parentKey) {
+		return iriKeys.has(key) || (key === "@value" || key === "@list" || key === "@set") && parentKey != null && iriKeys.has(parentKey);
+	}
+	function arrayItemParentKey(key, parentKey) {
+		return key === "@list" || key === "@set" ? parentKey : key;
+	}
+	function entryParentKey(entryKey, key, parentKey) {
+		if (entryKey === "@list" || entryKey === "@set") return parentKey ?? key;
+		return key === "@list" || key === "@set" ? parentKey : key;
+	}
+	function normalize(value, key, depth = 0, parentKey) {
+		if (depth > 32 || key === "@context") return value;
+		if (typeof value === "string") {
+			if (key != null && isIriPosition(key, parentKey) && iriPattern.test(value)) try {
+				return require_url.formatIri(value);
+			} catch {
+				return value;
+			}
+			return value;
+		}
+		if (Array.isArray(value)) {
+			let clone;
+			const itemParentKey = arrayItemParentKey(key, parentKey);
+			for (let i = 0; i < value.length; i++) {
+				const result = normalize(value[i], key, depth + 1, itemParentKey);
+				if (result !== value[i]) {
+					clone ??= value.slice(0, i);
+					clone.push(result);
+				} else if (clone != null) clone.push(value[i]);
+			}
+			return clone ?? value;
+		}
+		if (value == null || typeof value !== "object") return value;
+		const object = value;
+		let clone;
+		for (const entryKey of globalThis.Object.keys(object)) {
+			const result = normalize(object[entryKey], entryKey, depth + 1, entryParentKey(entryKey, key, parentKey));
+			if (result !== object[entryKey]) {
+				clone ??= { ...object };
+				defineJsonLdProperty(clone, entryKey, result);
+			}
+		}
+		return clone ?? object;
+	}
+}
+/**
+* Finds the first JSON-LD context in a value.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+function getJsonLdContext(value, depth = 0) {
+	if (depth > 32) return void 0;
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			const context = getJsonLdContext(item, depth + 1);
+			if (context !== void 0) return context;
+		}
+		return;
+	}
+	if (value == null || typeof value !== "object" || !("@context" in value)) return;
+	return value["@context"];
+}
+function getOwnJsonLdContext(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value) || !("@context" in value)) return noJsonLdContext;
+	return value["@context"];
+}
+/**
+* Recompacts normalized JSON-LD cache data against the original context.
+*
+* @internal Technically exported for generated vocabulary classes, but not
+* part of the public API contract.  This is not considered public API for
+* Semantic Versioning decisions.
+*/
+async function compactJsonLdCache(normalized, original, documentLoader, depth = 0, inheritedContext) {
+	if (depth > 32) return normalized;
+	if (Array.isArray(original)) {
+		const normalizedArray = Array.isArray(normalized) ? normalized : normalized != null && typeof normalized === "object" && "@graph" in normalized && Array.isArray(normalized["@graph"]) ? normalized["@graph"] : void 0;
+		if (normalizedArray == null) return normalized;
+		let clone;
+		for (let i = 0; i < normalizedArray.length; i++) {
+			const item = await compactJsonLdCache(normalizedArray[i], original[i], documentLoader, depth + 1, inheritedContext);
+			if (item !== normalizedArray[i]) {
+				clone ??= normalizedArray.slice(0, i);
+				clone.push(item);
+			} else if (clone != null) clone.push(normalizedArray[i]);
+		}
+		return clone ?? (Array.isArray(normalized) ? normalized : normalizedArray);
+	}
+	const ownContext = getOwnJsonLdContext(original);
+	const context = ownContext === noJsonLdContext ? inheritedContext : ownContext;
+	if (context == null) return preserveNoContextJsonLdShape(normalized, original, depth);
+	return await preserveJsonLdShape(await mergeUnmappedTerms(await jsonld_default.compact(Array.isArray(normalized) && normalized.length === 1 ? normalized[0] : normalized, context, { documentLoader }), original, context, documentLoader), original, context, documentLoader, depth);
+}
+function preserveNoContextJsonLdShape(normalized, original, depth = 0) {
+	if (depth > 32) return normalized;
+	if (original == null || typeof original !== "object" || Array.isArray(original)) return normalized;
+	const normalizedObject = Array.isArray(normalized) && normalized.length === 1 ? normalized[0] : normalized;
+	if (normalizedObject == null || typeof normalizedObject !== "object" || Array.isArray(normalizedObject)) return normalized;
+	const source = normalizedObject;
+	const originalObject = original;
+	let clone;
+	for (const key of globalThis.Object.keys(originalObject)) {
+		if (!globalThis.Object.prototype.hasOwnProperty.call(source, key)) continue;
+		const value = preserveNoContextValue(source[key], originalObject[key], depth + 1);
+		if (value !== originalObject[key]) {
+			clone ??= { ...originalObject };
+			defineJsonLdProperty(clone, key, value);
+		}
+	}
+	return clone ?? original;
+}
+function preserveNoContextValue(normalized, original, depth) {
+	if (depth > 32) return normalized;
+	if (Array.isArray(original)) {
+		const normalizedArray = Array.isArray(normalized) ? normalized : [normalized];
+		let clone;
+		for (let i = 0; i < original.length; i++) {
+			const value = preserveNoContextValue(normalizedArray[i], original[i], depth + 1);
+			if (value !== original[i]) {
+				clone ??= original.slice(0, i);
+				clone.push(value);
+			} else if (clone != null) clone.push(original[i]);
+		}
+		return clone ?? original;
+	}
+	const normalizedValue = Array.isArray(normalized) ? normalized[0] : normalized;
+	if (normalizedValue == null || typeof normalizedValue !== "object" || Array.isArray(normalizedValue)) return normalizedValue;
+	const normalizedObject = normalizedValue;
+	if (original != null && typeof original === "object" && !Array.isArray(original)) return preserveNoContextJsonLdShape(normalizedObject, original, depth + 1);
+	if (typeof normalizedObject["@id"] === "string") return normalizedObject["@id"];
+	if ("@value" in normalizedObject) return normalizedObject["@value"];
+	return normalizedValue;
+}
+function getTopLevelTerms(value) {
+	const terms = /* @__PURE__ */ new Set();
+	const nodes = Array.isArray(value) ? value : [value];
+	for (const node of nodes) {
+		if (node == null || typeof node !== "object" || Array.isArray(node)) continue;
+		for (const key of globalThis.Object.keys(node)) {
+			if (key.startsWith("@")) continue;
+			terms.add(key);
+		}
+	}
+	return terms;
+}
+async function mergeUnmappedTerms(compacted, original, context, documentLoader) {
+	if (original == null || typeof original !== "object" || Array.isArray(original) || compacted == null || typeof compacted !== "object" || Array.isArray(compacted)) return compacted;
+	const unmappedKeys = globalThis.Object.keys(original).filter((key) => key !== "@context" && !globalThis.Object.prototype.hasOwnProperty.call(compacted, key));
+	if (unmappedKeys.length < 1) return compacted;
+	const result = { ...compacted };
+	const compactedWithContext = compacted != null && typeof compacted === "object" && !Array.isArray(compacted) && !("@context" in compacted) ? {
+		"@context": context,
+		...compacted
+	} : compacted;
+	const compactedTerms = getTopLevelTerms(await jsonld_default.expand(compactedWithContext, { documentLoader }));
+	const dummyPrefix = "urn:fedify:dummy:";
+	const dummy = { "@context": context };
+	for (let i = 0; i < unmappedKeys.length; i++) defineJsonLdProperty(dummy, unmappedKeys[i], `${dummyPrefix}${i}`);
+	const expanded = await jsonld_default.expand(dummy, { documentLoader });
+	const representedKeys = /* @__PURE__ */ new Set();
+	const nodes = Array.isArray(expanded) ? expanded : [expanded];
+	for (const node of nodes) {
+		if (node == null || typeof node !== "object" || Array.isArray(node)) continue;
+		for (const [term, termValue] of globalThis.Object.entries(node)) {
+			if (!compactedTerms.has(term)) continue;
+			for (let i = 0; i < unmappedKeys.length; i++) if (containsValue(termValue, `${dummyPrefix}${i}`)) representedKeys.add(unmappedKeys[i]);
+		}
+	}
+	for (const key of unmappedKeys) if (!representedKeys.has(key)) defineJsonLdProperty(result, key, original[key]);
+	return result;
+}
+function defineJsonLdProperty(object, key, value) {
+	globalThis.Object.defineProperty(object, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+}
+function containsValue(value, expected, depth = 0) {
+	if (depth > 32) return false;
+	if (value === expected) return true;
+	if (Array.isArray(value)) return value.some((item) => containsValue(item, expected, depth + 1));
+	if (value == null || typeof value !== "object") return false;
+	return globalThis.Object.entries(value).some(([key, item]) => key !== "@context" && containsValue(item, expected, depth + 1));
+}
+async function preserveJsonLdShape(compacted, original, context, documentLoader, depth = 0) {
+	if (depth > 32) return compacted;
+	if (compacted === original) return compacted;
+	if (original == null || typeof original !== "object" || compacted == null || typeof compacted !== "object") return compacted;
+	if (Array.isArray(original)) {
+		const compactedArray = Array.isArray(compacted) ? compacted : "@graph" in compacted && Array.isArray(compacted["@graph"]) ? compacted["@graph"] : void 0;
+		if (compactedArray == null) return compacted;
+		let clone;
+		for (let i = 0; i < compactedArray.length; i++) {
+			const value = await preserveJsonLdShape(compactedArray[i], original[i], context, documentLoader, depth + 1);
+			const originalContext = original[i] != null && typeof original[i] === "object" && !Array.isArray(original[i]) && "@context" in original[i] ? original[i]["@context"] : void 0;
+			const shaped = originalContext !== void 0 && value != null && typeof value === "object" && !Array.isArray(value) && !("@context" in value) ? {
+				"@context": originalContext,
+				...value
+			} : value;
+			if (shaped !== compactedArray[i]) {
+				clone ??= compactedArray.slice(0, i);
+				clone.push(shaped);
+			} else if (clone != null) clone.push(compactedArray[i]);
+		}
+		return clone ?? (Array.isArray(compacted) ? compacted : compactedArray);
+	}
+	if (Array.isArray(compacted)) return compacted;
+	let clone;
+	const ownContext = getOwnJsonLdContext(original);
+	const objectContext = combineContexts(context, ownContext);
+	const objectCompacted = depth > 0 && ownContext === null ? await compactWithEmptyContext(compacted, context, documentLoader) : compacted;
+	const compactedObject = depth > 0 ? await mergeUnmappedTerms(objectCompacted, original, objectContext, documentLoader) : objectCompacted;
+	const originalObject = original;
+	for (const key of globalThis.Object.keys(compactedObject)) {
+		if (key === "@context") continue;
+		const value = await preserveJsonLdShape(compactedObject[key], originalObject[key], objectContext, documentLoader, depth + 1);
+		const shaped = Array.isArray(originalObject[key]) && !Array.isArray(value) ? [value] : value;
+		if (shaped !== compactedObject[key]) {
+			clone ??= { ...compactedObject };
+			defineJsonLdProperty(clone, key, shaped);
+		}
+	}
+	if (depth > 0) {
+		if ("@context" in originalObject && !("@context" in compactedObject)) {
+			clone ??= { ...compactedObject };
+			clone["@context"] = originalObject["@context"];
+		}
+	}
+	return clone ?? compactedObject;
+}
+async function compactWithEmptyContext(compacted, context, documentLoader) {
+	const compactedWithContext = compacted != null && typeof compacted === "object" && !Array.isArray(compacted) && !("@context" in compacted) ? {
+		"@context": context,
+		...compacted
+	} : compacted;
+	const expanded = await jsonld_default.expand(compactedWithContext, { documentLoader });
+	return await jsonld_default.compact(expanded, {}, { documentLoader });
+}
+function combineContexts(inheritedContext, ownContext) {
+	if (ownContext === noJsonLdContext || ownContext === inheritedContext) return inheritedContext;
+	if (ownContext == null) return ownContext;
+	const inherited = Array.isArray(inheritedContext) ? inheritedContext : [inheritedContext];
+	const own = Array.isArray(ownContext) ? ownContext : [ownContext];
+	return [...inherited, ...own];
+}
+//#endregion
+Object.defineProperty(exports, "compactJsonLdCache", {
+	enumerable: true,
+	get: function() {
+		return compactJsonLdCache;
+	}
+});
+Object.defineProperty(exports, "createScopedContextLoader", {
+	enumerable: true,
+	get: function() {
+		return createScopedContextLoader;
+	}
+});
+Object.defineProperty(exports, "getJsonLdContext", {
+	enumerable: true,
+	get: function() {
+		return getJsonLdContext;
+	}
+});
+Object.defineProperty(exports, "isTrustedIriOrigin", {
+	enumerable: true,
+	get: function() {
+		return isTrustedIriOrigin;
+	}
+});
+Object.defineProperty(exports, "jsonld_default", {
+	enumerable: true,
+	get: function() {
+		return jsonld_default;
+	}
+});
+Object.defineProperty(exports, "normalizeJsonLdIris", {
+	enumerable: true,
+	get: function() {
+		return normalizeJsonLdIris;
+	}
+});
+Object.defineProperty(exports, "registerDocumentLoaderWrapper", {
+	enumerable: true,
+	get: function() {
+		return registerDocumentLoaderWrapper;
+	}
+});
+Object.defineProperty(exports, "unwrapReleasedDocumentLoader", {
+	enumerable: true,
+	get: function() {
+		return unwrapReleasedDocumentLoader;
+	}
+});