foreslash 0.3.1 → 0.3.3

package/lib/index.mjs

@@ -9,6 +9,57 @@ EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 See the Mulan PSL v2 for more details.
 */
+function cartesianProduct(...arrList) {
+    const arrLen = arrList.length;
+    const pList = Array(arrLen).fill(0);
+    const lastIndex = arrLen - 1;
+    const res = [];
+    for (let i = 0; i < arrLen; i++) {
+        if (!arrList[i].length)
+            return [];
+    }
+    while (1) {
+        const temp = [];
+        for (let i = 0; i < arrLen; i++) {
+            temp.push(arrList[i][pList[i]]);
+        }
+        res.push(temp);
+        pList[lastIndex] += 1;
+        for (let i = lastIndex; i >= 0; i--) {
+            if (pList[i] >= arrList[i].length) {
+                if (i > 0) {
+                    pList[i] = 0;
+                    pList[i - 1] += 1;
+                }
+                else
+                    break;
+            }
+            else
+                break;
+        }
+        if (pList[0] >= arrList[0].length)
+            break;
+    }
+    return res;
+}
+
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
+function chunk(array, size = 2) {
+    const res = [];
+    if (size < 1 || isNaN(size))
+        return res;
+    let start = 0, end = size;
+    while (start < array.length) {
+        res.push(Array.prototype.slice.call(array, start, end));
+        start = end;
+        end += size;
+    }
+    return res;
+}
+
 function range(start, end, stepOrOptions) {
     if (!isFinite(start))
         throw new Error('start must be finite');
@@ -200,6 +251,22 @@ function isNumber(value) {
     return typeof value === 'number';
 }
 
+const fnToString = Function.prototype.toString;
+const objProtoContString = fnToString.call(Object.prototype.constructor);
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null)
+        return true;
+    if (!Object.prototype.hasOwnProperty.call(prototype, "constructor"))
+        return false;
+    const constructorFn = prototype.constructor;
+    if (!isFunction(constructorFn) || fnToString.call(constructorFn) !== objProtoContString)
+        return false;
+    return (Object.getPrototypeOf(prototype) === null);
+}
+
 function isPrimitive(value) {
     return value === undefined || value === null || (typeof value !== 'object' && typeof value !== 'function');
 }
@@ -372,6 +439,373 @@ function clamp(num, min, max, options) {
     return num < min ? defaultMin : num > max ? defaultMax : num;
 }
 
