@fedify/vocab-runtime 2.4.0-dev.1564 → 2.4.0-dev.1567

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.1564+5a2c6c2c",
+  "version": "2.4.0-dev.1567+12e6a3c0",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts",

package/dist/mod.cjs

@@ -4367,7 +4367,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1564+5a2c6c2c";
+var version = "2.4.0-dev.1567+12e6a3c0";
 //#endregion
 //#region src/link.ts
 const parametersNeedLowerCase = ["rel", "type"];
@@ -5253,6 +5253,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -5314,6 +5319,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -5489,6 +5557,7 @@ exports.decodeMultibase = decodeMultibase;
 exports.encodeMultibase = encodeMultibase;
 exports.encodingFromBaseData = encodingFromBaseData;
 exports.expandIPv6Address = require_url.expandIPv6Address;
+exports.exportDidKey = exportDidKey;
 exports.exportMultibaseKey = exportMultibaseKey;
 exports.exportSpki = exportSpki;
 exports.formatIri = require_url.formatIri;
@@ -5496,6 +5565,7 @@ exports.getDocumentLoader = getDocumentLoader;
 exports.getRemoteDocument = getRemoteDocument;
 exports.getUserAgent = getUserAgent;
 exports.haveSameIriOrigin = require_url.haveSameIriOrigin;
+exports.importDidKey = importDidKey;
 exports.importMultibaseKey = importMultibaseKey;
 exports.importPem = importPem;
 exports.importPkcs1 = importPkcs1;
@@ -5505,6 +5575,7 @@ exports.isValidPublicIPv4Address = require_url.isValidPublicIPv4Address;
 exports.isValidPublicIPv6Address = require_url.isValidPublicIPv6Address;
 exports.logRequest = logRequest;
 exports.parseDecimal = parseDecimal;
+exports.parseDidKeyVerificationMethod = parseDidKeyVerificationMethod;
 exports.parseIri = require_url.parseIri;
 exports.parseJsonLdId = require_url.parseJsonLdId;
 exports.preloadedContexts = preloadedContexts;

package/dist/mod.d.cts

