@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/sig/compound-proof.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/sig/compound-proof.test.mjs

@@ -0,0 +1,411 @@
+import { Temporal } from "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { n as preloadedOnlyDocumentLoader } from "../public-audience--klBIOk1.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
+import { a as signObject, d as verifyProof } from "../proof-Dxy6ByqI.mjs";
+import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
+import { s as verifyCompoundProofDocuments } from "../compound-proof-B-9mXxFW.mjs";
+import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
+import { t as map_local_context_conflict_default } from "../map-local-context-conflict-DOYEEJ3u.mjs";
+import { Create, DataIntegrityProof, Note, Question } from "@fedify/vocab";
+import { encodeMultibase, exportDidKey, parseIri } from "@fedify/vocab-runtime";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { encodeHex } from "byte-encodings/hex";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+import serialize from "json-canon";
+//#region src/sig/compound-proof.test.ts
+const outerPrivateKey = await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	d: "yW756hDF5BTEcXI6_53nLDX6W3D66X6IMuysfS4rjtY",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["sign"],
+	ext: true
+}, "Ed25519", true, ["sign"]);
+const outerDid = await exportDidKey(await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["verify"],
+	ext: true
+}, "Ed25519", true, ["verify"]));
+const innerDid = await exportDidKey(ed25519PublicKey.publicKey);
+const outerMethod = outerDid.substring(8);
+const innerMethod = innerDid.substring(8);
+const outerKeyId = new URL(`${outerDid}#${outerMethod}`);
+const innerKeyId = new URL(`${innerDid}#${innerMethod}`);
+const vectorInnerKeyId = new URL(map_local_create_note_default.keys.inner.verificationMethod);
+const conflictVectorInnerKeyId = new URL(map_local_context_conflict_default.keys.inner.verificationMethod);
+const context = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+const distinctInnerContext = [...context, { ex: "https://example.com/ns#" }];
+const options = {
+	context,
+	contextLoader: mockDocumentLoader,
+	documentLoader: mockDocumentLoader
+};
+const inboundOptions = {
+	contextLoader: preloadedOnlyDocumentLoader,
+	documentLoader: preloadedOnlyDocumentLoader
+};
+const compoundLimits = {
+	maxDepth: 16,
+	maxMaps: 32,
+	maxProofs: 8,
+	maxBytes: 16384
+};
+async function parseProof(document) {
+	const proof = document.proof;
+	assert(proof != null && typeof proof === "object" && !Array.isArray(proof));
+	return await DataIntegrityProof.fromJsonLd({
+		"@context": document["@context"],
+		...proof
+	}, options);
+}
+function asRecord(value) {
+	assert(value != null && typeof value === "object" && !Array.isArray(value));
+	return value;
+}
+function withoutDirectProof(document) {
+	const unsecuredDocument = structuredClone(document);
+	delete unsecuredDocument.proof;
+	return unsecuredDocument;
+}
+function withoutProofValue(proof) {
+	const proofConfiguration = structuredClone(proof);
+	delete proofConfiguration.proofValue;
+	return proofConfiguration;
+}
+async function sha256(value) {
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)));
+}
+async function assertRecordedProof(entry) {
+	assertEquals(withoutProofValue(entry.proof), entry.proofConfiguration);
+	assertEquals(entry.proof.proofValue, entry.proofValue);
+	const documentJcs = serialize(entry.document);
+	const proofConfigurationJcs = serialize(entry.proofConfiguration);
+	assertEquals(documentJcs, entry.canonicalization.documentJcs);
+	assertEquals(proofConfigurationJcs, entry.canonicalization.proofConfigurationJcs);
+	const documentDigest = await sha256(documentJcs);
+	const proofConfigurationDigest = await sha256(proofConfigurationJcs);
+	assertEquals(encodeHex(documentDigest), entry.hashes.documentSha256);
+	assertEquals(encodeHex(proofConfigurationDigest), entry.hashes.proofConfigurationSha256);
+	const combinedSigningInput = new Uint8Array(proofConfigurationDigest.length + documentDigest.length);
+	combinedSigningInput.set(proofConfigurationDigest);
+	combinedSigningInput.set(documentDigest, proofConfigurationDigest.length);
+	assertEquals(encodeHex(combinedSigningInput), entry.hashes.combinedSigningInput);
+	assertEquals(entry.hashes.combinedSigningInput, entry.hashes.proofConfigurationSha256 + entry.hashes.documentSha256);
+	const privateJwk = structuredClone(entry.key.testPrivateKeyJwk);
+	const publicJwk = structuredClone(entry.key.publicKeyJwk);
+	assertEquals(privateJwk.x, publicJwk.x);
+	const privateKey = await crypto.subtle.importKey("jwk", privateJwk, "Ed25519", true, ["sign"]);
+	const publicKey = await crypto.subtle.importKey("jwk", publicJwk, "Ed25519", true, ["verify"]);
+	const controller = await exportDidKey(publicKey);
+	assertEquals(controller, entry.key.controller);
+	const publicKeyMultibase = controller.replace(/^did:key:/, "");
+	assertEquals(publicKeyMultibase, entry.key.publicKeyMultibase);
+	assertEquals(entry.key.verificationMethod, `${controller}#${publicKeyMultibase}`);
+	assertEquals(entry.proofConfiguration.verificationMethod, entry.key.verificationMethod);
+	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, combinedSigningInput));
+	assert(await crypto.subtle.verify("Ed25519", publicKey, signature, combinedSigningInput));
+	assertEquals(new TextDecoder().decode(encodeMultibase("base58btc", signature)), entry.proofValue);
+}
+test("map-local compound vector records independently reproducible proofs", async () => {
+	const securedOuter = asRecord(map_local_create_note_default.documents.finalSecuredCompound);
+	const securedInner = asRecord(map_local_create_note_default.documents.securedInner);
+	const outerProof = asRecord(securedOuter.proof);
+	const innerProof = asRecord(securedInner.proof);
+	const replacementInnerProof = asRecord(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerProofConfiguration = withoutProofValue(replacementInnerProof);
+	assertEquals(withoutDirectProof(securedOuter), map_local_create_note_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(securedInner), map_local_create_note_default.documents.innerUnsecuredDocument);
+	assertEquals(withoutProofValue(outerProof), map_local_create_note_default.documents.outerProofConfiguration);
+	assertEquals(withoutProofValue(innerProof), map_local_create_note_default.documents.innerProofConfiguration);
+	const entries = [
+		{
+			document: map_local_create_note_default.documents.outerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.outerProofConfiguration,
+			proof: outerProof,
+			key: map_local_create_note_default.keys.outer,
+			canonicalization: map_local_create_note_default.canonicalization.outer,
+			hashes: map_local_create_note_default.hashes.outer,
+			proofValue: map_local_create_note_default.proofValues.outer
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.innerProofConfiguration,
+			proof: innerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.inner,
+			hashes: map_local_create_note_default.hashes.inner,
+			proofValue: map_local_create_note_default.proofValues.inner
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: replacementInnerProofConfiguration,
+			proof: replacementInnerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.replacementInner,
+			hashes: map_local_create_note_default.hashes.replacementInner,
+			proofValue: map_local_create_note_default.proofValues.replacementInner
+		}
+	];
+	for (const entry of entries) await assertRecordedProof(entry);
+});
+test("the context-conflict vector records valid proofs and divergent semantics", async () => {
+	const compound = asRecord(map_local_context_conflict_default.documents.finalSecuredCompound);
+	const embedded = asRecord(compound.object);
+	const securedInner = asRecord(map_local_context_conflict_default.documents.securedInner);
+	const outerProof = asRecord(compound.proof);
+	const innerProof = asRecord(embedded.proof);
+	assertEquals(embedded, securedInner);
+	assertEquals(withoutDirectProof(compound), map_local_context_conflict_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(embedded), map_local_context_conflict_default.documents.innerUnsecuredDocument);
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.outerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.outerProofConfiguration,
+		proof: outerProof,
+		key: map_local_context_conflict_default.keys.outer,
+		canonicalization: map_local_context_conflict_default.canonicalization.outer,
+		hashes: map_local_context_conflict_default.hashes.outer,
+		proofValue: map_local_context_conflict_default.proofValues.outer
+	});
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.innerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.innerProofConfiguration,
+		proof: innerProof,
+		key: map_local_context_conflict_default.keys.inner,
+		canonicalization: map_local_context_conflict_default.canonicalization.inner,
+		hashes: map_local_context_conflict_default.hashes.inner,
+		proofValue: map_local_context_conflict_default.proofValues.inner
+	});
+	const verifiedInner = await verifyProof(embedded, await parseProof(embedded), inboundOptions);
+	assertEquals(verifiedInner != null, map_local_context_conflict_default.expectedVerification.original.inner);
+	assertEquals(verifiedInner?.id, conflictVectorInnerKeyId);
+	const verifiedOuter = await verifyProof(compound, await parseProof(compound), inboundOptions);
+	assertEquals(verifiedOuter != null, map_local_context_conflict_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuter?.id, outerKeyId);
+	const standaloneExpansion = await jsonld.expand(embedded, { documentLoader: preloadedOnlyDocumentLoader });
+	const compoundExpansion = await jsonld.expand(compound, { documentLoader: preloadedOnlyDocumentLoader });
+	const content = "https://www.w3.org/ns/activitystreams#content";
+	const object = "https://www.w3.org/ns/activitystreams#object";
+	const standaloneContent = asRecord(standaloneExpansion[0])[content];
+	const inParentObject = asRecord(asRecord(compoundExpansion[0])[object][0]);
+	const inParentContent = inParentObject[content];
+	assertEquals(serialize(standaloneExpansion[0]) === serialize(inParentObject), map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+	assertEquals(standaloneContent, [{ "@value": "A portable note with inherited language" }]);
+	assertEquals(inParentContent, [{
+		"@value": "A portable note with inherited language",
+		"@language": map_local_context_conflict_default.expectedInterpretation.inParentContentLanguage
+	}]);
+	assertEquals(standaloneContent[0]["@language"] ?? null, map_local_context_conflict_default.expectedInterpretation.standaloneContentLanguage);
+	assertEquals(serialize(standaloneContent) !== serialize(inParentContent), !map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+});
+test("the raw same-context baseline verifies map-locally", async () => {
+	const compound = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const embedded = compound.object;
+	const embeddedProof = embedded.proof;
+	assertEquals(embedded, map_local_create_note_default.documents.securedInner);
+	assertEquals(embeddedProof["@context"], context);
+	assertEquals(embedded["@context"], context);
+	assert("proof" in embedded);
+	const verifiedInnerKey = await verifyProof(embedded, await parseProof(embedded), options);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.original.inner);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.standaloneInner);
+	assertEquals(verifiedInnerKey?.id, vectorInnerKeyId);
+	const verifiedOuterKey = await verifyProof(compound, await parseProof(compound), options);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.standaloneOuter);
+	assertEquals(verifiedOuterKey?.id, outerKeyId);
+	const tampered = structuredClone(compound);
+	const tamperedInner = tampered.object;
+	tamperedInner.content = "A tampered portable note";
+	assertEquals(await verifyProof(tamperedInner, await parseProof(tamperedInner), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.inner);
+	assertEquals(await verifyProof(tampered, await parseProof(tampered), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.outer);
+	const replaced = structuredClone(compound);
+	const replacedInner = replaced.object;
+	replacedInner.proof = structuredClone(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerKey = await verifyProof(replacedInner, await parseProof(replacedInner), options);
+	assertEquals(replacementInnerKey != null, map_local_create_note_default.expectedVerification.replacedInnerProof.inner);
+	assertEquals(replacementInnerKey?.id, vectorInnerKeyId);
+	assertEquals(await verifyProof(replaced, await parseProof(replaced), options) != null, map_local_create_note_default.expectedVerification.replacedInnerProof.outer);
+});
+async function signDistinctContextNote(created, path) {
+	return await signObject(new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/${path}`),
+		attribution: parseIri(`ap+ef61://${innerDid}/actor`),
+		content: "A portable note with its own context"
+	}), ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	});
+}
+async function serializeOutgoing(object, context) {
+	return await normalizeOutgoingActivityJsonLd(await object.toJsonLd({
+		format: "compact",
+		...options,
+		context: context ?? options.context
+	}), mockDocumentLoader, { preserveNestedSecuredDocuments: true });
+}
+async function signOuterCreate(created, path, child) {
+	return await signObject(new Create({
+		id: parseIri(`ap+ef61://${outerDid}/activities/${path}`),
+		actor: parseIri(`ap+ef61://${outerDid}/actor`),
+		object: child
+	}), outerPrivateKey, outerKeyId, {
+		...options,
+		created
+	});
+}
+test("typed Create serialization embeds the signed child representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "distinct-context");
+	assert(inner instanceof Note);
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const outer = await signOuterCreate(created, "distinct-context", inner);
+	assert(outer instanceof Create);
+	const compound = await serializeOutgoing(outer);
+	const embedded = compound.object;
+	const embeddedProof = embedded.proof;
+	assertEquals(embedded["@context"], distinctInnerContext);
+	assertEquals(embeddedProof["@context"], distinctInnerContext);
+	assertEquals(compound["@context"], context);
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals(embedded.type, "Note");
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
+	assertEquals((await verifyProof(compound, await parseProof(compound), options))?.id, outerKeyId);
+	const mapLocal = await verifyCompoundProofDocuments(compound, compoundLimits, inboundOptions);
+	assertEquals(mapLocal.status, "ok");
+	assert(mapLocal.status === "ok");
+	assert(mapLocal.verified);
+	assertEquals(mapLocal.documents.map(({ path, verified }) => ({
+		path,
+		verified
+	})), [{
+		path: "/object",
+		verified: true
+	}, {
+		path: "",
+		verified: true
+	}]);
+});
+test("tampering with an embedded signed child invalidates both proofs", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const tampered = await serializeOutgoing(await signOuterCreate(created, "tampered", await signDistinctContextNote(created, "tampered")));
+	const tamperedInner = tampered.object;
+	tamperedInner.content = "A tampered portable note";
+	assertEquals(await verifyProof(tamperedInner, await parseProof(tamperedInner), options), null);
+	assertEquals(await verifyProof(tampered, await parseProof(tampered), options), null);
+});
+test("replacing an embedded child proof invalidates only the outer proof", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const replacementCreated = Temporal.Instant.from("2023-02-25T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "replaced-proof");
+	const replacementProof = (await serializeOutgoing(await signDistinctContextNote(replacementCreated, "replaced-proof"), distinctInnerContext)).proof;
+	const compound = await serializeOutgoing(await signOuterCreate(created, "replaced-proof", inner));
+	const replacedInner = compound.object;
+	replacedInner.proof = replacementProof;
+	assertEquals((await verifyProof(replacedInner, await parseProof(replacedInner), options))?.id, innerKeyId);
+	assertEquals(await verifyProof(compound, await parseProof(compound), options), null);
+});
+test("cloning or re-signing a signed child drops its retained representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "cloned");
+	const cloned = inner.clone({});
+	assert(cloned instanceof Note);
+	const clonedEmbedded = (await serializeOutgoing(await signOuterCreate(created, "cloned", cloned))).object;
+	assertEquals(clonedEmbedded["@context"], void 0);
+	assertEquals(clonedEmbedded.proof["@context"], void 0);
+	const reSignedEmbedded = (await serializeOutgoing(await signOuterCreate(created, "re-signed", await signObject(inner, ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	})))).object;
+	assertEquals(reSignedEmbedded["@context"], void 0);
+});
+test("mutating a signed child does not change its embedded representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "mutated");
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const proof = (await Array.fromAsync(inner.getProofs(options)))[0];
+	assert(proof.proofValue != null);
+	proof.proofValue[0] ^= 255;
+	const embedded = (await serializeOutgoing(await signOuterCreate(created, "mutated", inner))).object;
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
+});
+test("a signed child is embedded through a compactable ancestor too", async () => {
+	const inner = await signDistinctContextNote(Temporal.Instant.from("2023-02-24T23:36:38Z"), "compactable-parent");
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const wrapper = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/wrapper`),
+		attachments: [inner]
+	});
+	const embedded = (await new Question({
+		id: parseIri(`ap+ef61://${outerDid}/objects/question`),
+		exclusiveOptions: [wrapper]
+	}).toJsonLd()).oneOf.attachment;
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
+});
+test("typed Create serialization bypasses a parsed child's JSON-LD cache", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const standaloneInner = await serializeOutgoing(await signDistinctContextNote(created, "reparsed-context"), distinctInnerContext);
+	const standaloneProof = await parseProof(standaloneInner);
+	const reparsedInner = await Note.fromJsonLd(standaloneInner, {
+		contextLoader: mockDocumentLoader,
+		documentLoader: mockDocumentLoader
+	});
+	assert(reparsedInner instanceof Note);
+	assertEquals(await reparsedInner.toJsonLd(), standaloneInner);
+	const reparsedCompound = await serializeOutgoing(await signOuterCreate(created, "reparsed-context", reparsedInner));
+	const reparsedEmbedded = reparsedCompound.object;
+	const reparsedEmbeddedProof = reparsedEmbedded.proof;
+	assertEquals(reparsedEmbedded["@context"], void 0);
+	assertEquals(reparsedEmbeddedProof["@context"], void 0);
+	assertEquals(reparsedEmbeddedProof.proofValue, standaloneInner.proof.proofValue);
+	assertEquals(await verifyProof(reparsedEmbedded, standaloneProof, options), null);
+	assertEquals((await verifyProof(reparsedCompound, await parseProof(reparsedCompound), options))?.id, outerKeyId);
+});
+test("verifyProof() does not invent a missing child context", async () => {
+	const received = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const receivedInner = received.object;
+	const receivedInnerProof = receivedInner.proof;
+	delete receivedInner["@context"];
+	delete receivedInnerProof["@context"];
+	const snapshot = structuredClone(received);
+	const proof = await DataIntegrityProof.fromJsonLd(received.proof, inboundOptions);
+	assertEquals(await verifyProof(received, proof, inboundOptions), null);
+	assertEquals(received, snapshot);
+	const guessed = structuredClone(received);
+	const guessedInner = guessed.object;
+	const guessedInnerProof = guessedInner.proof;
+	guessedInner["@context"] = structuredClone(guessed["@context"]);
+	guessedInnerProof["@context"] = structuredClone(guessed["@context"]);
+	assertEquals((await verifyProof(guessed, proof, inboundOptions))?.id, outerKeyId);
+});
+test("signing a document too deep to retain still succeeds", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	let deep = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/deep-leaf`),
+		content: "A portable note nested past the retention bounds"
+	});
+	for (let i = 0; i < 40; i++) deep = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/deep-${i}`),
+		attachments: [deep]
+	});
+	const signed = await signObject(deep, ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	});
+	assertEquals((await Array.fromAsync(signed.getProofs(options))).length, 1);
+	const embedded = (await serializeOutgoing(await signOuterCreate(created, "deep", signed))).object;
+	assertEquals(embedded["@context"], void 0);
+});
+//#endregion
+export {};