foreslash 0.3.2 → 0.3.4

package/lib/index.mjs

@@ -43,6 +43,10 @@ function cartesianProduct(...arrList) {
     return res;
 }
 
+function castArray(value) {
+    return Array.isArray(value) ? value.slice() : [value];
+}
+
 function chunk(array, size = 2) {
     const res = [];
     if (size < 1 || isNaN(size))
@@ -607,6 +611,201 @@ function format(num, options) {
         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, 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)
@@ -1238,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';
@@ -1864,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);
     }
@@ -2240,6 +2487,27 @@ function not(value) {
     return !Boolean(value);
 }
 
+function omit(obj, keys) {
+    const res = (Object.getPrototypeOf(obj) ? {} : Object.create(null));
+    const ownKeys = Reflect.ownKeys(obj);
+    if (isFunction(keys)) {
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (!keys(obj[key], key, obj))
+                res[key] = obj[key];
+        }
+    }
+    else {
+        const keysSet = new Set((isArray(keys) ? keys : [keys]).map((k) => (isNumber(k) ? String(k) : k)));
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (!keysSet.has(key))
+                res[key] = obj[key];
+        }
+    }
+    return res;
+}
+
 function pass(value) {
     return value;
 }
@@ -2250,6 +2518,31 @@ function passWith(fn) {
     });
 }
 
+function pick(obj, keys) {
+    const res = (Object.getPrototypeOf(obj) ? {} : Object.create(null));
+    const ownKeys = Reflect.ownKeys(obj);
+    if (isFunction(keys)) {
+        for (let i = 0; i < ownKeys.length; i++) {
+            const key = ownKeys[i];
+            if (keys(obj[key], key, obj))
+                res[key] = obj[key];
+        }
+    }
+    else if (isArray(keys)) {
+        const keysSet = new Set(ownKeys);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (keysSet.has(isNumber(key) ? String(key) : key))
+                res[key] = obj[key];
+        }
+    }
+    else if (isString(keys) || isNumber(keys) || isSymbol(keys)) {
+        if (ownKeys.includes(isNumber(keys) ? String(keys) : keys))
+            res[keys] = obj[keys];
+    }
+    return res;
+}
+
 function pipe(...pipeFunc) {
     if (pipeFunc.length === 0) {
         throw new Error('Invalid pipeFunc parameter: pipeFunc is empty');
@@ -2275,4 +2568,4 @@ function throttle(fn, delay, options) {
     return _throttle(fn, delay, Object.assign({ trailing: false, leading: true }, options));
 }
 
-export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, cartesianProduct, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, chunk, clamp, compose, _curryMore as curry, debounce, decimalNotation, dedent, deepClone, deepMerge, defer, fastClone, format, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, 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, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, round, roundBank, roundBase, roundCeil, roundFloor, 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, omit, parallel, pascalCase, pass, passWith, pick, 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 };