@fedify/fedify 1.6.1-dev.869 → 1.6.1-dev.871

package/dist/runtime/multibase/base.js

@@ -1,32 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-import { encodeText } from "./util.js";
-
-//#region runtime/multibase/base.ts
-/**
-* Class to encode/decode in the supported Bases
-*/
-var Base = class {
-	codeBuf;
-	codec;
-	constructor(name, code, factory, alphabet) {
-		this.name = name;
-		this.code = code;
-		this.alphabet = alphabet;
-		this.codeBuf = encodeText(this.code);
-		this.alphabet = alphabet;
-		this.codec = factory(alphabet);
-	}
-	encode(buf) {
-		return this.codec.encode(buf);
-	}
-	decode(string) {
-		for (const char of string) if (this.alphabet && this.alphabet.indexOf(char) < 0) throw new Error(`invalid character '${char}' in '${string}'`);
-		return this.codec.decode(string);
-	}
-};
-
-//#endregion
-export { Base };

package/dist/runtime/multibase/constants.js

@@ -1,172 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-import { decodeText, encodeText } from "./util.js";
-import { Base } from "./base.js";
-import { rfc4648 } from "./rfc4648.js";
-import baseX from "@multiformats/base-x";
-
-//#region runtime/multibase/constants.ts
-const identity = () => {
-	return {
-		encode: decodeText,
-		decode: encodeText
-	};
-};
-/**
-* name, code, implementation, alphabet
-*
-* @type {Array<[BaseName, BaseCode, CodecFactory, string]>}
-*/
-const constants = [
-	[
-		"identity",
-		"\0",
-		identity,
-		""
-	],
-	[
-		"base2",
-		"0",
-		rfc4648(1),
-		"01"
-	],
-	[
-		"base8",
-		"7",
-		rfc4648(3),
-		"01234567"
-	],
-	[
-		"base10",
-		"9",
-		baseX,
-		"0123456789"
-	],
-	[
-		"base16",
-		"f",
-		rfc4648(4),
-		"0123456789abcdef"
-	],
-	[
-		"base16upper",
-		"F",
-		rfc4648(4),
-		"0123456789ABCDEF"
-	],
-	[
-		"base32hex",
-		"v",
-		rfc4648(5),
-		"0123456789abcdefghijklmnopqrstuv"
-	],
-	[
-		"base32hexupper",
-		"V",
-		rfc4648(5),
-		"0123456789ABCDEFGHIJKLMNOPQRSTUV"
-	],
-	[
-		"base32hexpad",
-		"t",
-		rfc4648(5),
-		"0123456789abcdefghijklmnopqrstuv="
-	],
-	[
-		"base32hexpadupper",
-		"T",
-		rfc4648(5),
-		"0123456789ABCDEFGHIJKLMNOPQRSTUV="
-	],
-	[
-		"base32",
-		"b",
-		rfc4648(5),
-		"abcdefghijklmnopqrstuvwxyz234567"
-	],
-	[
-		"base32upper",
-		"B",
-		rfc4648(5),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
-	],
-	[
-		"base32pad",
-		"c",
-		rfc4648(5),
-		"abcdefghijklmnopqrstuvwxyz234567="
-	],
-	[
-		"base32padupper",
-		"C",
-		rfc4648(5),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567="
-	],
-	[
-		"base32z",
-		"h",
-		rfc4648(5),
-		"ybndrfg8ejkmcpqxot1uwisza345h769"
-	],
-	[
-		"base36",
-		"k",
-		baseX,
-		"0123456789abcdefghijklmnopqrstuvwxyz"
-	],
-	[
-		"base36upper",
-		"K",
-		baseX,
-		"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-	],
-	[
-		"base58btc",
-		"z",
-		baseX,
-		"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-	],
-	[
-		"base58flickr",
-		"Z",
-		baseX,
-		"123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
-	],
-	[
-		"base64",
-		"m",
-		rfc4648(6),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-	],
-	[
-		"base64pad",
-		"M",
-		rfc4648(6),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
-	],
-	[
-		"base64url",
-		"u",
-		rfc4648(6),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
-	],
-	[
-		"base64urlpad",
-		"U",
-		rfc4648(6),
-		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_="
-	]
-];
-const names = constants.reduce((prev, tupple) => {
-	prev[tupple[0]] = new Base(tupple[0], tupple[1], tupple[2], tupple[3]);
-	return prev;
-}, {});
-const codes = constants.reduce((prev, tupple) => {
-	prev[tupple[1]] = names[tupple[0]];
-	return prev;
-}, {});
-
-//#endregion
-export { codes, names };

package/dist/runtime/multibase/index.js

@@ -1,57 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-import { concat, decodeText, encodeText } from "./util.js";
-import { codes, names } from "./constants.js";
-
-//#region runtime/multibase/index.ts
-/**
-* Encode data with the specified base and add the multibase prefix.
-*
-* @throws {Error} Will throw if the encoding is not supported
-*/
-function encode(nameOrCode, buf) {
-	const enc = encoding(nameOrCode);
-	const data = encodeText(enc.encode(buf));
-	return concat([enc.codeBuf, data], enc.codeBuf.length + data.length);
-}
-/**
-* Takes a Uint8Array or string encoded with multibase header, decodes it and
-* returns the decoded buffer
-*
-* @throws {Error} Will throw if the encoding is not supported
-*/
-function decode(data) {
-	if (data instanceof Uint8Array) data = decodeText(data);
-	const prefix = data[0];
-	if ([
-		"f",
-		"F",
-		"v",
-		"V",
-		"t",
-		"T",
-		"b",
-		"B",
-		"c",
-		"C",
-		"h",
-		"k",
-		"K"
-	].includes(prefix)) data = data.toLowerCase();
-	const enc = encoding(data[0]);
-	return enc.decode(data.substring(1));
-}
-/**
-* Get the encoding by name or code
-* @throws {Error} Will throw if the encoding is not supported
-*/
-function encoding(nameOrCode) {
-	if (Object.prototype.hasOwnProperty.call(names, nameOrCode)) return names[nameOrCode];
-	else if (Object.prototype.hasOwnProperty.call(codes, nameOrCode)) return codes[nameOrCode];
-	else throw new Error(`Unsupported encoding: ${nameOrCode}`);
-}
-
-//#endregion
-export { decode, encode };

package/dist/runtime/multibase/rfc4648.js

@@ -1,61 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-//#region runtime/multibase/rfc4648.ts
-const decode = (string, alphabet, bitsPerChar) => {
-	const codes = {};
-	for (let i = 0; i < alphabet.length; ++i) codes[alphabet[i]] = i;
-	let end = string.length;
-	while (string[end - 1] === "=") --end;
-	const out = new Uint8Array(end * bitsPerChar / 8 | 0);
-	let bits = 0;
-	let buffer = 0;
-	let written = 0;
-	for (let i = 0; i < end; ++i) {
-		const value = codes[string[i]];
-		if (value === void 0) throw new SyntaxError("Invalid character " + string[i]);
-		buffer = buffer << bitsPerChar | value;
-		bits += bitsPerChar;
-		if (bits >= 8) {
-			bits -= 8;
-			out[written++] = 255 & buffer >> bits;
-		}
-	}
-	if (bits >= bitsPerChar || 255 & buffer << 8 - bits) throw new SyntaxError("Unexpected end of data");
-	return out;
-};
-const encode = (data, alphabet, bitsPerChar) => {
-	const pad = alphabet[alphabet.length - 1] === "=";
-	const mask = (1 << bitsPerChar) - 1;
-	let out = "";
-	let bits = 0;
-	let buffer = 0;
-	for (let i = 0; i < data.length; ++i) {
-		buffer = buffer << 8 | data[i];
-		bits += 8;
-		while (bits > bitsPerChar) {
-			bits -= bitsPerChar;
-			out += alphabet[mask & buffer >> bits];
-		}
-	}
-	if (bits) out += alphabet[mask & buffer << bitsPerChar - bits];
-	if (pad) while (out.length * bitsPerChar & 7) out += "=";
-	return out;
-};
-/**
-* RFC4648 Factory
-*/
-const rfc4648 = (bitsPerChar) => (alphabet) => {
-	return {
-		encode(input) {
-			return encode(input, alphabet, bitsPerChar);
-		},
-		decode(input) {
-			return decode(input, alphabet, bitsPerChar);
-		}
-	};
-};
-
-//#endregion
-export { rfc4648 };

package/dist/runtime/multibase/util.js

@@ -1,21 +0,0 @@
-
-      import { Temporal } from "@js-temporal/polyfill";
-      import { URLPattern } from "urlpattern-polyfill";
-    
-//#region runtime/multibase/util.ts
-const textDecoder = new TextDecoder();
-const decodeText = (bytes) => textDecoder.decode(bytes);
-const textEncoder = new TextEncoder();
-const encodeText = (text) => textEncoder.encode(text);
-function concat(arrs, length) {
-	const output = new Uint8Array(length);
-	let offset = 0;
-	for (const arr of arrs) {
-		output.set(arr, offset);
-		offset += arr.length;
-	}
-	return output;
-}
-
-//#endregion
-export { concat, decodeText, encodeText };

package/dist/sig/http.d.ts

@@ -1,143 +0,0 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
-import { DocumentLoader } from "../runtime/docloader.js";
-import { CryptographicKey$1 as CryptographicKey } from "../vocab/vocab.js";
-import { KeyCache } from "./key.js";
-import { TracerProvider } from "@opentelemetry/api";
-
-//#region sig/http.d.ts
-/**
-* The standard to use for signing and verifying HTTP signatures.
-* @since 1.6.0
-*/
-/**
- * The standard to use for signing and verifying HTTP signatures.
- * @since 1.6.0
- */
-type HttpMessageSignaturesSpec =
-/**
- * The Signing HTTP Messages (draft-cavage-http-signatures-12) specification,
- * which is widely adopted and used in the fediverse (as of May 2025).
- */
-"draft-cavage-http-signatures-12"
-/**
- * The HTTP Message Signatures (RFC 9421) specification, which is the
- * finalized standard but not widely adopted yet (as of May 2025).
- */ | "rfc9421";
-/**
- * Options for {@link signRequest}.
- * @since 1.3.0
- */
-interface SignRequestOptions {
-  /**
-   * The HTTP message signatures specification to use for signing.
-   * @default `"draft-cavage-http-signatures-12"`
-   * @since 1.6.0
-   */
-  spec?: HttpMessageSignaturesSpec;
-  /**
-   * The current time.  If not specified, the current time is used.  This is
-   * useful for testing.
-   * @since 1.6.0
-   */
-  currentTime?: Temporal.Instant;
-  /**
-   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
-   * is used.
-   */
-  tracerProvider?: TracerProvider;
-}
-/**
- * Signs a request using the given private key.
- * @param request The request to sign.
- * @param privateKey The private key to use for signing.
- * @param keyId The key ID to use for the signature.  It will be used by the
- *              verifier.
- * @returns The signed request.
- * @throws {TypeError} If the private key is invalid or unsupported.
- */
-declare function signRequest(request: Request, privateKey: CryptoKey, keyId: URL, options?: SignRequestOptions): Promise<Request>;
-/**
- * Options for {@link verifyRequest}.
- */
-interface VerifyRequestOptions {
-  /**
-   * The document loader to use for fetching the public key.
-   */
-  documentLoader?: DocumentLoader;
-  /**
-   * The context loader to use for JSON-LD context retrieval.
-   */
-  contextLoader?: DocumentLoader;
-  /**
-   * The time window to allow for the request date.  The actual time window is
-   * twice the value of this option, with the current time as the center.
-   * Or if it is `false`, no time check is performed.
-   *
-   * An hour by default.
-   */
-  timeWindow?: Temporal.Duration | Temporal.DurationLike | false;
-  /**
-   * The current time.  If not specified, the current time is used.  This is
-   * useful for testing.
-   */
-  currentTime?: Temporal.Instant;
-  /**
-   * The key cache to use for caching public keys.
-   * @since 0.12.0
-   */
-  keyCache?: KeyCache;
-  /**
-   * The HTTP message signatures specification to use for verifying.
-   * @default `"draft-cavage-http-signatures-12"`
-   * @since 1.6.0
-   */
-  spec?: HttpMessageSignaturesSpec;
-  /**
-   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
-   * is used.
-   * @since 1.3.0
-   */
-  tracerProvider?: TracerProvider;
-}
-/**
- * Verifies the signature of a request.
- *
- * Note that this function consumes the request body, so it should not be used
- * if the request body is already consumed.  Consuming the request body after
- * calling this function is okay, since this function clones the request
- * under the hood.
- *
- * @param request The request to verify.
- * @param options Options for verifying the request.
- * @returns The public key of the verified signature, or `null` if the signature
- *          could not be verified.
- */
-declare function verifyRequest(request: Request, options?: VerifyRequestOptions): Promise<CryptographicKey | null>;
-/**
- * A spec determiner for HTTP Message Signatures.
- * It determines the spec to use for signing requests.
- * It is used for double-knocking
- * (see <https://swicg.github.io/activitypub-http-signature/#how-to-upgrade-supported-versions>).
- * @since 1.6.0
- */
-interface HttpMessageSignaturesSpecDeterminer {
-  /**
-   * Determines the spec to use for signing requests.
-   * @param origin The origin of the URL to make the request to.
-   * @returns The spec to use for signing requests.
-   */
-  determineSpec(origin: string): HttpMessageSignaturesSpec | Promise<HttpMessageSignaturesSpec>;
-  /**
-   * Remembers the successfully used spec for the given origin.
-   * @param origin The origin of the URL that was requested.
-   * @param spec The spec to remember.
-   */
-  rememberSpec(origin: string, spec: HttpMessageSignaturesSpec): void | Promise<void>;
-} //#endregion
-
-/**
- * The options for double-knock requests.
- * @since 1.6.0
- */
-export { HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, SignRequestOptions, VerifyRequestOptions, signRequest as signRequest$1, verifyRequest as verifyRequest$1 };

package/dist/sig/key.d.ts

@@ -1,125 +0,0 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
-import { DocumentLoader } from "../runtime/docloader.js";
-import { CryptographicKey$1 as CryptographicKey, Multikey$1 as Multikey } from "../vocab/vocab.js";
-import { TracerProvider } from "@opentelemetry/api";
-
-//#region sig/key.d.ts
-/**
-* Generates a key pair which is appropriate for Fedify.
-* @param algorithm The algorithm to use.  Currently only RSASSA-PKCS1-v1_5 and
-*                  Ed25519 are supported.
-* @returns The generated key pair.
-* @throws {TypeError} If the algorithm is unsupported.
-*/
-
-/**
- * Generates a key pair which is appropriate for Fedify.
- * @param algorithm The algorithm to use.  Currently only RSASSA-PKCS1-v1_5 and
- *                  Ed25519 are supported.
- * @returns The generated key pair.
- * @throws {TypeError} If the algorithm is unsupported.
- */
-declare function generateCryptoKeyPair(algorithm?: "RSASSA-PKCS1-v1_5" | "Ed25519"): Promise<CryptoKeyPair>;
-/**
- * Exports a key in JWK format.
- * @param key The key to export.  Either public or private key.
- * @returns The exported key in JWK format.  The key is suitable for
- *          serialization and storage.
- * @throws {TypeError} If the key is invalid or unsupported.
- */
-declare function exportJwk(key: CryptoKey): Promise<JsonWebKey>;
-/**
- * Imports a key from JWK format.
- * @param jwk The key in JWK format.
- * @param type Which type of key to import, either `"public"` or `"private"`.
- * @returns The imported key.
- * @throws {TypeError} If the key is invalid or unsupported.
- */
-declare function importJwk(jwk: JsonWebKey, type: "public" | "private"): Promise<CryptoKey>;
-/**
- * Options for {@link fetchKey}.
- * @since 1.3.0
- */
-interface FetchKeyOptions {
-  /**
-   * The document loader for loading remote JSON-LD documents.
-   */
-  documentLoader?: DocumentLoader;
-  /**
-   * The context loader for loading remote JSON-LD contexts.
-   */
-  contextLoader?: DocumentLoader;
-  /**
-   * The key cache to use for caching public keys.
-   * @since 0.12.0
-   */
-  keyCache?: KeyCache;
-  /**
-   * The OpenTelemetry tracer provider to use for tracing.  If omitted,
-   * the global tracer provider is used.
-   * @since 1.3.0
-   */
-  tracerProvider?: TracerProvider;
-}
-/**
- * The result of {@link fetchKey}.
- * @since 1.3.0
- */
-interface FetchKeyResult<T extends CryptographicKey | Multikey> {
-  /**
-   * The fetched (or cached) key.
-   */
-  readonly key: T & {
-    publicKey: CryptoKey;
-  } | null;
-  /**
-   * Whether the key is fetched from the cache.
-   */
-  readonly cached: boolean;
-}
-/**
- * Fetches a {@link CryptographicKey} or {@link Multikey} from the given URL.
- * If the given URL contains an {@link Actor} object, it tries to find
- * the corresponding key in the `publicKey` or `assertionMethod` property.
- * @typeParam T The type of the key to fetch.  Either {@link CryptographicKey}
- *              or {@link Multikey}.
- * @param keyId The URL of the key.
- * @param cls The class of the key to fetch.  Either {@link CryptographicKey}
- *            or {@link Multikey}.
- * @param options Options for fetching the key.  See {@link FetchKeyOptions}.
- * @returns The fetched key or `null` if the key is not found.
- * @since 1.3.0
- */
-declare function fetchKey<T extends CryptographicKey | Multikey>(keyId: URL | string, cls: (new (...args: any[]) => T) & {
-  fromJsonLd(jsonLd: unknown, options: {
-    documentLoader?: DocumentLoader;
-    contextLoader?: DocumentLoader;
-    tracerProvider?: TracerProvider;
-  }): Promise<T>;
-}, options?: FetchKeyOptions): Promise<FetchKeyResult<T>>;
-/**
- * A cache for storing cryptographic keys.
- * @since 0.12.0
- */
-interface KeyCache {
-  /**
-   * Gets a key from the cache.
-   * @param keyId The key ID.
-   * @returns The key if found, `null` if the key is not available (e.g.,
-   *          fetching the key was tried but failed), or `undefined`
-   *          if the cache is not available.
-   */
-  get(keyId: URL): Promise<CryptographicKey | Multikey | null | undefined>;
-  /**
-   * Sets a key to the cache.
-   *
-   * Note that this caches unavailable keys (i.e., `null`) as well,
-   * and it is recommended to make unavailable keys expire after a short period.
-   * @param keyId The key ID.
-   * @param key The key to cache.  `null` means the key is not available
-   *            (e.g., fetching the key was tried but failed).
-   */
-  set(keyId: URL, key: CryptographicKey | Multikey | null): Promise<void>;
-} //#endregion
-export { FetchKeyOptions, FetchKeyResult, KeyCache, exportJwk as exportJwk$1, fetchKey as fetchKey$1, generateCryptoKeyPair as generateCryptoKeyPair$1, importJwk as importJwk$1 };