@fedify/vocab-runtime 2.0.0-dev.100

package/src/mod.ts

@@ -0,0 +1,47 @@
+/**
+ * This package contains the runtime facilities for working with Activity
+ * Vocabulary objects, which are auto-generated from the IDL.
+ *
+ * @module
+ */
+export { default as preloadedContexts } from "./contexts.ts";
+export {
+  type AuthenticatedDocumentLoaderFactory,
+  type DocumentLoader,
+  type DocumentLoaderFactory,
+  type DocumentLoaderFactoryOptions,
+  type DocumentLoaderOptions,
+  getDocumentLoader,
+  type GetDocumentLoaderOptions,
+  getRemoteDocument,
+  type RemoteDocument,
+} from "./docloader.ts";
+export {
+  exportMultibaseKey,
+  exportSpki,
+  importMultibaseKey,
+  importPem,
+  importPkcs1,
+  importSpki,
+} from "./key.ts";
+export { LanguageString } from "./langstr.ts";
+export {
+  decodeMultibase,
+  encodeMultibase,
+  encodingFromBaseData,
+} from "./multibase/mod.ts";
+export {
+  createActivityPubRequest,
+  type CreateRequestOptions,
+  FetchError,
+  getUserAgent,
+  type GetUserAgentOptions,
+  logRequest,
+} from "./request.ts";
+export {
+  expandIPv6Address,
+  isValidPublicIPv4Address,
+  isValidPublicIPv6Address,
+  UrlError,
+  validatePublicUrl,
+} from "./url.ts";

package/src/multibase/base.ts

@@ -0,0 +1,34 @@
+import { encodeText } from "./util.ts";
+import type { BaseCode, BaseName, Codec, CodecFactory } from "./types.d.ts";
+
+/**
+ * Class to encode/decode in the supported Bases
+ */
+export class Base {
+  public codeBuf: Uint8Array;
+  codec: Codec;
+
+  constructor(
+    public name: BaseName,
+    private code: BaseCode,
+    factory: CodecFactory,
+    private alphabet: string,
+  ) {
+    this.codeBuf = encodeText(this.code);
+    this.alphabet = alphabet;
+    this.codec = factory(alphabet);
+  }
+
+  encode(buf: Uint8Array): string {
+    return this.codec.encode(buf);
+  }
+
+  decode(string: string): Uint8Array {
+    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);
+  }
+}

package/src/multibase/constants.ts

@@ -0,0 +1,89 @@
+import baseX from "@multiformats/base-x";
+import { Base } from "./base.ts";
+import { rfc4648 } from "./rfc4648.ts";
+import { decodeText, encodeText } from "./util.ts";
+import type { BaseCode, BaseName, CodecFactory } from "./types.d.ts";
+
+const identity: CodecFactory = () => {
+  return {
+    encode: decodeText,
+    decode: encodeText,
+  };
+};
+
+/**
+ * name, code, implementation, alphabet
+ *
+ * @type {Array<[BaseName, BaseCode, CodecFactory, string]>}
+ */
+const constants: Array<[BaseName, BaseCode, CodecFactory, string]> = [
+  ["identity", "\x00", 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-_=",
+  ],
+];
+
+export const names = constants.reduce<Record<BaseName, Base>>(
+  (prev, tupple) => {
+    prev[tupple[0]] = new Base(tupple[0], tupple[1], tupple[2], tupple[3]);
+    return prev;
+  },
+  {} as Record<BaseName, Base>,
+);
+
+export const codes = constants.reduce<Record<BaseCode, Base>>(
+  (prev, tupple) => {
+    prev[tupple[1]] = names[tupple[0]];
+    return prev;
+  },
+  {} as Record<BaseCode, Base>,
+);

package/src/multibase/mod.ts

@@ -0,0 +1,82 @@
+import type { Base } from "./base.ts";
+import * as constants from "./constants.ts";
+import type { BaseCode, BaseName, BaseNameOrCode } from "./types.d.ts";
+import { concat, decodeText, encodeText } from "./util.ts";
+
+/**
+ * Encode data with the specified base and add the multibase prefix.
+ *
+ * @throws {Error} Will throw if the encoding is not supported
+ */
+export function encodeMultibase(
+  nameOrCode: BaseNameOrCode,
+  buf: Uint8Array,
+): Uint8Array {
+  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
+ */
+export function decodeMultibase(data: Uint8Array | string): Uint8Array {
+  if (data instanceof Uint8Array) {
+    data = decodeText(data);
+  }
+  const prefix = data[0];
+
+  // Make all encodings case-insensitive except the ones that include upper and lower chars in the alphabet
+  if (
+    ["f", "F", "v", "V", "t", "T", "b", "B", "c", "C", "h", "k", "K"].includes(
+      prefix,
+    )
+  ) {
+    data = data.toLowerCase();
+  }
+  const enc = encoding(data[0] as BaseCode);
+  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: BaseNameOrCode): Base {
+  if (
+    Object.prototype.hasOwnProperty.call(
+      constants.names,
+      nameOrCode as BaseName,
+    )
+  ) {
+    return constants.names[nameOrCode as BaseName];
+  } else if (
+    Object.prototype.hasOwnProperty.call(
+      constants.codes,
+      /** @type {BaseCode} */ (nameOrCode),
+    )
+  ) {
+    return constants.codes[nameOrCode as BaseCode];
+  } else {
+    throw new Error(`Unsupported encoding: ${nameOrCode}`);
+  }
+}
+
+/**
+ * Get encoding multibase from data
+ *
+ * @param {string|Uint8Array} data
+ * @returns {Base}
+ * @throws {Error} Will throw if the encoding is not supported
+ */
+export function encodingFromBaseData(data: string | Uint8Array): Base {
+  if (data instanceof Uint8Array) {
+    data = decodeText(data);
+  }
+
+  return encoding(data[0] as BaseCode);
+}

package/src/multibase/multibase.test.ts

@@ -0,0 +1,117 @@
+import { deepStrictEqual } from "node:assert";
+import { test } from "node:test";
+import * as constants from "./constants.ts";
+import { decodeMultibase, encodeMultibase } from "./mod.ts";
+import type { BaseName } from "./types.d.ts";
+import { decodeText, encodeText } from "./util.ts";
+
+test("multibase.encode and decode", async (t) => {
+  const testCases: Array<[BaseName, string, string]> = [
+    ["base16", decodeText(Uint8Array.from([0x01])), "f01"],
+    ["base16", decodeText(Uint8Array.from([15])), "f0f"],
+    ["base16", "f", "f66"],
+    ["base16", "fo", "f666f"],
+    ["base16", "foo", "f666f6f"],
+    ["base16", "foob", "f666f6f62"],
+    ["base16", "fooba", "f666f6f6261"],
+    ["base16", "foobar", "f666f6f626172"],
+    ["base32", "yes mani !", "bpfsxgidnmfxgsibb"],
+    ["base32", "f", "bmy"],
+    ["base32", "fo", "bmzxq"],
+    ["base32", "foo", "bmzxw6"],
+    ["base32", "foob", "bmzxw6yq"],
+    ["base32", "fooba", "bmzxw6ytb"],
+    ["base32", "foobar", "bmzxw6ytboi"],
+    ["base32pad", "yes mani !", "cpfsxgidnmfxgsibb"],
+    ["base32pad", "f", "cmy======"],
+    ["base32pad", "fo", "cmzxq===="],
+    ["base32pad", "foo", "cmzxw6==="],
+    ["base32pad", "foob", "cmzxw6yq="],
+    ["base32pad", "fooba", "cmzxw6ytb"],
+    ["base32pad", "foobar", "cmzxw6ytboi======"],
+    ["base32hex", "yes mani !", "vf5in683dc5n6i811"],
+    ["base32hex", "f", "vco"],
+    ["base32hex", "fo", "vcpng"],
+    ["base32hex", "foo", "vcpnmu"],
+    ["base32hex", "foob", "vcpnmuog"],
+    ["base32hex", "fooba", "vcpnmuoj1"],
+    ["base32hex", "foobar", "vcpnmuoj1e8"],
+    ["base32hexpad", "yes mani !", "tf5in683dc5n6i811"],
+    ["base32hexpad", "f", "tco======"],
+    ["base32hexpad", "fo", "tcpng===="],
+    ["base32hexpad", "foo", "tcpnmu==="],
+    ["base32hexpad", "foob", "tcpnmuog="],
+    ["base32hexpad", "fooba", "tcpnmuoj1"],
+    ["base32hexpad", "foobar", "tcpnmuoj1e8======"],
+    ["base32z", "yes mani !", "hxf1zgedpcfzg1ebb"],
+    ["base58flickr", "yes mani !", "Z7Pznk19XTTzBtx"],
+    ["base58btc", "yes mani !", "z7paNL19xttacUY"],
+    ["base64", "÷ïÿ", "mw7fDr8O/"],
+    ["base64", "f", "mZg"],
+    ["base64", "fo", "mZm8"],
+    ["base64", "foo", "mZm9v"],
+    ["base64", "foob", "mZm9vYg"],
+    ["base64", "fooba", "mZm9vYmE"],
+    ["base64", "foobar", "mZm9vYmFy"],
+    ["base64", "÷ïÿ🥰÷ïÿ😎🥶🤯", "mw7fDr8O/8J+lsMO3w6/Dv/CfmI7wn6W28J+krw"],
+    ["base64pad", "f", "MZg=="],
+    ["base64pad", "fo", "MZm8="],
+    ["base64pad", "foo", "MZm9v"],
+    ["base64pad", "foob", "MZm9vYg=="],
+    ["base64pad", "fooba", "MZm9vYmE="],
+    ["base64pad", "foobar", "MZm9vYmFy"],
+    ["base64url", "÷ïÿ", "uw7fDr8O_"],
+    ["base64url", "÷ïÿ🥰÷ïÿ😎🥶🤯", "uw7fDr8O_8J-lsMO3w6_Dv_CfmI7wn6W28J-krw"],
+    ["base64urlpad", "f", "UZg=="],
+    ["base64urlpad", "fo", "UZm8="],
+    ["base64urlpad", "foo", "UZm9v"],
+    ["base64urlpad", "foob", "UZm9vYg=="],
+    ["base64urlpad", "fooba", "UZm9vYmE="],
+    ["base64urlpad", "foobar", "UZm9vYmFy"],
+    [
+      "base64urlpad",
+      "÷ïÿ🥰÷ïÿ😎🥶🤯",
+      "Uw7fDr8O_8J-lsMO3w6_Dv_CfmI7wn6W28J-krw==",
+    ],
+  ];
+
+  for (const [name, input, expectedOutput] of testCases) {
+    await t.test(`Encoding/Decoding ${name} with ${input}`, () => {
+      const encoded = encodeMultibase(name, encodeText(input));
+      deepStrictEqual(
+        decodeText(encoded),
+        expectedOutput,
+        `Encoding ${name} failed`,
+      );
+
+      const decoded = decodeMultibase(expectedOutput);
+      deepStrictEqual(decoded, encodeText(input), `Decoding ${name} failed`);
+
+      const decodedFromBuffer = decodeMultibase(encodeText(expectedOutput));
+      deepStrictEqual(
+        decodedFromBuffer,
+        encodeText(input),
+        `Decoding buffer of ${name} failed`,
+      );
+    });
+  }
+
+  await t.test("should allow base32pad full alphabet", () => {
+    const encodedStr = "ctimaq4ygg2iegci7";
+    const decoded = decodeMultibase(encodedStr);
+    const encoded = encodeMultibase("c", decoded);
+    deepStrictEqual(decodeMultibase(encoded), decoded);
+  });
+});
+
+test("constants", async (t) => {
+  await t.test("constants indexed by name", () => {
+    const names = constants.names;
+    deepStrictEqual(Object.keys(names).length, 23);
+  });
+
+  await t.test("constants indexed by code", () => {
+    const codes = constants.codes;
+    deepStrictEqual(Object.keys(codes).length, 23);
+  });
+});

package/src/multibase/rfc4648.ts

@@ -0,0 +1,103 @@
+import type { CodecFactory } from "./types.d.ts";
+
+const decode = (
+  string: string,
+  alphabet: string,
+  bitsPerChar: number,
+): Uint8Array => {
+  // Build the character lookup table:
+  const codes: Record<string, number> = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+
+  // Count the padding bytes:
+  let end = string.length;
+  while (string[end - 1] === "=") {
+    --end;
+  }
+
+  // Allocate the output:
+  const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+
+  // Parse the data:
+  let bits = 0; // Number of bits currently in the buffer
+  let buffer = 0; // Bits waiting to be written out, MSB first
+  let written = 0; // Next byte to write
+  for (let i = 0; i < end; ++i) {
+    // Read one character from the string:
+    const value = codes[string[i]];
+    if (value === undefined) {
+      throw new SyntaxError("Invalid character " + string[i]);
+    }
+
+    // Append the bits to the buffer:
+    buffer = (buffer << bitsPerChar) | value;
+    bits += bitsPerChar;
+
+    // Write out some bits if the buffer has a byte's worth:
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 0xff & (buffer >> bits);
+    }
+  }
+
+  // Verify that we have received just enough bits:
+  if (bits >= bitsPerChar || 0xff & (buffer << (8 - bits))) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+
+  return out;
+};
+
+const encode = (
+  data: Uint8Array,
+  alphabet: string,
+  bitsPerChar: number,
+): string => {
+  const pad = alphabet[alphabet.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+
+  let bits = 0; // Number of bits currently in the buffer
+  let buffer = 0; // Bits waiting to be written out, MSB first
+  for (let i = 0; i < data.length; ++i) {
+    // Slurp data into the buffer:
+    buffer = (buffer << 8) | data[i];
+    bits += 8;
+
+    // Write out as much as we can:
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & (buffer >> bits)];
+    }
+  }
+
+  // Partial character:
+  if (bits) {
+    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+  }
+
+  // Add padding characters until we hit a byte boundary:
+  if (pad) {
+    while ((out.length * bitsPerChar) & 7) {
+      out += "=";
+    }
+  }
+
+  return out;
+};
+
+/**
+ * RFC4648 Factory
+ */
+export const rfc4648 = (bitsPerChar: number): CodecFactory => (alphabet) => {
+  return {
+    encode(input: Uint8Array): string {
+      return encode(input, alphabet, bitsPerChar);
+    },
+    decode(input: string): Uint8Array {
+      return decode(input, alphabet, bitsPerChar);
+    },
+  };
+};

