@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

package/esm/runtime/docloader.js

@@ -1,351 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import { HTTPHeaderLink } from "@hugoalh/http-header-link";
-import { getLogger } from "@logtape/logtape";
-import process from "node:process";
-import metadata from "../deno.js";
-import { doubleKnock, } from "../sig/http.js";
-import { validateCryptoKey } from "../sig/key.js";
-import preloadedContexts from "./contexts.js";
-import { UrlError, validatePublicUrl } from "./url.js";
-const logger = getLogger(["fedify", "runtime", "docloader"]);
-/**
- * Error thrown when fetching a JSON-LD document failed.
- */
-export class FetchError extends Error {
-    /**
-     * The URL that failed to fetch.
-     */
-    url;
-    /**
-     * Constructs a new `FetchError`.
-     *
-     * @param url The URL that failed to fetch.
-     * @param message Error message.
-     */
-    constructor(url, message) {
-        super(message == null ? url.toString() : `${url}: ${message}`);
-        this.name = "FetchError";
-        this.url = typeof url === "string" ? new URL(url) : url;
-    }
-}
-function createRequest(url, options = {}) {
-    return new Request(url, {
-        headers: {
-            Accept: "application/activity+json, application/ld+json",
-            "User-Agent": typeof options.userAgent === "string"
-                ? options.userAgent
-                : getUserAgent(options.userAgent),
-        },
-        redirect: "manual",
-    });
-}
-function logRequest(request) {
-    logger.debug("Fetching document: {method} {url} {headers}", {
-        method: request.method,
-        url: request.url,
-        headers: Object.fromEntries(request.headers.entries()),
-    });
-}
-async function getRemoteDocument(url, response, fetch) {
-    const documentUrl = response.url === "" ? url : response.url;
-    const docUrl = new URL(documentUrl);
-    if (!response.ok) {
-        logger.error("Failed to fetch document: {status} {url} {headers}", {
-            status: response.status,
-            url: documentUrl,
-            headers: Object.fromEntries(response.headers.entries()),
-        });
-        throw new FetchError(documentUrl, `HTTP ${response.status}: ${documentUrl}`);
-    }
-    const contentType = response.headers.get("Content-Type");
-    const jsonLd = contentType == null ||
-        contentType === "application/activity+json" ||
-        contentType.startsWith("application/activity+json;") ||
-        contentType === "application/ld+json" ||
-        contentType.startsWith("application/ld+json;");
-    const linkHeader = response.headers.get("Link");
-    let contextUrl = null;
-    if (linkHeader != null) {
-        let link;
-        try {
-            link = new HTTPHeaderLink(linkHeader);
-        }
-        catch (e) {
-            if (e instanceof SyntaxError) {
-                link = new HTTPHeaderLink();
-            }
-            else {
-                throw e;
-            }
-        }
-        if (jsonLd) {
-            const entries = link.getByRel("http://www.w3.org/ns/json-ld#context");
-            for (const [uri, params] of entries) {
-                if ("type" in params && params.type === "application/ld+json") {
-                    contextUrl = uri;
-                    break;
-                }
-            }
-        }
-        else {
-            const entries = link.getByRel("alternate");
-            for (const [uri, params] of entries) {
-                const altUri = new URL(uri, docUrl);
-                if ("type" in params &&
-                    (params.type === "application/activity+json" ||
-                        params.type === "application/ld+json" ||
-                        params.type.startsWith("application/ld+json;")) &&
-                    altUri.href !== docUrl.href) {
-                    logger.debug("Found alternate document: {alternateUrl} from {url}", { alternateUrl: altUri.href, url: documentUrl });
-                    return await fetch(altUri.href);
-                }
-            }
-        }
-    }
-    let document;
-    if (!jsonLd &&
-        (contentType === "text/html" || contentType?.startsWith("text/html;") ||
-            contentType === "application/xhtml+xml" ||
-            contentType?.startsWith("application/xhtml+xml;"))) {
-        const p = /<(a|link)((\s+[a-z][a-z:_-]*=("[^"]*"|'[^']*'|[^\s>]+))+)\/?>/ig;
-        const p2 = /\s+([a-z][a-z:_-]*)=("([^"]*)"|'([^']*)'|([^\s>]+))/ig;
-        const html = await response.text();
-        let m;
-        const rawAttribs = [];
-        while ((m = p.exec(html)) !== null)
-            rawAttribs.push(m[2]);
-        for (const rawAttrs of rawAttribs) {
-            let m2;
-            const attribs = {};
-            while ((m2 = p2.exec(rawAttrs)) !== null) {
-                const key = m2[1].toLowerCase();
-                const value = m2[3] ?? m2[4] ?? m2[5] ?? "";
-                attribs[key] = value;
-            }
-            if (attribs.rel === "alternate" && "type" in attribs && (attribs.type === "application/activity+json" ||
-                attribs.type === "application/ld+json" ||
-                attribs.type.startsWith("application/ld+json;")) && "href" in attribs &&
-                new URL(attribs.href, docUrl).href !== docUrl.href) {
-                logger.debug("Found alternate document: {alternateUrl} from {url}", { alternateUrl: attribs.href, url: documentUrl });
-                return await fetch(new URL(attribs.href, docUrl).href);
-            }
-        }
-        document = JSON.parse(html);
-    }
-    else {
-        document = await response.json();
-    }
-    logger.debug("Fetched document: {status} {url} {headers}", {
-        status: response.status,
-        url: documentUrl,
-        headers: Object.fromEntries(response.headers.entries()),
-    });
-    return { contextUrl, document, documentUrl };
-}
-/**
- * Creates a JSON-LD document loader that utilizes the browser's `fetch` API.
- *
- * The created loader preloads the below frequently used contexts by default
- * (unless `options.ignorePreloadedContexts` is set to `true`):
- *
- * - <https://www.w3.org/ns/activitystreams>
- * - <https://w3id.org/security/v1>
- * - <https://w3id.org/security/data-integrity/v1>
- * - <https://www.w3.org/ns/did/v1>
- * - <https://w3id.org/security/multikey/v1>
- * - <https://purl.archive.org/socialweb/webfinger>
- * - <http://schema.org/>
- * @param options Options for the document loader.
- * @returns The document loader.
- * @since 1.3.0
- */
-export function getDocumentLoader({ allowPrivateAddress, skipPreloadedContexts, userAgent } = {}) {
-    async function load(url) {
-        if (!skipPreloadedContexts && url in preloadedContexts) {
-            logger.debug("Using preloaded context: {url}.", { url });
-            return {
-                contextUrl: null,
-                document: preloadedContexts[url],
-                documentUrl: url,
-            };
-        }
-        if (!allowPrivateAddress) {
-            try {
-                await validatePublicUrl(url);
-            }
-            catch (error) {
-                if (error instanceof UrlError) {
-                    logger.error("Disallowed private URL: {url}", { url, error });
-                }
-                throw error;
-            }
-        }
-        const request = createRequest(url, { userAgent });
-        logRequest(request);
-        const response = await fetch(request, {
-            // Since Bun has a bug that ignores the `Request.redirect` option,
-            // to work around it we specify `redirect: "manual"` here too:
-            // https://github.com/oven-sh/bun/issues/10754
-            redirect: "manual",
-        });
-        // Follow redirects manually to get the final URL:
-        if (response.status >= 300 && response.status < 400 &&
-            response.headers.has("Location")) {
-            return load(response.headers.get("Location"));
-        }
-        return getRemoteDocument(url, response, load);
-    }
-    return load;
-}
-const _fetchDocumentLoader = getDocumentLoader();
-const _fetchDocumentLoader_allowPrivateAddress = getDocumentLoader({
-    allowPrivateAddress: true,
-});
-/**
- * A JSON-LD document loader that utilizes the browser's `fetch` API.
- *
- * This loader preloads the below frequently used contexts:
- *
- * - <https://www.w3.org/ns/activitystreams>
- * - <https://w3id.org/security/v1>
- * - <https://w3id.org/security/data-integrity/v1>
- * - <https://www.w3.org/ns/did/v1>
- * - <https://w3id.org/security/multikey/v1>
- * - <https://purl.archive.org/socialweb/webfinger>
- * - <http://schema.org/>
- * @param url The URL of the document to load.
- * @param allowPrivateAddress Whether to allow fetching private network
- *                            addresses.  Turned off by default.
- * @returns The remote document.
- * @deprecated Use {@link getDocumentLoader} instead.
- */
-export function fetchDocumentLoader(url, allowPrivateAddress = false) {
-    logger.warn("fetchDocumentLoader() function is deprecated.  " +
-        "Use getDocumentLoader() function instead.");
-    return (allowPrivateAddress
-        ? _fetchDocumentLoader_allowPrivateAddress
-        : _fetchDocumentLoader)(url);
-}
-/**
- * Gets an authenticated {@link DocumentLoader} for the given identity.
- * Note that an authenticated document loader intentionally does not cache
- * the fetched documents.
- * @param identity The identity to get the document loader for.
- *                 The actor's key pair.
- * @param options The options for the document loader.
- * @returns The authenticated document loader.
- * @throws {TypeError} If the key is invalid or unsupported.
- * @since 0.4.0
- */
-export function getAuthenticatedDocumentLoader(identity, { allowPrivateAddress, userAgent, specDeterminer, tracerProvider } = {}) {
-    validateCryptoKey(identity.privateKey);
-    async function load(url) {
-        if (!allowPrivateAddress) {
-            try {
-                await validatePublicUrl(url);
-            }
-            catch (error) {
-                if (error instanceof UrlError) {
-                    logger.error("Disallowed private URL: {url}", { url, error });
-                }
-                throw error;
-            }
-        }
-        const originalRequest = createRequest(url, { userAgent });
-        const response = await doubleKnock(originalRequest, identity, { specDeterminer, log: logRequest, tracerProvider });
-        return getRemoteDocument(url, response, load);
-    }
-    return load;
-}
-/**
- * Decorates a {@link DocumentLoader} with a cache backed by a {@link Deno.Kv}.
- * @param parameters The parameters for the cache.
- * @returns The decorated document loader which is cache-enabled.
- */
-export function kvCache({ loader, kv, prefix, rules }) {
-    const keyPrefix = prefix ?? ["_fedify", "remoteDocument"];
-    rules ??= [
-        [new dntShim.URLPattern({}), dntShim.Temporal.Duration.from({ minutes: 5 })],
-    ];
-    for (const [p, duration] of rules) {
-        if (dntShim.Temporal.Duration.compare(duration, { days: 30 }) > 0) {
-            throw new TypeError("The maximum cache duration is 30 days: " +
-                (p instanceof dntShim.URLPattern
-                    ? `${p.protocol}://${p.username}:${p.password}@${p.hostname}:${p.port}/${p.pathname}?${p.search}#${p.hash}`
-                    : p.toString()));
-        }
-    }
-    function matchRule(url) {
-        for (const [pattern, duration] of rules) {
-            if (typeof pattern === "string") {
-                if (url === pattern)
-                    return duration;
-                continue;
-            }
-            if (pattern instanceof URL) {
-                if (pattern.href == url)
-                    return duration;
-                continue;
-            }
-            if (pattern.test(url))
-                return duration;
-        }
-        return null;
-    }
-    return async (url) => {
-        const match = matchRule(url);
-        if (match == null)
-            return await loader(url);
-        const key = [...keyPrefix, url];
-        let cache = undefined;
-        try {
-            cache = await kv.get(key);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                logger.warn("Failed to get the document of {url} from the KV cache: {error}", { url, error });
-            }
-        }
-        if (cache == null) {
-            const remoteDoc = await loader(url);
-            try {
-                await kv.set(key, remoteDoc, { ttl: match });
-            }
-            catch (error) {
-                logger.warn("Failed to save the document of {url} to the KV cache: {error}", { url, error });
-            }
-            return remoteDoc;
-        }
-        return cache;
-    };
-}
-/**
- * Gets the user agent string for the given application and URL.
- * @param options The options for making the user agent string.
- * @returns The user agent string.
- * @since 1.3.0
- */
-export function getUserAgent({ software, url } = {}) {
-    const fedify = `Fedify/${metadata.version}`;
-    const runtime = // dnt-shim-ignore
-     
-    // deno-lint-ignore no-explicit-any
-    globalThis.Deno?.version?.deno != null
-        ? `Deno/${dntShim.Deno.version.deno}`
-        // dnt-shim-ignore
-        // deno-lint-ignore no-explicit-any
-        : globalThis.process?.versions?.bun != null
-            ? `Bun/${process.versions.bun}`
-            // dnt-shim-ignore
-            // deno-lint-ignore no-explicit-any
-            : globalThis.process?.versions?.node != null
-                ? `Node.js/${process.versions.node}`
-                : null;
-    const userAgent = software == null ? [fedify] : [software, fedify];
-    if (runtime != null)
-        userAgent.push(runtime);
-    if (url != null)
-        userAgent.push(`+${url.toString()}`);
-    const first = userAgent.shift();
-    return `${first} (${userAgent.join("; ")})`;
-}

