@rzl-zone/utils-js
Version:
A modern, lightweight set of JavaScript utility functions with TypeScript support for everyday development, crafted to enhance code readability and maintainability.
212 lines (208 loc) • 7.17 kB
JavaScript
/*!
* ====================================================
* Rzl Utils-JS.
* ----------------------------------------------------
* Version: 3.11.0.
* Author: Rizalvin Dwiky.
* Repository: https://github.com/rzl-zone/utils-js.
* ====================================================
*/
;
var chunkWXFTVXBF_cjs = require('./chunk-WXFTVXBF.cjs');
var chunkSYHPSOUU_cjs = require('./chunk-SYHPSOUU.cjs');
var maxInt = 2147483647;
var base = 36;
var tMin = 1;
var tMax = 26;
var skew = 38;
var damp = 700;
var initialBias = 72;
var initialN = 128;
var delimiter = "-";
var regexPunycode = /^xn--/;
var regexNonASCII = /[^\0-\x7F]/;
var regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
var errors = {
overflow: "Overflow: input needs wider integers to process",
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
"invalid-input": "Invalid input"
};
var floor = Math.floor;
var stringFromCharCode = String.fromCharCode;
function error(type) {
throw new RangeError(errors[type]);
}
function map(array, fn) {
const result = [];
let length = array.length;
while (length--) result[length] = fn(array[length]);
return result;
}
function mapDomain(domain, fn) {
const parts = domain.split("@");
let result = "";
if (parts.length > 1) {
result = parts[0] + "@";
domain = parts[1];
}
domain = domain.replace(regexSeparators, ".");
const labels = domain.split(".");
return result + map(labels, fn).join(".");
}
function ucs2decode(input) {
chunkWXFTVXBF_cjs.assertIsString(input, {
message: ({ currentType, validType }) => `Utils \`punycodeUtilsJS.ucs2.decode\`, parameter \`input\` must be of type \`${validType}\`, but received: \`${currentType}\`.`
});
const output = [];
let counter = 0;
const length = input.length;
while (counter < length) {
const value = input.charCodeAt(counter++);
if (value >= 55296 && value <= 56319 && counter < length) {
const extra = input.charCodeAt(counter++);
if ((extra & 64512) === 56320)
output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
else {
output.push(value);
counter--;
}
} else output.push(value);
}
return output;
}
var ucs2encode = (points) => {
if (!Array.isArray(points) || !points.every((p) => typeof p === "number" && Number.isFinite(p))) {
throw new TypeError(
`Utils \`punycodeUtilsJS.ucs2.encode\`, parameter \`points\` must be an array of numbers, but received: \`${chunkSYHPSOUU_cjs.getPreciseType(
points
)}\`.`
);
}
return String.fromCodePoint(...points);
};
function basicToDigit(codePoint) {
if (codePoint >= 48 && codePoint < 58) return 26 + (codePoint - 48);
if (codePoint >= 65 && codePoint < 91) return codePoint - 65;
if (codePoint >= 97 && codePoint < 123) return codePoint - 97;
return base;
}
function digitToBasic(digit, flag) {
return digit + 22 + 75 * (digit < 26 ? 1 : 0) - Number(flag !== 0) * 32;
}
function adapt(delta, numPoints, firstTime) {
let k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
while (delta > (base - tMin) * tMax >> 1) {
delta = floor(delta / (base - tMin));
k += base;
}
return floor(k + (base - tMin + 1) * delta / (delta + skew));
}
function decode(input) {
chunkWXFTVXBF_cjs.assertIsString(input, {
message: ({ currentType, validType }) => `Utils \`punycodeUtilsJS.decode\`, parameter \`input\` must be of type \`${validType}\`, but received: \`${currentType}\`.`
});
const output = [];
const inputLength = input.length;
let i = 0, n = initialN, bias = initialBias;
let basic = input.lastIndexOf(delimiter);
if (basic < 0) basic = 0;
for (let j = 0; j < basic; j++) {
if (input.charCodeAt(j) >= 128) error("not-basic");
output.push(input.charCodeAt(j));
}
for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
const oldi = i;
let w = 1;
for (let k = base; ; k += base) {
if (index >= inputLength) error("invalid-input");
const digit = basicToDigit(input.charCodeAt(index++));
if (digit >= base) error("invalid-input");
if (digit > floor((maxInt - i) / w)) error("overflow");
i += digit * w;
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
if (digit < t) break;
const baseMinusT = base - t;
if (w > floor(maxInt / baseMinusT)) error("overflow");
w *= baseMinusT;
}
const out = output.length + 1;
bias = adapt(i - oldi, out, oldi === 0);
if (floor(i / out) > maxInt - n) error("overflow");
n += floor(i / out);
i %= out;
output.splice(i++, 0, n);
}
return String.fromCodePoint(...output);
}
function encode(input) {
chunkWXFTVXBF_cjs.assertIsString(input, {
message: ({ currentType, validType }) => `Utils \`punycodeUtilsJS.encode\`, parameter \`input\` must be of type \`${validType}\`, but received: \`${currentType}\`.`
});
const output = [];
const points = ucs2decode(input);
const inputLength = points.length;
let n = initialN, delta = 0, bias = initialBias;
for (const cp of points) if (cp < 128) output.push(stringFromCharCode(cp));
const basicLength = output.length;
let handledCPCount = basicLength;
if (basicLength) output.push(delimiter);
while (handledCPCount < inputLength) {
let m = maxInt;
for (const cp of points) if (cp >= n && cp < m) m = cp;
const handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (const cp of points) {
if (cp < n) delta++;
if (cp === n) {
let q = delta;
for (let k = base; ; k += base) {
const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
if (q < t) break;
output.push(stringFromCharCode(digitToBasic(t + (q - t) % (base - t), 0)));
q = floor((q - t) / (base - t));
}
output.push(stringFromCharCode(digitToBasic(q, 0)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
delta = 0;
handledCPCount++;
}
}
delta++;
n++;
}
return output.join("");
}
function toUnicode(input) {
chunkWXFTVXBF_cjs.assertIsString(input, {
message: ({ currentType, validType }) => `Utils \`punycodeUtilsJS.toUnicode\`, parameter \`input\` must be of type \`${validType}\`, but received: \`${currentType}\`.`
});
return mapDomain(
input,
(str) => regexPunycode.test(str) ? decode(str.slice(4).toLowerCase()) : str
);
}
function toASCII(input) {
chunkWXFTVXBF_cjs.assertIsString(input, {
message: ({ currentType, validType }) => `Utils \`punycodeUtilsJS.toASCII\`, parameter \`input\` must be of type \`${validType}\`, but received: \`${currentType}\`.`
});
return mapDomain(
input,
(str) => regexNonASCII.test(str) ? "xn--" + encode(str) : str
);
}
var punycodeUtilsJS = {
version: "1.0.0",
ucs2: {
decode: ucs2decode,
encode: ucs2encode
},
decode,
encode,
toASCII,
toUnicode
};
exports.punycodeUtilsJS = punycodeUtilsJS;