@@ -7,6 +7,29 @@ declare const preloadedContexts: Record<string, unknown>;
 //#endregion
 //#region src/key.d.ts
 /**
+* Parsed `did:key` verification method.
+*
+* @since 2.4.0
+*/
+interface DidKeyVerificationMethod {
+  /**
+  * The DID URL identifying the verification method.
+  */
+  readonly id: URL;
+  /**
+  * The controller DID.
+  */
+  readonly controller: URL;
+  /**
+  * The Ed25519 public key encoded as a Multibase Multikey value.
+  */
+  readonly publicKeyMultibase: string;
+  /**
+  * The Ed25519 public key.
+  */
+  readonly publicKey: CryptoKey;
+}
+/**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
 * @returns The imported public key.
@@ -39,6 +62,34 @@ declare function importPkcs1(pem: string): Promise<CryptoKey>;
 */
 declare function importPem(pem: string): Promise<CryptoKey>;
 /**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+declare function importDidKey(did: string | URL): Promise<CryptoKey>;
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+declare function exportDidKey(key: CryptoKey): Promise<string>;
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+declare function parseDidKeyVerificationMethod(didUrl: string | URL): Promise<DidKeyVerificationMethod>;
+/**
 * Imports a [Multibase]-encoded public key.
 *
 * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
@@ -286,4 +337,4 @@ declare function isValidPublicIPv4Address(address: string): boolean;
 declare function isValidPublicIPv6Address(address: string): boolean;
 declare function expandIPv6Address(address: string): string;
 //#endregion
-export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };
+export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };

package/dist/mod.d.ts

@@ -7,6 +7,29 @@ declare const preloadedContexts: Record<string, unknown>;
 //#endregion
 //#region src/key.d.ts
 /**
+* Parsed `did:key` verification method.
+*
+* @since 2.4.0
+*/
+interface DidKeyVerificationMethod {
+  /**
+  * The DID URL identifying the verification method.
+  */
+  readonly id: URL;
+  /**
+  * The controller DID.
+  */
+  readonly controller: URL;
+  /**
+  * The Ed25519 public key encoded as a Multibase Multikey value.
+  */
+  readonly publicKeyMultibase: string;
+  /**
+  * The Ed25519 public key.
+  */
+  readonly publicKey: CryptoKey;
+}
+/**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
 * @returns The imported public key.
@@ -39,6 +62,34 @@ declare function importPkcs1(pem: string): Promise<CryptoKey>;
 */
 declare function importPem(pem: string): Promise<CryptoKey>;
 /**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+declare function importDidKey(did: string | URL): Promise<CryptoKey>;
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+declare function exportDidKey(key: CryptoKey): Promise<string>;
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+declare function parseDidKeyVerificationMethod(didUrl: string | URL): Promise<DidKeyVerificationMethod>;
+/**
 * Imports a [Multibase]-encoded public key.
 *
 * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
@@ -286,4 +337,4 @@ declare function isValidPublicIPv4Address(address: string): boolean;
 declare function isValidPublicIPv6Address(address: string): boolean;
 declare function expandIPv6Address(address: string): string;
 //#endregion
-export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };
+export { type AuthenticatedDocumentLoaderFactory, type CreateRequestOptions, type Decimal, type DidKeyVerificationMethod, type DocumentLoader, type DocumentLoaderFactory, type DocumentLoaderFactoryOptions, type DocumentLoaderOptions, FetchError, type GetDocumentLoaderOptions, type GetUserAgentOptions, type Json, LanguageString, type PropertyPreprocessor, type PropertyPreprocessorContext, type RemoteDocument, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };

package/dist/mod.js

@@ -4363,7 +4363,7 @@ const preloadedContexts = {
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1564+5a2c6c2c";
+var version = "2.4.0-dev.1567+12e6a3c0";
 //#endregion
 //#region src/link.ts
 const parametersNeedLowerCase = ["rel", "type"];
@@ -5249,6 +5249,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -5310,6 +5315,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -5476,4 +5544,4 @@ LanguageString.prototype[Symbol.for("nodejs.util.inspect.custom")] = function(_d
 	return `<${this.locale.baseName}> ${inspect(this.toString(), options)}`;
 };
 //#endregion
-export { FetchError, LanguageString, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };
+export { FetchError, LanguageString, UrlError, canParseDecimal, createActivityPubRequest, decodeMultibase, encodeMultibase, encodingFromBaseData, expandIPv6Address, exportDidKey, exportMultibaseKey, exportSpki, formatIri, getDocumentLoader, getRemoteDocument, getUserAgent, haveSameIriOrigin, importDidKey, importMultibaseKey, importPem, importPkcs1, importSpki, isDecimal, isValidPublicIPv4Address, isValidPublicIPv6Address, logRequest, parseDecimal, parseDidKeyVerificationMethod, parseIri, parseJsonLdId, preloadedContexts, validatePublicUrl };

package/dist/tests/decimal.test.cjs

@@ -1,7 +1,7 @@
 require("./chunk-C2EiDwsr.cjs");
-require("./docloader-UAdXnDwt.cjs");
+require("./docloader-BcaQHb0Q.cjs");
 require("./url-2XwVbUS_.cjs");
-require("./key-pMmqUKuo.cjs");
+require("./key-_wXwomh_.cjs");
 require("./multibase-Bz_UUDtL.cjs");
 require("./langstr-CbAxaeEZ.cjs");
 let node_assert = require("node:assert");

package/dist/tests/decimal.test.mjs

@@ -1,6 +1,6 @@
-import "./docloader-CYQvKbtL.mjs";
+import "./docloader-D61oV0K1.mjs";
 import "./url-YWJbnRlf.mjs";
-import "./key-CrrK9mYh.mjs";
+import "./key-CDGDH_vC.mjs";
 import "./multibase-B4bvakyA.mjs";
 import "./langstr-Di5AvKpB.mjs";
 import { deepStrictEqual, throws } from "node:assert";

package/dist/tests/{docloader-UAdXnDwt.cjs → docloader-BcaQHb0Q.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_request = require("./request-DnzhAfki.cjs");
+const require_request = require("./request-DnNWah97.cjs");
 const require_link = require("./link-FguCydMA.cjs");
 const require_url = require("./url-2XwVbUS_.cjs");
 let _logtape_logtape = require("@logtape/logtape");

package/dist/tests/{docloader-CYQvKbtL.mjs → docloader-D61oV0K1.mjs}

@@ -1,4 +1,4 @@
-import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-DgAlI7RF.mjs";
+import { a as name, i as logRequest, n as createActivityPubRequest, o as version, t as FetchError } from "./request-Cn0vP7Hj.mjs";
 import { t as HttpHeaderLink } from "./link-NUUWCdnK.mjs";
 import { l as validatePublicUrl, t as UrlError } from "./url-YWJbnRlf.mjs";
 import { getLogger } from "@logtape/logtape";

package/dist/tests/docloader.test.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require("./chunk-C2EiDwsr.cjs");
-const require_docloader = require("./docloader-UAdXnDwt.cjs");
-const require_request = require("./request-DnzhAfki.cjs");
+const require_docloader = require("./docloader-BcaQHb0Q.cjs");
+const require_request = require("./request-DnNWah97.cjs");
 const require_url = require("./url-2XwVbUS_.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");

package/dist/tests/docloader.test.mjs

@@ -1,5 +1,5 @@
-import { n as getRemoteDocument, r as preloadedContexts, t as getDocumentLoader } from "./docloader-CYQvKbtL.mjs";
-import { t as FetchError } from "./request-DgAlI7RF.mjs";
+import { n as getRemoteDocument, r as preloadedContexts, t as getDocumentLoader } from "./docloader-D61oV0K1.mjs";
+import { t as FetchError } from "./request-Cn0vP7Hj.mjs";
 import { t as UrlError } from "./url-YWJbnRlf.mjs";
 import { deepStrictEqual, ok, rejects } from "node:assert";
 import { test } from "node:test";

package/dist/tests/{key-CrrK9mYh.mjs → key-CDGDH_vC.mjs}

@@ -45,6 +45,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -106,6 +111,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -169,4 +237,4 @@ async function exportMultibaseKey(key) {
 	return new TextDecoder().decode(encoded);
 }
 //#endregion
-export { importPkcs1 as a, importJwk as c, importPem as i, exportSpki as n, importSpki as o, importMultibaseKey as r, exportJwk as s, exportMultibaseKey as t };
+export { importMultibaseKey as a, importSpki as c, importJwk as d, importDidKey as i, parseDidKeyVerificationMethod as l, exportMultibaseKey as n, importPem as o, exportSpki as r, importPkcs1 as s, exportDidKey as t, exportJwk as u };

package/dist/tests/{key-pMmqUKuo.cjs → key-_wXwomh_.cjs}

@@ -46,6 +46,11 @@ const algorithms = {
 	},
 	"1.3.101.112": "Ed25519"
 };
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 237;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
 /**
 * Imports a PEM-SPKI formatted public key.
 * @param pem The PEM-SPKI formatted public key.
@@ -107,6 +112,69 @@ const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
 function importPem(pem) {
 	return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
+function decodeEd25519DidKeyMultibase(multibaseKey) {
+	if (!multibaseKey.startsWith("z")) throw new TypeError("did:key must use base58-btc Multibase encoding.");
+	let decoded;
+	try {
+		decoded = require_multibase.decodeMultibase(multibaseKey);
+	} catch (error) {
+		throw new TypeError("Invalid did:key Multibase encoding.", { cause: error });
+	}
+	const { code } = require_multicodec.getMulticodecPrefix(decoded);
+	if (code !== ED25519_PUBLIC_KEY_MULTICODEC) throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+	const content = require_multicodec.removeMulticodecPrefix(decoded);
+	if (content.length !== ED25519_PUBLIC_KEY_LENGTH) throw new TypeError("Invalid Ed25519 did:key length.");
+	return content;
+}
+/**
+* Imports an Ed25519 `did:key` DID.
+*
+* @param did The `did:key` DID.
+* @returns The imported Ed25519 public key.
+* @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+* @since 2.4.0
+*/
+async function importDidKey(did) {
+	const match = (did instanceof URL ? did.href : did).match(DID_KEY_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key DID.");
+	const content = decodeEd25519DidKeyMultibase(match[1]);
+	return await crypto.subtle.importKey("raw", content.slice(), "Ed25519", true, ["verify"]);
+}
+/**
+* Exports an Ed25519 public key as a `did:key` DID.
+*
+* @param key The Ed25519 public key.
+* @returns The `did:key` DID.
+* @throws {TypeError} If the key is invalid or unsupported.
+* @since 2.4.0
+*/
+async function exportDidKey(key) {
+	if (key.algorithm.name !== "Ed25519") throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
+	return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+/**
+* Parses an Ed25519 `did:key` verification method DID URL.
+*
+* @param didUrl The `did:key` DID URL.
+* @returns The parsed verification method.
+* @throws {TypeError} If the DID URL is malformed, unsupported, or its
+*                     fragment does not identify the same key as the DID.
+* @since 2.4.0
+*/
+async function parseDidKeyVerificationMethod(didUrl) {
+	const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+	const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+	if (match == null) throw new TypeError("Invalid did:key verification method.");
+	const [, publicKeyMultibase, fragment] = match;
+	if (publicKeyMultibase !== fragment) throw new TypeError("Invalid did:key verification method fragment.");
+	const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+	return {
+		id: new URL(didUrlString),
+		controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+		publicKeyMultibase,
+		publicKey
+	};
+}
 /**
 * Imports a [Multibase]-encoded public key.
 *
@@ -170,6 +238,12 @@ async function exportMultibaseKey(key) {
 	return new TextDecoder().decode(encoded);
 }
 //#endregion
+Object.defineProperty(exports, "exportDidKey", {
+	enumerable: true,
+	get: function() {
+		return exportDidKey;
+	}
+});
 Object.defineProperty(exports, "exportJwk", {
 	enumerable: true,
 	get: function() {
@@ -188,6 +262,12 @@ Object.defineProperty(exports, "exportSpki", {
 		return exportSpki;
 	}
 });
+Object.defineProperty(exports, "importDidKey", {
+	enumerable: true,
+	get: function() {
+		return importDidKey;
+	}
+});
 Object.defineProperty(exports, "importJwk", {
 	enumerable: true,
 	get: function() {
@@ -218,3 +298,9 @@ Object.defineProperty(exports, "importSpki", {
 		return importSpki;
 	}
 });
+Object.defineProperty(exports, "parseDidKeyVerificationMethod", {
+	enumerable: true,
+	get: function() {
+		return parseDidKeyVerificationMethod;
+	}
+});

package/dist/tests/key.test.cjs

@@ -1,5 +1,6 @@
 require("./chunk-C2EiDwsr.cjs");
-const require_key = require("./key-pMmqUKuo.cjs");
+const require_multicodec = require("./multicodec-CxGVGa91.cjs");
+const require_key = require("./key-_wXwomh_.cjs");
 const require_multibase = require("./multibase-Bz_UUDtL.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
@@ -71,4 +72,50 @@ const ed25519Multibase = "z6MksHj1MJnidCtDiyYW9ugNFftoX9fLK4bornTxmMZ6X7vq";
 		x: "Lm_M42cB3HkUiODQsXRcweM6TByfzEHGO9ND274JcOY"
 	}, "public")), "z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK");
 });
+(0, node_test.test)("exportDidKey() and importDidKey()", async () => {
+	const did = await require_key.exportDidKey(await require_key.importJwk(ed25519Jwk, "public"));
+	(0, node_assert.deepStrictEqual)(did, `did:key:${ed25519Multibase}`);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(await require_key.importDidKey(did)), ed25519Jwk);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(await require_key.importDidKey(new URL(did))), ed25519Jwk);
+	const rsaKey = await require_key.importJwk(rsaJwk, "public");
+	await (0, node_assert.rejects)(() => require_key.exportDidKey(rsaKey), TypeError);
+	await (0, node_assert.rejects)(() => require_key.importDidKey(`did:key:${rsaMultibase}`), /* @__PURE__ */ new TypeError("Unsupported did:key type: 0x1205"));
+});
+(0, node_test.test)("parseDidKeyVerificationMethod()", async () => {
+	const verificationMethod = `did:key:${ed25519Multibase}#${ed25519Multibase}`;
+	const parsed = await require_key.parseDidKeyVerificationMethod(verificationMethod);
+	(0, node_assert.deepStrictEqual)(parsed.id, new URL(verificationMethod));
+	(0, node_assert.deepStrictEqual)(parsed.controller, new URL(`did:key:${ed25519Multibase}`));
+	(0, node_assert.deepStrictEqual)(parsed.publicKeyMultibase, ed25519Multibase);
+	(0, node_assert.deepStrictEqual)(await require_key.exportJwk(parsed.publicKey), ed25519Jwk);
+});
+(0, node_test.test)("did:key helpers reject malformed values", async () => {
+	const ed25519Key = await require_key.importJwk(ed25519Jwk, "public");
+	const raw = new Uint8Array(await crypto.subtle.exportKey("raw", ed25519Key));
+	const shortEd25519 = new TextDecoder().decode(require_multibase.encodeMultibase("base58btc", require_multicodec.addMulticodecPrefix(237, raw.slice(0, 31))));
+	const base64UrlEd25519 = new TextDecoder().decode(require_multibase.encodeMultibase("base64url", require_multicodec.addMulticodecPrefix(237, raw)));
+	const malformedMulticodec = new TextDecoder().decode(require_multibase.encodeMultibase("base58btc", Uint8Array.from([128])));
+	for (const value of [
+		"did:web:example.com",
+		"did:key:",
+		`did:key:${ed25519Multibase}/path`,
+		`did:key:${ed25519Multibase}?query`,
+		`did:key:${ed25519Multibase}#${ed25519Multibase}`,
+		"did:key:z0",
+		`did:key:${base64UrlEd25519}`,
+		`did:key:${shortEd25519}`,
+		`did:key:${malformedMulticodec}`
+	]) await (0, node_assert.rejects)(() => require_key.importDidKey(value), TypeError);
+	for (const value of [
+		`did:key:${ed25519Multibase}`,
+		`did:key:${ed25519Multibase}#`,
+		`did:key:${ed25519Multibase}#z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`,
+		`did:key:${ed25519Multibase}#${base64UrlEd25519}`,
+		"did:key:z0#z0",
+		`did:key:${rsaMultibase}#${rsaMultibase}`,
+		`did:key:${shortEd25519}#${shortEd25519}`,
+		`did:key:${malformedMulticodec}#${malformedMulticodec}`,
+		"https://example.com/key"
+	]) await (0, node_assert.rejects)(() => require_key.parseDidKeyVerificationMethod(value), TypeError);
+});
 //#endregion

