@fedify/vocab-runtime 2.0.0-pr.451.1730

package/src/link.ts

@@ -0,0 +1,345 @@
+// Borrowed from https://github.com/hugoalh/http-header-link-es
+const parametersNeedLowerCase: readonly string[] = ["rel", "type"];
+
+const regexpLinkWhitespace = /[\n\r\s\t]/;
+
+/**
+ * HTTP header `Link` entry.
+ */
+export type HttpHeaderLinkEntry = [
+  uri: string,
+  parameters: { [key: string]: string },
+];
+
+function validateURI(uri: string): void {
+  if (uri.includes("\n") || regexpLinkWhitespace.test(uri)) {
+    throw new SyntaxError(`\`${uri}\` is not a valid URI!`);
+  }
+}
+
+function* parseLinkFromString(input: string): Generator<HttpHeaderLinkEntry> {
+  // Remove Unicode characters of BOM (Byte Order Mark) and no-break space.
+  const inputFmt: string = input.replaceAll("\u00A0", "").replaceAll(
+    "\uFEFF",
+    "",
+  );
+  for (let cursor: number = 0; cursor < inputFmt.length; cursor += 1) {
+    while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+      cursor += 1;
+    }
+    if (inputFmt.charAt(cursor) !== "<") {
+      throw new SyntaxError(
+        `Unexpected character \`${
+          inputFmt.charAt(cursor)
+        }\` at position ${cursor}; Expect character \`<\`!`,
+      );
+    }
+    cursor += 1;
+    const cursorEndUri: number = inputFmt.indexOf(">", cursor);
+    if (cursorEndUri === -1) {
+      throw new SyntaxError(
+        `Missing end of URI delimiter character \`>\` after position ${cursor}!`,
+      );
+    }
+    if (cursorEndUri === cursor) {
+      throw new SyntaxError(`Missing URI at position ${cursor}!`);
+    }
+    const uriSlice: string = inputFmt.slice(cursor, cursorEndUri);
+    validateURI(uriSlice);
+    const uri: HttpHeaderLinkEntry[0] = decodeURI(uriSlice);
+    const parameters: HttpHeaderLinkEntry[1] = {};
+    cursor = cursorEndUri + 1;
+    while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+      cursor += 1;
+    }
+    if (
+      cursor === inputFmt.length ||
+      inputFmt.charAt(cursor) === ","
+    ) {
+      yield [uri, parameters];
+      continue;
+    }
+    if (inputFmt.charAt(cursor) !== ";") {
+      throw new SyntaxError(
+        `Unexpected character \`${
+          inputFmt.charAt(cursor)
+        }\` at position ${cursor}; Expect character \`;\`!`,
+      );
+    }
+    cursor += 1;
+    while (cursor < inputFmt.length) {
+      while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+        cursor += 1;
+      }
+      const parameterKey: string | undefined = inputFmt.slice(cursor).match(
+        /^[\w-]+\*?/,
+      )?.[0].toLowerCase();
+      if (typeof parameterKey === "undefined") {
+        throw new SyntaxError(
+          `Unexpected character \`${
+            inputFmt.charAt(cursor)
+          }\` at position ${cursor}; Expect a valid parameter key!`,
+        );
+      }
+      cursor += parameterKey.length;
+      while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+        cursor += 1;
+      }
+      if (
+        cursor === inputFmt.length ||
+        inputFmt.charAt(cursor) === ","
+      ) {
+        parameters[parameterKey] = "";
+        break;
+      }
+      if (inputFmt.charAt(cursor) === ";") {
+        parameters[parameterKey] = "";
+        cursor += 1;
+        continue;
+      }
+      if (inputFmt.charAt(cursor) !== "=") {
+        throw new SyntaxError(
+          `Unexpected character \`${
+            inputFmt.charAt(cursor)
+          }\` at position ${cursor}; Expect character \`=\`!`,
+        );
+      }
+      cursor += 1;
+      while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+        cursor += 1;
+      }
+      let parameterValue: string = "";
+      if (inputFmt.charAt(cursor) === '"') {
+        cursor += 1;
+        while (cursor < inputFmt.length) {
+          if (inputFmt.charAt(cursor) === '"') {
+            cursor += 1;
+            break;
+          }
+          if (inputFmt.charAt(cursor) === "\\") {
+            cursor += 1;
+          }
+          parameterValue += inputFmt.charAt(cursor);
+          cursor += 1;
+        }
+      } else {
+        const cursorDiffParameterValue: number = inputFmt.slice(cursor).search(
+          /[\s;,]/,
+        );
+        if (cursorDiffParameterValue === -1) {
+          parameterValue += inputFmt.slice(cursor);
+          cursor += parameterValue.length;
+        } else {
+          parameterValue += inputFmt.slice(cursor, cursorDiffParameterValue);
+          cursor += cursorDiffParameterValue;
+        }
+      }
+      parameters[parameterKey] = parametersNeedLowerCase.includes(parameterKey)
+        ? parameterValue.toLowerCase()
+        : parameterValue;
+      while (regexpLinkWhitespace.test(inputFmt.charAt(cursor))) {
+        cursor += 1;
+      }
+      if (
+        cursor === inputFmt.length ||
+        inputFmt.charAt(cursor) === ","
+      ) {
+        break;
+      }
+      if (inputFmt.charAt(cursor) === ";") {
+        cursor += 1;
+        continue;
+      }
+      throw new SyntaxError(
+        `Unexpected character \`${
+          inputFmt.charAt(cursor)
+        }\` at position ${cursor}; Expect character \`,\`, character \`;\`, or end of the string!`,
+      );
+    }
+    yield [uri, parameters];
+  }
+}
+
+/**
+ * Handle the HTTP header `Link` according to the specification RFC 8288.
+ */
+export class HttpHeaderLink {
+  get [Symbol.toStringTag](): string {
+    return "HTTPHeaderLink";
+  }
+
+  #entries: HttpHeaderLinkEntry[] = [];
+
+  /**
+   * Handle the HTTP header `Link` according to the specification RFC 8288.
+   * @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+   */
+  constructor(
+    ...inputs:
+      (string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)[]
+  ) {
+    if (inputs.length > 0) {
+      this.add(...inputs);
+    }
+  }
+
+  /**
+   * Add entries.
+   * @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+   * @returns {this}
+   */
+  add(
+    ...inputs:
+      (string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)[]
+  ): this {
+    for (const input of inputs) {
+      if (input instanceof HttpHeaderLink) {
+        this.#entries.push(...structuredClone(input.#entries));
+      } else if (Array.isArray(input)) {
+        this.#entries.push(
+          ...input.map(
+            ([uri, parameters]: HttpHeaderLinkEntry): HttpHeaderLinkEntry => {
+              validateURI(uri);
+              Object.entries(parameters).forEach(
+                ([key, value]: [string, string]): void => {
+                  if (
+                    key !== key.toLowerCase() ||
+                    !(/^[\w-]+\*?$/.test(key))
+                  ) {
+                    throw new SyntaxError(
+                      `\`${key}\` is not a valid parameter key!`,
+                    );
+                  }
+                  if (
+                    parametersNeedLowerCase.includes(key) &&
+                    value !== value.toLowerCase()
+                  ) {
+                    throw new SyntaxError(
+                      `\`${value}\` is not a valid parameter value!`,
+                    );
+                  }
+                },
+              );
+              return [uri, structuredClone(parameters)];
+            },
+          ),
+        );
+      } else {
+        for (
+          const entry of parseLinkFromString(
+            ((
+                input instanceof Headers ||
+                input instanceof Response
+              )
+              ? ((input instanceof Headers) ? input : input.headers).get("Link")
+              : input) ?? "",
+          )
+        ) {
+          this.#entries.push(entry);
+        }
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Return all of the entries.
+   * @returns {HttpHeaderLinkEntry[]} Entries.
+   */
+  entries(): HttpHeaderLinkEntry[] {
+    return structuredClone(this.#entries);
+  }
+
+  /**
+   * Get entries by parameter.
+   * @param {string} key Key of the parameter.
+   * @param {string} value Value of the parameter.
+   * @returns {HttpHeaderLinkEntry[]} Entries which match the parameter.
+   */
+  getByParameter(key: string, value: string): HttpHeaderLinkEntry[] {
+    if (key !== key.toLowerCase()) {
+      throw new SyntaxError(`\`${key}\` is not a valid parameter key!`);
+    }
+    if (key === "rel") {
+      return this.getByRel(value);
+    }
+    return structuredClone(
+      this.#entries.filter((entry: HttpHeaderLinkEntry): boolean => {
+        return (entry[1][key] === value);
+      }),
+    );
+  }
+
+  /**
+   * Get entries by parameter `rel`.
+   * @param {string} value Value of the parameter `rel`.
+   * @returns {HttpHeaderLinkEntry[]} Entries which match the parameter.
+   */
+  getByRel(value: string): HttpHeaderLinkEntry[] {
+    if (value !== value.toLowerCase()) {
+      throw new SyntaxError(
+        `\`${value}\` is not a valid parameter \`rel\` value!`,
+      );
+    }
+    return structuredClone(
+      this.#entries.filter((entity: HttpHeaderLinkEntry): boolean => {
+        return (entity[1].rel?.toLowerCase() === value);
+      }),
+    );
+  }
+
+  /**
+   * Whether have entries that match parameter.
+   * @param {string} key Key of the parameter.
+   * @param {string} value Value of the parameter.
+   * @returns {boolean} Determine result.
+   */
+  hasParameter(key: string, value: string): boolean {
+    return (this.getByParameter(key, value).length > 0);
+  }
+
+  /**
+   * Stringify entries.
+   * @returns {string} Stringified entries.
+   */
+  toString(): string {
+    return this.#entries.map(
+      ([uri, parameters]: HttpHeaderLinkEntry): string => {
+        return [
+          `<${encodeURI(uri)}>`,
+          ...Object.entries(parameters).map(
+            ([key, value]: [string, string]): string => {
+              return ((value.length > 0)
+                ? `${key}="${value.replaceAll('"', '\\"')}"`
+                : key);
+            },
+          ),
+        ].join("; ");
+      },
+    ).join(", ");
+  }
+
+  /**
+   * Parse the HTTP header `Link` according to the specification RFC 8288.
+   * @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+   * @returns {HttpHeaderLink}
+   */
+  static parse(
+    ...inputs:
+      (string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)[]
+  ): HttpHeaderLink {
+    return new this(...inputs);
+  }
+
+  /**
+   * Stringify as the HTTP header `Link` according to the specification RFC 8288.
+   * @param {...(string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)} inputs Input.
+   * @returns {string}
+   */
+  static stringify(
+    ...inputs:
+      (string | Headers | HttpHeaderLink | HttpHeaderLinkEntry[] | Response)[]
+  ): string {
+    return new this(...inputs).toString();
+  }
+}

package/src/mod.ts

@@ -0,0 +1,31 @@
+/**
+ * This package contains the runtime facilities for working with Activity
+ * Vocabulary objects, which are auto-generated from the IDL.
+ *
+ * @module
+ */
+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";

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);
+  });
+});