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

package/CHANGES.md

@@ -37,8 +37,14 @@ 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

package/esm/deno.js

@@ -1,6 +1,6 @@
 export default {
     "name": "@fedify/fedify",
-    "version": "1.5.0-dev.709+d405668c",
+    "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;
+}