+function decimalNotation(num) {
+    const n = isNumber(num) ? num : Number(num);
+    if (!isFinite(n))
+        return String(n);
+    let str = String(n);
+    if (!/e/i.test(str))
+        return str;
+    const match = str.match(/^(-?)(\d+)\.?(\d*)e([+-]?)(\d+)$/);
+    const [_, sign, mantissaI, mantissaF, expSign, _exponent] = match;
+    const exponent = Number(_exponent);
+    let mantissa = mantissaI + mantissaF;
+    let dotPos = mantissaI.length;
+    if (expSign === '-') {
+        const zeroCount = exponent - dotPos + 1;
+        if (zeroCount > 0)
+            mantissa = '0'.repeat(zeroCount) + mantissa;
+        return sign + mantissa[0] + '.' + mantissa.substring(1);
+    }
+    else {
+        const zeroCount = exponent + dotPos - mantissa.length;
+        if (zeroCount > 0)
+            mantissa = mantissa + '0'.repeat(zeroCount);
+        return sign + mantissa.substring(0, exponent + dotPos);
+    }
+}
+
+function isOdd(num) {
+    return !!(num & 1);
+}
+function isEven(num) {
+    return !(num & 1);
+}
+
+function round(num, precision, type) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    let [_integer, _fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(_integer)) {
+        _integer = _integer.substring(1);
+        sign = '-';
+    }
+    _fractional = _fractional !== null && _fractional !== void 0 ? _fractional : '';
+    const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+    const [integer, fractional] = (roundMap[type || 'round'] || roundBase)(_integer, _fractional, precision, !!sign);
+    if (precision > 0)
+        return sign + integer + '.' + fractional;
+    else
+        return sign + integer;
+}
+function roundBase(integer, fractional, precision) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (Number(fractional[precision]) > 4)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundBank(integer, fractional, precision) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        const rightNumber = Number(fractional[precision]);
+        if (rightNumber < 5)
+            return [integer, splitF];
+        if (rightNumber > 5)
+            return increase(integer, splitF);
+        const rightNumbers = fractional.substring(precision);
+        if (!/^50*$/.test(rightNumbers))
+            return increase(integer, splitF);
+        const leftNumber = Number(precision ? fractional[precision - 1] : integer[integer.length - 1]);
+        if (isEven(leftNumber))
+            return [integer, splitF];
+        else
+            return increase(integer, splitF);
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundFloor(integer, fractional, precision, isNegative) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (isNegative)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function roundCeil(integer, fractional, precision, isNegative) {
+    if (fractional.length > precision) {
+        const splitF = fractional.substring(0, precision);
+        if (!isNegative)
+            return increase(integer, splitF);
+        return [integer, splitF];
+    }
+    if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    return [integer, fractional];
+}
+function increase(integer, fractional) {
+    if (fractional) {
+        const _fractional = _increase(fractional);
+        if (_fractional.length > fractional.length) {
+            return [_increase(integer), _fractional.substring(1)];
+        }
+        return [integer, _fractional];
+    }
+    return [_increase(integer), ''];
+}
+function _increase(num) {
+    const numList = num.split('').map(Number).reverse();
+    numList[0] += 1;
+    numList.push(0);
+    for (let i = 0; i < numList.length; i++) {
+        if (numList[i] > 9) {
+            numList[i] -= 10;
+            numList[i + 1] += 1;
+        }
+        else
+            break;
+    }
+    if (numList[numList.length - 1] === 0)
+        numList.pop();
+    return numList.reverse().map(String).join('');
+}
+
+function format(num, options) {
+    var _a;
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const separator = (options || {}).separator || ',';
+    const separate = clamp((options || {}).separate || 3, 1, Infinity);
+    const decimal = (options || {}).decimal || '.';
+    const precision = clamp((_a = (options || {}).precision) !== null && _a !== void 0 ? _a : 2, 0, Infinity);
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    if (fractional.length > precision) {
+        const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+        [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+    }
+    else if (fractional.length < precision) {
+        fractional += '0'.repeat(precision - fractional.length);
+    }
+    if (integer.length > separate) {
+        integer = chunk(Array.from(integer).reverse(), separate)
+            .map((part) => part.join(''))
+            .join(separator);
+        integer = Array.from(integer).reverse().join('');
+    }
+    if (precision > 0)
+        return sign + integer + decimal + fractional;
+    else
+        return sign + integer;
+}
+
+function lerp(val1, val2, t) {
+    if (isNumber(val1)) {
+        if (!isNumber(val2))
+            throw new Error('Invalid val2 parameter: val2 should be a number');
+        return _lerp(val1, val2, t);
+    }
+    else if (isArray(val1)) {
+        if (!isArray(val2))
+            throw new Error('Invalid val2 parameter: val2 should be an Array');
+        if (val1.length !== val2.length) {
+            throw new Error(`Invalid val2 parameter: the length of val2 (${val2.length}) should be consistent with val1 (${val1.length})`);
+        }
+        if (val1.length === 0)
+            return [];
+        if (isNumber(val1[0])) {
+            if (!isNumber(val2[0]))
+                throw new Error('Invalid val2 parameter: val2 should be an Array<number>');
+            return val1.map((v1, index) => _lerp(v1, val2[index], t));
+        }
+        else if (isArray(val1[0])) {
+            const res = [];
+            for (let i = 0; i < val1.length; i++) {
+                const arr1 = val1[i];
+                const arr2 = val2[i];
+                if (arr1.length !== arr2.length) {
+                    throw new Error(`Invalid val2 parameter: The length of array at index ${i} in val2 (${arr2.length}) must match the length of the corresponding array in val1 (${arr1.length})`);
+                }
+                res.push(arr1.map((v1, index) => _lerp(v1, arr2[index], t)));
+            }
+            return res;
+        }
+    }
+    throw new Error('Invalid val1 parameter: val1 should be a number or Array');
+}
+function _lerp(val1, val2, t) {
+    return val1 + (val2 - val1) * t;
+}
+
+function romanNumerals(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const thousand = (options || {}).thousand || 'normal';
+    const forceSplitThousand = thousand === 'strict';
+    const integer = str.split('.')[0].replace('-', '');
+    if (integer === '0') {
+        const zero = (options || {}).zero || '0';
+        if (type === 'json')
+            return `["${zero}"]`;
+        else
+            return zero;
+    }
+    if (integer === '1') {
+        const one = (options || {}).one || 'I';
+        if (type === 'json')
+            return `["${one}"]`;
+        else
+            return one;
+    }
+    const chunks = chunk(Array.from(integer).reverse(), 3);
+    const romanChunks = [];
+    for (let i = 0; i < chunks.length; i++) {
+        const val = Number(chunks[i].reverse().join(''));
+        if (i === chunks.length - 2 && !forceSplitThousand && Number(chunks[i + 1]) < 4) {
+            romanChunks.push(number2roman(val + Number(chunks[i + 1]) * 1000));
+            break;
+        }
+        else {
+            romanChunks.push(number2roman(val));
+        }
+    }
+    switch (type) {
+        case 'js':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\\\\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'html':
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '&#x0305;'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+        case 'json':
+            return `[${romanChunks.map((str) => `"${str}"`).join(', ')}]`;
+        case 'unicode':
+        default:
+            return romanChunks
+                .map((str, index) => str
+                .split('')
+                .map((s) => s + '\u0305'.repeat(index))
+                .join(''))
+                .reverse()
+                .join('');
+    }
+}
+function number2roman(num) {
+    const symbols = [
+        [1000, 'M'],
+        [900, 'CM'],
+        [500, 'D'],
+        [400, 'CD'],
+        [100, 'C'],
+        [90, 'XC'],
+        [50, 'L'],
+        [40, 'XL'],
+        [10, 'X'],
+        [9, 'IX'],
+        [5, 'V'],
+        [4, 'IV'],
+        [1, 'I'],
+    ];
+    let roman = '';
+    for (const [val, str] of symbols) {
+        while (num >= val) {
+            num -= val;
+            roman += str;
+        }
+        if (num == 0)
+            break;
+    }
+    return roman;
+}
+
+function scientificNotation(num, options) {
+    const str = decimalNotation(num);
+    if (/NaN|Inf/.test(str))
+        return str;
+    const type = (options || {}).type || 'unicode';
+    const _precision = (options || {}).precision;
+    const precision = isNumber(_precision) ? clamp(_precision !== null && _precision !== void 0 ? _precision : 2, 0, Infinity) : null;
+    const round = (options || {}).round || 'round';
+    let [integer, fractional] = str.split('.');
+    let sign = '';
+    if (/^-/.test(integer)) {
+        integer = integer.substring(1);
+        sign = '-';
+    }
+    fractional = fractional !== null && fractional !== void 0 ? fractional : '';
+    let exp = 0;
+    let n = '';
+    if (integer === '0') {
+        exp = /^(0+)/.test(fractional) ? -(fractional.match(/^(0+)/)[0].length + 1) : -1;
+        [integer, fractional] = [fractional.slice(-exp - 1, -exp), fractional.slice(-exp)];
+    }
+    else {
+        exp = integer.length - 1;
+        [integer, fractional] = [integer.slice(0, 1), integer.slice(1) + fractional];
+    }
+    if (isNumber(precision)) {
+        if (fractional.length > precision) {
+            const roundMap = { round: roundBase, banker: roundBank, floor: roundFloor, ceil: roundCeil };
+            [integer, fractional] = (roundMap[round] || roundBase)(integer, fractional, precision, !!sign);
+        }
+        else if (fractional.length < precision) {
+            fractional += '0'.repeat(precision - fractional.length);
+        }
+    }
+    else {
+        fractional = fractional.replace(/0+$/, '');
+    }
+    if ((precision === null && fractional) || (isNumber(precision) && precision > 0)) {
+        n = sign + integer + '.' + fractional;
+    }
+    else
+        n = sign + integer;
+    switch (type) {
+        case 'exp':
+            return `${n}e${exp < 0 ? '' : '+'}${exp}`;
+        case 'js':
+            return `${n}*10**${exp}`;
+        case 'code':
+            return `${n}*10^${exp}`;
+        case 'html':
+            return `${n}&#x00d7;10<sup>${exp}</sup>`;
+        case 'json':
+            return `{"number":"${n}","exp":${exp}}`;
+        case 'unicode':
+        default:
+            return `${n}×10${transferNumberToUniCode(String(exp))}`;
+    }
+}
+function transferNumberToUniCode(n) {
+    const strMap = Object.assign(Object.assign({}, Array.from('⁰¹²³⁴⁵⁶⁷⁸⁹')), { '-': '⁻', '+': '⁺' });
+    return Array.from(n)
+        .map((s) => (strMap[s] ? strMap[s] : s))
+        .join('');
+}
+
 function parallel(args, fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!args.length)
@@ -1003,6 +1437,54 @@ function randomChoice(arr, weights) {
     return arr[index];
 }
 
+function randomDistribution(p, options) {
+    const threshold = (options === null || options === void 0 ? void 0 : options.threshold) ? Math.max(options.threshold, Number.MIN_VALUE * 2) : 5e-6;
+    const C = getInitP(p, threshold);
+    let current = C;
+    return function getRandomDistribution() {
+        const res = Math.random() < current;
+        if (res)
+            current = C;
+        else
+            current += C;
+        return res;
+    };
+}
+function getInitP(targetP, threshold = 5e-6) {
+    if (targetP <= 0)
+        return 0;
+    if (targetP >= 1)
+        return 1;
+    let [down, up] = [0, 1];
+    let mid = 1;
+    let tempP = 1;
+    let tempPLast = 1;
+    let step = 64;
+    while (step-- > 0) {
+        mid = (down + up) / 2;
+        tempP = getRealPFromInitP(mid);
+        if (Math.abs(tempPLast - tempP) < threshold)
+            break;
+        if (tempP > targetP)
+            up = mid;
+        else
+            down = mid;
+    }
+    return mid;
+}
+function getRealPFromInitP(initP) {
+    let sum = 0;
+    let prod = 0;
+    let cur = 0;
+    let max = Math.ceil(1 / initP);
+    for (let n = 1; n <= max; n++) {
+        cur = Math.min(1, n * initP) * (1 - prod);
+        prod += cur;
+        sum += n * cur;
+    }
+    return 1 / sum;
+}
+
 const radix32 = '0123456789abcdefghijklmnopqrstuv';
 const base32Chars = 'abcdefghijklmnopqrstuvwxyz234567';
 const base32Crockford = '0123456789abcdefghjkmnpqrstvwxyz';
@@ -1629,22 +2111,22 @@ function _deepClone(obj, map, options) {
     if (isFormData(obj))
         return _cloneFormData(obj, map, _deepClone, options);
     let res;
-    if (obj instanceof Date) {
+    if (isDate(obj)) {
         res = new Date(obj.valueOf());
         map.set(obj, res);
     }
-    else if (obj instanceof RegExp) {
+    else if (isRegExp(obj)) {
         res = new RegExp(obj.source, obj.flags);
         map.set(obj, res);
     }
-    else if (obj instanceof ArrayBuffer) {
+    else if (isArrayBuffer(obj)) {
         res = _cloneArrayBuffer(obj, map);
     }
     else if (isTypedArray(obj)) {
         res = new obj.constructor(_cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.length);
         map.set(obj, res);
     }
-    else if (obj instanceof DataView) {
+    else if (isDataView(obj)) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
@@ -2040,4 +2522,4 @@ function throttle(fn, delay, options) {
     return _throttle(fn, delay, Object.assign({ trailing: false, leading: true }, options));
 }
 
-export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, clamp, compose, _curryMore as curry, debounce, dedent, deepClone, deepMerge, defer, fastClone, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isPlaceholder, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };
+export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, castArray, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getInitP, getTag, indent, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isEven, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isOdd, isPlaceholder, isPlainObject, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, lerp, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomDistribution, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, romanNumerals, round, roundBank, roundBase, roundCeil, roundFloor, scientificNotation, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };