@fedify/vocab-runtime 2.0.6 → 2.0.7-dev.586

package/deno.json

@@ -1,9 +1,10 @@
 {
   "name": "@fedify/vocab-runtime",
-  "version": "2.0.6",
+  "version": "2.0.7-dev.586+b3928d60",
   "license": "MIT",
   "exports": {
-    ".": "./src/mod.ts"
+    ".": "./src/mod.ts",
+    "./jsonld": "./src/jsonld.ts"
   },
   "description": "Runtime library for @fedify/vocab",
   "author": {
@@ -16,7 +17,7 @@
     "asn1js": "npm:asn1js@^3.0.6",
     "byte-encodings": "npm:byte-encodings@^1.0.11",
     "fetch-mock": "npm:fetch-mock@^12.5.4",
-    "multicodec": "npm:multicodec@^3.2.1",
+    "jsonld": "npm:jsonld@^9.0.0",
     "pkijs": "npm:pkijs@^3.2.5"
   },
   "exclude": [

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/jsonld.cjs

@@ -0,0 +1,8 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const jsonld_dist_jsonld_esm_js = require_chunk.__toESM(require("jsonld/dist/jsonld.esm.js"));
+
+//#region src/jsonld.ts
+var jsonld_default = jsonld_dist_jsonld_esm_js.default;
+
+//#endregion
+module.exports = jsonld_default;

package/dist/jsonld.d.cts

@@ -0,0 +1,6 @@
+import * as jsonld0 from "jsonld";
+
+//#region src/jsonld.d.ts
+declare const _default: typeof jsonld0;
+//#endregion
+export { _default as default };

package/dist/jsonld.d.ts

@@ -0,0 +1,6 @@
+import * as jsonld0 from "jsonld";
+
+//#region src/jsonld.d.ts
+declare const _default: typeof jsonld0;
+//#endregion
+export { _default as default };

package/dist/jsonld.js

@@ -0,0 +1,7 @@
+import jsonld from "jsonld/dist/jsonld.esm.js";
+
+//#region src/jsonld.ts
+var jsonld_default = jsonld;
+
+//#endregion
+export { jsonld_default as default };

package/dist/mod.cjs

@@ -1,39 +1,15 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __logtape_logtape = __toESM(require("@logtape/logtape"));
-const __opentelemetry_api = __toESM(require("@opentelemetry/api"));
-const node_process = __toESM(require("node:process"));
-const node_dns_promises = __toESM(require("node:dns/promises"));
-const node_net = __toESM(require("node:net"));
-const asn1js = __toESM(require("asn1js"));
-const byte_encodings_base64 = __toESM(require("byte-encodings/base64"));
-const byte_encodings_base64url = __toESM(require("byte-encodings/base64url"));
-const byte_encodings_hex = __toESM(require("byte-encodings/hex"));
-const multicodec = __toESM(require("multicodec"));
-const node_crypto = __toESM(require("node:crypto"));
-const pkijs = __toESM(require("pkijs"));
-const __multiformats_base_x = __toESM(require("@multiformats/base-x"));
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
+const __opentelemetry_api = require_chunk.__toESM(require("@opentelemetry/api"));
+const node_process = require_chunk.__toESM(require("node:process"));
+const node_dns_promises = require_chunk.__toESM(require("node:dns/promises"));
+const node_net = require_chunk.__toESM(require("node:net"));
+const asn1js = require_chunk.__toESM(require("asn1js"));
+const byte_encodings_base64 = require_chunk.__toESM(require("byte-encodings/base64"));
+const byte_encodings_base64url = require_chunk.__toESM(require("byte-encodings/base64url"));
+const node_crypto = require_chunk.__toESM(require("node:crypto"));
+const pkijs = require_chunk.__toESM(require("pkijs"));
+const __multiformats_base_x = require_chunk.__toESM(require("@multiformats/base-x"));
 
 //#region src/contexts.ts
 const preloadedContexts = {
@@ -4287,9 +4263,12 @@ var contexts_default = preloadedContexts;
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.6";
+var version = "2.0.7-dev.586+b3928d60";
 var license = "MIT";
-var exports$1 = { ".": "./src/mod.ts" };
+var exports$1 = {
+	".": "./src/mod.ts",
+	"./jsonld": "./src/jsonld.ts"
+};
 var description = "Runtime library for @fedify/vocab";
 var author = {
 	"name": "Hong Minhee",
@@ -4301,7 +4280,7 @@ var imports = {
 	"asn1js": "npm:asn1js@^3.0.6",
 	"byte-encodings": "npm:byte-encodings@^1.0.11",
 	"fetch-mock": "npm:fetch-mock@^12.5.4",
-	"multicodec": "npm:multicodec@^3.2.1",
+	"jsonld": "npm:jsonld@^9.0.0",
 	"pkijs": "npm:pkijs@^3.2.5"
 };
 var exclude = ["dist", "node_modules"];
@@ -4810,6 +4789,46 @@ function getDocumentLoader({ allowPrivateAddress, skipPreloadedContexts, userAge
 	return load;
 }
 
+//#endregion
+//#region src/internal/multicodec.ts
+const INVALID_MULTICODEC_PREFIX = "Invalid multicodec prefix.";
+function getMulticodecPrefix(data) {
+	if (data.length < 1) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	let code = 0;
+	let shift = 0;
+	for (let i = 0; i < data.length; i++) {
+		const byte = data[i];
+		code += (byte & 127) * 2 ** shift;
+		if (code > Number.MAX_SAFE_INTEGER) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+		if ((byte & 128) === 0) return {
+			code,
+			prefixLength: i + 1
+		};
+		shift += 7;
+		if (shift >= 53) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	}
+	throw new TypeError(INVALID_MULTICODEC_PREFIX);
+}
+function removeMulticodecPrefix(data) {
+	const { prefixLength } = getMulticodecPrefix(data);
+	return data.slice(prefixLength);
+}
+function addMulticodecPrefix(code, payload) {
+	if (!Number.isSafeInteger(code) || code < 0) throw new TypeError("Invalid multicodec code.");
+	const prefix = [];
+	let value = code;
+	do {
+		let byte = value & 127;
+		value = Math.floor(value / 128);
+		if (value > 0) byte |= 128;
+		prefix.push(byte);
+	} while (value > 0);
+	const prefixed = new Uint8Array(prefix.length + payload.length);
+	prefixed.set(prefix);
+	prefixed.set(payload, prefix.length);
+	return prefixed;
+}
+
 //#endregion
 //#region src/jwk.ts
 function validateCryptoKey(key, type) {
@@ -5226,8 +5245,8 @@ function importPem(pem) {
 */
 async function importMultibaseKey(key) {
 	const decoded = decodeMultibase(key);
-	const code = (0, multicodec.getCodeFromData)(decoded);
-	const content = (0, multicodec.rmPrefix)(decoded);
+	const { code } = getMulticodecPrefix(decoded);
+	const content = removeMulticodecPrefix(decoded);
 	if (code === 4613) {
 		const keyObject = (0, node_crypto.createPublicKey)({
 			key: content,
@@ -5276,9 +5295,7 @@ async function exportMultibaseKey(key) {
 		content = sequence.toBER(false);
 		code = 4613;
 	} else throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
-	const codeHex = code.toString(16);
-	const codeBytes = (0, byte_encodings_hex.decodeHex)(codeHex.length % 2 < 1 ? codeHex : "0" + codeHex);
-	const prefixed = (0, multicodec.addPrefix)(codeBytes, new Uint8Array(content));
+	const prefixed = addMulticodecPrefix(code, new Uint8Array(content));
 	const encoded = encodeMultibase("base58btc", prefixed);
 	return new TextDecoder().decode(encoded);
 }

package/dist/mod.js

@@ -6,8 +6,6 @@ import { isIP } from "node:net";
 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";
 import baseX from "@multiformats/base-x";
@@ -4264,9 +4262,12 @@ var contexts_default = preloadedContexts;
 //#endregion
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.6";
+var version = "2.0.7-dev.586+b3928d60";
 var license = "MIT";
-var exports = { ".": "./src/mod.ts" };
+var exports = {
+	".": "./src/mod.ts",
+	"./jsonld": "./src/jsonld.ts"
+};
 var description = "Runtime library for @fedify/vocab";
 var author = {
 	"name": "Hong Minhee",
@@ -4278,7 +4279,7 @@ var imports = {
 	"asn1js": "npm:asn1js@^3.0.6",
 	"byte-encodings": "npm:byte-encodings@^1.0.11",
 	"fetch-mock": "npm:fetch-mock@^12.5.4",
-	"multicodec": "npm:multicodec@^3.2.1",
+	"jsonld": "npm:jsonld@^9.0.0",
 	"pkijs": "npm:pkijs@^3.2.5"
 };
 var exclude = ["dist", "node_modules"];
@@ -4787,6 +4788,46 @@ function getDocumentLoader({ allowPrivateAddress, skipPreloadedContexts, userAge
 	return load;
 }
 
+//#endregion
+//#region src/internal/multicodec.ts
+const INVALID_MULTICODEC_PREFIX = "Invalid multicodec prefix.";
+function getMulticodecPrefix(data) {
+	if (data.length < 1) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	let code = 0;
+	let shift = 0;
+	for (let i = 0; i < data.length; i++) {
+		const byte = data[i];
+		code += (byte & 127) * 2 ** shift;
+		if (code > Number.MAX_SAFE_INTEGER) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+		if ((byte & 128) === 0) return {
+			code,
+			prefixLength: i + 1
+		};
+		shift += 7;
+		if (shift >= 53) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	}
+	throw new TypeError(INVALID_MULTICODEC_PREFIX);
+}
+function removeMulticodecPrefix(data) {
+	const { prefixLength } = getMulticodecPrefix(data);
+	return data.slice(prefixLength);
+}
+function addMulticodecPrefix(code, payload) {
+	if (!Number.isSafeInteger(code) || code < 0) throw new TypeError("Invalid multicodec code.");
+	const prefix = [];
+	let value = code;
+	do {
+		let byte = value & 127;
+		value = Math.floor(value / 128);
+		if (value > 0) byte |= 128;
+		prefix.push(byte);
+	} while (value > 0);
+	const prefixed = new Uint8Array(prefix.length + payload.length);
+	prefixed.set(prefix);
+	prefixed.set(payload, prefix.length);
+	return prefixed;
+}
+
 //#endregion
 //#region src/jwk.ts
 function validateCryptoKey(key, type) {
@@ -5203,8 +5244,8 @@ function importPem(pem) {
 */
 async function importMultibaseKey(key) {
 	const decoded = decodeMultibase(key);
-	const code = getCodeFromData(decoded);
-	const content = rmPrefix(decoded);
+	const { code } = getMulticodecPrefix(decoded);
+	const content = removeMulticodecPrefix(decoded);
 	if (code === 4613) {
 		const keyObject = createPublicKey({
 			key: content,
@@ -5253,9 +5294,7 @@ async function exportMultibaseKey(key) {
 		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 prefixed = addMulticodecPrefix(code, new Uint8Array(content));
 	const encoded = encodeMultibase("base58btc", prefixed);
 	return new TextDecoder().decode(encoded);
 }

package/dist/tests/docloader.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('./chunk-DWy1uDak.cjs');
-const require_request = require('./request-B7jBLGoM.cjs');
+const require_request = require('./request-DHjhMKWk.cjs');
 const require_link = require('./link-CdFPEo9O.cjs');
 const require_url = require('./url-C5Vs9nYh.cjs');
 const node_assert = require_chunk.__toESM(require("node:assert"));

package/dist/tests/docloader.test.js

@@ -1,4 +1,4 @@
-import { FetchError, createActivityPubRequest, deno_default, logRequest } from "./request-Dlac5CA8.js";
+import { FetchError, createActivityPubRequest, deno_default, logRequest } from "./request-CvrhEgps.js";
 import { HttpHeaderLink } from "./link-Ck2yj4dH.js";
 import { UrlError, validatePublicUrl } from "./url-fW_DHbih.js";
 import "node:module";

package/dist/tests/internal/multicodec.test.cjs

@@ -0,0 +1,77 @@
+const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_multicodec = require('../multicodec-mHcRzSGY.cjs');
+const node_assert = require_chunk.__toESM(require("node:assert"));
+const node_test = require_chunk.__toESM(require("node:test"));
+
+//#region src/internal/multicodec.test.ts
+(0, node_test.test)("getMulticodecPrefix() decodes supported multicodec prefixes", () => {
+	(0, node_assert.deepStrictEqual)(require_multicodec.getMulticodecPrefix(Uint8Array.from([
+		237,
+		1,
+		170
+	])), {
+		code: 237,
+		prefixLength: 2
+	});
+	(0, node_assert.deepStrictEqual)(require_multicodec.getMulticodecPrefix(Uint8Array.from([
+		133,
+		36,
+		170
+	])), {
+		code: 4613,
+		prefixLength: 2
+	});
+});
+(0, node_test.test)("removeMulticodecPrefix() strips the varint prefix", () => {
+	(0, node_assert.deepStrictEqual)(require_multicodec.removeMulticodecPrefix(Uint8Array.from([
+		237,
+		1,
+		17,
+		34
+	])), Uint8Array.from([17, 34]));
+});
+(0, node_test.test)("addMulticodecPrefix() prepends the varint-encoded code", () => {
+	(0, node_assert.deepStrictEqual)(require_multicodec.addMulticodecPrefix(237, Uint8Array.from([17, 34])), Uint8Array.from([
+		237,
+		1,
+		17,
+		34
+	]));
+	(0, node_assert.deepStrictEqual)(require_multicodec.addMulticodecPrefix(4613, Uint8Array.from([17, 34])), Uint8Array.from([
+		133,
+		36,
+		17,
+		34
+	]));
+});
+(0, node_test.test)("multicodec helpers round-trip prefixed payloads", () => {
+	const payload = Uint8Array.from([
+		222,
+		173,
+		190,
+		239
+	]);
+	const prefixed = require_multicodec.addMulticodecPrefix(4613, payload);
+	(0, node_assert.deepStrictEqual)(require_multicodec.getMulticodecPrefix(prefixed), {
+		code: 4613,
+		prefixLength: 2
+	});
+	(0, node_assert.deepStrictEqual)(require_multicodec.removeMulticodecPrefix(prefixed), payload);
+});
+(0, node_test.test)("multicodec helpers reject malformed prefixes", () => {
+	(0, node_assert.throws)(() => require_multicodec.getMulticodecPrefix(new Uint8Array([])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	(0, node_assert.throws)(() => require_multicodec.getMulticodecPrefix(Uint8Array.from([128])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	(0, node_assert.throws)(() => require_multicodec.getMulticodecPrefix(Uint8Array.from([
+		128,
+		128,
+		128,
+		128,
+		128,
+		128,
+		128,
+		128
+	])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	(0, node_assert.throws)(() => require_multicodec.addMulticodecPrefix(-1, Uint8Array.from([0])), /* @__PURE__ */ new TypeError("Invalid multicodec code."));
+});
+
+//#endregion

package/dist/tests/internal/multicodec.test.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/tests/internal/multicodec.test.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/tests/internal/multicodec.test.js

@@ -0,0 +1,76 @@
+import { addMulticodecPrefix, getMulticodecPrefix, removeMulticodecPrefix } from "../multicodec-DvC5xnX2.js";
+import { deepStrictEqual, throws } from "node:assert";
+import { test } from "node:test";
+
+//#region src/internal/multicodec.test.ts
+test("getMulticodecPrefix() decodes supported multicodec prefixes", () => {
+	deepStrictEqual(getMulticodecPrefix(Uint8Array.from([
+		237,
+		1,
+		170
+	])), {
+		code: 237,
+		prefixLength: 2
+	});
+	deepStrictEqual(getMulticodecPrefix(Uint8Array.from([
+		133,
+		36,
+		170
+	])), {
+		code: 4613,
+		prefixLength: 2
+	});
+});
+test("removeMulticodecPrefix() strips the varint prefix", () => {
+	deepStrictEqual(removeMulticodecPrefix(Uint8Array.from([
+		237,
+		1,
+		17,
+		34
+	])), Uint8Array.from([17, 34]));
+});
+test("addMulticodecPrefix() prepends the varint-encoded code", () => {
+	deepStrictEqual(addMulticodecPrefix(237, Uint8Array.from([17, 34])), Uint8Array.from([
+		237,
+		1,
+		17,
+		34
+	]));
+	deepStrictEqual(addMulticodecPrefix(4613, Uint8Array.from([17, 34])), Uint8Array.from([
+		133,
+		36,
+		17,
+		34
+	]));
+});
+test("multicodec helpers round-trip prefixed payloads", () => {
+	const payload = Uint8Array.from([
+		222,
+		173,
+		190,
+		239
+	]);
+	const prefixed = addMulticodecPrefix(4613, payload);
+	deepStrictEqual(getMulticodecPrefix(prefixed), {
+		code: 4613,
+		prefixLength: 2
+	});
+	deepStrictEqual(removeMulticodecPrefix(prefixed), payload);
+});
+test("multicodec helpers reject malformed prefixes", () => {
+	throws(() => getMulticodecPrefix(new Uint8Array([])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	throws(() => getMulticodecPrefix(Uint8Array.from([128])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	throws(() => getMulticodecPrefix(Uint8Array.from([
+		128,
+		128,
+		128,
+		128,
+		128,
+		128,
+		128,
+		128
+	])), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	throws(() => addMulticodecPrefix(-1, Uint8Array.from([0])), /* @__PURE__ */ new TypeError("Invalid multicodec code."));
+});
+
+//#endregion

package/dist/tests/key.test.cjs

@@ -1,12 +1,11 @@
 const require_chunk = require('./chunk-DWy1uDak.cjs');
-const require_multibase = require('./multibase-BFbBiaPE.cjs');
+const require_multicodec = require('./multicodec-mHcRzSGY.cjs');
+const require_multibase = require('./multibase-B2D6B0V4.cjs');
 const node_assert = require_chunk.__toESM(require("node:assert"));
 const node_test = require_chunk.__toESM(require("node:test"));
 const asn1js = require_chunk.__toESM(require("asn1js"));
 const byte_encodings_base64 = require_chunk.__toESM(require("byte-encodings/base64"));
 const byte_encodings_base64url = require_chunk.__toESM(require("byte-encodings/base64url"));
-const byte_encodings_hex = require_chunk.__toESM(require("byte-encodings/hex"));
-const multicodec = require_chunk.__toESM(require("multicodec"));
 const node_crypto = require_chunk.__toESM(require("node:crypto"));
 const pkijs = require_chunk.__toESM(require("pkijs"));
 
@@ -128,8 +127,8 @@ function importPem(pem) {
 */
 async function importMultibaseKey(key) {
 	const decoded = require_multibase.decodeMultibase(key);
-	const code = (0, multicodec.getCodeFromData)(decoded);
-	const content = (0, multicodec.rmPrefix)(decoded);
+	const { code } = require_multicodec.getMulticodecPrefix(decoded);
+	const content = require_multicodec.removeMulticodecPrefix(decoded);
 	if (code === 4613) {
 		const keyObject = (0, node_crypto.createPublicKey)({
 			key: content,
@@ -178,9 +177,7 @@ async function exportMultibaseKey(key) {
 		content = sequence.toBER(false);
 		code = 4613;
 	} else throw new TypeError("Unsupported key type: " + JSON.stringify(key.algorithm));
-	const codeHex = code.toString(16);
-	const codeBytes = (0, byte_encodings_hex.decodeHex)(codeHex.length % 2 < 1 ? codeHex : "0" + codeHex);
-	const prefixed = (0, multicodec.addPrefix)(codeBytes, new Uint8Array(content));
+	const prefixed = require_multicodec.addMulticodecPrefix(code, new Uint8Array(content));
 	const encoded = require_multibase.encodeMultibase("base58btc", prefixed);
 	return new TextDecoder().decode(encoded);
 }
@@ -240,6 +237,11 @@ const ed25519Multibase = "z6MksHj1MJnidCtDiyYW9ugNFftoX9fLK4bornTxmMZ6X7vq";
 	const ed25519Key = await importMultibaseKey(ed25519Multibase);
 	(0, node_assert.deepStrictEqual)(await exportJwk(ed25519Key), ed25519Jwk);
 });
+(0, node_test.test)("importMultibase() rejects malformed multicodec prefixes", async () => {
+	const decoder = new TextDecoder();
+	await (0, node_assert.rejects)(() => importMultibaseKey(decoder.decode(require_multibase.encodeMultibase("base58btc", new Uint8Array([])))), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	await (0, node_assert.rejects)(() => importMultibaseKey(decoder.decode(require_multibase.encodeMultibase("base58btc", Uint8Array.from([128])))), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+});
 (0, node_test.test)("exportMultibaseKey()", async () => {
 	const rsaKey = await importJwk(rsaJwk, "public");
 	const rsaMb = await exportMultibaseKey(rsaKey);

package/dist/tests/key.test.js

@@ -1,11 +1,10 @@
-import { decodeMultibase, encodeMultibase } from "./multibase-DStmqni9.js";
-import { deepStrictEqual } from "node:assert";
+import { addMulticodecPrefix, getMulticodecPrefix, removeMulticodecPrefix } from "./multicodec-DvC5xnX2.js";
+import { decodeMultibase, encodeMultibase } from "./multibase-BdHCGO4H.js";
+import { deepStrictEqual, rejects } from "node:assert";
 import { test } from "node:test";
 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";
 
@@ -127,8 +126,8 @@ function importPem(pem) {
 */
 async function importMultibaseKey(key) {
 	const decoded = decodeMultibase(key);
-	const code = getCodeFromData(decoded);
-	const content = rmPrefix(decoded);
+	const { code } = getMulticodecPrefix(decoded);
+	const content = removeMulticodecPrefix(decoded);
 	if (code === 4613) {
 		const keyObject = createPublicKey({
 			key: content,
@@ -177,9 +176,7 @@ async function exportMultibaseKey(key) {
 		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 prefixed = addMulticodecPrefix(code, new Uint8Array(content));
 	const encoded = encodeMultibase("base58btc", prefixed);
 	return new TextDecoder().decode(encoded);
 }
@@ -239,6 +236,11 @@ test("importMultibase()", async () => {
 	const ed25519Key = await importMultibaseKey(ed25519Multibase);
 	deepStrictEqual(await exportJwk(ed25519Key), ed25519Jwk);
 });
+test("importMultibase() rejects malformed multicodec prefixes", async () => {
+	const decoder = new TextDecoder();
+	await rejects(() => importMultibaseKey(decoder.decode(encodeMultibase("base58btc", new Uint8Array([])))), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+	await rejects(() => importMultibaseKey(decoder.decode(encodeMultibase("base58btc", Uint8Array.from([128])))), /* @__PURE__ */ new TypeError("Invalid multicodec prefix."));
+});
 test("exportMultibaseKey()", async () => {
 	const rsaKey = await importJwk(rsaJwk, "public");
 	const rsaMb = await exportMultibaseKey(rsaKey);

package/dist/tests/multibase/multibase.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('../chunk-DWy1uDak.cjs');
-const require_multibase = require('../multibase-BFbBiaPE.cjs');
+const require_multibase = require('../multibase-B2D6B0V4.cjs');
 const node_assert = require_chunk.__toESM(require("node:assert"));
 const node_test = require_chunk.__toESM(require("node:test"));
 

package/dist/tests/multibase/multibase.test.js

@@ -1,4 +1,4 @@
-import { codes, decodeMultibase, decodeText, encodeMultibase, encodeText, names } from "../multibase-DStmqni9.js";
+import { codes, decodeMultibase, decodeText, encodeMultibase, encodeText, names } from "../multibase-BdHCGO4H.js";
 import { deepStrictEqual } from "node:assert";
 import { test } from "node:test";
 

package/dist/tests/multicodec-DvC5xnX2.js

@@ -0,0 +1,41 @@
+//#region src/internal/multicodec.ts
+const INVALID_MULTICODEC_PREFIX = "Invalid multicodec prefix.";
+function getMulticodecPrefix(data) {
+	if (data.length < 1) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	let code = 0;
+	let shift = 0;
+	for (let i = 0; i < data.length; i++) {
+		const byte = data[i];
+		code += (byte & 127) * 2 ** shift;
+		if (code > Number.MAX_SAFE_INTEGER) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+		if ((byte & 128) === 0) return {
+			code,
+			prefixLength: i + 1
+		};
+		shift += 7;
+		if (shift >= 53) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	}
+	throw new TypeError(INVALID_MULTICODEC_PREFIX);
+}
+function removeMulticodecPrefix(data) {
+	const { prefixLength } = getMulticodecPrefix(data);
+	return data.slice(prefixLength);
+}
+function addMulticodecPrefix(code, payload) {
+	if (!Number.isSafeInteger(code) || code < 0) throw new TypeError("Invalid multicodec code.");
+	const prefix = [];
+	let value = code;
+	do {
+		let byte = value & 127;
+		value = Math.floor(value / 128);
+		if (value > 0) byte |= 128;
+		prefix.push(byte);
+	} while (value > 0);
+	const prefixed = new Uint8Array(prefix.length + payload.length);
+	prefixed.set(prefix);
+	prefixed.set(payload, prefix.length);
+	return prefixed;
+}
+
+//#endregion
+export { addMulticodecPrefix, getMulticodecPrefix, removeMulticodecPrefix };

package/dist/tests/multicodec-mHcRzSGY.cjs

@@ -0,0 +1,59 @@
+
+//#region src/internal/multicodec.ts
+const INVALID_MULTICODEC_PREFIX = "Invalid multicodec prefix.";
+function getMulticodecPrefix(data) {
+	if (data.length < 1) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	let code = 0;
+	let shift = 0;
+	for (let i = 0; i < data.length; i++) {
+		const byte = data[i];
+		code += (byte & 127) * 2 ** shift;
+		if (code > Number.MAX_SAFE_INTEGER) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+		if ((byte & 128) === 0) return {
+			code,
+			prefixLength: i + 1
+		};
+		shift += 7;
+		if (shift >= 53) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+	}
+	throw new TypeError(INVALID_MULTICODEC_PREFIX);
+}
+function removeMulticodecPrefix(data) {
+	const { prefixLength } = getMulticodecPrefix(data);
+	return data.slice(prefixLength);
+}
+function addMulticodecPrefix(code, payload) {
+	if (!Number.isSafeInteger(code) || code < 0) throw new TypeError("Invalid multicodec code.");
+	const prefix = [];
+	let value = code;
+	do {
+		let byte = value & 127;
+		value = Math.floor(value / 128);
+		if (value > 0) byte |= 128;
+		prefix.push(byte);
+	} while (value > 0);
+	const prefixed = new Uint8Array(prefix.length + payload.length);
+	prefixed.set(prefix);
+	prefixed.set(payload, prefix.length);
+	return prefixed;
+}
+
+//#endregion
+Object.defineProperty(exports, 'addMulticodecPrefix', {
+  enumerable: true,
+  get: function () {
+    return addMulticodecPrefix;
+  }
+});
+Object.defineProperty(exports, 'getMulticodecPrefix', {
+  enumerable: true,
+  get: function () {
+    return getMulticodecPrefix;
+  }
+});
+Object.defineProperty(exports, 'removeMulticodecPrefix', {
+  enumerable: true,
+  get: function () {
+    return removeMulticodecPrefix;
+  }
+});

package/dist/tests/{request-Dlac5CA8.js → request-CvrhEgps.js}

@@ -2,9 +2,12 @@ import process from "node:process";
 
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.6";
+var version = "2.0.7-dev.586+b3928d60";
 var license = "MIT";
-var exports = { ".": "./src/mod.ts" };
+var exports = {
+	".": "./src/mod.ts",
+	"./jsonld": "./src/jsonld.ts"
+};
 var description = "Runtime library for @fedify/vocab";
 var author = {
 	"name": "Hong Minhee",
@@ -16,7 +19,7 @@ var imports = {
 	"asn1js": "npm:asn1js@^3.0.6",
 	"byte-encodings": "npm:byte-encodings@^1.0.11",
 	"fetch-mock": "npm:fetch-mock@^12.5.4",
-	"multicodec": "npm:multicodec@^3.2.1",
+	"jsonld": "npm:jsonld@^9.0.0",
 	"pkijs": "npm:pkijs@^3.2.5"
 };
 var exclude = ["dist", "node_modules"];

package/dist/tests/{request-B7jBLGoM.cjs → request-DHjhMKWk.cjs}

@@ -3,9 +3,12 @@ const node_process = require_chunk.__toESM(require("node:process"));
 
 //#region deno.json
 var name = "@fedify/vocab-runtime";
-var version = "2.0.6";
+var version = "2.0.7-dev.586+b3928d60";
 var license = "MIT";
-var exports$1 = { ".": "./src/mod.ts" };
+var exports$1 = {
+	".": "./src/mod.ts",
+	"./jsonld": "./src/jsonld.ts"
+};
 var description = "Runtime library for @fedify/vocab";
 var author = {
 	"name": "Hong Minhee",
@@ -17,7 +20,7 @@ var imports = {
 	"asn1js": "npm:asn1js@^3.0.6",
 	"byte-encodings": "npm:byte-encodings@^1.0.11",
 	"fetch-mock": "npm:fetch-mock@^12.5.4",
-	"multicodec": "npm:multicodec@^3.2.1",
+	"jsonld": "npm:jsonld@^9.0.0",
 	"pkijs": "npm:pkijs@^3.2.5"
 };
 var exclude = ["dist", "node_modules"];

package/dist/tests/request.test.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('./chunk-DWy1uDak.cjs');
-const require_request = require('./request-B7jBLGoM.cjs');
+const require_request = require('./request-DHjhMKWk.cjs');
 const node_assert = require_chunk.__toESM(require("node:assert"));
 const node_test = require_chunk.__toESM(require("node:test"));
 const node_process = require_chunk.__toESM(require("node:process"));

package/dist/tests/request.test.js

@@ -1,4 +1,4 @@
-import { deno_default, getUserAgent } from "./request-Dlac5CA8.js";
+import { deno_default, getUserAgent } from "./request-CvrhEgps.js";
 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.0.6",
+  "version": "2.0.7-dev.586+b3928d60",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",
@@ -35,6 +35,16 @@
       "require": "./dist/mod.cjs",
       "default": "./dist/mod.js"
     },
+    "./jsonld": {
+      "types": {
+        "import": "./dist/jsonld.d.ts",
+        "require": "./dist/jsonld.d.cts",
+        "default": "./dist/jsonld.d.ts"
+      },
+      "import": "./dist/jsonld.js",
+      "require": "./dist/jsonld.cjs",
+      "default": "./dist/jsonld.js"
+    },
     "./package.json": "./package.json"
   },
   "keywords": [
@@ -60,7 +70,7 @@
     "@opentelemetry/api": "^1.9.0",
     "asn1js": "^3.0.6",
     "byte-encodings": "^1.0.11",
-    "multicodec": "^3.2.1",
+    "jsonld": "^9.0.0",
     "pkijs": "^3.3.3"
   },
   "scripts": {

package/src/internal/multicodec.test.ts

@@ -0,0 +1,68 @@
+import { deepStrictEqual, throws } from "node:assert";
+import { test } from "node:test";
+import {
+  addMulticodecPrefix,
+  getMulticodecPrefix,
+  removeMulticodecPrefix,
+} from "./multicodec.ts";
+
+test("getMulticodecPrefix() decodes supported multicodec prefixes", () => {
+  deepStrictEqual(
+    getMulticodecPrefix(Uint8Array.from([0xed, 0x01, 0xaa])),
+    { code: 0xed, prefixLength: 2 },
+  );
+  deepStrictEqual(
+    getMulticodecPrefix(Uint8Array.from([0x85, 0x24, 0xaa])),
+    { code: 0x1205, prefixLength: 2 },
+  );
+});
+
+test("removeMulticodecPrefix() strips the varint prefix", () => {
+  deepStrictEqual(
+    removeMulticodecPrefix(Uint8Array.from([0xed, 0x01, 0x11, 0x22])),
+    Uint8Array.from([0x11, 0x22]),
+  );
+});
+
+test("addMulticodecPrefix() prepends the varint-encoded code", () => {
+  deepStrictEqual(
+    addMulticodecPrefix(0xed, Uint8Array.from([0x11, 0x22])),
+    Uint8Array.from([0xed, 0x01, 0x11, 0x22]),
+  );
+  deepStrictEqual(
+    addMulticodecPrefix(0x1205, Uint8Array.from([0x11, 0x22])),
+    Uint8Array.from([0x85, 0x24, 0x11, 0x22]),
+  );
+});
+
+test("multicodec helpers round-trip prefixed payloads", () => {
+  const payload = Uint8Array.from([0xde, 0xad, 0xbe, 0xef]);
+  const prefixed = addMulticodecPrefix(0x1205, payload);
+  deepStrictEqual(getMulticodecPrefix(prefixed), {
+    code: 0x1205,
+    prefixLength: 2,
+  });
+  deepStrictEqual(removeMulticodecPrefix(prefixed), payload);
+});
+
+test("multicodec helpers reject malformed prefixes", () => {
+  throws(
+    () => getMulticodecPrefix(new Uint8Array([])),
+    new TypeError("Invalid multicodec prefix."),
+  );
+  throws(
+    () => getMulticodecPrefix(Uint8Array.from([0x80])),
+    new TypeError("Invalid multicodec prefix."),
+  );
+  throws(
+    () =>
+      getMulticodecPrefix(
+        Uint8Array.from([0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80]),
+      ),
+    new TypeError("Invalid multicodec prefix."),
+  );
+  throws(
+    () => addMulticodecPrefix(-1, Uint8Array.from([0x00])),
+    new TypeError("Invalid multicodec code."),
+  );
+});

package/src/internal/multicodec.ts

@@ -0,0 +1,53 @@
+const INVALID_MULTICODEC_PREFIX = "Invalid multicodec prefix.";
+
+export interface MulticodecPrefix {
+  code: number;
+  prefixLength: number;
+}
+
+export function getMulticodecPrefix(
+  data: Uint8Array,
+): MulticodecPrefix {
+  if (data.length < 1) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+  let code = 0;
+  let shift = 0;
+  for (let i = 0; i < data.length; i++) {
+    const byte = data[i];
+    code += (byte & 0x7f) * 2 ** shift;
+    if (code > Number.MAX_SAFE_INTEGER) {
+      throw new TypeError(INVALID_MULTICODEC_PREFIX);
+    }
+    if ((byte & 0x80) === 0) {
+      return { code, prefixLength: i + 1 };
+    }
+    shift += 7;
+    if (shift >= 53) throw new TypeError(INVALID_MULTICODEC_PREFIX);
+  }
+  throw new TypeError(INVALID_MULTICODEC_PREFIX);
+}
+
+export function removeMulticodecPrefix(data: Uint8Array): Uint8Array {
+  const { prefixLength } = getMulticodecPrefix(data);
+  return data.slice(prefixLength);
+}
+
+export function addMulticodecPrefix(
+  code: number,
+  payload: Uint8Array,
+): Uint8Array {
+  if (!Number.isSafeInteger(code) || code < 0) {
+    throw new TypeError("Invalid multicodec code.");
+  }
+  const prefix: number[] = [];
+  let value = code;
+  do {
+    let byte = value & 0x7f;
+    value = Math.floor(value / 0x80);
+    if (value > 0) byte |= 0x80;
+    prefix.push(byte);
+  } while (value > 0);
+  const prefixed = new Uint8Array(prefix.length + payload.length);
+  prefixed.set(prefix);
+  prefixed.set(payload, prefix.length);
+  return prefixed;
+}

package/src/jsonld.ts

@@ -0,0 +1,4 @@
+// @ts-ignore TS7016
+import jsonld from "jsonld/dist/jsonld.esm.js";
+
+export default jsonld as typeof import("jsonld");

package/src/key.test.ts

@@ -1,4 +1,4 @@
-import { deepStrictEqual } from "node:assert";
+import { deepStrictEqual, rejects } from "node:assert";
 import { test } from "node:test";
 import { exportJwk, importJwk } from "./jwk.ts";
 import {
@@ -9,6 +9,7 @@ import {
   importPkcs1,
   importSpki,
 } from "./key.ts";
+import { encodeMultibase } from "./multibase/mod.ts";
 
 // cSpell: disable
 const rsaSpki = "-----BEGIN PUBLIC KEY-----\n" +
@@ -122,6 +123,26 @@ test("importMultibase()", async () => {
   deepStrictEqual(await exportJwk(ed25519Key), ed25519Jwk);
 });
 
+test("importMultibase() rejects malformed multicodec prefixes", async () => {
+  const decoder = new TextDecoder();
+  await rejects(
+    () =>
+      importMultibaseKey(
+        decoder.decode(encodeMultibase("base58btc", new Uint8Array([]))),
+      ),
+    new TypeError("Invalid multicodec prefix."),
+  );
+  await rejects(
+    () =>
+      importMultibaseKey(
+        decoder.decode(
+          encodeMultibase("base58btc", Uint8Array.from([0x80])),
+        ),
+      ),
+    new TypeError("Invalid multicodec prefix."),
+  );
+});
+
 test("exportMultibaseKey()", async () => {
   const rsaKey = await importJwk(rsaJwk, "public");
   const rsaMb = await exportMultibaseKey(rsaKey);

package/src/key.ts

@@ -1,10 +1,13 @@
 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";
+import {
+  addMulticodecPrefix,
+  getMulticodecPrefix,
+  removeMulticodecPrefix,
+} from "./internal/multicodec.ts";
 import { validateCryptoKey } from "./jwk.ts";
 import { decodeMultibase, encodeMultibase } from "./multibase/mod.ts";
 
@@ -101,8 +104,8 @@ export function importPem(pem: string): Promise<CryptoKey> {
  */
 export async function importMultibaseKey(key: string): Promise<CryptoKey> {
   const decoded = decodeMultibase(key);
-  const code: number = getCodeFromData(decoded);
-  const content = rmPrefix(decoded);
+  const { code } = getMulticodecPrefix(decoded);
+  const content = removeMulticodecPrefix(decoded);
   if (code === 0x1205) { // rsa-pub
     const keyObject = createPublicKey({
       // deno-lint-ignore no-explicit-any
@@ -177,11 +180,9 @@ export async function exportMultibaseKey(key: CryptoKey): Promise<string> {
       "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 prefixed = addMulticodecPrefix(code, new Uint8Array(content));
   const encoded = encodeMultibase("base58btc", prefixed);
   return new TextDecoder().decode(encoded);
 }
 
-// cSpell: ignore multicodec pkijs
+// cSpell: ignore pkijs

package/tsdown.config.ts

@@ -4,7 +4,7 @@ import { defineConfig } from "tsdown";
 
 export default [
   defineConfig({
-    entry: ["src/mod.ts"],
+    entry: ["src/mod.ts", "src/jsonld.ts"],
     dts: { compilerOptions: { isolatedDeclarations: true, declaration: true } },
     format: ["esm", "cjs"],
     platform: "neutral",