package/esm/runtime/key.js

@@ -1,153 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-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 { decode, encode } from "./multibase/index.js";
-import { validateCryptoKey } from "../sig/key.js";
-const algorithms = {
-    "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) {
-    pem = pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, "");
-    let spki;
-    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 dntShim.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) {
-    validateCryptoKey(key);
-    const spki = await dntShim.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) {
-    const key = createPublicKey({ key: pem, format: "pem", type: "pkcs1" });
-    const spki = key.export({ type: "spki", format: "pem" });
-    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) {
-    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) {
-    const decoded = decode(key);
-    const code = getCodeFromData(decoded);
-    const content = rmPrefix(decoded);
-    if (code === 0x1205) { // rsa-pub
-        const keyObject = createPublicKey({
-            // deno-lint-ignore no-explicit-any
-            key: content,
-            format: "der",
-            type: "pkcs1",
-        });
-        const spki = keyObject.export({ type: "spki", format: "der" }).buffer;
-        return await dntShim.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 dntShim.crypto.subtle.importKey("raw", content, "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) {
-    let content;
-    let code;
-    if (key.algorithm.name === "Ed25519") {
-        content = await dntShim.crypto.subtle.exportKey("raw", key);
-        code = 0xed; // ed25519-pub
-    }
-    else if (key.algorithm.name === "RSASSA-PKCS1-v1_5" &&
-        key.algorithm.hash.name ===
-            "SHA-256") {
-        const jwk = await dntShim.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 = encode("base58btc", prefixed);
-    return new TextDecoder().decode(encoded);
-}
-// cSpell: ignore multicodec pkijs

package/esm/runtime/langstr.js

@@ -1,25 +0,0 @@
-import { parseLanguageTag } from "@phensley/language-tag";
-/**
- * A language-tagged string which corresponds to the `rdf:langString` type.
- */
-export class LanguageString extends String {
-    language;
-    /**
-     * Constructs a new `LanguageString`.
-     * @param value A string value written in the given language.
-     * @param language The language of the string.  If a string is given, it will
-     *                 be parsed as a `LanguageTag`.
-     */
-    constructor(value, language) {
-        super(value);
-        this.language = typeof language === "string"
-            ? parseLanguageTag(language)
-            : language;
-    }
-    [Symbol.for("Deno.customInspect")](inspect, options) {
-        return `<${this.language.compact()}> ${inspect(this.toString(), options)}`;
-    }
-    [Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
-        return `<${this.language.compact()}> ${inspect(this.toString(), options)}`;
-    }
-}

package/esm/runtime/mod.js

@@ -1,10 +0,0 @@
-/**
- * This module contains the runtime facilities for working with Activity
- * Vocabulary objects, which are auto-generated from the IDL.
- *
- * @module
- */
-import "../_dnt.polyfills.js";
-export * from "./docloader.js";
-export * from "./key.js";
-export * from "./langstr.js";

package/esm/runtime/multibase/base.js

@@ -1,30 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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;
-}, {});