package/dist/tests/key.test.mjs

@@ -1,4 +1,5 @@
-import { a as importPkcs1, c as importJwk, i as importPem, n as exportSpki, o as importSpki, r as importMultibaseKey, s as exportJwk, t as exportMultibaseKey } from "./key-CrrK9mYh.mjs";
+import { t as addMulticodecPrefix } from "./multicodec-CyFp54fI.mjs";
+import { a as importMultibaseKey, c as importSpki, d as importJwk, i as importDidKey, l as parseDidKeyVerificationMethod, n as exportMultibaseKey, o as importPem, r as exportSpki, s as importPkcs1, t as exportDidKey, u as exportJwk } from "./key-CDGDH_vC.mjs";
 import { n as encodeMultibase } from "./multibase-B4bvakyA.mjs";
 import { deepStrictEqual, rejects } from "node:assert";
 import { test } from "node:test";
@@ -70,5 +71,51 @@ test("exportMultibaseKey()", async () => {
 		x: "Lm_M42cB3HkUiODQsXRcweM6TByfzEHGO9ND274JcOY"
 	}, "public")), "z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK");
 });
+test("exportDidKey() and importDidKey()", async () => {
+	const did = await exportDidKey(await importJwk(ed25519Jwk, "public"));
+	deepStrictEqual(did, `did:key:${ed25519Multibase}`);
+	deepStrictEqual(await exportJwk(await importDidKey(did)), ed25519Jwk);
+	deepStrictEqual(await exportJwk(await importDidKey(new URL(did))), ed25519Jwk);
+	const rsaKey = await importJwk(rsaJwk, "public");
+	await rejects(() => exportDidKey(rsaKey), TypeError);
+	await rejects(() => importDidKey(`did:key:${rsaMultibase}`), /* @__PURE__ */ new TypeError("Unsupported did:key type: 0x1205"));
+});
+test("parseDidKeyVerificationMethod()", async () => {
+	const verificationMethod = `did:key:${ed25519Multibase}#${ed25519Multibase}`;
+	const parsed = await parseDidKeyVerificationMethod(verificationMethod);
+	deepStrictEqual(parsed.id, new URL(verificationMethod));
+	deepStrictEqual(parsed.controller, new URL(`did:key:${ed25519Multibase}`));
+	deepStrictEqual(parsed.publicKeyMultibase, ed25519Multibase);
+	deepStrictEqual(await exportJwk(parsed.publicKey), ed25519Jwk);
+});
+test("did:key helpers reject malformed values", async () => {
+	const ed25519Key = await importJwk(ed25519Jwk, "public");
+	const raw = new Uint8Array(await crypto.subtle.exportKey("raw", ed25519Key));
+	const shortEd25519 = new TextDecoder().decode(encodeMultibase("base58btc", addMulticodecPrefix(237, raw.slice(0, 31))));
+	const base64UrlEd25519 = new TextDecoder().decode(encodeMultibase("base64url", addMulticodecPrefix(237, raw)));
+	const malformedMulticodec = new TextDecoder().decode(encodeMultibase("base58btc", Uint8Array.from([128])));
+	for (const value of [
+		"did:web:example.com",
+		"did:key:",
+		`did:key:${ed25519Multibase}/path`,
+		`did:key:${ed25519Multibase}?query`,
+		`did:key:${ed25519Multibase}#${ed25519Multibase}`,
+		"did:key:z0",
+		`did:key:${base64UrlEd25519}`,
+		`did:key:${shortEd25519}`,
+		`did:key:${malformedMulticodec}`
+	]) await rejects(() => importDidKey(value), TypeError);
+	for (const value of [
+		`did:key:${ed25519Multibase}`,
+		`did:key:${ed25519Multibase}#`,
+		`did:key:${ed25519Multibase}#z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`,
+		`did:key:${ed25519Multibase}#${base64UrlEd25519}`,
+		"did:key:z0#z0",
+		`did:key:${rsaMultibase}#${rsaMultibase}`,
+		`did:key:${shortEd25519}#${shortEd25519}`,
+		`did:key:${malformedMulticodec}#${malformedMulticodec}`,
+		"https://example.com/key"
+	]) await rejects(() => parseDidKeyVerificationMethod(value), TypeError);
+});
 //#endregion
 export {};

