@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/common/decimal.js

@@ -1,19 +1,19 @@
-import { getMiniDecimal, toFixed as roundFixed } from './bigInt';
-export { roundFixed };
-var DECIMAL_SEPARATOR = '.';
-var asInteger = function asInteger(number) {
-  var tokens = number.split(DECIMAL_SEPARATOR);
-  var integer = tokens[0];
-  var fractional = tokens[1];
-  var value;
-  var exp;
+import "../chunk-PKUHTIDK.js";
+import { getMiniDecimal, toFixed as roundFixed } from "./bigInt";
+const DECIMAL_SEPARATOR = ".";
+const asInteger = (number) => {
+  const tokens = number.split(DECIMAL_SEPARATOR);
+  const integer = tokens[0];
+  const fractional = tokens[1];
+  let value;
+  let exp;
   if (fractional) {
-    value = parseInt(number.split(DECIMAL_SEPARATOR).join(''), 10);
+    value = parseInt(number.split(DECIMAL_SEPARATOR).join(""), 10);
     exp = fractional.length * -1;
   } else {
-    var trailingZeros = integer.match(/0+$/);
+    const trailingZeros = integer.match(/0+$/);
     if (trailingZeros) {
-      var length = trailingZeros[0].length;
+      const length = trailingZeros[0].length;
       value = integer.substr(0, integer.length - length);
       exp = length;
     } else {
@@ -21,50 +21,42 @@ var asInteger = function asInteger(number) {
       exp = 0;
     }
   }
-  return {
-    value: value,
-    exp: exp
-  };
+  return { value, exp };
 };
-var zero = function zero(exp) {
-  var result;
+const zero = (exp) => {
+  let result;
   if (exp <= 0) {
-    result = '';
+    result = "";
   } else if (String.prototype.repeat) {
-    result = '0'.repeat(exp);
+    result = "0".repeat(exp);
   } else {
-    result = function (times) {
-      var zeros = [];
-      for (var i = 0; i < times; i++) {
+    result = ((times) => {
+      const zeros = [];
+      for (let i = 0; i < times; i++) {
         zeros.push(0);
       }
-      return zeros.join('');
-    }(exp);
+      return zeros.join("");
+    })(exp);
   }
   return result;
 };
-var negExp = function negExp(str, position) {
+const negExp = (str, position) => {
   position = Math.abs(position);
-  var offset = position - str.length;
-  var sep = DECIMAL_SEPARATOR;
+  const offset = position - str.length;
+  let sep = DECIMAL_SEPARATOR;
   if (offset >= 0) {
     str = zero(offset) + str;
-    sep = '0.';
+    sep = "0.";
   }
-  var length = str.length;
-  var dif = length - position;
-  var head = str.substr(0, dif);
-  var tail = str.substring(dif, length);
+  const length = str.length;
+  const dif = length - position;
+  const head = str.substr(0, dif);
+  const tail = str.substring(dif, length);
   return head + sep + tail;
 };
-var posExp = function posExp(str, exp) {
-  return String(str + zero(exp));
-};
-var format = function format(num, exp) {
-  return (exp >= 0 ? posExp : negExp)(String(num), exp);
-};
-export function Decimal(num) {
-  var _this = this;
+const posExp = (str, exp) => String(str + zero(exp));
+const format = (num, exp) => (exp >= 0 ? posExp : negExp)(String(num), exp);
+function Decimal(num) {
   if (!this || this.constructor !== Decimal) {
     return new Decimal(num);
   }
@@ -73,131 +65,91 @@ export function Decimal(num) {
   }
   this.internal = String(num);
   this.asInt = asInteger(this.internal);
-  this.add = function (target) {
-    var operands = [_this, new Decimal(target)];
-    operands.sort(function (x, y) {
-      return x.asInt.exp - y.asInt.exp;
-    });
-    var smallest = operands[0].asInt.exp;
-    var biggest = operands[1].asInt.exp;
-    var x = Number(format(operands[1].asInt.value, biggest - smallest));
-    var y = Number(operands[0].asInt.value);
+  this.add = (target) => {
+    const operands = [this, new Decimal(target)];
+    operands.sort((x2, y2) => x2.asInt.exp - y2.asInt.exp);
+    const smallest = operands[0].asInt.exp;
+    const biggest = operands[1].asInt.exp;
+    const x = Number(format(operands[1].asInt.value, biggest - smallest));
+    const y = Number(operands[0].asInt.value);
     return new Decimal(format(String(x + y), smallest));
   };
-  this.sub = function (target) {
-    return new Decimal(_this.add(target * -1));
-  };
-  this.mul = function (target) {
+  this.sub = (target) => new Decimal(this.add(target * -1));
+  this.mul = (target) => {
     target = new Decimal(target);
-    var result = String(_this.asInt.value * target.asInt.value);
-    var exp = _this.asInt.exp + target.asInt.exp;
+    const result = String(this.asInt.value * target.asInt.value);
+    const exp = this.asInt.exp + target.asInt.exp;
     return new Decimal(format(result, exp));
   };
-  this.div = function (target) {
+  this.div = (target) => {
     target = new Decimal(target);
-    var smallest = Math.min(_this.asInt.exp, target.asInt.exp);
-    var absSmallest = Math.pow(10, Math.abs(smallest));
-    var x = Decimal.mul(absSmallest, _this);
-    var y = Decimal.mul(absSmallest, target);
+    const smallest = Math.min(this.asInt.exp, target.asInt.exp);
+    const absSmallest = 10 ** Math.abs(smallest);
+    const x = Decimal.mul(absSmallest, this);
+    const y = Decimal.mul(absSmallest, target);
     return new Decimal(x / y);
   };
-  this.toString = function () {
-    return _this.internal;
-  };
-  this.toNumber = function () {
-    return Number(_this.internal);
-  };
+  this.toString = () => this.internal;
+  this.toNumber = () => Number(this.internal);
 }
-Decimal.add = function (a, b) {
-  return new Decimal(a).add(b);
-};
-Decimal.mul = function (a, b) {
-  return new Decimal(a).mul(b);
-};
-Decimal.sub = function (a, b) {
-  return new Decimal(a).sub(b);
-};
-Decimal.div = function (a, b) {
-  return new Decimal(a).div(b);
-};
-export var toFixed = function toFixed(num) {
-  var fraction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var sign = num < 0 ? '-' : '';
+Decimal.add = (a, b) => new Decimal(a).add(b);
+Decimal.mul = (a, b) => new Decimal(a).mul(b);
+Decimal.sub = (a, b) => new Decimal(a).sub(b);
+Decimal.div = (a, b) => new Decimal(a).div(b);
+const toFixed = (num, fraction = 0) => {
+  const sign = num < 0 ? "-" : "";
   num = Math.abs(num);
-  var npmPow = num.toString().length < Math.pow(2, 53).toString().length - 1 ? Math.pow(10, fraction) : Math.pow(10, fraction - 1);
-  var result = new Decimal(Math.round(new Decimal(num).mul(npmPow))).div(npmPow).toString();
-  var numResult = Number(result);
+  const npmPow = num.toString().length < (2 ** 53).toString().length - 1 ? 10 ** fraction : 10 ** (fraction - 1);
+  const result = new Decimal(Math.round(new Decimal(num).mul(npmPow))).div(npmPow).toString();
+  const numResult = Number(result);
   return numResult ? sign + numResult.toFixed(fraction) : numResult.toFixed(fraction);
 };
-var formatInteger = function formatInteger(value, _ref) {
-  var _ref$secondaryGroupSi = _ref.secondaryGroupSize,
-    secondaryGroupSize = _ref$secondaryGroupSi === void 0 ? 3 : _ref$secondaryGroupSi,
-    _ref$groupSize = _ref.groupSize,
-    groupSize = _ref$groupSize === void 0 ? 0 : _ref$groupSize,
-    _ref$groupSeparator = _ref.groupSeparator,
-    groupSeparator = _ref$groupSeparator === void 0 ? ',' : _ref$groupSeparator;
-  var negative = /^-\d+/.test(value);
-  var result = negative ? value.slice(1) : value;
-  var secSize = secondaryGroupSize || groupSize;
+const formatInteger = (value, { secondaryGroupSize = 3, groupSize = 0, groupSeparator = "," }) => {
+  const negative = /^-\d+/.test(value);
+  let result = negative ? value.slice(1) : value;
+  const secSize = secondaryGroupSize || groupSize;
   if (groupSize && result.length > groupSize) {
-    var left = result.slice(0, 0 - groupSize);
-    var right = result.slice(0 - groupSize);
-    left = left.replace(new RegExp("\\B(?=(\\d{".concat(secSize, "})+(?!\\d))"), 'g'), groupSeparator);
-    result = "".concat(left).concat(groupSeparator).concat(right);
+    let left = result.slice(0, 0 - groupSize);
+    const right = result.slice(0 - groupSize);
+    left = left.replace(new RegExp(`\\B(?=(\\d{${secSize}})+(?!\\d))`, "g"), groupSeparator);
+    result = `${left}${groupSeparator}${right}`;
   }
-  return "".concat(negative ? '-' : '').concat(result);
+  return `${negative ? "-" : ""}${result}`;
 };
-var reverseString = function reverseString(str) {
-  var arr = [];
-  for (var i = 0; i < str.length; i++) {
+const reverseString = (str) => {
+  const arr = [];
+  for (let i = 0; i < str.length; i++) {
     arr.push(str[i]);
   }
-  return arr.reverse().join('');
+  return arr.reverse().join("");
 };
-var formatDecimal = function formatDecimal(num, _ref2) {
-  var _ref2$fractionGroupSi = _ref2.fractionGroupSize,
-    fractionGroupSize = _ref2$fractionGroupSi === void 0 ? 0 : _ref2$fractionGroupSi,
-    _ref2$fractionGroupSe = _ref2.fractionGroupSeparator,
-    fractionGroupSeparator = _ref2$fractionGroupSe === void 0 ? '\xA0' : _ref2$fractionGroupSe;
-  var RE = new RegExp("\\B(?=(\\d{".concat(fractionGroupSize, "})+(?!\\d))"), 'g');
+const formatDecimal = (num, { fractionGroupSize = 0, fractionGroupSeparator = "\xA0" }) => {
+  const RE = new RegExp(`\\B(?=(\\d{${fractionGroupSize}})+(?!\\d))`, "g");
   return reverseString(reverseString(num).replace(RE, fractionGroupSeparator));
 };
-export var formatNumber = function formatNumber(value) {
-  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var fraction = format.fraction,
-    rounding = format.rounding,
-    _format$prefix = format.prefix,
-    prefix = _format$prefix === void 0 ? '' : _format$prefix,
-    _format$decimalSepara = format.decimalSeparator,
-    decimalSeparator = _format$decimalSepara === void 0 ? '.' : _format$decimalSepara,
-    _format$suffix = format.suffix,
-    suffix = _format$suffix === void 0 ? '' : _format$suffix;
-  var reslut = getMiniDecimal(value);
+const formatNumber = (value, format2 = {}) => {
+  const { fraction, rounding, prefix = "", decimalSeparator = ".", suffix = "" } = format2;
+  let reslut = getMiniDecimal(value);
   if (reslut.isNaN() || !reslut.toString()) {
     return value;
   }
   reslut = roundFixed(reslut.toString(), fraction, rounding);
-  format.zeroize === false && reslut.match(/\./) && (reslut = reslut.replace(/\.?0+$/g, ''));
-  var number = reslut.toString().split('.').slice(0, 2).map(function (str, index) {
-    return index ? formatDecimal(str, format) : formatInteger(str, format);
-  }).join(decimalSeparator);
-  return "".concat(prefix).concat(number).concat(suffix);
+  format2.zeroize === false && reslut.match(/\./) && (reslut = reslut.replace(/\.?0+$/g, ""));
+  const number = reslut.toString().split(".").slice(0, 2).map((str, index) => index ? formatDecimal(str, format2) : formatInteger(str, format2)).join(decimalSeparator);
+  return `${prefix}${number}${suffix}`;
 };
-export var recoverNumber = function recoverNumber(number) {
-  var format = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var _format$prefix2 = format.prefix,
-    prefix = _format$prefix2 === void 0 ? '' : _format$prefix2,
-    _format$suffix2 = format.suffix,
-    suffix = _format$suffix2 === void 0 ? '' : _format$suffix2,
-    _format$decimalSepara2 = format.decimalSeparator,
-    decimalSeparator = _format$decimalSepara2 === void 0 ? '.' : _format$decimalSepara2;
-  var result = number;
-  if (typeof number === 'string') {
-    result = number.replace(new RegExp("^".concat(prefix, "(.+)").concat(suffix, "$")), function ($1, $2) {
-      return $2;
-    }).split(decimalSeparator).map(function (s) {
-      return s.replace(/[^\d]/g, '');
-    }).join('.');
+const recoverNumber = (number, format2 = {}) => {
+  const { prefix = "", suffix = "", decimalSeparator = "." } = format2;
+  let result = number;
+  if (typeof number === "string") {
+    result = number.replace(new RegExp(`^${prefix}(.+)${suffix}$`), ($1, $2) => $2).split(decimalSeparator).map((s) => s.replace(/[^\d]/g, "")).join(".");
   }
   return Number(result);
-};
+};
+export {
+  Decimal,
+  formatNumber,
+  recoverNumber,
+  roundFixed,
+  toFixed
+};