source: frontend/node_modules/webpack/lib/util/hash/hash-digest.js

/*
        MIT License http://www.opensource.org/licenses/mit-license.php
        Author Alexander Akait @alexander-akait
*/

"use strict";

/** @typedef {import("../Hash")} Hash */
/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */

/** @typedef {"26" | "32" | "36" | "49" | "52" | "58" | "62"} Base */

/* cSpell:disable */

/** @type {Record<Base, string>} */
const ENCODE_TABLE = Object.freeze({
        26: "abcdefghijklmnopqrstuvwxyz",
        32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
        36: "0123456789abcdefghijklmnopqrstuvwxyz",
        49: "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ",
        52: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
        58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
        62: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
});

/* cSpell:enable */

const ZERO = BigInt("0");
const EIGHT = BigInt("8");
const FF = BigInt("0xff");

/**
 * It encodes octet arrays by doing long divisions on all significant digits in the array, creating a representation of that number in the new base.
 * Then for every leading zero in the input (not significant as a number) it will encode as a single leader character.
 * This is the first in the alphabet and will decode as 8 bits. The other characters depend upon the base.
 * For example, a base58 alphabet packs roughly 5.858 bits per character.
 * This means the encoded string 000f (using a base16, 0-f alphabet) will actually decode to 4 bytes unlike a canonical hex encoding which uniformly packs 4 bits into each character.
 * While unusual, this does mean that no padding is required, and it works for bases like 43.
 * @param {Buffer} buffer buffer
 * @param {Base} base base
 * @returns {string} encoded buffer
 */
const encode = (buffer, base) => {
        if (buffer.length === 0) return "";
        const bigIntBase = BigInt(ENCODE_TABLE[base].length);
        // Convert buffer to BigInt efficiently using bitwise operations
        let value = ZERO;
        for (let i = 0; i < buffer.length; i++) {
                value = (value << EIGHT) | BigInt(buffer[i]);
        }
        // Convert to baseX string efficiently using array
        /** @type {string[]} */
        const digits = [];
        if (value === ZERO) return ENCODE_TABLE[base][0];
        while (value > ZERO) {
                const remainder = Number(value % bigIntBase);
                digits.push(ENCODE_TABLE[base][remainder]);
                value /= bigIntBase;
        }
        return digits.reverse().join("");
};

/**
 * Returns buffer.
 * @param {string} data string
 * @param {Base} base base
 * @returns {Buffer} buffer
 */
const decode = (data, base) => {
        if (data.length === 0) return Buffer.from("");
        const bigIntBase = BigInt(ENCODE_TABLE[base].length);
        // Convert the baseX string to a BigInt value
        let value = ZERO;
        for (let i = 0; i < data.length; i++) {
                const digit = ENCODE_TABLE[base].indexOf(data[i]);
                if (digit === -1) {
                        throw new Error(`Invalid character at position ${i}: ${data[i]}`);
                }
                value = value * bigIntBase + BigInt(digit);
        }
        // If value is 0, return a single-byte buffer with value 0
        if (value === ZERO) {
                return Buffer.alloc(1);
        }
        // Determine buffer size efficiently by counting bytes
        let temp = value;
        let byteLength = 0;
        while (temp > ZERO) {
                temp >>= EIGHT;
                byteLength++;
        }
        // Create buffer and fill it from right to left
        const buffer = Buffer.alloc(byteLength);
        for (let i = byteLength - 1; i >= 0; i--) {
                buffer[i] = Number(value & FF);
                value >>= EIGHT;
        }
        return buffer;
};

// Compatibility with the old hash libraries, they can return different structures, so let's stringify them firstly

/**
 * Returns a string representation.
 * @param {string | { toString: (radix: number) => string }} value value
 * @param {string} encoding encoding
 * @returns {string} string
 */
const toString = (value, encoding) =>
        typeof value === "string"
                ? value
                : Buffer.from(value.toString(16), "hex").toString(
                                /** @type {NodeJS.BufferEncoding} */
                                (encoding)
                        );

/**
 * Returns buffer.
 * @param {Buffer | { toString: (radix: number) => string }} value value
 * @returns {Buffer} buffer
 */
const toBuffer = (value) =>
        Buffer.isBuffer(value) ? value : Buffer.from(value.toString(16), "hex");

let isBase64URLSupported = false;

try {
        isBase64URLSupported = Boolean(Buffer.from("", "base64url"));
} catch (_err) {
        // Nothing
}

/**
 * Processes the provided hash.
 * @param {Hash} hash hash
 * @param {string | Buffer} data data
 * @param {Encoding=} encoding encoding of the return value
 * @returns {void}
 */
const update = (hash, data, encoding) => {
        if (encoding === "base64url" && !isBase64URLSupported) {
                const base64String = /** @type {string} */ (data)
                        .replace(/-/g, "+")
                        .replace(/_/g, "/");
                const buf = Buffer.from(base64String, "base64");
                hash.update(buf);
                return;
        } else if (
                typeof data === "string" &&
                encoding &&
                typeof ENCODE_TABLE[/** @type {Base} */ (encoding.slice(4))] !== "undefined"
        ) {
                const buf = decode(data, /** @type {Base} */ (encoding.slice(4)));
                hash.update(buf);
                return;
        }

        if (encoding) {
                hash.update(/** @type {string} */ (data), encoding);
        } else {
                hash.update(data);
        }
};

/**
 * Returns digest.
 * @overload
 * @param {Hash} hash hash
 * @returns {Buffer} digest
 */
/**
 * Returns digest.
 * @overload
 * @param {Hash} hash hash
 * @param {undefined} encoding encoding of the return value
 * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
 * @returns {Buffer} digest
 */
/**
 * Returns digest.
 * @overload
 * @param {Hash} hash hash
 * @param {Encoding} encoding encoding of the return value
 * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
 * @returns {string} digest
 */
/**
 * Returns digest.
 * @param {Hash} hash hash
 * @param {Encoding=} encoding encoding of the return value
 * @param {boolean=} isSafe true when we await right types from digest(), otherwise false
 * @returns {string | Buffer} digest
 */
const digest = (hash, encoding, isSafe) => {
        if (typeof encoding === "undefined") {
                return isSafe ? hash.digest() : toBuffer(hash.digest());
        }

        if (encoding === "base64url" && !isBase64URLSupported) {
                const digest = isSafe
                        ? hash.digest("base64")
                        : toString(hash.digest("base64"), "base64");

                return digest.replace(/\+/g, "-").replace(/\//g, "_").replace(/[=]+$/, "");
        } else if (
                typeof ENCODE_TABLE[/** @type {Base} */ (encoding.slice(4))] !== "undefined"
        ) {
                const buf = isSafe ? hash.digest() : toBuffer(hash.digest());

                return encode(
                        buf,
                        /** @type {Base} */
                        (encoding.slice(4))
                );
        }

        return isSafe
                ? hash.digest(encoding)
                : toString(hash.digest(encoding), encoding);
};

module.exports.decode = decode;
module.exports.digest = digest;
module.exports.encode = encode;
module.exports.update = update;