@fedify/vocab-runtime 2.0.0-dev.12

package/src/key.ts

@@ -0,0 +1,187 @@
+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 { validateCryptoKey } from "./jwk.ts";
+import { decodeMultibase, encodeMultibase } from "./multibase/mod.ts";
+
+const algorithms: Record<
+  string,
+  | AlgorithmIdentifier
+  | HmacImportParams
+  | RsaHashedImportParams
+  | EcKeyImportParams
+> = {
+  "1.2.840.113549.1.1.1": { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+  "1.3.101.112": "Ed25519",
+};
+
+/**
+ * Imports a PEM-SPKI formatted public key.
+ * @param pem The PEM-SPKI formatted public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.5.0
+ */
+export async function importSpki(pem: string): Promise<CryptoKey> {
+  pem = pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, "");
+  let spki: Uint8Array<ArrayBuffer>;
+  try {
+    spki = decodeBase64(pem);
+  } catch (_) {
+    throw new TypeError("Invalid PEM-SPKI format.");
+  }
+  const pki = PublicKeyInfo.fromBER(spki);
+  const oid = pki.algorithm.algorithmId;
+  const algorithm = algorithms[oid];
+  if (algorithm == null) {
+    throw new TypeError("Unsupported algorithm: " + oid);
+  }
+  return await crypto.subtle.importKey(
+    "spki",
+    spki,
+    algorithm,
+    true,
+    ["verify"],
+  );
+}
+
+/**
+ * Exports a public key in PEM-SPKI format.
+ * @param key The public key to export.
+ * @returns The exported public key in PEM-SPKI format.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.5.0
+ */
+export async function exportSpki(key: CryptoKey): Promise<string> {
+  validateCryptoKey(key);
+  const spki = await crypto.subtle.exportKey("spki", key);
+  let pem = encodeBase64(spki);
+  pem = (pem.match(/.{1,64}/g) || []).join("\n");
+  return `-----BEGIN PUBLIC KEY-----\n${pem}\n-----END PUBLIC KEY-----\n`;
+}
+
+/**
+ * Imports a PEM-PKCS#1 formatted public key.
+ * @param pem The PEM-PKCS#1 formatted public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 1.5.0
+ */
+export function importPkcs1(pem: string): Promise<CryptoKey> {
+  const key = createPublicKey({ key: pem, format: "pem", type: "pkcs1" });
+  const spki = key.export({ type: "spki", format: "pem" }) as string;
+  return importSpki(spki);
+}
+
+const PKCS1_HEADER = /^\s*-----BEGIN\s+RSA\s+PUBLIC\s+KEY-----\s*\n/;
+
+/**
+ * Imports a PEM formatted public key (SPKI or PKCS#1).
+ * @param pem The PEM formatted public key to import (SPKI or PKCS#1).
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 1.5.0
+ */
+export function importPem(pem: string): Promise<CryptoKey> {
+  return PKCS1_HEADER.test(pem) ? importPkcs1(pem) : importSpki(pem);
+}
+
+/**
+ * Imports a [Multibase]-encoded public key.
+ *
+ * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+ * @param key The Multibase-encoded public key.
+ * @returns The imported public key.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.10.0
+ */
+export async function importMultibaseKey(key: string): Promise<CryptoKey> {
+  const decoded = decodeMultibase(key);
+  const code: number = getCodeFromData(decoded);
+  const content = rmPrefix(decoded);
+  if (code === 0x1205) { // rsa-pub
+    const keyObject = createPublicKey({
+      // deno-lint-ignore no-explicit-any
+      key: content as any,
+      format: "der",
+      type: "pkcs1",
+    });
+    const exported = keyObject.export({ type: "spki", format: "der" });
+    const spki = exported instanceof Uint8Array
+      ? exported
+      : new Uint8Array(exported);
+    return await crypto.subtle.importKey(
+      "spki",
+      new Uint8Array(spki),
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      true,
+      ["verify"],
+    );
+  } else if (code === 0xed) { // ed25519-pub
+    return await crypto.subtle.importKey(
+      "raw",
+      content.slice(),
+      "Ed25519",
+      true,
+      ["verify"],
+    );
+  } else {
+    throw new TypeError("Unsupported key type: 0x" + code.toString(16));
+  }
+}
+
+/**
+ * Exports a public key in [Multibase] format.
+ *
+ * [Multibase]: https://www.w3.org/TR/vc-data-integrity/#multibase-0
+ * @param key The public key to export.
+ * @returns The exported public key in Multibase format.
+ * @throws {TypeError} If the key is invalid or unsupported.
+ * @since 0.10.0
+ */
+export async function exportMultibaseKey(key: CryptoKey): Promise<string> {
+  let content: ArrayBuffer;
+  let code: number;
+  if (key.algorithm.name === "Ed25519") {
+    content = await crypto.subtle.exportKey("raw", key);
+    code = 0xed; // ed25519-pub
+  } else if (
+    key.algorithm.name === "RSASSA-PKCS1-v1_5" &&
+    (key.algorithm as unknown as { hash: { name: string } }).hash.name ===
+      "SHA-256"
+  ) {
+    const jwk = await crypto.subtle.exportKey("jwk", key);
+    const decodedN = decodeBase64Url(jwk.n!);
+    const n = new Uint8Array(decodedN.length + 1);
+    n.set(decodedN, 1);
+    const sequence = new Sequence({
+      value: [
+        new Integer({
+          isHexOnly: true,
+          valueHex: n,
+        }),
+        new Integer({
+          isHexOnly: true,
+          valueHex: decodeBase64Url(jwk.e!),
+        }),
+      ],
+    });
+    content = sequence.toBER(false);
+    code = 0x1205; // rsa-pub
+  } 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 encoded = encodeMultibase("base58btc", prefixed);
+  return new TextDecoder().decode(encoded);
+}
+
+// cSpell: ignore multicodec pkijs

