@fedify/vocab 2.0.0-dev.0

package/dist/vocab.test.js

@@ -0,0 +1,1304 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { Activity, Announce, Collection, Create, CryptographicKey, Follow, Hashtag, Link, Note, Object as Object$1, OrderedCollectionPage, Person, Place, Question, Source, vocab_exports } from "./vocab-DBispxj5.js";
+import { assertInstanceOf } from "./utils-BSWXlrig.js";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, notDeepStrictEqual, ok, rejects, throws } from "node:assert/strict";
+import { LanguageString, decodeMultibase } from "@fedify/vocab-runtime";
+import { pascalCase } from "es-toolkit";
+import { areAllScalarTypes, loadSchemaFiles } from "@fedify/vocab-tools";
+
+//#region src/vocab.test.ts
+test("new Object()", () => {
+	const obj = new Object$1({
+		name: "Test",
+		contents: [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]
+	});
+	deepStrictEqual(obj.name, "Test");
+	deepStrictEqual(obj.contents[0], new LanguageString("Hello", "en"));
+	deepStrictEqual(obj.contents[1], new LanguageString("你好", "zh"));
+	throws(() => new Object$1({ id: 123 }), TypeError);
+	throws(() => new Object$1({
+		name: "singular",
+		names: ["plural"]
+	}), TypeError);
+	throws(() => new Object$1({ name: 123 }), TypeError);
+	throws(() => new Object$1({ names: "foo" }), TypeError);
+	throws(() => new Object$1({ names: ["foo", 123] }), TypeError);
+});
+test("Object.clone()", () => {
+	const obj = new Object$1({
+		id: new URL("https://example.com/"),
+		name: "Test",
+		contents: [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]
+	});
+	const clone = obj.clone({ content: "Modified" });
+	assertInstanceOf(clone, Object$1);
+	deepStrictEqual(clone.id, new URL("https://example.com/"));
+	deepStrictEqual(clone.name, "Test");
+	deepStrictEqual(clone.content, "Modified");
+	const cloned2 = obj.clone({ id: new URL("https://example.com/modified") });
+	assertInstanceOf(cloned2, Object$1);
+	deepStrictEqual(cloned2.id, new URL("https://example.com/modified"));
+	deepStrictEqual(cloned2.name, "Test");
+	deepStrictEqual(cloned2.contents, [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]);
+	throws(() => obj.clone({ id: 123 }), TypeError);
+	throws(() => obj.clone({
+		name: "singular",
+		names: ["plural"]
+	}), TypeError);
+	throws(() => obj.clone({ name: 123 }), TypeError);
+	throws(() => obj.clone({ names: "foo" }), TypeError);
+	throws(() => obj.clone({ names: ["foo", 123] }), TypeError);
+});
+test("Object.fromJsonLd()", async () => {
+	const obj = await Object$1.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Object",
+		"name": "Test",
+		"contentMap": {
+			"en": "Hello",
+			"zh": "你好"
+		},
+		"source": {
+			"content": "Hello",
+			"mediaType": "text/plain"
+		},
+		"published": "2025-01-01 12:34:56"
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assertInstanceOf(obj, Object$1);
+	deepStrictEqual(obj.name, "Test");
+	deepStrictEqual(obj.contents, [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]);
+	assertInstanceOf(obj.source, Source);
+	deepStrictEqual(obj.source.content, "Hello");
+	deepStrictEqual(obj.source.mediaType, "text/plain");
+	deepStrictEqual(obj.published, Temporal.Instant.from("2025-01-01T12:34:56Z"));
+	const createJsonLd = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Create",
+		"name": "Test",
+		"contentMap": {
+			"en": "Hello",
+			"zh": "你好"
+		},
+		"object": {
+			"type": "Note",
+			"content": "Content"
+		}
+	};
+	const create = await Object$1.fromJsonLd(createJsonLd, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assertInstanceOf(create, Create);
+	deepStrictEqual(create.name, "Test");
+	deepStrictEqual(create.contents, [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]);
+	deepStrictEqual(await create.toJsonLd(), createJsonLd);
+	const note = await create.getObject();
+	assertInstanceOf(note, Note);
+	deepStrictEqual(note.content, "Content");
+	const empty = await Object$1.fromJsonLd({});
+	assertInstanceOf(empty, Object$1);
+	await rejects(() => Object$1.fromJsonLd(null), TypeError);
+	await rejects(() => Object$1.fromJsonLd(void 0), TypeError);
+});
+test("Object.toJsonLd()", async () => {
+	const obj = new Object$1({
+		name: "Test",
+		contents: [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]
+	});
+	deepStrictEqual(await obj.toJsonLd({
+		format: "expand",
+		contextLoader: mockDocumentLoader
+	}), [{
+		"@type": ["https://www.w3.org/ns/activitystreams#Object"],
+		"https://www.w3.org/ns/activitystreams#name": [{ "@value": "Test" }],
+		"https://www.w3.org/ns/activitystreams#content": [{
+			"@value": "Hello",
+			"@language": "en"
+		}, {
+			"@value": "你好",
+			"@language": "zh"
+		}]
+	}]);
+	deepStrictEqual(await obj.toJsonLd({ contextLoader: mockDocumentLoader }), {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{
+				fedibird: "http://fedibird.com/ns#",
+				sensitive: "as:sensitive",
+				emojiReactions: {
+					"@id": "fedibird:emojiReactions",
+					"@type": "@id"
+				}
+			}
+		],
+		type: "Object",
+		name: "Test",
+		contentMap: {
+			en: "Hello",
+			zh: "你好"
+		}
+	});
+});
+test("Note.toJsonLd()", async () => {
+	const note = new Note({ tags: [new Hashtag({
+		name: "#Fedify",
+		href: new URL("https://fedify.dev/")
+	})] });
+	deepStrictEqual(await note.toJsonLd({ contextLoader: mockDocumentLoader }), {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{
+				Emoji: "toot:Emoji",
+				Hashtag: "as:Hashtag",
+				_misskey_quote: "misskey:_misskey_quote",
+				fedibird: "http://fedibird.com/ns#",
+				misskey: "https://misskey-hub.net/ns#",
+				quoteUri: "fedibird:quoteUri",
+				quoteUrl: "as:quoteUrl",
+				sensitive: "as:sensitive",
+				toot: "http://joinmastodon.org/ns#",
+				emojiReactions: {
+					"@id": "fedibird:emojiReactions",
+					"@type": "@id"
+				}
+			}
+		],
+		tag: {
+			"@context": ["https://www.w3.org/ns/activitystreams", { Hashtag: "as:Hashtag" }],
+			href: "https://fedify.dev/",
+			name: "#Fedify",
+			type: "Hashtag"
+		},
+		type: "Note"
+	});
+	const noteWithName = note.clone({ name: "Test" });
+	deepStrictEqual(await noteWithName.toJsonLd({ contextLoader: mockDocumentLoader }), await noteWithName.toJsonLd({
+		contextLoader: mockDocumentLoader,
+		format: "compact"
+	}));
+});
+test("Activity.fromJsonLd()", async () => {
+	const follow = await Activity.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://activitypub.academy/80c50305-7405-4e38-809f-697647a1f679",
+		type: "Follow",
+		actor: "https://activitypub.academy/users/egulia_anbeiss",
+		object: "https://example.com/users/hongminhee"
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assertInstanceOf(follow, Follow);
+	deepStrictEqual(follow.id, new URL("https://activitypub.academy/80c50305-7405-4e38-809f-697647a1f679"));
+	deepStrictEqual(follow.actorId, new URL("https://activitypub.academy/users/egulia_anbeiss"));
+	deepStrictEqual(follow.objectId, new URL("https://example.com/users/hongminhee"));
+	const create = await Activity.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		type: "Create",
+		actor: "https://server.example/users/alice",
+		object: {
+			type: "Note",
+			content: "Hello world"
+		},
+		proof: {
+			type: "DataIntegrityProof",
+			cryptosuite: "eddsa-jcs-2022",
+			verificationMethod: "https://server.example/users/alice#ed25519-key",
+			proofPurpose: "assertionMethod",
+			proofValue: "z3sXaxjKs4M3BRicwWA9peyNPJvJqxtGsDmpt1jjoHCjgeUf71TRFz56osPSfDErszyLp5Ks1EhYSgpDaNM977Rg2",
+			created: "2023-02-24T23:36:38Z"
+		}
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	const proofs = [];
+	for await (const proof of create.getProofs()) proofs.push(proof);
+	deepStrictEqual(proofs.length, 1);
+	deepStrictEqual(proofs[0].cryptosuite, "eddsa-jcs-2022");
+	deepStrictEqual(proofs[0].verificationMethodId, new URL("https://server.example/users/alice#ed25519-key"));
+	deepStrictEqual(proofs[0].proofPurpose, "assertionMethod");
+	deepStrictEqual(proofs[0].proofValue, decodeMultibase("z3sXaxjKs4M3BRicwWA9peyNPJvJqxtGsDmpt1jjoHCjgeUf71TRFz56osPSfDErszyLp5Ks1EhYSgpDaNM977Rg2"));
+	deepStrictEqual(proofs[0].created, Temporal.Instant.from("2023-02-24T23:36:38Z"));
+});
+test({
+	name: "Activity.getObject()",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const activity = new Activity({ object: new URL("https://example.com/announce") });
+		const announce = await activity.getObject({
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertInstanceOf(announce, Announce);
+		deepStrictEqual(announce.id, new URL("https://example.com/announce"));
+		const object = await announce.getObject();
+		assertInstanceOf(object, Object$1);
+		deepStrictEqual(object.id, new URL("https://example.com/object"));
+		deepStrictEqual(object.name, "Fetched object");
+		const jsonLd = await activity.toJsonLd();
+		deepStrictEqual(jsonLd, {
+			"@context": [
+				"https://w3id.org/identity/v1",
+				"https://www.w3.org/ns/activitystreams",
+				"https://w3id.org/security/v1",
+				"https://w3id.org/security/data-integrity/v1"
+			],
+			type: "Activity",
+			object: {
+				id: "https://example.com/announce",
+				type: "Announce",
+				object: {
+					type: "Object",
+					id: "https://example.com/object",
+					name: "Fetched object"
+				}
+			}
+		});
+		const activity2 = new Activity({ object: new URL("https://example.com/not-found") });
+		deepStrictEqual(await activity2.getObject({ suppressError: true }), null);
+		const activity3 = await Activity.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			object: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Note",
+				content: "Hello world"
+			}
+		});
+		const object3 = await activity3.getObject();
+		assertInstanceOf(object3, Note);
+		deepStrictEqual(await object3.toJsonLd(), {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Note",
+			content: "Hello world"
+		});
+	}
+});
+test({
+	name: "Activity.getObjects()",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const activity = new Activity({ objects: [new URL("https://example.com/object"), new Object$1({ name: "Second object" })] });
+		const objects = await Array.fromAsync(activity.getObjects({
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		}));
+		deepStrictEqual(objects.length, 2);
+		assertInstanceOf(objects[0], Object$1);
+		deepStrictEqual(objects[0].id, new URL("https://example.com/object"));
+		deepStrictEqual(objects[0].name, "Fetched object");
+		assertInstanceOf(objects[1], Object$1);
+		deepStrictEqual(objects[1].name, "Second object");
+		const activity2 = new Activity({ objects: [new URL("https://example.com/not-found"), new Object$1({ name: "Second object" })] });
+		const objects2 = await Array.fromAsync(activity2.getObjects({ suppressError: true }));
+		deepStrictEqual(objects2.length, 1);
+		assertInstanceOf(objects2[0], Object$1);
+		deepStrictEqual(objects2[0].name, "Second object");
+	}
+});
+test("Activity.clone()", async () => {
+	const activity = new Activity({
+		actor: new Person({ name: "John Doe" }),
+		object: new Object$1({ name: "Test" }),
+		name: "Test",
+		summary: "Test"
+	});
+	const clone = activity.clone({
+		object: new Object$1({ name: "Modified" }),
+		summary: "Modified"
+	});
+	deepStrictEqual((await activity.getActor())?.name, "John Doe");
+	deepStrictEqual((await clone.getActor())?.name, "John Doe");
+	deepStrictEqual((await activity.getObject())?.name, "Test");
+	deepStrictEqual((await clone.getObject())?.name, "Modified");
+	deepStrictEqual(activity.name, "Test");
+	deepStrictEqual(clone.name, "Test");
+	deepStrictEqual(activity.summary, "Test");
+	deepStrictEqual(clone.summary, "Modified");
+	throws(() => activity.clone({
+		summary: "singular",
+		summaries: ["plural"]
+	}), TypeError);
+});
+test("Question.voters", async () => {
+	const question = new Question({ voters: 123 });
+	const json = await question.toJsonLd({ format: "compact" });
+	ok(typeof json === "object" && json != null);
+	ok("votersCount" in json);
+	deepStrictEqual(json["votersCount"], 123);
+});
+test({
+	name: "Deno.inspect(Object)",
+	ignore: !("Deno" in globalThis),
+	fn() {
+		const obj = new Object$1({
+			id: new URL("https://example.com/"),
+			attribution: new URL("https://example.com/foo"),
+			name: "Test",
+			contents: [new LanguageString("Hello", "en"), new LanguageString("你好", "zh")]
+		});
+		deepStrictEqual(Deno.inspect(obj, {
+			colors: false,
+			sorted: true,
+			compact: false
+		}), "Deno" in globalThis ? "Object {\n  attribution: URL \"https://example.com/foo\",\n  contents: [\n    <en> \"Hello\",\n    <zh> \"你好\"\n  ],\n  id: URL \"https://example.com/\",\n  name: \"Test\"\n}" : "Object {\n  attribution: URL 'https://example.com/foo',\n  contents: [\n    <en> 'Hello',\n    <zh> '你好'\n  ],\n  id: URL 'https://example.com/',\n  name: 'Test'\n}");
+	}
+});
+test("Person.fromJsonLd()", async () => {
+	const person = await Person.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+		"id": "https://todon.eu/users/hongminhee",
+		"publicKey": {
+			"id": "https://todon.eu/users/hongminhee#main-key",
+			"owner": "https://todon.eu/users/hongminhee",
+			"publicKeyPem": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxsRuvCkgJtflBTl4OVsm\nnt/J1mQfZasfJtN33dcZ3d1lJroxmgmMu69zjGEAwkNbMQaWNLqC4eogkJaeJ4RR\n5MHYXkL9nNilVoTkjX5BVit3puzs7XJ7WQnKQgQMI+ezn24GHsZ/v1JIo77lerX5\nk4HNwTNVt+yaZVQWaOMR3+6FwziQR6kd0VuG9/a9dgAnz2cEoORRC1i4W7IZaB1s\nZnh1WbHbevlGd72HSXll5rocPIHn8gq6xpBgpHwRphlRsgn4KHaJ6brXDIJjrnQh\nIe/YUBOGj/ImSEXhRwlFerKsoAVnZ0Hwbfa46qk44TAt8CyoPMWmpK6pt0ng4pQ2\nuwIDAQAB\n-----END PUBLIC KEY-----\n"
+		}
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader,
+		baseUrl: new URL("https://todon.eu/")
+	});
+	deepStrictEqual(person.publicKeyId, new URL("https://todon.eu/users/hongminhee#main-key"));
+	const publicKey = await person.getPublicKey({ documentLoader: mockDocumentLoader });
+	assertInstanceOf(publicKey, CryptographicKey);
+	deepStrictEqual(publicKey?.ownerId, new URL("https://todon.eu/users/hongminhee"));
+	const person2 = await Person.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", { alsoKnownAs: {
+			"@id": "as:alsoKnownAs",
+			"@type": "@id"
+		} }],
+		"type": "Person",
+		"alsoKnownAs": "at://did:plc:x7xdowahlhm5xulzqw4ehv6q"
+	});
+	deepStrictEqual(person2.aliasId, new URL("at://did%3Aplc%3Ax7xdowahlhm5xulzqw4ehv6q"));
+});
+test("Person.toJsonLd()", async () => {
+	const person = new Person({ aliases: [new URL("https://example.com/alias")] });
+	deepStrictEqual(await person.toJsonLd(), {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/v1",
+			"https://w3id.org/security/data-integrity/v1",
+			"https://www.w3.org/ns/did/v1",
+			"https://w3id.org/security/multikey/v1",
+			{
+				PropertyValue: "schema:PropertyValue",
+				alsoKnownAs: {
+					"@id": "as:alsoKnownAs",
+					"@type": "@id"
+				},
+				movedTo: {
+					"@id": "as:movedTo",
+					"@type": "@id"
+				},
+				discoverable: "toot:discoverable",
+				featured: {
+					"@id": "toot:featured",
+					"@type": "@id"
+				},
+				featuredTags: {
+					"@id": "toot:featuredTags",
+					"@type": "@id"
+				},
+				indexable: "toot:indexable",
+				_misskey_followedMessage: "misskey:_misskey_followedMessage",
+				isCat: "misskey:isCat",
+				manuallyApprovesFollowers: "as:manuallyApprovesFollowers",
+				memorial: "toot:memorial",
+				misskey: "https://misskey-hub.net/ns#",
+				schema: "http://schema.org#",
+				suspended: "toot:suspended",
+				toot: "http://joinmastodon.org/ns#",
+				value: "schema:value",
+				Emoji: "toot:Emoji"
+			}
+		],
+		alsoKnownAs: "https://example.com/alias",
+		type: "Person"
+	});
+});
+test("Collection.fromJsonLd()", async () => {
+	const collection = await Collection.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/fep/5711"],
+		"type": "Collection",
+		"id": "https://example.com/collection/jzc50wc28l",
+		"inboxOf": "https://example.com/person/bup9a8eqm"
+	});
+	deepStrictEqual(collection.id, new URL("https://example.com/collection/jzc50wc28l"));
+	deepStrictEqual(collection.inboxOfId, new URL("https://example.com/person/bup9a8eqm"));
+});
+test("Note.quoteUrl", async () => {
+	const note = new Note({ quoteUrl: new URL("https://example.com/object") });
+	const expected = {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{
+				Emoji: "toot:Emoji",
+				Hashtag: "as:Hashtag",
+				_misskey_quote: "misskey:_misskey_quote",
+				fedibird: "http://fedibird.com/ns#",
+				misskey: "https://misskey-hub.net/ns#",
+				quoteUri: "fedibird:quoteUri",
+				quoteUrl: "as:quoteUrl",
+				sensitive: "as:sensitive",
+				toot: "http://joinmastodon.org/ns#",
+				emojiReactions: {
+					"@id": "fedibird:emojiReactions",
+					"@type": "@id"
+				}
+			}
+		],
+		_misskey_quote: "https://example.com/object",
+		quoteUri: "https://example.com/object",
+		quoteUrl: "https://example.com/object",
+		type: "Note"
+	};
+	deepStrictEqual(await note.toJsonLd(), expected);
+	deepStrictEqual(await note.toJsonLd({ format: "compact" }), expected);
+	const jsonLd = {
+		"@context": ["https://www.w3.org/ns/activitystreams", {
+			_misskey_quote: "misskey:_misskey_quote",
+			fedibird: "http://fedibird.com/ns#",
+			misskey: "https://misskey-hub.net/ns#",
+			quoteUri: "fedibird:quoteUri",
+			quoteUrl: "as:quoteUrl"
+		}],
+		type: "Note",
+		quoteUrl: "https://example.com/object",
+		_misskey_quote: "https://example.com/object2",
+		quoteUri: "https://example.com/object3"
+	};
+	const loaded = await Note.fromJsonLd(jsonLd);
+	deepStrictEqual(loaded.quoteUrl, new URL("https://example.com/object"));
+	delete jsonLd.quoteUrl;
+	const loaded2 = await Note.fromJsonLd(jsonLd);
+	deepStrictEqual(loaded2.quoteUrl, new URL("https://example.com/object2"));
+	delete jsonLd._misskey_quote;
+	const loaded3 = await Note.fromJsonLd(jsonLd);
+	deepStrictEqual(loaded3.quoteUrl, new URL("https://example.com/object3"));
+});
+test("Key.publicKey", async () => {
+	const jwk = {
+		kty: "RSA",
+		alg: "RS256",
+		n: "xsRuvCkgJtflBTl4OVsmnt_J1mQfZasfJtN33dcZ3d1lJroxmgmMu69zjGEAwkNbMQaWNLqC4eogkJaeJ4RR5MHYXkL9nNilVoTkjX5BVit3puzs7XJ7WQnKQgQMI-ezn24GHsZ_v1JIo77lerX5k4HNwTNVt-yaZVQWaOMR3-6FwziQR6kd0VuG9_a9dgAnz2cEoORRC1i4W7IZaB1sZnh1WbHbevlGd72HSXll5rocPIHn8gq6xpBgpHwRphlRsgn4KHaJ6brXDIJjrnQhIe_YUBOGj_ImSEXhRwlFerKsoAVnZ0Hwbfa46qk44TAt8CyoPMWmpK6pt0ng4pQ2uw",
+		e: "AQAB",
+		key_ops: ["verify"],
+		ext: true
+	};
+	const key = new CryptographicKey({ publicKey: await crypto.subtle.importKey("jwk", jwk, {
+		name: "RSASSA-PKCS1-v1_5",
+		hash: "SHA-256"
+	}, true, ["verify"]) });
+	const jsonLd = await key.toJsonLd({ contextLoader: mockDocumentLoader });
+	deepStrictEqual(jsonLd, {
+		"@context": "https://w3id.org/security/v1",
+		publicKeyPem: "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxsRuvCkgJtflBTl4OVsm\nnt/J1mQfZasfJtN33dcZ3d1lJroxmgmMu69zjGEAwkNbMQaWNLqC4eogkJaeJ4RR\n5MHYXkL9nNilVoTkjX5BVit3puzs7XJ7WQnKQgQMI+ezn24GHsZ/v1JIo77lerX5\nk4HNwTNVt+yaZVQWaOMR3+6FwziQR6kd0VuG9/a9dgAnz2cEoORRC1i4W7IZaB1s\nZnh1WbHbevlGd72HSXll5rocPIHn8gq6xpBgpHwRphlRsgn4KHaJ6brXDIJjrnQh\nIe/YUBOGj/ImSEXhRwlFerKsoAVnZ0Hwbfa46qk44TAt8CyoPMWmpK6pt0ng4pQ2\nuwIDAQAB\n-----END PUBLIC KEY-----\n",
+		type: "CryptographicKey"
+	});
+	const loadedKey = await CryptographicKey.fromJsonLd(jsonLd, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	notDeepStrictEqual(loadedKey.publicKey, null);
+	deepStrictEqual(await crypto.subtle.exportKey("jwk", loadedKey.publicKey), jwk);
+});
+test("Place.fromJsonLd()", async () => {
+	const place = await Place.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Place",
+		name: "Fresno Area",
+		latitude: 36.75,
+		longitude: 119.7667,
+		radius: 15,
+		units: "miles"
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	assertInstanceOf(place, Place);
+	deepStrictEqual(place.name, "Fresno Area");
+	deepStrictEqual(place.latitude, 36.75);
+	deepStrictEqual(place.longitude, 119.7667);
+	deepStrictEqual(place.radius, 15);
+	deepStrictEqual(place.units, "miles");
+	let jsonLd = await place.toJsonLd({ contextLoader: mockDocumentLoader });
+	deepStrictEqual(jsonLd, {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Place",
+		name: "Fresno Area",
+		latitude: 36.75,
+		longitude: 119.7667,
+		radius: 15,
+		units: "miles"
+	});
+	jsonLd = await place.toJsonLd({
+		format: "compact",
+		contextLoader: mockDocumentLoader
+	});
+	deepStrictEqual(jsonLd, {
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		type: "Place",
+		name: "Fresno Area",
+		latitude: 36.75,
+		longitude: 119.7667,
+		radius: 15,
+		units: "miles"
+	});
+});
+test("Actor.getOutbox()", async () => {
+	const person = new Person({ outbox: new URL("https://example.com/orderedcollectionpage") });
+	const outbox = await person.getOutbox({ documentLoader: mockDocumentLoader });
+	assertInstanceOf(outbox, OrderedCollectionPage);
+	deepStrictEqual(outbox.totalItems, 1);
+});
+test("Link.fromJsonLd()", async () => {
+	const link = await Link.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Link",
+		"rel": "canonical",
+		"href": "at://did:plc:ia76kvnndjutgedggx2ibrem/app.bsky.feed.post/3lyxjjs27jkqg"
+	});
+	deepStrictEqual(link.rel, "canonical");
+	deepStrictEqual(link.href, new URL("at://did%3Aplc%3Aia76kvnndjutgedggx2ibrem/app.bsky.feed.post/3lyxjjs27jkqg"));
+	const link2 = await Link.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Link",
+		"href": "at://bnewbold.bsky.team/app.bsky.feed.post/3jwdwj2ctlk26"
+	});
+	deepStrictEqual(link2.href, new URL("at://bnewbold.bsky.team/app.bsky.feed.post/3jwdwj2ctlk26"));
+	const link3 = await Link.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"type": "Link",
+		"href": "at://did:plc:ia76kvnndjutgedggx2ibrem"
+	});
+	deepStrictEqual(link3.href, new URL("at://did%3Aplc%3Aia76kvnndjutgedggx2ibrem"));
+});
+test("Person.fromJsonLd() with relative URLs", async () => {
+	const json = {
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+		id: "https://example.com/ap/actors/019382d3-63d7-7cf7-86e8-91e2551c306c",
+		type: "Person",
+		name: "Test User",
+		icon: {
+			type: "Image",
+			url: "/avatars/test-avatar.jpg"
+		}
+	};
+	const person = await Person.fromJsonLd(json, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	const icon = await person.getIcon();
+	deepStrictEqual(icon?.url, new URL("https://example.com/avatars/test-avatar.jpg"));
+	const json2 = {
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+		id: "https://example.com/ap/actors/019382d3-63d7-7cf7-86e8-91e2551c306c",
+		type: "Person",
+		name: "Test User",
+		icon: {
+			id: "https://media.example.com/avatars/test-avatar.jpg",
+			type: "Image",
+			url: "/avatars/test-avatar.jpg"
+		}
+	};
+	const person2 = await Person.fromJsonLd(json2, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	const icon2 = await person2.getIcon();
+	deepStrictEqual(icon2?.url, new URL("https://media.example.com/avatars/test-avatar.jpg"));
+});
+test("Person.fromJsonLd() with relative URLs and baseUrl", async () => {
+	const json = {
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
+		"id": "https://example.com/ap/actors/019382d3-63d7-7cf7-86e8-91e2551c306c",
+		"type": "Person",
+		"name": "Test User",
+		"icon": {
+			"type": "Image",
+			"url": "/avatars/test-avatar.jpg"
+		}
+	};
+	const personWithBase = await Person.fromJsonLd(json, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader,
+		baseUrl: new URL("https://example.com")
+	});
+	const icon = await personWithBase.getIcon();
+	deepStrictEqual(icon?.url, new URL("https://example.com/avatars/test-avatar.jpg"));
+});
+test("FEP-fe34: Trust tracking in object construction", async () => {
+	const note = new Note({
+		id: new URL("https://example.com/note"),
+		content: "Hello World"
+	});
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: note
+	});
+	deepStrictEqual(create.objectId, new URL("https://example.com/note"));
+	const result = await create.getObject();
+	deepStrictEqual(result, note);
+	deepStrictEqual(result?.content, "Hello World");
+});
+test("FEP-fe34: Trust tracking in object cloning", () => {
+	const originalNote = new Note({
+		id: new URL("https://example.com/note"),
+		content: "Original content"
+	});
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: originalNote
+	});
+	const newNote = new Note({
+		id: new URL("https://example.com/new-note"),
+		content: "New content"
+	});
+	const clonedCreate = create.clone({ object: newNote });
+	deepStrictEqual(clonedCreate.objectId, new URL("https://example.com/new-note"));
+});
+test("FEP-fe34: crossOrigin ignore behavior (default)", async () => {
+	const crossOriginDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://malicious.com/fake-note",
+				"content": "This is a spoofed note"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: new URL("https://different-origin.com/note")
+	});
+	const result = await create.getObject({ documentLoader: crossOriginDocumentLoader });
+	deepStrictEqual(result, null);
+});
+test("FEP-fe34: crossOrigin throw behavior", async () => {
+	const crossOriginDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://malicious.com/fake-note",
+				"content": "This is a spoofed note"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: new URL("https://different-origin.com/note")
+	});
+	await rejects(() => create.getObject({
+		documentLoader: crossOriginDocumentLoader,
+		crossOrigin: "throw"
+	}), Error);
+});
+test("FEP-fe34: crossOrigin trust behavior", async () => {
+	const crossOriginDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://malicious.com/fake-note",
+				"content": "This is a spoofed note"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: new URL("https://different-origin.com/note")
+	});
+	const result = await create.getObject({
+		documentLoader: crossOriginDocumentLoader,
+		crossOrigin: "trust"
+	});
+	assertInstanceOf(result, Note);
+	deepStrictEqual(result?.id, new URL("https://malicious.com/fake-note"));
+	deepStrictEqual(result?.content, "This is a spoofed note");
+});
+test("FEP-fe34: Same origin objects are trusted", async () => {
+	const sameOriginDocumentLoader = async (url) => {
+		if (url === "https://example.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://example.com/note",
+				"content": "This is a legitimate note"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const create = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: new URL("https://example.com/note")
+	});
+	const result = await create.getObject({ documentLoader: sameOriginDocumentLoader });
+	assertInstanceOf(result, Note);
+	deepStrictEqual(result?.id, new URL("https://example.com/note"));
+	deepStrictEqual(result?.content, "This is a legitimate note");
+});
+test("FEP-fe34: Embedded cross-origin objects from JSON-LD are ignored by default", async () => {
+	const createDocumentLoader = async (url) => {
+		if (url === "https://example.com/create") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Create",
+				"@id": "https://example.com/create",
+				"actor": "https://example.com/actor",
+				"object": {
+					"@type": "Note",
+					"@id": "https://different-origin.com/note",
+					"content": "Embedded note from JSON-LD"
+				}
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const create = await Create.fromJsonLd(await createDocumentLoader("https://example.com/create").then((r) => r.document), { documentLoader: createDocumentLoader });
+	const objectDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://different-origin.com/note",
+				"content": "Legitimate note from origin"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const result = await create.getObject({ documentLoader: objectDocumentLoader });
+	assertInstanceOf(result, Note);
+	deepStrictEqual(result?.content, "Legitimate note from origin");
+});
+test("FEP-fe34: Constructor vs JSON-LD parsing trust difference", async () => {
+	const constructorCreate = new Create({
+		id: new URL("https://example.com/create"),
+		actor: new URL("https://example.com/actor"),
+		object: new Note({
+			id: new URL("https://different-origin.com/note"),
+			content: "Constructor embedded note"
+		})
+	});
+	const constructorResult = await constructorCreate.getObject();
+	deepStrictEqual(constructorResult?.content, "Constructor embedded note");
+	const jsonLdCreate = await Create.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		"@type": "Create",
+		"@id": "https://example.com/create",
+		"actor": "https://example.com/actor",
+		"object": {
+			"@type": "Note",
+			"@id": "https://different-origin.com/note",
+			"content": "JSON-LD embedded note"
+		}
+	});
+	const documentLoader = async (url) => {
+		if (url === "https://different-origin.com/note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://different-origin.com/note",
+				"content": "Fetched from origin"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const jsonLdResult = await jsonLdCreate.getObject({ documentLoader });
+	deepStrictEqual(jsonLdResult?.content, "Fetched from origin");
+});
+test("FEP-fe34: Array properties respect cross-origin policy", async () => {
+	const crossOriginDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note1") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://malicious.com/fake-note1",
+				"content": "Fake note 1"
+			}
+		};
+		else if (url === "https://example.com/note2") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://example.com/note2",
+				"content": "Legitimate note 2"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const collection = new Collection({
+		id: new URL("https://example.com/collection"),
+		items: [new URL("https://different-origin.com/note1"), new URL("https://example.com/note2")]
+	});
+	const items = [];
+	for await (const item of collection.getItems({ documentLoader: crossOriginDocumentLoader })) items.push(item);
+	deepStrictEqual(items.length, 1);
+	assertInstanceOf(items[0], Note);
+	deepStrictEqual(items[0].content, "Legitimate note 2");
+});
+test("FEP-fe34: Array properties with crossOrigin trust option", async () => {
+	const crossOriginDocumentLoader = async (url) => {
+		if (url === "https://different-origin.com/note1") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://malicious.com/fake-note1",
+				"content": "Fake note 1"
+			}
+		};
+		else if (url === "https://example.com/note2") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://example.com/note2",
+				"content": "Legitimate note 2"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const collection = new Collection({
+		id: new URL("https://example.com/collection"),
+		items: [new URL("https://different-origin.com/note1"), new URL("https://example.com/note2")]
+	});
+	const items = [];
+	for await (const item of collection.getItems({
+		documentLoader: crossOriginDocumentLoader,
+		crossOrigin: "trust"
+	})) items.push(item);
+	deepStrictEqual(items.length, 2);
+	assertInstanceOf(items[0], Note);
+	assertInstanceOf(items[1], Note);
+	deepStrictEqual(items[0].content, "Fake note 1");
+	deepStrictEqual(items[1].content, "Legitimate note 2");
+});
+test("FEP-fe34: Embedded objects in arrays from JSON-LD respect cross-origin policy", async () => {
+	const collectionDocumentLoader = async (url) => {
+		if (url === "https://example.com/collection") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Collection",
+				"@id": "https://example.com/collection",
+				"items": [{
+					"@type": "Note",
+					"@id": "https://example.com/trusted-note",
+					"content": "Trusted embedded note from JSON-LD"
+				}, {
+					"@type": "Note",
+					"@id": "https://different-origin.com/untrusted-note",
+					"content": "Untrusted embedded note from JSON-LD"
+				}]
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const collection = await Collection.fromJsonLd(await collectionDocumentLoader("https://example.com/collection").then((r) => r.document), { documentLoader: collectionDocumentLoader });
+	const itemDocumentLoader = async (url) => {
+		if (url === "https://example.com/trusted-note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://example.com/trusted-note",
+				"content": "Trusted note from origin"
+			}
+		};
+		else if (url === "https://different-origin.com/untrusted-note") return {
+			documentUrl: url,
+			contextUrl: null,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				"@type": "Note",
+				"@id": "https://different-origin.com/untrusted-note",
+				"content": "Legitimate note from actual origin"
+			}
+		};
+		throw new Error("Document not found");
+	};
+	const items = [];
+	for await (const item of collection.getItems({ documentLoader: itemDocumentLoader })) items.push(item);
+	deepStrictEqual(items.length, 2);
+	assertInstanceOf(items[0], Note);
+	deepStrictEqual(items[0].content, "Trusted embedded note from JSON-LD");
+	assertInstanceOf(items[1], Note);
+	deepStrictEqual(items[1].content, "Legitimate note from actual origin");
+});
+function getAllProperties(type, types$1) {
+	const props = type.properties;
+	if (type.extends != null) props.push(...getAllProperties(types$1[type.extends], types$1));
+	return props;
+}
+const ed25519PublicKey = new CryptographicKey({
+	id: new URL("https://example.com/person2#key4"),
+	owner: new URL("https://example.com/person2"),
+	publicKey: await crypto.subtle.importKey("jwk", {
+		crv: "Ed25519",
+		ext: true,
+		key_ops: ["verify"],
+		kty: "OKP",
+		x: "LR8epAGDe-cVq5p2Tx49CCfphpk1rNhkNoY9i-XEUfg"
+	}, "Ed25519", true, ["verify"])
+});
+const rsaPublicKey = new CryptographicKey({
+	id: new URL("https://example.com/key"),
+	owner: new URL("https://example.com/person"),
+	publicKey: await crypto.subtle.importKey("jwk", {
+		kty: "RSA",
+		alg: "RS256",
+		n: "yIB9rotX8G6r6_6toT-x24BUiQ_HaPH1Em9dOt4c94s-OPFoEdH7DY7Iym9A8LlH4JaGF8KD38bLHWe1S4x0jV3gHJKhK7veJfGZCKUENcQecBZ-YWUs5HWvUIX1vVB__0luHrg6BQKGOrSOE-WIAxyr0qsWCFfZzQrvSnUD2yvg1arJX2xhms14uxoRd5Kg9efKSCmmQaNEapicARUmFWrIEpGFa_nUUnqimssAGw1eZFqf3wA4TjhsuARBhGaJtv_3KEa016eMZxy3kDlOjZnXZTaTgWkXdodwUvy8563fes3Al6BlcS2iJ9qbtha8rSm0FHqoUKH73JsLPKQIwQ",
+		e: "AQAB",
+		key_ops: ["verify"],
+		ext: true
+	}, {
+		name: "RSASSA-PKCS1-v1_5",
+		hash: "SHA-256"
+	}, true, ["verify"])
+});
+const sampleValues = {
+	"http://www.w3.org/2001/XMLSchema#boolean": true,
+	"http://www.w3.org/2001/XMLSchema#integer": -123,
+	"http://www.w3.org/2001/XMLSchema#nonNegativeInteger": 123,
+	"http://www.w3.org/2001/XMLSchema#float": 12.34,
+	"http://www.w3.org/2001/XMLSchema#string": "hello",
+	"http://www.w3.org/2001/XMLSchema#anyURI": new URL("https://example.com/"),
+	"http://www.w3.org/1999/02/22-rdf-syntax-ns#langString": new LanguageString("hello", "en"),
+	"http://www.w3.org/2001/XMLSchema#dateTime": Temporal.Instant.from("2024-03-03T08:30:06.796196096Z"),
+	"http://www.w3.org/2001/XMLSchema#duration": Temporal.Duration.from({ hours: 1 }),
+	"https://w3id.org/security#cryptosuiteString": "eddsa-jcs-2022",
+	"https://w3id.org/security#multibase": new Uint8Array([
+		143,
+		155,
+		90,
+		201,
+		20,
+		23,
+		208,
+		209,
+		136,
+		190,
+		250,
+		133,
+		143,
+		116,
+		68,
+		152,
+		29,
+		200,
+		121,
+		218,
+		186,
+		80,
+		152,
+		60,
+		67,
+		235,
+		207,
+		114,
+		95,
+		56,
+		88,
+		17,
+		159,
+		35,
+		197,
+		191,
+		132,
+		35,
+		118,
+		162,
+		29,
+		83,
+		192,
+		190,
+		26,
+		170,
+		150,
+		110,
+		48,
+		101,
+		89,
+		118,
+		240,
+		176,
+		219,
+		120,
+		13,
+		245,
+		193,
+		173,
+		63,
+		189,
+		243,
+		7
+	]),
+	"fedify:langTag": new Intl.Locale("en-Latn-US"),
+	"fedify:url": new URL("https://fedify.dev/"),
+	"fedify:publicKey": rsaPublicKey.publicKey,
+	"fedify:multibaseKey": ed25519PublicKey.publicKey,
+	"fedify:proofPurpose": "assertionMethod",
+	"fedify:units": "m"
+};
+const types = navigator?.userAgent === "Cloudflare-Workers" ? {} : await loadSchemaFiles(import.meta.dirname);
+for (const typeUri in types) {
+	const type = types[typeUri];
+	const cls = vocab_exports[type.name];
+	sampleValues[typeUri] = new cls({
+		"@id": "https://example.com/",
+		"@type": typeUri
+	});
+}
+const { assertSnapshot } = await import("@std/testing/snapshot").catch(() => ({ assertSnapshot: () => Promise.resolve() }));
+for (const typeUri in types) {
+	const type = types[typeUri];
+	const cls = vocab_exports[type.name];
+	const allProperties = getAllProperties(type, types);
+	const initValues = globalThis.Object.fromEntries(allProperties.map((property) => !property.functional ? [property.pluralName, property.range.map((t) => sampleValues[t])] : [property.singularName, sampleValues[property.range[0]]]));
+	test(`new ${type.name}() [auto]`, async () => {
+		const instance = new cls(initValues);
+		for (const property of allProperties) {
+			if (areAllScalarTypes(property.range, types)) {
+				if (property.functional || property.singularAccessor) deepStrictEqual(instance[property.singularName], sampleValues[property.range[0]]);
+				if (!property.functional) deepStrictEqual(instance[property.pluralName], property.range.map((t) => sampleValues[t]));
+			} else {
+				if (property.functional || property.singularAccessor) {
+					deepStrictEqual(await instance[`get${pascalCase(property.singularName)}`].call(instance, { documentLoader: mockDocumentLoader }), sampleValues[property.range[0]]);
+					deepStrictEqual(instance[`${property.singularName}Id`], sampleValues[property.range[0]].id);
+				}
+				if (!property.functional) {
+					deepStrictEqual(await Array.fromAsync(instance[`get${pascalCase(property.pluralName)}`].call(instance, { documentLoader: mockDocumentLoader })), property.range.map((t) => sampleValues[t]));
+					deepStrictEqual(instance[`${property.singularName}Ids`], property.range.map((t) => sampleValues[t].id).filter((i) => i != null));
+				}
+			}
+			const empty = new cls({});
+			for (const property$1 of allProperties) if (areAllScalarTypes(property$1.range, types)) {
+				if (property$1.functional || property$1.singularAccessor) deepStrictEqual(empty[property$1.singularName], null);
+				if (!property$1.functional) deepStrictEqual(empty[property$1.pluralName], []);
+			} else {
+				if (property$1.functional || property$1.singularAccessor) {
+					deepStrictEqual(await empty[`get${pascalCase(property$1.singularName)}`].call(empty, { documentLoader: mockDocumentLoader }), null);
+					deepStrictEqual(empty[`${property$1.singularName}Id`], null);
+				}
+				if (!property$1.functional) {
+					deepStrictEqual(await Array.fromAsync(empty[`get${pascalCase(property$1.pluralName)}`].call(empty, { documentLoader: mockDocumentLoader })), []);
+					deepStrictEqual(empty[`${property$1.singularName}Ids`], []);
+				}
+			}
+		}
+		for (const property of allProperties) if (!property.functional && property.singularAccessor) throws(() => new cls({
+			[property.singularName]: sampleValues[property.range[0]],
+			[property.pluralName]: property.range.map((t) => sampleValues[t])
+		}), TypeError);
+		const instance2 = new cls({
+			id: new URL("https://example.com/"),
+			...globalThis.Object.fromEntries(allProperties.filter((p) => !areAllScalarTypes(p.range, types)).map((p) => p.functional ? [p.singularName, new URL("https://example.com/test")] : [p.pluralName, [new URL("https://example.com/test")]]))
+		});
+		for (const property of allProperties) {
+			if (areAllScalarTypes(property.range, types)) continue;
+			if (property.functional || property.singularAccessor) deepStrictEqual(instance2[`${property.singularName}Id`], new URL("https://example.com/test"));
+			if (!property.functional) deepStrictEqual(instance2[`${property.singularName}Ids`], [new URL("https://example.com/test")]);
+		}
+		throws(() => new cls({ id: 123 }), TypeError, "The id must be a URL.");
+		for (const property of allProperties) {
+			const wrongValues = globalThis.Object.fromEntries(globalThis.Object.entries(initValues));
+			if (property.functional) wrongValues[property.singularName] = {};
+			else wrongValues[property.pluralName] = [{}];
+			throws(() => new cls(wrongValues), TypeError);
+		}
+	});
+	test(`${type.name}.clone() [auto]`, () => {
+		const instance = new cls({});
+		for (const property of allProperties) if (!property.functional && property.singularAccessor) throws(() => instance.clone({
+			[property.singularName]: sampleValues[property.range[0]],
+			[property.pluralName]: property.range.map((t) => sampleValues[t])
+		}), TypeError);
+		throws(() => instance.clone({ id: 123 }), TypeError, "The id must be a URL.");
+		for (const property of allProperties) {
+			const wrongValues = globalThis.Object.fromEntries(globalThis.Object.entries(initValues));
+			if (property.functional) wrongValues[property.singularName] = {};
+			else wrongValues[property.pluralName] = [{}];
+			throws(() => instance.clone(wrongValues), TypeError);
+		}
+	});
+	for (const property of allProperties) {
+		if (areAllScalarTypes(property.range, types)) continue;
+		const docLoader = async (url) => {
+			if (url !== `https://example.com/test`) throw new Error("Not Found");
+			return {
+				documentUrl: url,
+				contextUrl: null,
+				document: await sampleValues[property.range[0]].toJsonLd({ contextLoader: mockDocumentLoader })
+			};
+		};
+		if (property.functional || property.singularAccessor) test(`${type.name}.get${pascalCase(property.singularName)}() [auto]`, async () => {
+			const instance = new cls({ [property.singularName]: new URL("https://example.com/test") });
+			const value = await instance[`get${pascalCase(property.singularName)}`].call(instance, { documentLoader: docLoader });
+			deepStrictEqual(value, sampleValues[property.range[0]]);
+			if (property.untyped) return;
+			const wrongRef = new cls({ [property.singularName]: new URL("https://example.com/wrong-type") });
+			await rejects(() => wrongRef[`get${pascalCase(property.singularName)}`].call(wrongRef, { documentLoader: mockDocumentLoader }), TypeError);
+		});
+		if (!property.functional) test(`${type.name}.get${pascalCase(property.pluralName)}() [auto]`, async () => {
+			const instance = new cls({ [property.pluralName]: [new URL("https://example.com/test")] });
+			const value = instance[`get${pascalCase(property.pluralName)}`].call(instance, { documentLoader: docLoader });
+			deepStrictEqual(await Array.fromAsync(value), [sampleValues[property.range[0]]]);
+			if (property.untyped) return;
+			const wrongRef = new cls({ [property.pluralName]: [new URL("https://example.com/wrong-type")] });
+			await rejects(() => Array.fromAsync(wrongRef[`get${pascalCase(property.pluralName)}`].call(wrongRef, { documentLoader: mockDocumentLoader })), TypeError);
+		});
+	}
+	test(`${type.name}.fromJsonLd() [auto]`, async () => {
+		const instance = await cls.fromJsonLd({
+			"@id": "https://example.com/",
+			"@type": typeUri
+		}, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertInstanceOf(instance, cls);
+		deepStrictEqual(instance.id, new URL("https://example.com/"));
+		deepStrictEqual(await instance.toJsonLd(), {
+			"@id": "https://example.com/",
+			"@type": typeUri
+		});
+		deepStrictEqual(await instance.toJsonLd({
+			format: "compact",
+			contextLoader: mockDocumentLoader
+		}), {
+			"@context": type.defaultContext,
+			"id": "https://example.com/",
+			"type": type.compactName ?? (type.name === "DataIntegrityProof" ? type.name : type.uri)
+		});
+		if (type.extends != null) await rejects(() => cls.fromJsonLd({
+			"@id": "https://example.com/",
+			"@type": "https://example.com/"
+		}), TypeError);
+		await rejects(() => cls.fromJsonLd(null), TypeError);
+		await rejects(() => cls.fromJsonLd(void 0), TypeError);
+	});
+	test(`${type.name}.toJsonLd() [auto]`, async () => {
+		const instance = new cls({
+			id: new URL("https://example.com/"),
+			...initValues
+		});
+		const jsonLd = await instance.toJsonLd({ contextLoader: mockDocumentLoader });
+		deepStrictEqual(jsonLd["@context"], type.defaultContext);
+		deepStrictEqual(jsonLd.id, "https://example.com/");
+		const restored = await cls.fromJsonLd(jsonLd, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		deepStrictEqual(restored, instance);
+		deepStrictEqual(await restored.toJsonLd({ contextLoader: mockDocumentLoader }), jsonLd);
+		const jsonLd2 = await instance.toJsonLd({
+			contextLoader: mockDocumentLoader,
+			format: "compact",
+			context: "https://www.w3.org/ns/activitystreams"
+		});
+		deepStrictEqual(jsonLd2["@context"], "https://www.w3.org/ns/activitystreams");
+		deepStrictEqual(jsonLd2.id, "https://example.com/");
+		const restored2 = await cls.fromJsonLd(jsonLd2, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		deepStrictEqual(restored2, instance);
+		const expanded = await instance.toJsonLd({
+			contextLoader: mockDocumentLoader,
+			format: "expand"
+		});
+		const restored3 = await cls.fromJsonLd(expanded, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		deepStrictEqual(restored3, instance);
+		const instance2 = new cls({
+			id: new URL("https://example.com/"),
+			...initValues,
+			...globalThis.Object.fromEntries(allProperties.filter((p) => !areAllScalarTypes(p.range, types)).map((p) => p.functional ? [p.singularName, new URL("https://example.com/test")] : [p.pluralName, [new URL("https://example.com/test")]]))
+		});
+		const jsonLd3 = await instance2.toJsonLd({ contextLoader: mockDocumentLoader });
+		const restored4 = await cls.fromJsonLd(jsonLd3, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		deepStrictEqual(restored4, instance2);
+		rejects(() => instance.toJsonLd({ context: "https://www.w3.org/ns/activitystreams" }), TypeError);
+		rejects(() => instance.toJsonLd({
+			format: "expand",
+			context: "https://www.w3.org/ns/activitystreams"
+		}), TypeError);
+	});
+	if ("Deno" in globalThis) Deno.test(`Deno.inspect(${type.name}) [auto]`, async (t) => {
+		const empty = new cls({});
+		deepStrictEqual(Deno.inspect(empty), `${type.name} {}`);
+		const instance = new cls({
+			id: new URL("https://example.com/"),
+			...initValues
+		});
+		await assertSnapshot(t, Deno.inspect(instance));
+		const instance2 = instance.clone(globalThis.Object.fromEntries(type.properties.filter((p) => !areAllScalarTypes(p.range, types)).map((p) => p.functional ? [p.singularName, new URL("https://example.com/")] : [p.pluralName, [new URL("https://example.com/")]])));
+		await assertSnapshot(t, Deno.inspect(instance2));
+		const instance3 = instance.clone(globalThis.Object.fromEntries(type.properties.filter((p) => !p.functional).map((p) => {
+			ok(!p.functional);
+			return [p.pluralName, [sampleValues[p.range[0]], sampleValues[p.range[0]]]];
+		})));
+		await assertSnapshot(t, Deno.inspect(instance3));
+	});
+	test(`${type.name}.typeId`, () => {
+		deepStrictEqual(cls.typeId, new URL(type.uri));
+	});
+}
+
+//#endregion