package/src/multibase/types.d.ts

@@ -0,0 +1,61 @@
+export type BaseCode =
+  | "\x00"
+  | "0"
+  | "7"
+  | "9"
+  | "f"
+  | "F"
+  | "v"
+  | "V"
+  | "t"
+  | "T"
+  | "b"
+  | "B"
+  | "c"
+  | "C"
+  | "h"
+  | "k"
+  | "K"
+  | "z"
+  | "Z"
+  | "m"
+  | "M"
+  | "u"
+  | "U";
+
+/**
+ * - Names of the supported encodings
+ */
+export type BaseName =
+  | "identity"
+  | "base2"
+  | "base8"
+  | "base10"
+  | "base16"
+  | "base16upper"
+  | "base32hex"
+  | "base32hexupper"
+  | "base32hexpad"
+  | "base32hexpadupper"
+  | "base32"
+  | "base32upper"
+  | "base32pad"
+  | "base32padupper"
+  | "base32z"
+  | "base36"
+  | "base36upper"
+  | "base58btc"
+  | "base58flickr"
+  | "base64"
+  | "base64pad"
+  | "base64url"
+  | "base64urlpad";
+
+export type BaseNameOrCode = BaseCode | BaseName;
+export interface Codec {
+  encode: (buffer: Uint8Array) => string;
+  decode: (hash: string) => Uint8Array;
+}
+export interface CodecFactory {
+  (input: string): Codec;
+}

