@fedify/fedify 1.6.0-dev.813 → 1.6.0-experiment.0

package/dist/runtime/docloader.test.js

@@ -0,0 +1,428 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { deno_default } from "../deno.js";
+import { contexts_default } from "./contexts.js";
+import { UrlError } from "./url.js";
+import { FetchError, getDocumentLoader, getUserAgent, kvCache } from "./docloader.js";
+import { MemoryKvStore } from "../federation/kv.js";
+import { assertEquals } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_equals.js";
+import { test } from "../testing/mod.js";
+import { assertRejects } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_rejects.js";
+import { assertThrows } from "../node_modules/.pnpm/@jsr_std__assert@0.226.0/node_modules/@jsr/std__assert/assert_throws.js";
+import { mockDocumentLoader } from "../testing/docloader.js";
+import { install, mock, uninstall } from "../node_modules/.pnpm/@jsr_hongminhee__deno-mock-fetch@0.3.2/node_modules/@jsr/hongminhee__deno-mock-fetch/mod.js";
+import process from "node:process";
+
+//#region runtime/docloader.test.ts
+test("new FetchError()", () => {
+	const e = new FetchError("https://example.com/", "An error message.");
+	assertEquals(e.name, "FetchError");
+	assertEquals(e.url, new URL("https://example.com/"));
+	assertEquals(e.message, "https://example.com/: An error message.");
+	const e2 = new FetchError(new URL("https://example.org/"));
+	assertEquals(e2.url, new URL("https://example.org/"));
+	assertEquals(e2.message, "https://example.org/");
+});
+test("getDocumentLoader()", async (t) => {
+	const fetchDocumentLoader = getDocumentLoader();
+	install();
+	mock("GET@/object", (_req) => new Response(JSON.stringify({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/object",
+		name: "Fetched object",
+		type: "Object"
+	}), { status: 200 }));
+	await t.step("ok", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/object"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	mock("GET@/link-ctx", (_req) => new Response(JSON.stringify({
+		id: "https://example.com/link-ctx",
+		name: "Fetched object",
+		type: "Object"
+	}), {
+		status: 200,
+		headers: {
+			"Content-Type": "application/activity+json",
+			Link: "<https://www.w3.org/ns/activitystreams>; rel=\"http://www.w3.org/ns/json-ld#context\"; type=\"application/ld+json\""
+		}
+	}));
+	mock("GET@/link-obj", (_req) => new Response("", {
+		status: 200,
+		headers: {
+			"Content-Type": "text/html; charset=utf-8",
+			Link: "<https://example.com/object>; rel=\"alternate\"; type=\"application/activity+json\""
+		}
+	}));
+	mock("GET@/link-obj-relative", (_req) => new Response("", {
+		status: 200,
+		headers: {
+			"Content-Type": "text/html; charset=utf-8",
+			Link: "</object>; rel=\"alternate\"; type=\"application/activity+json\""
+		}
+	}));
+	mock("GET@/obj-w-wrong-link", (_req) => new Response(JSON.stringify({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/obj-w-wrong-link",
+		name: "Fetched object",
+		type: "Object"
+	}), {
+		status: 200,
+		headers: {
+			"Content-Type": "text/html; charset=utf-8",
+			Link: "<https://example.com/object>; rel=\"alternate\"; type=\"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"\""
+		}
+	}));
+	await t.step("Link header", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/link-ctx"), {
+			contextUrl: "https://www.w3.org/ns/activitystreams",
+			documentUrl: "https://example.com/link-ctx",
+			document: {
+				id: "https://example.com/link-ctx",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+		assertEquals(await fetchDocumentLoader("https://example.com/link-obj"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	await t.step("Link header relative url", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/link-ctx"), {
+			contextUrl: "https://www.w3.org/ns/activitystreams",
+			documentUrl: "https://example.com/link-ctx",
+			document: {
+				id: "https://example.com/link-ctx",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+		assertEquals(await fetchDocumentLoader("https://example.com/link-obj-relative"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	await t.step("wrong Link header syntax", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/obj-w-wrong-link"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/obj-w-wrong-link",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/obj-w-wrong-link",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	mock("GET@/html-link", (_req) => new Response(`<html>
+        <head>
+          <meta charset=utf-8>
+          <link
+            rel=alternate
+            type='application/activity+json'
+            href="https://example.com/object">
+        </head>
+      </html>`, {
+		status: 200,
+		headers: { "Content-Type": "text/html; charset=utf-8" }
+	}));
+	await t.step("HTML <link>", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/html-link"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	mock("GET@/html-a", (_req) => new Response(`<html>
+        <head>
+          <meta charset=utf-8>
+        </head>
+        <body>
+          <a
+            rel=alternate
+            type=application/activity+json
+            href=https://example.com/object>test</a>
+        </body>
+      </html>`, {
+		status: 200,
+		headers: { "Content-Type": "text/html; charset=utf-8" }
+	}));
+	await t.step("HTML <a>", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/html-a"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	mock("GET@/wrong-content-type", (_req) => new Response(JSON.stringify({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://example.com/wrong-content-type",
+		name: "Fetched object",
+		type: "Object"
+	}), {
+		status: 200,
+		headers: { "Content-Type": "text/html; charset=utf-8" }
+	}));
+	await t.step("Wrong Content-Type", async () => {
+		assertEquals(await fetchDocumentLoader("https://example.com/wrong-content-type"), {
+			contextUrl: null,
+			documentUrl: "https://example.com/wrong-content-type",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/wrong-content-type",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+	mock("GET@/404", (_req) => new Response("", { status: 404 }));
+	await t.step("not ok", async () => {
+		await assertRejects(() => fetchDocumentLoader("https://example.com/404"), FetchError, "HTTP 404: https://example.com/404");
+	});
+	await t.step("preloaded contexts", async () => {
+		for (const [url, document] of Object.entries(contexts_default)) assertEquals(await fetchDocumentLoader(url), {
+			contextUrl: null,
+			documentUrl: url,
+			document
+		});
+	});
+	await t.step("deny non-HTTP/HTTPS", async () => {
+		await assertRejects(() => fetchDocumentLoader("ftp://localhost"), UrlError);
+	});
+	mock("GET@/localhost-redirect", (_req) => Response.redirect("https://localhost/object", 302));
+	mock("GET@/localhost-link", (_req) => new Response(`<html>
+        <head>
+          <meta charset=utf-8>
+          <link
+            rel=alternate
+            type='application/activity+json'
+            href="https://localhost/object">
+        </head>
+      </html>`, {
+		status: 200,
+		headers: { "Content-Type": "text/html; charset=utf-8" }
+	}));
+	await t.step("allowPrivateAddress: false", async () => {
+		await assertRejects(() => fetchDocumentLoader("https://localhost/object"), UrlError);
+		await assertRejects(() => fetchDocumentLoader("https://example.com/localhost-redirect"), UrlError);
+		await assertRejects(() => fetchDocumentLoader("https://example.com/localhost-link"), UrlError);
+	});
+	const fetchDocumentLoader2 = getDocumentLoader({ allowPrivateAddress: true });
+	await t.step("allowPrivateAddress: true", async () => {
+		const expected = {
+			contextUrl: null,
+			documentUrl: "https://localhost/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		};
+		assertEquals(await fetchDocumentLoader2("https://localhost/object"), expected);
+		assertEquals(await fetchDocumentLoader2("https://example.com/localhost-redirect"), expected);
+		assertEquals(await fetchDocumentLoader2("https://example.com/localhost-link"), expected);
+	});
+	uninstall();
+});
+test("kvCache()", async (t) => {
+	const kv = new MemoryKvStore();
+	await t.step("cached", async () => {
+		const loader = kvCache({
+			kv,
+			loader: mockDocumentLoader,
+			rules: [
+				["https://example.org/", Temporal.Duration.from({ days: 1 })],
+				[new URL("https://example.net/"), Temporal.Duration.from({ days: 1 })],
+				[new URLPattern("https://example.com/*"), Temporal.Duration.from({ days: 30 })]
+			],
+			prefix: ["_test", "cached"]
+		});
+		const result = await loader("https://example.com/object");
+		assertEquals(result, {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+		const cache = await kv.get([
+			"_test",
+			"cached",
+			"https://example.com/object"
+		]);
+		assertEquals(cache, result);
+		await kv.set([
+			"_test",
+			"cached",
+			"https://example.org/"
+		], {
+			contextUrl: null,
+			documentUrl: "https://example.org/",
+			document: { "id": "https://example.org/" }
+		});
+		const result2 = await loader("https://example.org/");
+		assertEquals(result2, {
+			contextUrl: null,
+			documentUrl: "https://example.org/",
+			document: { "id": "https://example.org/" }
+		});
+		await kv.set([
+			"_test",
+			"cached",
+			"https://example.net/"
+		], {
+			contextUrl: null,
+			documentUrl: "https://example.net/",
+			document: { "id": "https://example.net/" }
+		});
+		const result3 = await loader("https://example.net/");
+		assertEquals(result3, {
+			contextUrl: null,
+			documentUrl: "https://example.net/",
+			document: { "id": "https://example.net/" }
+		});
+	});
+	await t.step("not cached", async () => {
+		const loader = kvCache({
+			kv,
+			loader: mockDocumentLoader,
+			rules: [],
+			prefix: ["_test", "not cached"]
+		});
+		const result = await loader("https://example.com/object");
+		assertEquals(result, {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+		const cache = await kv.get([
+			"test2",
+			"not cached",
+			"https://example.com/object"
+		]);
+		assertEquals(cache, void 0);
+	});
+	await t.step("maximum cache duration", () => {
+		assertThrows(() => kvCache({
+			kv,
+			loader: mockDocumentLoader,
+			rules: [["https://example.com/", Temporal.Duration.from({
+				days: 30,
+				seconds: 1
+			})]]
+		}), TypeError, "The maximum cache duration is 30 days");
+		assertThrows(() => kvCache({
+			kv,
+			loader: mockDocumentLoader,
+			rules: [[new URLPattern("https://example.com/*"), Temporal.Duration.from({
+				days: 30,
+				seconds: 1
+			})]]
+		}), TypeError, "The maximum cache duration is 30 days");
+	});
+	await t.step("on kv store exception", async () => {
+		class KvStoreThrowsException {
+			get(_key) {
+				throw new Error("Failed to get key");
+			}
+			set(_key, _value, _options) {
+				throw new Error("Failed to set key");
+			}
+			delete(_key) {
+				throw new Error("Failed to delete key");
+			}
+		}
+		const loader = kvCache({
+			kv: new KvStoreThrowsException(),
+			loader: mockDocumentLoader,
+			rules: [
+				["https://example.org/", Temporal.Duration.from({ days: 1 })],
+				[new URL("https://example.net/"), Temporal.Duration.from({ days: 1 })],
+				[new URLPattern("https://example.com/*"), Temporal.Duration.from({ days: 30 })]
+			],
+			prefix: ["_test", "not cached"]
+		});
+		const result = await loader("https://example.com/object");
+		assertEquals(result, {
+			contextUrl: null,
+			documentUrl: "https://example.com/object",
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: "https://example.com/object",
+				name: "Fetched object",
+				type: "Object"
+			}
+		});
+	});
+});
+test("getUserAgent()", () => {
+	if ("Deno" in globalThis) {
+		assertEquals(getUserAgent(), `Fedify/${deno_default.version} (Deno/${Deno.version.deno})`);
+		assertEquals(getUserAgent({ software: "MyApp/1.0.0" }), `MyApp/1.0.0 (Fedify/${deno_default.version}; Deno/${Deno.version.deno})`);
+		assertEquals(getUserAgent({ url: "https://example.com/" }), `Fedify/${deno_default.version} (Deno/${Deno.version.deno}; +https://example.com/)`);
+		assertEquals(getUserAgent({
+			software: "MyApp/1.0.0",
+			url: new URL("https://example.com/")
+		}), `MyApp/1.0.0 (Fedify/${deno_default.version}; Deno/${Deno.version.deno}; +https://example.com/)`);
+	} else if ("Bun" in globalThis) {
+		assertEquals(getUserAgent(), `Fedify/${deno_default.version} (Bun/${Bun.version})`);
+		assertEquals(getUserAgent({ software: "MyApp/1.0.0" }), `MyApp/1.0.0 (Fedify/${deno_default.version}; Bun/${Bun.version})`);
+		assertEquals(getUserAgent({ url: "https://example.com/" }), `Fedify/${deno_default.version} (Bun/${Bun.version}; +https://example.com/)`);
+		assertEquals(getUserAgent({
+			software: "MyApp/1.0.0",
+			url: new URL("https://example.com/")
+		}), `MyApp/1.0.0 (Fedify/${deno_default.version}; Bun/${Bun.version}; +https://example.com/)`);
+	} else {
+		assertEquals(getUserAgent(), `Fedify/${deno_default.version} (Node.js/${process.versions.node})`);
+		assertEquals(getUserAgent({ software: "MyApp/1.0.0" }), `MyApp/1.0.0 (Fedify/${deno_default.version}; Node.js/${process.versions.node})`);
+		assertEquals(getUserAgent({ url: "https://example.com/" }), `Fedify/${deno_default.version} (Node.js/${process.versions.node}; +https://example.com/)`);
+		assertEquals(getUserAgent({
+			software: "MyApp/1.0.0",
+			url: new URL("https://example.com/")
+		}), `MyApp/1.0.0 (Fedify/${deno_default.version}; Node.js/${process.versions.node}; +https://example.com/)`);
+	}
+});
+
+//#endregion

package/dist/runtime/key.d.ts

@@ -0,0 +1,66 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+
+//#region runtime/key.d.ts
+/**
+* Imports a PEM-SPKI formatted public key.
+* @param pem The PEM-SPKI formatted public key.
+* @returns The imported public key.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 0.5.0
+*/
+/**
+ * Imports a PEM-SPKI formatted public key.
+ * @param pem The PEM-SPKI formatted public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.5.0
+ */
+declare function importSpki(pem: string): Promise<CryptoKey>;
+/**
+ * Exports a public key in PEM-SPKI format.
+ * @param key The public key to export.
+ * @returns The exported public key in PEM-SPKI format.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.5.0
+ */
+declare function exportSpki(key: CryptoKey): Promise<string>;
+/**
+ * Imports a PEM-PKCS#1 formatted public key.
+ * @param pem The PEM-PKCS#1 formatted public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 1.5.0
+ */
+declare function importPkcs1(pem: string): Promise<CryptoKey>;
+/**
+ * Imports a PEM formatted public key (SPKI or PKCS#1).
+ * @param pem The PEM formatted public key to import (SPKI or PKCS#1).
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 1.5.0
+ */
+declare function importPem(pem: string): Promise<CryptoKey>;
+/**
+ * Imports a [Multibase]-encoded public key.
+ *
+ * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+ * @param key The Multibase-encoded public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.10.0
+ */
+declare function importMultibaseKey(key: string): Promise<CryptoKey>;
+/**
+ * Exports a public key in [Multibase] format.
+ *
+ * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+ * @param key The public key to export.
+ * @returns The exported public key in Multibase format.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.10.0
+ */
+declare function exportMultibaseKey(key: CryptoKey): Promise<string>;
+
+//#endregion
+export { exportMultibaseKey as exportMultibaseKey$1, exportSpki as exportSpki$1, importMultibaseKey as importMultibaseKey$1, importPem as importPem$1, importPkcs1 as importPkcs1$1, importSpki as importSpki$1 };

package/dist/runtime/key.js

@@ -0,0 +1,156 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { decode, encode } from "./multibase/index.js";
+import { Integer, Sequence } from "asn1js";
+import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
+import { decodeBase64Url } from "byte-encodings/base64url";
+import { decodeHex } from "byte-encodings/hex";
+import { addPrefix, getCodeFromData, rmPrefix } from "multicodec";
+import { createPublicKey } from "node:crypto";
+import { PublicKeyInfo } from "pkijs";
+
+//#region runtime/key.ts
+const algorithms = {
+	"1.2.840.113549.1.1.1": {
+		name: "RSASSA-PKCS1-v1_5",
+		hash: "SHA-256"
+	},
+	"1.3.101.112": "Ed25519"
+};
+/**
+* Imports a PEM-SPKI formatted public key.
+* @param pem The PEM-SPKI formatted public key.
+* @returns The imported public key.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 0.5.0
+*/
+async function importSpki(pem) {
+	pem = pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, "");
+	let spki;
+	try {
+		spki = decodeBase64(pem);
+	} catch (_) {
+		throw new TypeError("Invalid PEM-SPKI format.");
+	}
+	const pki = PublicKeyInfo.fromBER(spki);
+	const oid = pki.algorithm.algorithmId;
+	const algorithm = algorithms[oid];
+	if (algorithm == null) throw new TypeError("Unsupported algorithm: " + oid);
+	return await crypto.subtle.importKey("spki", spki, algorithm, true, ["verify"]);
+}
+/**
+* Exports a public key in PEM-SPKI format.
+* @param key The public key to export.
+* @returns The exported public key in PEM-SPKI format.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 0.5.0
+*/
+async function exportSpki(key) {
+	const { validateCryptoKey } = await import("../sig/key.js");
+	validateCryptoKey(key);
+	const spki = await crypto.subtle.exportKey("spki", key);
+	let pem = encodeBase64(spki);
+	pem = (pem.match(/.{1,64}/g) || []).join("\n");
+	return `-----BEGIN PUBLIC KEY-----\n${pem}\n-----END PUBLIC KEY-----\n`;
+}
+/**
+* Imports a PEM-PKCS#1 formatted public key.
+* @param pem The PEM-PKCS#1 formatted public key.
+* @returns The imported public key.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 1.5.0
+*/
+function importPkcs1(pem) {
+	const key = createPublicKey({
+		key: pem,
+		format: "pem",
+		type: "pkcs1"
+	});
+	const spki = key.export({
+		type: "spki",
+		format: "pem"
+	});
+	return importSpki(spki);
+}
+const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
+/**
+* Imports a PEM formatted public key (SPKI or PKCS#1).
+* @param pem The PEM formatted public key to import (SPKI or PKCS#1).
+* @returns The imported public key.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 1.5.0
+*/
+function importPem(pem) {
+	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
+}
+/**
+* Imports a [Multibase]-encoded public key.
+*
+* [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+* @param key The Multibase-encoded public key.
+* @returns The imported public key.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 0.10.0
+*/
+async function importMultibaseKey(key) {
+	const decoded = decode(key);
+	const code = getCodeFromData(decoded);
+	const content = rmPrefix(decoded);
+	if (code === 4613) {
+		const keyObject = createPublicKey({
+			key: content,
+			format: "der",
+			type: "pkcs1"
+		});
+		const spki = keyObject.export({
+			type: "spki",
+			format: "der"
+		}).buffer;
+		return await crypto.subtle.importKey("spki", new Uint8Array(spki), {
+			name: "RSASSA-PKCS1-v1_5",
+			hash: "SHA-256"
+		}, true, ["verify"]);
+	} else if (code === 237) return await crypto.subtle.importKey("raw", content, "Ed25519", true, ["verify"]);
+	else throw new TypeError("Unsupported key type: 0x" + code.toString(16));
+}
+/**
+* Exports a public key in [Multibase] format.
+*
+* [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+* @param key The public key to export.
+* @returns The exported public key in Multibase format.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 0.10.0
+*/
+async function exportMultibaseKey(key) {
+	let content;
+	let code;
+	if (key.algorithm.name === "Ed25519") {
+		content = await crypto.subtle.exportKey("raw", key);
+		code = 237;
+	} else if (key.algorithm.name === "RSASSA-PKCS1-v1_5" && key.algorithm.hash.name === "SHA-256") {
+		const jwk = await crypto.subtle.exportKey("jwk", key);
+		const decodedN = decodeBase64Url(jwk.n);
+		const n = new Uint8Array(decodedN.length + 1);
+		n.set(decodedN, 1);
+		const sequence = new Sequence({ value: [new Integer({
+			isHexOnly: true,
+			valueHex: n
+		}), new Integer({
+			isHexOnly: true,
+			valueHex: decodeBase64Url(jwk.e)
+		})] });
+		content = sequence.toBER(false);
+		code = 4613;
+	} else throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	const codeHex = code.toString(16);
+	const codeBytes = decodeHex(codeHex.length % 2 < 1 ? codeHex : "0" + codeHex);
+	const prefixed = addPrefix(codeBytes, new Uint8Array(content));
+	const encoded = encode("base58btc", prefixed);
+	return new TextDecoder().decode(encoded);
+}
+
+//#endregion
+export { exportMultibaseKey, exportSpki, importMultibaseKey, importPem, importPkcs1, importSpki };

package/dist/runtime/key.test.d.ts

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