nhb-toolbox
Version:
A versatile collection of smart, efficient, and reusable utility functions, classes and types for everyday development needs.
187 lines (186 loc) • 6.9 kB
JavaScript
import { isObjectWithKeys } from '../guards/non-primitives.js';
import { isNonEmptyString, isString } from '../guards/primitives.js';
import { isUUID } from '../guards/specials.js';
import { randomHex } from './utils.js';
function _add32(x, y) {
return (x + y) & 0xffffffff;
}
export function _numToHex(n) {
return [0, 8, 16, 24]
.map((shift) => ((n >> shift) & 0xff).toString(16).padStart(2, '0'))
.join('');
}
export 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);
};
export 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]);
}
export function _uuidTimestamp() {
const UUID_EPOCH_DIFF = 12219292800000n;
const unixMs = BigInt(Date.now());
const uuidMs = unixMs + UUID_EPOCH_DIFF;
return uuidMs * 10000n;
}
export function _randomNode48() {
const node = 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('');
}
export 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;
}
export function _clockSeq14() {
const seq = parseInt(randomHex(4), 16) & 0x3fff;
return seq.toString(16).padStart(4, '0');
}
export 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');
}
export function _isOptionV3V5(opt) {
if (isObjectWithKeys(opt, ['name', 'namespace'])) {
return isUUID(opt?.namespace) && isNonEmptyString(opt?.name);
}
return false;
}
export function _checkUUIDVersion(value, v) {
return isUUID(value) && value[14] === v;
}
export function _constantTimeEquals(a, b) {
if (a.length !== b.length)
return false;
const _getRes = (x, idx) => {
return 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;
}
export function _splitByCharLength(str, splitByChars = 2) {
if (!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;
}
export function _padStartWith0(byte, type) {
return byte.toString(type === 'hex' ? 16 : 2).padStart(type === 'hex' ? 2 : 8, '0');
}