package/src/multibase/util.ts

@@ -0,0 +1,22 @@
+const textDecoder = new TextDecoder();
+export const decodeText = (bytes: DataView | Uint8Array): string =>
+  textDecoder.decode(bytes);
+
+const textEncoder = new TextEncoder();
+export const encodeText = (text: string): Uint8Array =>
+  textEncoder.encode(text);
+
+export function concat(
+  arrs: Array<ArrayLike<number>>,
+  length: number,
+): Uint8Array {
+  const output = new Uint8Array(length);
+  let offset = 0;
+
+  for (const arr of arrs) {
+    output.set(arr, offset);
+    offset += arr.length;
+  }
+
+  return output;
+}

package/src/request.test.ts

@@ -0,0 +1,93 @@
+import { deepStrictEqual } from "node:assert";
+import process from "node:process";
+import { test } from "node:test";
+import metadata from "../deno.json" with { type: "json" };
+import { getUserAgent } from "./request.ts";
+
+test("getUserAgent()", () => {
+  if ("Deno" in globalThis) {
+    deepStrictEqual(
+      getUserAgent(),
+      `Fedify/${metadata.version} (Deno/${Deno.version.deno})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ software: "MyApp/1.0.0" }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Deno/${Deno.version.deno})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ url: "https://example.com/" }),
+      `Fedify/${metadata.version} (Deno/${Deno.version.deno}; +https://example.com/)`,
+    );
+    deepStrictEqual(
+      getUserAgent({
+        software: "MyApp/1.0.0",
+        url: new URL("https://example.com/"),
+      }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Deno/${Deno.version.deno}; +https://example.com/)`,
+    );
+  } else if ("Bun" in globalThis) {
+    deepStrictEqual(
+      getUserAgent(),
+      // @ts-ignore: `Bun` is a global variable in Bun
+      `Fedify/${metadata.version} (Bun/${Bun.version})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ software: "MyApp/1.0.0" }),
+      // @ts-ignore: `Bun` is a global variable in Bun
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Bun/${Bun.version})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ url: "https://example.com/" }),
+      // @ts-ignore: `Bun` is a global variable in Bun
+      `Fedify/${metadata.version} (Bun/${Bun.version}; +https://example.com/)`,
+    );
+    deepStrictEqual(
+      getUserAgent({
+        software: "MyApp/1.0.0",
+        url: new URL("https://example.com/"),
+      }),
+      // @ts-ignore: `Bun` is a global variable in Bun
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Bun/${Bun.version}; +https://example.com/)`,
+    );
+  } else if (navigator.userAgent === "Cloudflare-Workers") {
+    deepStrictEqual(
+      getUserAgent(),
+      `Fedify/${metadata.version} (Cloudflare-Workers)`,
+    );
+    deepStrictEqual(
+      getUserAgent({ software: "MyApp/1.0.0" }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Cloudflare-Workers)`,
+    );
+    deepStrictEqual(
+      getUserAgent({ url: "https://example.com/" }),
+      `Fedify/${metadata.version} (Cloudflare-Workers; +https://example.com/)`,
+    );
+    deepStrictEqual(
+      getUserAgent({
+        software: "MyApp/1.0.0",
+        url: new URL("https://example.com/"),
+      }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Cloudflare-Workers; +https://example.com/)`,
+    );
+  } else {
+    deepStrictEqual(
+      getUserAgent(),
+      `Fedify/${metadata.version} (Node.js/${process.versions.node})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ software: "MyApp/1.0.0" }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Node.js/${process.versions.node})`,
+    );
+    deepStrictEqual(
+      getUserAgent({ url: "https://example.com/" }),
+      `Fedify/${metadata.version} (Node.js/${process.versions.node}; +https://example.com/)`,
+    );
+    deepStrictEqual(
+      getUserAgent({
+        software: "MyApp/1.0.0",
+        url: new URL("https://example.com/"),
+      }),
+      `MyApp/1.0.0 (Fedify/${metadata.version}; Node.js/${process.versions.node}; +https://example.com/)`,
+    );
+  }
+});