{"ast":null,"code":"import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport { supportBigInt } from \"./supportUtil\";\nexport function isEmpty(value) {\n  return !value && value !== 0 && !Number.isNaN(value) || !String(value).trim();\n}\n\n/**\n * Format string number to readable number\n */\nexport function trimNumber(numStr) {\n  var str = numStr.trim();\n  var negative = str.startsWith('-');\n  if (negative) {\n    str = str.slice(1);\n  }\n  str = str\n  // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`\n  .replace(/(\\.\\d*[^0])0*$/, '$1')\n  // Remove useless decimal. `1.` => `1`\n  .replace(/\\.0*$/, '')\n  // Remove integer 0. `0001` => `1`, 000.1' => `.1`\n  .replace(/^0+/, '');\n  if (str.startsWith('.')) {\n    str = \"0\".concat(str);\n  }\n  var trimStr = str || '0';\n  var splitNumber = trimStr.split('.');\n  var integerStr = splitNumber[0] || '0';\n  var decimalStr = splitNumber[1] || '0';\n  if (integerStr === '0' && decimalStr === '0') {\n    negative = false;\n  }\n  var negativeStr = negative ? '-' : '';\n  return {\n    negative: negative,\n    negativeStr: negativeStr,\n    trimStr: trimStr,\n    integerStr: integerStr,\n    decimalStr: decimalStr,\n    fullStr: \"\".concat(negativeStr).concat(trimStr)\n  };\n}\nexport function isE(number) {\n  var str = String(number);\n  return !Number.isNaN(Number(str)) && str.includes('e');\n}\n/**\n * Parse a scientific-notation string into reusable parts.\n *\n * The idea is to split the value into mantissa and exponent first, then\n * normalize the mantissa into sign, integer/decimal segments, and a compact\n * digit sequence so later logic can move the decimal point without re-parsing.\n */\nfunction parseScientificNotation(numStr) {\n  var _numStr$toLowerCase$s = numStr.toLowerCase().split('e'),\n    _numStr$toLowerCase$s2 = _slicedToArray(_numStr$toLowerCase$s, 2),\n    mantissa = _numStr$toLowerCase$s2[0],\n    _numStr$toLowerCase$s3 = _numStr$toLowerCase$s2[1],\n    exponent = _numStr$toLowerCase$s3 === void 0 ? '0' : _numStr$toLowerCase$s3;\n  var negative = mantissa.startsWith('-');\n  var unsignedMantissa = negative ? mantissa.slice(1) : mantissa;\n  var _unsignedMantissa$spl = unsignedMantissa.split('.'),\n    _unsignedMantissa$spl2 = _slicedToArray(_unsignedMantissa$spl, 2),\n    _unsignedMantissa$spl3 = _unsignedMantissa$spl2[0],\n    integer = _unsignedMantissa$spl3 === void 0 ? '0' : _unsignedMantissa$spl3,\n    _unsignedMantissa$spl4 = _unsignedMantissa$spl2[1],\n    decimal = _unsignedMantissa$spl4 === void 0 ? '' : _unsignedMantissa$spl4;\n  var digits = \"\".concat(integer).concat(decimal).replace(/^0+/, '') || '0';\n  return {\n    decimal: decimal,\n    digits: digits,\n    exponent: Number(exponent),\n    integer: integer,\n    negative: negative\n  };\n}\n\n/**\n * Expand parsed scientific notation into a plain decimal string.\n *\n * The core idea is to calculate where the decimal point lands after applying\n * the exponent, then rebuild the string by either padding zeros or inserting\n * the decimal point inside the normalized digit sequence.\n */\nfunction expandScientificNotation(parsed) {\n  var decimal = parsed.decimal,\n    digits = parsed.digits,\n    exponent = parsed.exponent,\n    integer = parsed.integer,\n    negative = parsed.negative;\n  if (digits === '0') {\n    return '0';\n  }\n  var integerDigits = integer.replace(/^0+/, '').length;\n  var leadingDecimalZeros = (decimal.match(/^0*/) || [''])[0].length;\n  var initialDecimalIndex = integerDigits || -leadingDecimalZeros;\n  var decimalIndex = initialDecimalIndex + exponent;\n  var expanded = '';\n  if (decimalIndex <= 0) {\n    expanded = \"0.\".concat('0'.repeat(-decimalIndex)).concat(digits);\n  } else if (decimalIndex >= digits.length) {\n    expanded = \"\".concat(digits).concat('0'.repeat(decimalIndex - digits.length));\n  } else {\n    expanded = \"\".concat(digits.slice(0, decimalIndex), \".\").concat(digits.slice(decimalIndex));\n  }\n  return \"\".concat(negative ? '-' : '').concat(expanded);\n}\nfunction getScientificPrecision(parsed) {\n  if (parsed.exponent >= 0) {\n    return Math.max(0, parsed.decimal.length - parsed.exponent);\n  }\n  return Math.abs(parsed.exponent) + parsed.decimal.length;\n}\n\n/**\n * [Legacy] Convert 1e-9 to 0.000000001.\n * This may lose some precision if user really want 1e-9.\n */\nexport function getNumberPrecision(number) {\n  var numStr = String(number);\n  if (isE(number)) {\n    return getScientificPrecision(parseScientificNotation(numStr));\n  }\n  return numStr.includes('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;\n}\n\n/**\n * Convert number (includes scientific notation) to -xxx.yyy format\n */\nexport function num2str(number) {\n  var numStr = String(number);\n  if (isE(number)) {\n    if (number > Number.MAX_SAFE_INTEGER) {\n      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);\n    }\n    if (number < Number.MIN_SAFE_INTEGER) {\n      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);\n    }\n    var parsed = parseScientificNotation(numStr);\n    var precision = getScientificPrecision(parsed);\n    numStr = precision > 100 ? expandScientificNotation(parsed) : number.toFixed(precision);\n  }\n  return trimNumber(numStr).fullStr;\n}\nexport function validateNumber(num) {\n  if (typeof num === 'number') {\n    return !Number.isNaN(num);\n  }\n\n  // Empty\n  if (!num) {\n    return false;\n  }\n  return (\n    // Normal type: 11.28\n    /^\\s*-?\\d+(\\.\\d+)?\\s*$/.test(num) ||\n    // Pre-number: 1.\n    /^\\s*-?\\d+\\.\\s*$/.test(num) ||\n    // Post-number: .1\n    /^\\s*-?\\.\\d+\\s*$/.test(num)\n  );\n}","map":{"version":3,"names":["_slicedToArray","supportBigInt","isEmpty","value","Number","isNaN","String","trim","trimNumber","numStr","str","negative","startsWith","slice","replace","concat","trimStr","splitNumber","split","integerStr","decimalStr","negativeStr","fullStr","isE","number","includes","parseScientificNotation","_numStr$toLowerCase$s","toLowerCase","_numStr$toLowerCase$s2","mantissa","_numStr$toLowerCase$s3","exponent","unsignedMantissa","_unsignedMantissa$spl","_unsignedMantissa$spl2","_unsignedMantissa$spl3","integer","_unsignedMantissa$spl4","decimal","digits","expandScientificNotation","parsed","integerDigits","length","leadingDecimalZeros","match","initialDecimalIndex","decimalIndex","expanded","repeat","getScientificPrecision","Math","max","abs","getNumberPrecision","validateNumber","indexOf","num2str","MAX_SAFE_INTEGER","BigInt","toString","MIN_SAFE_INTEGER","precision","toFixed","num","test"],"sources":["/Users/nili/Documents/trae_projects/client/node_modules/@rc-component/mini-decimal/es/numberUtil.js"],"sourcesContent":["import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport { supportBigInt } from \"./supportUtil\";\nexport function isEmpty(value) {\n  return !value && value !== 0 && !Number.isNaN(value) || !String(value).trim();\n}\n\n/**\n * Format string number to readable number\n */\nexport function trimNumber(numStr) {\n  var str = numStr.trim();\n  var negative = str.startsWith('-');\n  if (negative) {\n    str = str.slice(1);\n  }\n  str = str\n  // Remove decimal 0. `1.000` => `1.`, `1.100` => `1.1`\n  .replace(/(\\.\\d*[^0])0*$/, '$1')\n  // Remove useless decimal. `1.` => `1`\n  .replace(/\\.0*$/, '')\n  // Remove integer 0. `0001` => `1`, 000.1' => `.1`\n  .replace(/^0+/, '');\n  if (str.startsWith('.')) {\n    str = \"0\".concat(str);\n  }\n  var trimStr = str || '0';\n  var splitNumber = trimStr.split('.');\n  var integerStr = splitNumber[0] || '0';\n  var decimalStr = splitNumber[1] || '0';\n  if (integerStr === '0' && decimalStr === '0') {\n    negative = false;\n  }\n  var negativeStr = negative ? '-' : '';\n  return {\n    negative: negative,\n    negativeStr: negativeStr,\n    trimStr: trimStr,\n    integerStr: integerStr,\n    decimalStr: decimalStr,\n    fullStr: \"\".concat(negativeStr).concat(trimStr)\n  };\n}\nexport function isE(number) {\n  var str = String(number);\n  return !Number.isNaN(Number(str)) && str.includes('e');\n}\n/**\n * Parse a scientific-notation string into reusable parts.\n *\n * The idea is to split the value into mantissa and exponent first, then\n * normalize the mantissa into sign, integer/decimal segments, and a compact\n * digit sequence so later logic can move the decimal point without re-parsing.\n */\nfunction parseScientificNotation(numStr) {\n  var _numStr$toLowerCase$s = numStr.toLowerCase().split('e'),\n    _numStr$toLowerCase$s2 = _slicedToArray(_numStr$toLowerCase$s, 2),\n    mantissa = _numStr$toLowerCase$s2[0],\n    _numStr$toLowerCase$s3 = _numStr$toLowerCase$s2[1],\n    exponent = _numStr$toLowerCase$s3 === void 0 ? '0' : _numStr$toLowerCase$s3;\n  var negative = mantissa.startsWith('-');\n  var unsignedMantissa = negative ? mantissa.slice(1) : mantissa;\n  var _unsignedMantissa$spl = unsignedMantissa.split('.'),\n    _unsignedMantissa$spl2 = _slicedToArray(_unsignedMantissa$spl, 2),\n    _unsignedMantissa$spl3 = _unsignedMantissa$spl2[0],\n    integer = _unsignedMantissa$spl3 === void 0 ? '0' : _unsignedMantissa$spl3,\n    _unsignedMantissa$spl4 = _unsignedMantissa$spl2[1],\n    decimal = _unsignedMantissa$spl4 === void 0 ? '' : _unsignedMantissa$spl4;\n  var digits = \"\".concat(integer).concat(decimal).replace(/^0+/, '') || '0';\n  return {\n    decimal: decimal,\n    digits: digits,\n    exponent: Number(exponent),\n    integer: integer,\n    negative: negative\n  };\n}\n\n/**\n * Expand parsed scientific notation into a plain decimal string.\n *\n * The core idea is to calculate where the decimal point lands after applying\n * the exponent, then rebuild the string by either padding zeros or inserting\n * the decimal point inside the normalized digit sequence.\n */\nfunction expandScientificNotation(parsed) {\n  var decimal = parsed.decimal,\n    digits = parsed.digits,\n    exponent = parsed.exponent,\n    integer = parsed.integer,\n    negative = parsed.negative;\n  if (digits === '0') {\n    return '0';\n  }\n  var integerDigits = integer.replace(/^0+/, '').length;\n  var leadingDecimalZeros = (decimal.match(/^0*/) || [''])[0].length;\n  var initialDecimalIndex = integerDigits || -leadingDecimalZeros;\n  var decimalIndex = initialDecimalIndex + exponent;\n  var expanded = '';\n  if (decimalIndex <= 0) {\n    expanded = \"0.\".concat('0'.repeat(-decimalIndex)).concat(digits);\n  } else if (decimalIndex >= digits.length) {\n    expanded = \"\".concat(digits).concat('0'.repeat(decimalIndex - digits.length));\n  } else {\n    expanded = \"\".concat(digits.slice(0, decimalIndex), \".\").concat(digits.slice(decimalIndex));\n  }\n  return \"\".concat(negative ? '-' : '').concat(expanded);\n}\nfunction getScientificPrecision(parsed) {\n  if (parsed.exponent >= 0) {\n    return Math.max(0, parsed.decimal.length - parsed.exponent);\n  }\n  return Math.abs(parsed.exponent) + parsed.decimal.length;\n}\n\n/**\n * [Legacy] Convert 1e-9 to 0.000000001.\n * This may lose some precision if user really want 1e-9.\n */\nexport function getNumberPrecision(number) {\n  var numStr = String(number);\n  if (isE(number)) {\n    return getScientificPrecision(parseScientificNotation(numStr));\n  }\n  return numStr.includes('.') && validateNumber(numStr) ? numStr.length - numStr.indexOf('.') - 1 : 0;\n}\n\n/**\n * Convert number (includes scientific notation) to -xxx.yyy format\n */\nexport function num2str(number) {\n  var numStr = String(number);\n  if (isE(number)) {\n    if (number > Number.MAX_SAFE_INTEGER) {\n      return String(supportBigInt() ? BigInt(number).toString() : Number.MAX_SAFE_INTEGER);\n    }\n    if (number < Number.MIN_SAFE_INTEGER) {\n      return String(supportBigInt() ? BigInt(number).toString() : Number.MIN_SAFE_INTEGER);\n    }\n    var parsed = parseScientificNotation(numStr);\n    var precision = getScientificPrecision(parsed);\n    numStr = precision > 100 ? expandScientificNotation(parsed) : number.toFixed(precision);\n  }\n  return trimNumber(numStr).fullStr;\n}\nexport function validateNumber(num) {\n  if (typeof num === 'number') {\n    return !Number.isNaN(num);\n  }\n\n  // Empty\n  if (!num) {\n    return false;\n  }\n  return (\n    // Normal type: 11.28\n    /^\\s*-?\\d+(\\.\\d+)?\\s*$/.test(num) ||\n    // Pre-number: 1.\n    /^\\s*-?\\d+\\.\\s*$/.test(num) ||\n    // Post-number: .1\n    /^\\s*-?\\.\\d+\\s*$/.test(num)\n  );\n}"],"mappings":"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","ignoreList":[]},"metadata":{},"sourceType":"module","externalDependencies":[]}