@fedify/fedify 2.1.1 → 2.1.3

package/dist/{proof-sCID81Ua.cjs → proof-D39qiki3.cjs}

@@ -1,20 +1,19 @@
-
-          const { Temporal } = require("@js-temporal/polyfill");
-          const { URLPattern } = require("urlpattern-polyfill");
-        
-const require_chunk = require('./chunk-CGaQZ11T.cjs');
-const require_http = require('./http-ca2xny58.cjs');
-const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
-const __fedify_vocab = require_chunk.__toESM(require("@fedify/vocab"));
-const __opentelemetry_api = require_chunk.__toESM(require("@opentelemetry/api"));
-const byte_encodings_hex = require_chunk.__toESM(require("byte-encodings/hex"));
-const __fedify_vocab_runtime = require_chunk.__toESM(require("@fedify/vocab-runtime"));
-const byte_encodings_base64 = require_chunk.__toESM(require("byte-encodings/base64"));
-const __fedify_vocab_runtime_jsonld = require_chunk.__toESM(require("@fedify/vocab-runtime/jsonld"));
-const json_canon = require_chunk.__toESM(require("json-canon"));
-
+const { Temporal } = require("@js-temporal/polyfill");
+const { URLPattern } = require("urlpattern-polyfill");
+const require_chunk = require("./chunk-DDcVe30Y.cjs");
+const require_http = require("./http-BngkmEhl.cjs");
+let _logtape_logtape = require("@logtape/logtape");
+let _fedify_vocab = require("@fedify/vocab");
+let _opentelemetry_api = require("@opentelemetry/api");
+let byte_encodings_hex = require("byte-encodings/hex");
+let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
+let byte_encodings_base64 = require("byte-encodings/base64");
+let _fedify_vocab_runtime_jsonld = require("@fedify/vocab-runtime/jsonld");
+_fedify_vocab_runtime_jsonld = require_chunk.__toESM(_fedify_vocab_runtime_jsonld);
+let json_canon = require("json-canon");
+json_canon = require_chunk.__toESM(json_canon);
 //#region src/sig/ld.ts
