basant307/AI_Governance_Project

1const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;2const binRegex = /^0b[01]+$/;3const octRegex = /^0o[0-7]+$/;4const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;5 6import anynum from "anynum";7 8const consider = {9    hex: true,10    binary: false,11    octal: false,12    leadingZeros: true,13    decimalPoint: "\.",14    eNotation: true,15    //skipLike: /regex/,16    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))17    unicode: false,18};19 20export default function toNumber(str, options = {}) {21    options = Object.assign({}, consider, options);22    if (!str || typeof str !== "string") return str;23 24    let trimmedStr = str.trim();25 26    if (trimmedStr.length === 0) return str;27    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;28    else if (trimmedStr === "0") return 0;29 30    if (options.unicode) {31        trimmedStr = anynum(trimmedStr);32        if (trimmedStr === "0") return 0; // re-check after normalization33    }34    if (options.hex && hexRegex.test(trimmedStr)) {35        return parse_int(trimmedStr, 16);36    } else if (options.binary && binRegex.test(trimmedStr)) {37        return parse_int(trimmedStr, 2);38    } else if (options.octal && octRegex.test(trimmedStr)) {39        return parse_int(trimmedStr, 8);40    } else if (!isFinite(trimmedStr)) { //Infinity41        return handleInfinity(str, Number(trimmedStr), options);42    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation43        return resolveEnotation(str, trimmedStr, options);44    } else {45        //separate negative sign, leading zeros, and rest number46        const match = numRegex.exec(trimmedStr);47        // +00.123 => [ , '+', '00', '.123', ..48        if (match) {49            const sign = match[1] || "";50            const leadingZeros = match[2];51            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros52            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.53                str[leadingZeros.length + 1] === "."54                : str[leadingZeros.length] === ".";55 56            //trim ending zeros for floating number57            if (!options.leadingZeros //leading zeros are not allowed58                && (leadingZeros.length > 159                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))) {60                // 00, 00.3, +03.24, 03, 03.2461                return str;62            }63            else {//no leading zeros or leading zeros are allowed64                const num = Number(trimmedStr);65                const parsedStr = String(num);66 67                if (num === 0) return num;68                if (parsedStr.search(/[eE]/) !== -1) { //given number is long and parsed to eNotation69                    if (options.eNotation) return num;70                    else return str;71                } else if (trimmedStr.indexOf(".") !== -1) { //floating number72                    if (parsedStr === "0") return num; //0.073                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.7900074                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;75                    else return str;76                }77 78                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;79                if (leadingZeros) {80                    // -009 => -981                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str82                } else {83                    // +984                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str85                }86            }87        } else { //non-numeric string88            return str;89        }90    }91}92 93const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;94function resolveEnotation(str, trimmedStr, options) {95    if (!options.eNotation) return str;96    const notation = trimmedStr.match(eNotationRegx);97    if (notation) {98        let sign = notation[1] || "";99        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";100        const leadingZeros = notation[2];101        const eAdjacentToLeadingZeros = sign ? // 0E.102            str[leadingZeros.length + 1] === eChar103            : str[leadingZeros.length] === eChar;104 105        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;106        else if (leadingZeros.length === 1107            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {108            return Number(trimmedStr);109        } else if (leadingZeros.length > 0) {110            // Has leading zeros — only accept if leadingZeros option allows it111            if (options.leadingZeros && !eAdjacentToLeadingZeros) {112                trimmedStr = (notation[1] || "") + notation[3];113                return Number(trimmedStr);114            } else return str;115        } else {116            // No leading zeros — always valid e-notation, parse it117            return Number(trimmedStr);118        }119    } else {120        return str;121    }122}123 124/**125 * 126 * @param {string} numStr without leading zeros127 * @returns 128 */129function trimZeros(numStr) {130    if (numStr && numStr.indexOf(".") !== -1) {//float131        numStr = numStr.replace(/0+$/, ""); //remove ending zeros132        if (numStr === ".") numStr = "0";133        else if (numStr[0] === ".") numStr = "0" + numStr;134        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);135        return numStr;136    }137    return numStr;138}139 140function parse_int(numStr, base) {141    const str = numStr.trim();142    if (base === 2 || base === 8) numStr = str.substring(2);143 144    if (parseInt) return parseInt(numStr, base);145    else if (Number.parseInt) return Number.parseInt(numStr, base);146    else if (window && window.parseInt) return window.parseInt(numStr, base);147    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");148}149 150/**151 * Handle infinite values based on user option152 * @param {string} str - original input string153 * @param {number} num - parsed number (Infinity or -Infinity)154 * @param {object} options - user options155 * @returns {string|number|null} based on infinity option156 */157function handleInfinity(str, num, options) {158    const isPositive = num === Infinity;159 160    switch (options.infinity.toLowerCase()) {161        case "null":162            return null;163        case "infinity":164            return num; // Return Infinity or -Infinity165        case "string":166            return isPositive ? "Infinity" : "-Infinity";167        case "original":168        default:169            return str; // Return original string like "1e1000"170    }171}