package/dist/tests/{request-DgAlI7RF.mjs → request-Cn0vP7Hj.mjs}

@@ -1,7 +1,7 @@
 import process from "node:process";
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1564+5a2c6c2c";
+var version = "2.4.0-dev.1567+12e6a3c0";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/{request-DnzhAfki.cjs → request-DnNWah97.cjs}

@@ -3,7 +3,7 @@ let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process, 1);
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.4.0-dev.1564+5a2c6c2c";
+var version = "2.4.0-dev.1567+12e6a3c0";
 //#endregion
 //#region src/request.ts
 /**

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-C2EiDwsr.cjs");
-const require_request = require("./request-DnzhAfki.cjs");
+const require_request = require("./request-DnNWah97.cjs");
 let node_assert = require("node:assert");
 let node_test = require("node:test");
 let node_process = require("node:process");

package/dist/tests/request.test.mjs

@@ -1,4 +1,4 @@
-import { o as version, r as getUserAgent } from "./request-DgAlI7RF.mjs";
+import { o as version, r as getUserAgent } from "./request-Cn0vP7Hj.mjs";
 import { deepStrictEqual } from "node:assert";
 import { test } from "node:test";
 import process from "node:process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.4.0-dev.1564+5a2c6c2c",
+  "version": "2.4.0-dev.1567+12e6a3c0",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",

package/src/key.test.ts

@@ -2,13 +2,17 @@ import { deepStrictEqual, rejects } from "node:assert";
 import { test } from "node:test";
 import { exportJwk, importJwk } from "./jwk.ts";
 import {
+  exportDidKey,
   exportMultibaseKey,
   exportSpki,
+  importDidKey,
   importMultibaseKey,
   importPem,
   importPkcs1,
   importSpki,
+  parseDidKeyVerificationMethod,
 } from "./key.ts";
+import { addMulticodecPrefix } from "./internal/multicodec.ts";
 import { encodeMultibase } from "./multibase/mod.ts";
 
 // cSpell: disable
@@ -198,3 +202,85 @@ test("exportMultibaseKey()", async () => {
     // cSpell: enable
   );
 });
+
+test("exportDidKey() and importDidKey()", async () => {
+  const ed25519Key = await importJwk(ed25519Jwk, "public");
+  const did = await exportDidKey(ed25519Key);
+  deepStrictEqual(did, `did:key:${ed25519Multibase}`);
+  deepStrictEqual(await exportJwk(await importDidKey(did)), ed25519Jwk);
+  deepStrictEqual(
+    await exportJwk(await importDidKey(new URL(did))),
+    ed25519Jwk,
+  );
+
+  const rsaKey = await importJwk(rsaJwk, "public");
+  await rejects(
+    () => exportDidKey(rsaKey),
+    TypeError,
+  );
+  await rejects(
+    () => importDidKey(`did:key:${rsaMultibase}`),
+    new TypeError("Unsupported did:key type: 0x1205"),
+  );
+});
+
+test("parseDidKeyVerificationMethod()", async () => {
+  const verificationMethod = `did:key:${ed25519Multibase}#${ed25519Multibase}`;
+  const parsed = await parseDidKeyVerificationMethod(verificationMethod);
+  deepStrictEqual(parsed.id, new URL(verificationMethod));
+  deepStrictEqual(parsed.controller, new URL(`did:key:${ed25519Multibase}`));
+  deepStrictEqual(parsed.publicKeyMultibase, ed25519Multibase);
+  deepStrictEqual(await exportJwk(parsed.publicKey), ed25519Jwk);
+});
+
+test("did:key helpers reject malformed values", async () => {
+  const ed25519Key = await importJwk(ed25519Jwk, "public");
+  const raw = new Uint8Array(await crypto.subtle.exportKey("raw", ed25519Key));
+  const shortEd25519 = new TextDecoder().decode(
+    encodeMultibase(
+      "base58btc",
+      addMulticodecPrefix(0xed, raw.slice(0, 31)),
+    ),
+  );
+  const base64UrlEd25519 = new TextDecoder().decode(
+    encodeMultibase(
+      "base64url",
+      addMulticodecPrefix(0xed, raw),
+    ),
+  );
+  const malformedMulticodec = new TextDecoder().decode(
+    encodeMultibase("base58btc", Uint8Array.from([0x80])),
+  );
+
+  for (
+    const value of [
+      "did:web:example.com",
+      "did:key:",
+      `did:key:${ed25519Multibase}/path`,
+      `did:key:${ed25519Multibase}?query`,
+      `did:key:${ed25519Multibase}#${ed25519Multibase}`,
+      "did:key:z0",
+      `did:key:${base64UrlEd25519}`,
+      `did:key:${shortEd25519}`,
+      `did:key:${malformedMulticodec}`,
+    ]
+  ) {
+    await rejects(() => importDidKey(value), TypeError);
+  }
+
+  for (
+    const value of [
+      `did:key:${ed25519Multibase}`,
+      `did:key:${ed25519Multibase}#`,
+      `did:key:${ed25519Multibase}#z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK`,
+      `did:key:${ed25519Multibase}#${base64UrlEd25519}`,
+      "did:key:z0#z0",
+      `did:key:${rsaMultibase}#${rsaMultibase}`,
+      `did:key:${shortEd25519}#${shortEd25519}`,
+      `did:key:${malformedMulticodec}#${malformedMulticodec}`,
+      "https://example.com/key",
+    ]
+  ) {
+    await rejects(() => parseDidKeyVerificationMethod(value), TypeError);
+  }
+});

package/src/key.ts

@@ -22,6 +22,39 @@ const algorithms: Record<
   "1.3.101.112": "Ed25519",
 };
 
+const DID_KEY_PREFIX = "did:key:";
+const ED25519_PUBLIC_KEY_MULTICODEC = 0xed;
+const ED25519_PUBLIC_KEY_LENGTH = 32;
+const DID_KEY_PATTERN = /^did:key:([^/?#]+)$/;
+const DID_KEY_VERIFICATION_METHOD_PATTERN = /^did:key:([^/?#]+)#([^/?#]+)$/;
+
+/**
+ * Parsed `did:key` verification method.
+ *
+ * @since 2.4.0
+ */
+export interface DidKeyVerificationMethod {
+  /**
+   * The DID URL identifying the verification method.
+   */
+  readonly id: URL;
+
+  /**
+   * The controller DID.
+   */
+  readonly controller: URL;
+
+  /**
+   * The Ed25519 public key encoded as a Multibase Multikey value.
+   */
+  readonly publicKeyMultibase: string;
+
+  /**
+   * The Ed25519 public key.
+   */
+  readonly publicKey: CryptoKey;
+}
+
 /**
  * Imports a PEM-SPKI formatted public key.
  * @param pem The PEM-SPKI formatted public key.
@@ -93,6 +126,98 @@ export function importPem(pem: string): Promise<CryptoKey> {
   return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
 }
 
+function decodeEd25519DidKeyMultibase(multibaseKey: string): Uint8Array {
+  if (!multibaseKey.startsWith("z")) {
+    throw new TypeError("did:key must use base58-btc Multibase encoding.");
+  }
+  let decoded: Uint8Array;
+  try {
+    decoded = decodeMultibase(multibaseKey);
+  } catch (error) {
+    throw new TypeError("Invalid did:key Multibase encoding.", {
+      cause: error,
+    });
+  }
+  const { code } = getMulticodecPrefix(decoded);
+  if (code !== ED25519_PUBLIC_KEY_MULTICODEC) {
+    throw new TypeError("Unsupported did:key type: 0x" + code.toString(16));
+  }
+  const content = removeMulticodecPrefix(decoded);
+  if (content.length !== ED25519_PUBLIC_KEY_LENGTH) {
+    throw new TypeError("Invalid Ed25519 did:key length.");
+  }
+  return content;
+}
+
+/**
+ * Imports an Ed25519 `did:key` DID.
+ *
+ * @param did The `did:key` DID.
+ * @returns The imported Ed25519 public key.
+ * @throws {TypeError} If the DID is malformed or uses an unsupported key type.
+ * @since 2.4.0
+ */
+export async function importDidKey(did: string | URL): Promise<CryptoKey> {
+  const didString = did instanceof URL ? did.href : did;
+  const match = didString.match(DID_KEY_PATTERN);
+  if (match == null) throw new TypeError("Invalid did:key DID.");
+  const content = decodeEd25519DidKeyMultibase(match[1]);
+  return await crypto.subtle.importKey(
+    "raw",
+    content.slice(),
+    "Ed25519",
+    true,
+    ["verify"],
+  );
+}
+
+/**
+ * Exports an Ed25519 public key as a `did:key` DID.
+ *
+ * @param key The Ed25519 public key.
+ * @returns The `did:key` DID.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 2.4.0
+ */
+export async function exportDidKey(key: CryptoKey): Promise<string> {
+  if (key.algorithm.name !== "Ed25519") {
+    throw new TypeError(
+      "Unsupported key type: " + JSON.stringify(key.algorithm),
+    );
+  }
+  return DID_KEY_PREFIX + await exportMultibaseKey(key);
+}
+
+/**
+ * Parses an Ed25519 `did:key` verification method DID URL.
+ *
+ * @param didUrl The `did:key` DID URL.
+ * @returns The parsed verification method.
+ * @throws {TypeError} If the DID URL is malformed, unsupported, or its
+ *                     fragment does not identify the same key as the DID.
+ * @since 2.4.0
+ */
+export async function parseDidKeyVerificationMethod(
+  didUrl: string | URL,
+): Promise<DidKeyVerificationMethod> {
+  const didUrlString = didUrl instanceof URL ? didUrl.href : didUrl;
+  const match = didUrlString.match(DID_KEY_VERIFICATION_METHOD_PATTERN);
+  if (match == null) {
+    throw new TypeError("Invalid did:key verification method.");
+  }
+  const [, publicKeyMultibase, fragment] = match;
+  if (publicKeyMultibase !== fragment) {
+    throw new TypeError("Invalid did:key verification method fragment.");
+  }
+  const publicKey = await importDidKey(DID_KEY_PREFIX + publicKeyMultibase);
+  return {
+    id: new URL(didUrlString),
+    controller: new URL(DID_KEY_PREFIX + publicKeyMultibase),
+    publicKeyMultibase,
+    publicKey,
+  };
+}
+
 /**
  * Imports a [Multibase]-encoded public key.
  *

package/src/mod.ts

@@ -17,12 +17,16 @@ export {
   type RemoteDocument,
 } from "./docloader.ts";
 export {
+  type DidKeyVerificationMethod,
+  exportDidKey,
   exportMultibaseKey,
   exportSpki,
+  importDidKey,
   importMultibaseKey,
   importPem,
   importPkcs1,
   importSpki,
+  parseDidKeyVerificationMethod,
 } from "./key.ts";
 export {
   canParseDecimal,