@fedify/fedify 1.5.0-dev.699 → 1.5.0-dev.714

package/CHANGES.md

@@ -37,8 +37,24 @@ To be released.
         the page.
      -  You can easily copy the fediverse handle of the ephemeral actor.
 
+ -  Internalized the [multibase] package, which is obsolete and no longer
+    maintained.  [[#127], [#215] by Fróði Karlsson]
+
+[#127]: https://github.com/fedify-dev/fedify/issues/127
 [#209]: https://github.com/fedify-dev/fedify/issues/209
 [#211]: https://github.com/fedify-dev/fedify/issues/211
+[#215]: https://github.com/fedify-dev/fedify/pull/215
+[multibase]: https://github.com/multiformats/js-multibase
+
+
+Version 1.4.6
+-------------
+
+Released on March 9, 2025.
+
+ -  Fedify no more depends on `node:punycode` module, which is deprecated in
+    Node.js.  Now it uses the built-in `node:url` module instead.
+    [[#212], [#214] by Fróði Karlsson]
 
 
 Version 1.4.5
@@ -194,6 +210,16 @@ Released on February 5, 2025.
 [#195]: https://github.com/fedify-dev/fedify/issues/195
 
 
+Version 1.3.13
+--------------
+
+Released on March 9, 2025.
+
+ -  Fedify no more depends on `node:punycode` module, which is deprecated in
+    Node.js.  Now it uses the built-in `node:url` module instead.
+    [[#212], [#214] by Fróði Karlsson]
+
+
 Version 1.3.12
 --------------
 
@@ -463,6 +489,16 @@ Released on November 30, 2024.
 [#193]: https://github.com/fedify-dev/fedify/issues/193
 
 
+Version 1.2.17
+--------------
+
+Released on March 9, 2025.
+
+ -  Fedify no more depends on `node:punycode` module, which is deprecated in
+    Node.js.  Now it uses the built-in `node:url` module instead.
+    [[#212], [#214] by Fróði Karlsson]
+
+
 Version 1.2.16
 --------------
 
@@ -781,6 +817,16 @@ Released on October 31, 2024.
 [#118]: https://github.com/fedify-dev/fedify/issues/118
 
 
+Version 1.1.17
+--------------
+
+Released on March 9, 2025.
+
+ -  Fedify no more depends on `node:punycode` module, which is deprecated in
+    Node.js.  Now it uses the built-in `node:url` module instead.
+    [[#212], [#214] by Fróði Karlsson]
+
+
 Version 1.1.16
 --------------
 
@@ -1140,6 +1186,19 @@ Released on October 20, 2024.
 [#150]: https://github.com/fedify-dev/fedify/issues/150
 
 
+Version 1.0.20
+--------------
+
+Released on March 9, 2025.
+
+ -  Fedify no more depends on `node:punycode` module, which is deprecated in
+    Node.js.  Now it uses the built-in `node:url` module instead.
+    [[#212], [#214] by Fróði Karlsson]
+
+[#212]: https://github.com/fedify-dev/fedify/issues/212
+[#214]: https://github.com/fedify-dev/fedify/pull/214
+
+
 Version 1.0.19
 --------------
 
@@ -3291,4 +3350,5 @@ Version 0.1.0
 
 Initial release.  Released on March 8, 2024.
 
-<!-- cSpell: ignore Dogeon Fabien Wressell Emelia Hana Heesun Kyunghee Jiyu -->
+<!-- cSpell: ignore Dogeon Fabien Wressell Emelia Fróði Karlsson -->
+<!-- cSpell: ignore Hana Heesun Kyunghee Jiyu -->

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.5.0-dev.699+a9e5f890",
+    "version": "1.5.0-dev.714+56abdd05",
     "license": "MIT",
     "exports": {
         ".": "./mod.ts",
@@ -40,7 +40,6 @@ export default {
         "json-canon": "npm:json-canon@^1.0.1",
         "jsonld": "npm:jsonld@^8.3.2",
         "mock_fetch": "jsr:@hongminhee/deno-mock-fetch@^0.3.2",
-        "multibase": "npm:multibase@^4.0.6",
         "multicodec": "npm:multicodec@^3.2.1",
         "pkijs": "npm:pkijs@^3.2.4",
         "uri-template-router": "npm:uri-template-router@^0.0.16",

package/esm/runtime/key.js

@@ -4,7 +4,7 @@ import { decodeBase64, encodeBase64 } from "../deps/jsr.io/@std/encoding/1.0.7/b
 import { decodeBase64Url } from "../deps/jsr.io/@std/encoding/1.0.7/base64url.js";
 import { decodeHex } from "../deps/jsr.io/@std/encoding/1.0.7/hex.js";
 import { Integer, Sequence } from "asn1js";
-import { decode, encode } from "multibase";
+import { decode, encode } from "./multibase/index.js";
 import { addPrefix, getCodeFromData, rmPrefix } from "multicodec";
 import { createPublicKey } from "node:crypto";
 import { PublicKeyInfo } from "pkijs";

package/esm/runtime/multibase/base.js

@@ -0,0 +1,30 @@
+import { encodeText } from "./util.js";
+/**
+ * Class to encode/decode in the supported Bases
+ */
+export class Base {
+    name;
+    code;
+    alphabet;
+    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);
+    }
+}

package/esm/runtime/multibase/constants.js

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

package/esm/runtime/multibase/index.js

@@ -0,0 +1,59 @@
+import * as constants from "./constants.js";
+import { concat, decodeText, encodeText } from "./util.js";
+/**
+ * Encode data with the specified base and add the multibase prefix.
+ *
+ * @throws {Error} Will throw if the encoding is not supported
+ */
+export 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
+ */
+export function decode(data) {
+    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]);
+    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(constants.names, nameOrCode)) {
+        return constants.names[nameOrCode];
+    }
+    else if (Object.prototype.hasOwnProperty.call(constants.codes, 
+    /** @type {BaseCode} */ (nameOrCode))) {
+        return constants.codes[nameOrCode];
+    }
+    else {
+        throw new Error(`Unsupported encoding: ${nameOrCode}`);
+    }
+}
+/**
+ * Get encoding from data
+ *
+ * @param {string|Uint8Array} data
+ * @returns {Base}
+ * @throws {Error} Will throw if the encoding is not supported
+ */
+export function encodingFromData(data) {
+    if (data instanceof Uint8Array) {
+        data = decodeText(data);
+    }
+    return encoding(data[0]);
+}

package/esm/runtime/multibase/rfc4648.js

@@ -0,0 +1,79 @@
+const decode = (string, alphabet, bitsPerChar) => {
+    // Build the character lookup table:
+    const codes = {};
+    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, alphabet, bitsPerChar) => {
+    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) => (alphabet) => {
+    return {
+        encode(input) {
+            return encode(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return decode(input, alphabet, bitsPerChar);
+        },
+    };
+};

package/esm/runtime/multibase/util.js

@@ -0,0 +1,13 @@
+const textDecoder = new TextDecoder();
+export const decodeText = (bytes) => textDecoder.decode(bytes);
+const textEncoder = new TextEncoder();
+export const encodeText = (text) => textEncoder.encode(text);
+export 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;
+}

package/esm/runtime/url.js

@@ -33,8 +33,13 @@ export async function validatePublicUrl(url) {
     // FIXME: This is a temporary workaround for the `Bun` runtime; for unknown
     // reasons, the Web Crypto API does not work as expected after a DNS lookup.
     // This workaround purposes to prevent unit tests from hanging up:
-    if ("Bun" in dntShim.dntGlobalThis && hostname === "example.com") {
-        return;
+    if ("Bun" in dntShim.dntGlobalThis) {
+        if (hostname === "example.com" || hostname.endsWith(".example.com")) {
+            return;
+        }
+        else if (hostname === "fedify-test.internal") {
+            throw new UrlError("Invalid or private address: fedify-test.internal");
+        }
     }
     // To prevent SSRF via DNS rebinding, we need to resolve all IP addresses
     // and ensure that they are all public:

package/esm/vocab/actor.js

@@ -1,5 +1,5 @@
 import { SpanStatusCode, trace } from "@opentelemetry/api";
-import { toASCII, toUnicode } from "node:punycode";
+import { domainToASCII, domainToUnicode } from "node:url";
 import metadata from "../deno.js";
 import { lookupWebFinger } from "../webfinger/lookup.js";
 import { getTypeId } from "./type.js";
@@ -161,7 +161,7 @@ export function normalizeActorHandle(handle, options = {}) {
         throw new TypeError("Invalid actor handle.");
     }
     domain = domain.toLowerCase();
-    domain = options.punycode ? toASCII(domain) : toUnicode(domain);
+    domain = options.punycode ? domainToASCII(domain) : domainToUnicode(domain);
     domain = domain.toLowerCase();
     const user = handle.substring(0, atPos);
     return options.trimLeadingAt ? `${user}@${domain}` : `@${user}@${domain}`;