package/src/langstr.test.ts

@@ -0,0 +1,28 @@
+import { deepStrictEqual } from "node:assert";
+import { test } from "node:test";
+import util from "node:util";
+import { LanguageString } from "./langstr.ts";
+
+test("new LanguageString()", () => {
+  const langStr = new LanguageString("Hello", "en");
+  deepStrictEqual(langStr.toString(), "Hello");
+  deepStrictEqual(langStr.locale, new Intl.Locale("en"));
+
+  deepStrictEqual(new LanguageString("Hello", new Intl.Locale("en")), langStr);
+});
+
+test("Deno.inspect(LanguageString)", () => {
+  const langStr = new LanguageString("Hello, 'world'", "en");
+  deepStrictEqual(
+    util.inspect(langStr, { colors: false }),
+    "<en> \"Hello, 'world'\"",
+  );
+});
+
+test("util.inspect(LanguageString)", () => {
+  const langStr = new LanguageString("Hello, 'world'", "en");
+  deepStrictEqual(
+    util.inspect(langStr, { colors: false }),
+    "<en> \"Hello, 'world'\"",
+  );
+});

package/src/langstr.ts

@@ -0,0 +1,38 @@
+/**
+ * A language-tagged string which corresponds to the `rdf:langString` type.
+ */
+export class LanguageString extends String {
+  /**
+   * The locale of the string.
+   * @since 2.0.0
+   */
+  readonly locale: Intl.Locale;
+
+  /**
+   * Constructs a new `LanguageString`.
+   * @param value A string value written in the given language.
+   * @param locale The language of the string.  If a string is given, it will
+   *               be parsed as a `Intl.Locale` object.
+   */
+  constructor(value: string, language: Intl.Locale | string) {
+    super(value);
+    this.locale = typeof language === "string"
+      ? new Intl.Locale(language)
+      : language;
+  }
+
+  [Symbol.for("Deno.customInspect")](
+    inspect: typeof Deno.inspect,
+    options: Deno.InspectOptions,
+  ): string {
+    return `<${this.locale.baseName}> ${inspect(this.toString(), options)}`;
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](
+    _depth: number,
+    options: unknown,
+    inspect: (value: unknown, options: unknown) => string,
+  ): string {
+    return `<${this.locale.baseName}> ${inspect(this.toString(), options)}`;
+  }
+}

package/src/link.test.ts

@@ -0,0 +1,82 @@
+// Borrowed from https://github.com/hugoalh/http-header-link-es
+import { deepStrictEqual, throws } from "node:assert";
+import { test } from "node:test";
+import { HttpHeaderLink } from "./link.ts";
+
+test("String Good 1", () => {
+  const instance = new HttpHeaderLink(
+    `<https://example.com>; rel="preconnect"`,
+  );
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), true);
+  deepStrictEqual(instance.hasParameter("rel", "connect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "postconnect"), false);
+  deepStrictEqual(instance.getByRel("preconnect")[0][0], "https://example.com");
+});
+
+test("String Good 2", () => {
+  const instance = new HttpHeaderLink(`<https://example.com>; rel=preconnect`);
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), true);
+  deepStrictEqual(instance.hasParameter("rel", "connect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "postconnect"), false);
+  deepStrictEqual(instance.getByRel("preconnect")[0][0], "https://example.com");
+});
+
+test("String Good 3", () => {
+  const instance = new HttpHeaderLink(
+    `<https://example.com/%E8%8B%97%E6%9D%A1>; rel="preconnect"`,
+  );
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), true);
+  deepStrictEqual(instance.hasParameter("rel", "connect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "postconnect"), false);
+  deepStrictEqual(
+    instance.getByRel("preconnect")[0][0],
+    "https://example.com/苗条",
+  );
+});
+
+test("String Good 4", () => {
+  const instance = new HttpHeaderLink(
+    `<https://one.example.com>; rel="preconnect", <https://two.example.com>; rel="preconnect", <https://three.example.com>; rel="preconnect"`,
+  );
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), true);
+  deepStrictEqual(instance.hasParameter("rel", "connect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "postconnect"), false);
+  deepStrictEqual(
+    instance.getByRel("preconnect")[0][0],
+    "https://one.example.com",
+  );
+  deepStrictEqual(
+    instance.getByRel("preconnect")[1][0],
+    "https://two.example.com",
+  );
+  deepStrictEqual(
+    instance.getByRel("preconnect")[2][0],
+    "https://three.example.com",
+  );
+});
+
+test("String Good 5", () => {
+  const instance = new HttpHeaderLink();
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "connect"), false);
+  deepStrictEqual(instance.hasParameter("rel", "postconnect"), false);
+  deepStrictEqual(instance.entries().length, 0);
+});
+
+test("Entries Good 1", () => {
+  const instance = new HttpHeaderLink([["https://one.example.com", {
+    rel: "preconnect",
+  }]]);
+  deepStrictEqual(instance.hasParameter("rel", "preconnect"), true);
+  deepStrictEqual(instance.entries().length, 1);
+  deepStrictEqual(
+    instance.toString(),
+    `<https://one.example.com>; rel="preconnect"`,
+  );
+});
+
+test("String Bad 1", () => {
+  throws(() => {
+    new HttpHeaderLink(`https://bad.example; rel="preconnect"`);
+  });
+});

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