-const logger$1 = (0, __logtape_logtape.getLogger)([
+const logger$1 = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"sig",
 	"ld"
@@ -54,11 +53,8 @@ async function createSignature(jsonLd, privateKey, keyId, { contextLoader, creat
 		creator: keyId.href,
 		created: created?.toString() ?? (/* @__PURE__ */ new Date()).toISOString()
 	};
-	const optionsHash = await hashJsonLd(options, contextLoader);
-	const docHash = await hashJsonLd(jsonLd, contextLoader);
-	const message = optionsHash + docHash;
-	const encoder = new TextEncoder();
-	const messageBytes = encoder.encode(message);
+	const message = await hashJsonLd(options, contextLoader) + await hashJsonLd(jsonLd, contextLoader);
+	const messageBytes = new TextEncoder().encode(message);
 	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", privateKey, messageBytes);
 	return {
 		...options,
@@ -80,9 +76,7 @@ async function createSignature(jsonLd, privateKey, keyId, { contextLoader, creat
 * @since 1.0.0
 */
 async function signJsonLd(jsonLd, privateKey, keyId, options) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(require_http.deno_default.name, require_http.deno_default.version);
-	return await tracer.startActiveSpan("ld_signatures.sign", { attributes: { "ld_signatures.key_id": keyId.href } }, async (span) => {
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(require_http.name, require_http.version).startActiveSpan("ld_signatures.sign", { attributes: { "ld_signatures.key_id": keyId.href } }, async (span) => {
 		try {
 			const signature = await createSignature(jsonLd, privateKey, keyId, options);
 			if (span.isRecording()) {
@@ -92,7 +86,7 @@ async function signJsonLd(jsonLd, privateKey, keyId, options) {
 			return attachSignature(jsonLd, signature);
 		} catch (error) {
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
 			throw error;
@@ -150,7 +144,7 @@ async function verifySignature(jsonLd, options = {}) {
 		});
 		return null;
 	}
-	const { key, cached } = await require_http.fetchKey(new URL(sig.creator), __fedify_vocab.CryptographicKey, options);
+	const { key, cached } = await require_http.fetchKey(new URL(sig.creator), _fedify_vocab.CryptographicKey, options);
 	if (key == null) return null;
 	const sigOpts = {
 		...sig,
@@ -184,23 +178,21 @@ async function verifySignature(jsonLd, options = {}) {
 	const encoder = new TextEncoder();
 	const message = sigOptsHash + docHash;
 	const messageBytes = encoder.encode(message);
-	const verified = await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes);
-	if (verified) return key;
+	if (await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes)) return key;
 	if (cached) {
 		logger$1.debug("Failed to verify with the cached key {keyId}; signature {signatureValue} is invalid.  Retrying with the freshly fetched key...", {
 			keyId: sig.creator,
 			...sig
 		});
-		const { key: key$1 } = await require_http.fetchKey(new URL(sig.creator), __fedify_vocab.CryptographicKey, {
+		const { key } = await require_http.fetchKey(new URL(sig.creator), _fedify_vocab.CryptographicKey, {
 			...options,
 			keyCache: {
 				get: () => Promise.resolve(void 0),
-				set: async (keyId, key$2) => await options.keyCache?.set(keyId, key$2)
+				set: async (keyId, key) => await options.keyCache?.set(keyId, key)
 			}
 		});
-		if (key$1 == null) return null;
-		const verified$1 = await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key$1.publicKey, signature.slice(), messageBytes);
-		return verified$1 ? key$1 : null;
+		if (key == null) return null;
+		return await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes) ? key : null;
 	}
 	logger$1.debug("Failed to verify with the fetched key {keyId}; signature {signatureValue} is invalid.  Check if the key is correct or if the signed message is correct.  The message to sign is:\n{message}", {
 		keyId: sig.creator,
@@ -219,20 +211,18 @@ async function verifySignature(jsonLd, options = {}) {
 * @returns `true` if the document is authentic; `false` otherwise.
 */
 async function verifyJsonLd(jsonLd, options = {}) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(require_http.deno_default.name, require_http.deno_default.version);
-	return await tracer.startActiveSpan("ld_signatures.verify", async (span) => {
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(require_http.name, require_http.version).startActiveSpan("ld_signatures.verify", async (span) => {
 		try {
-			const object = await __fedify_vocab.Object.fromJsonLd(jsonLd, options);
+			const object = await _fedify_vocab.Object.fromJsonLd(jsonLd, options);
 			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
-			span.setAttribute("activitypub.object.type", (0, __fedify_vocab.getTypeId)(object).href);
+			span.setAttribute("activitypub.object.type", (0, _fedify_vocab.getTypeId)(object).href);
 			if (typeof jsonLd === "object" && jsonLd != null && "signature" in jsonLd && typeof jsonLd.signature === "object" && jsonLd.signature != null) {
 				if ("creator" in jsonLd.signature && typeof jsonLd.signature.creator === "string") span.setAttribute("ld_signatures.key_id", jsonLd.signature.creator);
 				if ("signatureValue" in jsonLd.signature && typeof jsonLd.signature.signatureValue === "string") span.setAttribute("ld_signatures.signature", jsonLd.signature.signatureValue);
 				if ("type" in jsonLd.signature && typeof jsonLd.signature.type === "string") span.setAttribute("ld_signatures.type", jsonLd.signature.type);
 			}
 			const attributions = new Set(object.attributionIds.map((uri) => uri.href));
-			if (object instanceof __fedify_vocab.Activity) for (const uri of object.actorIds) attributions.add(uri.href);
+			if (object instanceof _fedify_vocab.Activity) for (const uri of object.actorIds) attributions.add(uri.href);
 			const key = await verifySignature(jsonLd, options);
 			if (key == null) return false;
 			if (key.ownerId == null) {
@@ -247,7 +237,7 @@ async function verifyJsonLd(jsonLd, options = {}) {
 			return true;
 		} catch (error) {
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
 			throw error;
@@ -257,15 +247,13 @@ async function verifyJsonLd(jsonLd, options = {}) {
 	});
 }
 async function hashJsonLd(jsonLd, contextLoader) {
-	const canon = await __fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
+	const canon = await _fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
 		format: "application/n-quads",
-		documentLoader: contextLoader ?? (0, __fedify_vocab_runtime.getDocumentLoader)()
+		documentLoader: contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)()
 	});
 	const encoder = new TextEncoder();
-	const hash = await crypto.subtle.digest("SHA-256", encoder.encode(canon));
-	return (0, byte_encodings_hex.encodeHex)(hash);
+	return (0, byte_encodings_hex.encodeHex)(await crypto.subtle.digest("SHA-256", encoder.encode(canon)));
 }
-
 //#endregion
 //#region src/sig/owner.ts
 /**
@@ -276,10 +264,8 @@ async function hashJsonLd(jsonLd, contextLoader) {
 * @returns Whether the actor is the owner of the key.
 */
 async function doesActorOwnKey(activity, key, options) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(require_http.deno_default.name, require_http.deno_default.version);
-	return await tracer.startActiveSpan("activitypub.verify_key_ownership", {
-		kind: __opentelemetry_api.SpanKind.INTERNAL,
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(require_http.name, require_http.version).startActiveSpan("activitypub.verify_key_ownership", {
+		kind: _opentelemetry_api.SpanKind.INTERNAL,
 		attributes: {
 			"activitypub.actor.id": activity.actorId?.href ?? "",
 			"activitypub.key.id": key.id?.href ?? ""
@@ -293,7 +279,7 @@ async function doesActorOwnKey(activity, key, options) {
 				return owns;
 			}
 			const actor = await activity.getActor(options);
-			if (actor == null || !(0, __fedify_vocab.isActor)(actor)) {
+			if (actor == null || !(0, _fedify_vocab.isActor)(actor)) {
 				span.setAttribute("activitypub.key_ownership.verified", false);
 				span.setAttribute("activitypub.key_ownership.method", "actor_fetch");
 				return false;
@@ -309,7 +295,7 @@ async function doesActorOwnKey(activity, key, options) {
 		} catch (error) {
 			span.recordException(error);
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
 			throw error;
@@ -329,11 +315,11 @@ async function doesActorOwnKey(activity, key, options) {
 * @since 0.7.0
 */
 async function getKeyOwner(keyId, options) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const documentLoader = options.documentLoader ?? (0, __fedify_vocab_runtime.getDocumentLoader)();
-	const contextLoader = options.contextLoader ?? (0, __fedify_vocab_runtime.getDocumentLoader)();
+	const tracerProvider = options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
+	const documentLoader = options.documentLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const contextLoader = options.contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
 	let object;
-	if (keyId instanceof __fedify_vocab.CryptographicKey) {
+	if (keyId instanceof _fedify_vocab.CryptographicKey) {
 		object = keyId;
 		if (object.id == null) return null;
 		keyId = object.id;
@@ -346,7 +332,7 @@ async function getKeyOwner(keyId, options) {
 			return null;
 		}
 		try {
-			object = await __fedify_vocab.Object.fromJsonLd(keyDoc, {
+			object = await _fedify_vocab.Object.fromJsonLd(keyDoc, {
 				documentLoader,
 				contextLoader,
 				tracerProvider
@@ -354,35 +340,34 @@ async function getKeyOwner(keyId, options) {
 		} catch (e) {
 			if (!(e instanceof TypeError)) throw e;
 			try {
-				object = await __fedify_vocab.CryptographicKey.fromJsonLd(keyDoc, {
+				object = await _fedify_vocab.CryptographicKey.fromJsonLd(keyDoc, {
 					documentLoader,
 					contextLoader,
 					tracerProvider
 				});
-			} catch (e$1) {
-				if (e$1 instanceof TypeError) return null;
-				throw e$1;
+			} catch (e) {
+				if (e instanceof TypeError) return null;
+				throw e;
 			}
 		}
 	}
 	let owner = null;
-	if (object instanceof __fedify_vocab.CryptographicKey) {
+	if (object instanceof _fedify_vocab.CryptographicKey) {
 		if (object.ownerId == null) return null;
 		owner = await object.getOwner({
 			documentLoader,
 			contextLoader,
 			tracerProvider
 		});
-	} else if ((0, __fedify_vocab.isActor)(object)) owner = object;
+	} else if ((0, _fedify_vocab.isActor)(object)) owner = object;
 	else return null;
 	if (owner == null) return null;
 	for (const kid of owner.publicKeyIds) if (kid.href === keyId.href) return owner;
 	return null;
 }
-
 //#endregion
 //#region src/sig/proof.ts
-const logger = (0, __logtape_logtape.getLogger)([
+const logger = (0, _logtape_logtape.getLogger)([
 	"fedify",
 	"sig",
 	"proof"
@@ -400,8 +385,7 @@ const logger = (0, __logtape_logtape.getLogger)([
 async function createProof(object, privateKey, keyId, { contextLoader, context, created } = {}) {
 	require_http.validateCryptoKey(privateKey, "private");
 	if (privateKey.algorithm.name !== "Ed25519") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
-	const objectWithoutProofs = object.clone({ proofs: [] });
-	const compactMsg = await objectWithoutProofs.toJsonLd({
+	const compactMsg = await object.clone({ proofs: [] }).toJsonLd({
 		format: "compact",
 		contextLoader,
 		context
@@ -411,22 +395,21 @@ async function createProof(object, privateKey, keyId, { contextLoader, context,
 	const msgBytes = encoder.encode(msgCanon);
 	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
 	created ??= Temporal.Now.instant();
-	const proofConfig = {
+	const proofCanon = (0, json_canon.default)({
 		"@context": compactMsg["@context"],
 		type: "DataIntegrityProof",
 		cryptosuite: "eddsa-jcs-2022",
 		verificationMethod: keyId.href,
 		proofPurpose: "assertionMethod",
 		created: created.toString()
-	};
-	const proofCanon = (0, json_canon.default)(proofConfig);
+	});
 	const proofBytes = encoder.encode(proofCanon);
 	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
 	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
 	digest.set(new Uint8Array(proofDigest), 0);
 	digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
 	const sig = await crypto.subtle.sign("Ed25519", privateKey, digest);
-	return new __fedify_vocab.DataIntegrityProof({
+	return new _fedify_vocab.DataIntegrityProof({
 		cryptosuite: "eddsa-jcs-2022",
 		verificationMethod: keyId,
 		proofPurpose: "assertionMethod",
@@ -445,13 +428,11 @@ async function createProof(object, privateKey, keyId, { contextLoader, context,
 * @since 0.10.0
 */
 async function signObject(object, privateKey, keyId, options = {}) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(require_http.deno_default.name, require_http.deno_default.version);
-	return await tracer.startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": (0, __fedify_vocab.getTypeId)(object).href } }, async (span) => {
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(require_http.name, require_http.version).startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": (0, _fedify_vocab.getTypeId)(object).href } }, async (span) => {
 		try {
 			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
 			const existingProofs = [];
-			for await (const proof$1 of object.getProofs(options)) existingProofs.push(proof$1);
+			for await (const proof of object.getProofs(options)) existingProofs.push(proof);
 			const proof = await createProof(object, privateKey, keyId, options);
 			if (span.isRecording()) {
 				if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
@@ -461,7 +442,7 @@ async function signObject(object, privateKey, keyId, options = {}) {
 			return object.clone({ proofs: [...existingProofs, proof] });
 		} catch (error) {
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
 			throw error;
@@ -481,9 +462,7 @@ async function signObject(object, privateKey, keyId, options = {}) {
 * @since 0.10.0
 */
 async function verifyProof(jsonLd, proof, options = {}) {
-	const tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(require_http.deno_default.name, require_http.deno_default.version);
-	return await tracer.startActiveSpan("object_integrity_proofs.verify", async (span) => {
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(require_http.name, require_http.version).startActiveSpan("object_integrity_proofs.verify", async (span) => {
 		if (span.isRecording()) {
 			if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
 			if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
@@ -491,11 +470,11 @@ async function verifyProof(jsonLd, proof, options = {}) {
 		}
 		try {
 			const key = await verifyProofInternal(jsonLd, proof, options);
-			if (key == null) span.setStatus({ code: __opentelemetry_api.SpanStatusCode.ERROR });
+			if (key == null) span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
 			return key;
 		} catch (error) {
 			span.setStatus({
-				code: __opentelemetry_api.SpanStatusCode.ERROR,
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
 				message: String(error)
 			});
 			throw error;
@@ -506,16 +485,15 @@ async function verifyProof(jsonLd, proof, options = {}) {
 }
 async function verifyProofInternal(jsonLd, proof, options) {
 	if (typeof jsonLd !== "object" || proof.cryptosuite !== "eddsa-jcs-2022" || proof.verificationMethodId == null || proof.proofPurpose !== "assertionMethod" || proof.proofValue == null || proof.created == null) return null;
-	const publicKeyPromise = require_http.fetchKey(proof.verificationMethodId, __fedify_vocab.Multikey, options);
-	const proofConfig = {
+	const publicKeyPromise = require_http.fetchKey(proof.verificationMethodId, _fedify_vocab.Multikey, options);
+	const proofCanon = (0, json_canon.default)({
 		"@context": jsonLd["@context"],
 		type: "DataIntegrityProof",
 		cryptosuite: proof.cryptosuite,
 		verificationMethod: proof.verificationMethodId.href,
 		proofPurpose: proof.proofPurpose,
 		created: proof.created.toString()
-	};
-	const proofCanon = (0, json_canon.default)(proofConfig);
+	});
 	const encoder = new TextEncoder();
 	const proofBytes = encoder.encode(proofCanon);
 	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
@@ -566,8 +544,7 @@ async function verifyProofInternal(jsonLd, proof, options) {
 		});
 		return null;
 	}
-	const verified = await crypto.subtle.verify("Ed25519", publicKey.publicKey, proof.proofValue.slice(), digest);
-	if (!verified) {
+	if (!await crypto.subtle.verify("Ed25519", publicKey.publicKey, proof.proofValue.slice(), digest)) {
 		if (fetchedKey.cached) {
 			logger.debug("Failed to verify the proof with the cached key {keyId}; retrying with the freshly fetched key...", {
 				keyId: proof.verificationMethodId.href,
@@ -604,106 +581,105 @@ async function verifyProofInternal(jsonLd, proof, options) {
 * @since 0.10.0
 */
 async function verifyObject(cls, jsonLd, options = {}) {
-	const logger$2 = (0, __logtape_logtape.getLogger)([
+	const logger = (0, _logtape_logtape.getLogger)([
 		"fedify",
 		"sig",
 		"proof"
 	]);
 	const object = await cls.fromJsonLd(jsonLd, options);
 	const attributions = new Set(object.attributionIds.map((uri) => uri.href));
-	if (object instanceof __fedify_vocab.Activity) for (const uri of object.actorIds) attributions.add(uri.href);
+	if (object instanceof _fedify_vocab.Activity) for (const uri of object.actorIds) attributions.add(uri.href);
 	for await (const proof of object.getProofs(options)) {
 		const key = await verifyProof(jsonLd, proof, options);
 		if (key === null) return null;
 		if (key.controllerId == null) {
-			logger$2.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
+			logger.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
 			continue;
 		}
 		attributions.delete(key.controllerId.href);
 	}
 	if (attributions.size > 0) {
-		logger$2.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
+		logger.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
 		return null;
 	}
 	return object;
 }
-
 //#endregion
-Object.defineProperty(exports, 'attachSignature', {
-  enumerable: true,
-  get: function () {
-    return attachSignature;
-  }
+Object.defineProperty(exports, "attachSignature", {
+	enumerable: true,
+	get: function() {
+		return attachSignature;
+	}
 });
-Object.defineProperty(exports, 'createProof', {
-  enumerable: true,
-  get: function () {
-    return createProof;
-  }
+Object.defineProperty(exports, "createProof", {
+	enumerable: true,
+	get: function() {
+		return createProof;
+	}
+});
+Object.defineProperty(exports, "createSignature", {
+	enumerable: true,
+	get: function() {
+		return createSignature;
+	}
 });
-Object.defineProperty(exports, 'createSignature', {
-  enumerable: true,
-  get: function () {
-    return createSignature;
-  }
+Object.defineProperty(exports, "detachSignature", {
+	enumerable: true,
+	get: function() {
+		return detachSignature;
+	}
 });
-Object.defineProperty(exports, 'detachSignature', {
-  enumerable: true,
-  get: function () {
-    return detachSignature;
-  }
+Object.defineProperty(exports, "doesActorOwnKey", {
+	enumerable: true,
+	get: function() {
+		return doesActorOwnKey;
+	}
 });
-Object.defineProperty(exports, 'doesActorOwnKey', {
-  enumerable: true,
-  get: function () {
-    return doesActorOwnKey;
-  }
+Object.defineProperty(exports, "getKeyOwner", {
+	enumerable: true,
+	get: function() {
+		return getKeyOwner;
+	}
 });
-Object.defineProperty(exports, 'getKeyOwner', {
-  enumerable: true,
-  get: function () {
-    return getKeyOwner;
-  }
+Object.defineProperty(exports, "hasSignature", {
+	enumerable: true,
+	get: function() {
+		return hasSignature;
+	}
 });
-Object.defineProperty(exports, 'hasSignature', {
-  enumerable: true,
-  get: function () {
-    return hasSignature;
-  }
+Object.defineProperty(exports, "signJsonLd", {
+	enumerable: true,
+	get: function() {
+		return signJsonLd;
+	}
 });
-Object.defineProperty(exports, 'signJsonLd', {
-  enumerable: true,
-  get: function () {
-    return signJsonLd;
-  }
+Object.defineProperty(exports, "signObject", {
+	enumerable: true,
+	get: function() {
+		return signObject;
+	}
 });
-Object.defineProperty(exports, 'signObject', {
-  enumerable: true,
-  get: function () {
-    return signObject;
-  }
+Object.defineProperty(exports, "verifyJsonLd", {
+	enumerable: true,
+	get: function() {
+		return verifyJsonLd;
+	}
 });
-Object.defineProperty(exports, 'verifyJsonLd', {
-  enumerable: true,
-  get: function () {
-    return verifyJsonLd;
-  }
+Object.defineProperty(exports, "verifyObject", {
+	enumerable: true,
+	get: function() {
+		return verifyObject;
+	}
 });
-Object.defineProperty(exports, 'verifyObject', {
-  enumerable: true,
-  get: function () {
-    return verifyObject;
-  }
+Object.defineProperty(exports, "verifyProof", {
+	enumerable: true,
+	get: function() {
+		return verifyProof;
+	}
 });
-Object.defineProperty(exports, 'verifyProof', {
-  enumerable: true,
-  get: function () {
-    return verifyProof;
-  }
+Object.defineProperty(exports, "verifySignature", {
+	enumerable: true,
+	get: function() {
+		return verifySignature;
+	}
 });
-Object.defineProperty(exports, 'verifySignature', {
-  enumerable: true,
-  get: function () {
-    return verifySignature;
-  }
-});