nhb-toolbox/dist/cjs/hash/helpers.js

A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports._numToHex = _numToHex;
exports._stringToNumbers = _stringToNumbers;
exports._md5cycle = _md5cycle;
exports._uuidTimestamp = _uuidTimestamp;
exports._randomNode48 = _randomNode48;
exports._bytesToRandomHex = _bytesToRandomHex;
exports._clockSeq14 = _clockSeq14;
exports._formatUUID = _formatUUID;
exports._isOptionV3V5 = _isOptionV3V5;
exports._checkUUIDVersion = _checkUUIDVersion;
exports._constantTimeEquals = _constantTimeEquals;
exports._splitByCharLength = _splitByCharLength;
exports._padStartWith0 = _padStartWith0;
const non_primitives_1 = require("../guards/non-primitives");
const primitives_1 = require("../guards/primitives");
const specials_1 = require("../guards/specials");
const utils_1 = require("./utils");
function _add32(x, y) {
    return (x + y) & 0xffffffff;
}
function _numToHex(n) {
    return [0, 8, 16, 24]
        .map((shift) => ((n >> shift) & 0xff).toString(16).padStart(2, '0'))
        .join('');
}
function _stringToNumbers(s) {
    return Array.from({ length: 16 }, (_, i) => {
        const x = i << 2;
        return (s.charCodeAt(x) |
            (s.charCodeAt(x + 1) << 8) |
            (s.charCodeAt(x + 2) << 16) |
            (s.charCodeAt(x + 3) << 24));
    });
}
function _transform(q, a, b, x, s, t) {
    const a1 = _add32(_add32(a, q), _add32(x, t));
    return _add32((a1 << s) | (a1 >>> (32 - s)), b);
}
const ff = (a, b, c, d, x, s, t) => {
    return _transform((b & c) | (~b & d), a, b, x, s, t);
};
const gg = (a, b, c, d, x, s, t) => {
    return _transform((b & d) | (c & ~d), a, b, x, s, t);
};
const hh = (a, b, c, d, x, s, t) => {
    return _transform(b ^ c ^ d, a, b, x, s, t);
};
const ii = (a, b, c, d, x, s, t) => {
    return _transform(c ^ (b | ~d), a, b, x, s, t);
};
function _md5cycle(x, k) {
    let a = x[0];
    let b = x[1];
    let c = x[2];
    let d = x[3];
    a = ff(a, b, c, d, k[0], 7, -680876936);
    d = ff(d, a, b, c, k[1], 12, -389564586);
    c = ff(c, d, a, b, k[2], 17, 606105819);
    b = ff(b, c, d, a, k[3], 22, -1044525330);
    a = ff(a, b, c, d, k[4], 7, -176418897);
    d = ff(d, a, b, c, k[5], 12, 1200080426);
    c = ff(c, d, a, b, k[6], 17, -1473231341);
    b = ff(b, c, d, a, k[7], 22, -45705983);
    a = ff(a, b, c, d, k[8], 7, 1770035416);
    d = ff(d, a, b, c, k[9], 12, -1958414417);
    c = ff(c, d, a, b, k[10], 17, -42063);
    b = ff(b, c, d, a, k[11], 22, -1990404162);
    a = ff(a, b, c, d, k[12], 7, 1804603682);
    d = ff(d, a, b, c, k[13], 12, -40341101);
    c = ff(c, d, a, b, k[14], 17, -1502002290);
    b = ff(b, c, d, a, k[15], 22, 1236535329);
    a = gg(a, b, c, d, k[1], 5, -165796510);
    d = gg(d, a, b, c, k[6], 9, -1069501632);
    c = gg(c, d, a, b, k[11], 14, 643717713);
    b = gg(b, c, d, a, k[0], 20, -373897302);
    a = gg(a, b, c, d, k[5], 5, -701558691);
    d = gg(d, a, b, c, k[10], 9, 38016083);
    c = gg(c, d, a, b, k[15], 14, -660478335);
    b = gg(b, c, d, a, k[4], 20, -405537848);
    a = gg(a, b, c, d, k[9], 5, 568446438);
    d = gg(d, a, b, c, k[14], 9, -1019803690);
    c = gg(c, d, a, b, k[3], 14, -187363961);
    b = gg(b, c, d, a, k[8], 20, 1163531501);
    a = gg(a, b, c, d, k[13], 5, -1444681467);
    d = gg(d, a, b, c, k[2], 9, -51403784);
    c = gg(c, d, a, b, k[7], 14, 1735328473);
    b = gg(b, c, d, a, k[12], 20, -1926607734);
    a = hh(a, b, c, d, k[5], 4, -378558);
    d = hh(d, a, b, c, k[8], 11, -2022574463);
    c = hh(c, d, a, b, k[11], 16, 1839030562);
    b = hh(b, c, d, a, k[14], 23, -35309556);
    a = hh(a, b, c, d, k[1], 4, -1530992060);
    d = hh(d, a, b, c, k[4], 11, 1272893353);
    c = hh(c, d, a, b, k[7], 16, -155497632);
    b = hh(b, c, d, a, k[10], 23, -1094730640);
    a = hh(a, b, c, d, k[13], 4, 681279174);
    d = hh(d, a, b, c, k[0], 11, -358537222);
    c = hh(c, d, a, b, k[3], 16, -722521979);
    b = hh(b, c, d, a, k[6], 23, 76029189);
    a = hh(a, b, c, d, k[9], 4, -640364487);
    d = hh(d, a, b, c, k[12], 11, -421815835);
    c = hh(c, d, a, b, k[15], 16, 530742520);
    b = hh(b, c, d, a, k[2], 23, -995338651);
    a = ii(a, b, c, d, k[0], 6, -198630844);
    d = ii(d, a, b, c, k[7], 10, 1126891415);
    c = ii(c, d, a, b, k[14], 15, -1416354905);
    b = ii(b, c, d, a, k[5], 21, -57434055);
    a = ii(a, b, c, d, k[12], 6, 1700485571);
    d = ii(d, a, b, c, k[3], 10, -1894986606);
    c = ii(c, d, a, b, k[10], 15, -1051523);
    b = ii(b, c, d, a, k[1], 21, -2054922799);
    a = ii(a, b, c, d, k[8], 6, 1873313359);
    d = ii(d, a, b, c, k[15], 10, -30611744);
    c = ii(c, d, a, b, k[6], 15, -1560198380);
    b = ii(b, c, d, a, k[13], 21, 1309151649);
    a = ii(a, b, c, d, k[4], 6, -145523070);
    d = ii(d, a, b, c, k[11], 10, -1120210379);
    c = ii(c, d, a, b, k[2], 15, 718787259);
    b = ii(b, c, d, a, k[9], 21, -343485551);
    x[0] = _add32(a, x[0]);
    x[1] = _add32(b, x[1]);
    x[2] = _add32(c, x[2]);
    x[3] = _add32(d, x[3]);
}
function _uuidTimestamp() {
    const UUID_EPOCH_DIFF = 12219292800000n;
    const unixMs = BigInt(Date.now());
    const uuidMs = unixMs + UUID_EPOCH_DIFF;
    return uuidMs * 10000n;
}
function _randomNode48() {
    const node = (0, utils_1.randomHex)(12).split('');
    const firstByte = parseInt(node.slice(0, 2).join(''), 16);
    const modified = (firstByte | 0b00000001).toString(16).padStart(2, '0');
    return modified + node.slice(2).join('');
}
function _bytesToRandomHex(bytes) {
    if (crypto?.getRandomValues) {
        crypto.getRandomValues(bytes);
    }
    else {
        for (let i = 0; i < bytes.length; i++) {
            bytes[i] = Math.floor(Math.random() * 256);
        }
    }
    let hex = '';
    for (let i = 0; i < bytes.length; i++) {
        hex += bytes[i].toString(16).padStart(2, '0');
    }
    return hex;
}
function _clockSeq14() {
    const seq = parseInt((0, utils_1.randomHex)(4), 16) & 0x3fff;
    return seq.toString(16).padStart(4, '0');
}
function _formatUUID(h, v, up) {
    const part3 = String(v) + h.slice(13, 16);
    const part4 = _hexVariant(h.slice(16, 18)) + h.slice(18, 20);
    const formatted = [h.slice(0, 8), h.slice(8, 12), part3, part4, h.slice(20, 32)].join('-');
    return (up ? formatted.toUpperCase() : formatted);
}
function _hexVariant(hex) {
    const v = parseInt(hex, 16);
    return ((v & 0x3f) | 0x80).toString(16).padStart(2, '0');
}
function _isOptionV3V5(opt) {
    if ((0, non_primitives_1.isObjectWithKeys)(opt, ['name', 'namespace'])) {
        return (0, specials_1.isUUID)(opt?.namespace) && (0, primitives_1.isNonEmptyString)(opt?.name);
    }
    return false;
}
function _checkUUIDVersion(value, v) {
    return (0, specials_1.isUUID)(value) && value[14] === v;
}
function _constantTimeEquals(a, b) {
    if (a.length !== b.length)
        return false;
    const _getRes = (x, idx) => {
        return (0, primitives_1.isString)(x) ? x.charCodeAt(idx) : x[idx];
    };
    let res = 0;
    for (let i = 0; i < a.length; i++) {
        res |= _getRes(a, i) ^ _getRes(b, i);
    }
    return res === 0;
}
function _splitByCharLength(str, splitByChars = 2) {
    if (!(0, primitives_1.isNonEmptyString)(str))
        return [];
    const sanitized = str.replace(/\s+/g, '');
    const result = [];
    for (let i = 0; i < sanitized.length; i += splitByChars) {
        result.push(sanitized.slice(i, i + splitByChars));
    }
    return result;
}
function _padStartWith0(byte, type) {
    return byte.toString(type === 'hex' ? 16 : 2).padStart(type === 'hex' ? 2 : 8, '0');
}