@gct-paas/excel 0.1.31 → 0.1.33-beta.0

package/dist/{dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-CeMxIrHD.js → dynamic-table-action.vue_vue_type_style_index_0_scoped_53d7e66c_lang-b00q9wdA.js}

@@ -8267,7 +8267,7 @@ function requireEstraverse() {
   if (hasRequiredEstraverse) return estraverse$1;
   hasRequiredEstraverse = 1;
   (function(exports2) {
-    (function clone(exports3) {
+    (function clone2(exports3) {
       var Syntax2, VisitorOption, VisitorKeys, BREAK, SKIP, REMOVE;
       function deepCopy(obj) {
         var ret = {}, key, val;
@@ -8872,7 +8872,7 @@ function requireEstraverse() {
       exports3.VisitorOption = VisitorOption;
       exports3.Controller = Controller;
       exports3.cloneEnvironment = function() {
-        return clone({});
+        return clone2({});
       };
       return exports3;
     })(exports2);
@@ -8969,7 +8969,7 @@ function requireBigInteger() {
   hasRequiredBigInteger = 1;
   (function(module2) {
     var bigInt = (function(undefined$1) {
-      var BASE = 1e7, LOG_BASE = 7, MAX_INT = 9007199254740992, MAX_INT_ARR = smallToArray(MAX_INT), DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+      var BASE2 = 1e7, LOG_BASE2 = 7, MAX_INT = 9007199254740992, MAX_INT_ARR = smallToArray(MAX_INT), DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
       var supportsNativeBigInt = typeof BigInt === "function";
       function Integer(v, radix, alphabet, caseSensitive) {
         if (typeof v === "undefined") return Integer[0];
@@ -9012,9 +9012,9 @@ function requireBigInteger() {
             case 1:
               return arr[0];
             case 2:
-              return arr[0] + arr[1] * BASE;
+              return arr[0] + arr[1] * BASE2;
             default:
-              return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
+              return arr[0] + (arr[1] + arr[2] * BASE2) * BASE2;
           }
         }
         return arr;
@@ -9037,7 +9037,7 @@ function requireBigInteger() {
         return Math.ceil(n);
       }
       function add(a, b) {
-        var l_a = a.length, l_b = b.length, r = new Array(l_a), carry = 0, base = BASE, sum, i3;
+        var l_a = a.length, l_b = b.length, r = new Array(l_a), carry = 0, base = BASE2, sum, i3;
         for (i3 = 0; i3 < l_b; i3++) {
           sum = a[i3] + b[i3] + carry;
           carry = sum >= base ? 1 : 0;
@@ -9056,7 +9056,7 @@ function requireBigInteger() {
         return add(b, a);
       }
       function addSmall(a, carry) {
-        var l = a.length, r = new Array(l), base = BASE, sum, i3;
+        var l = a.length, r = new Array(l), base = BASE2, sum, i3;
         for (i3 = 0; i3 < l; i3++) {
           sum = a[i3] - base + carry;
           carry = Math.floor(sum / base);
@@ -9100,7 +9100,7 @@ function requireBigInteger() {
       };
       NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
       function subtract(a, b) {
-        var a_l = a.length, b_l = b.length, r = new Array(a_l), borrow = 0, base = BASE, i3, difference;
+        var a_l = a.length, b_l = b.length, r = new Array(a_l), borrow = 0, base = BASE2, i3, difference;
         for (i3 = 0; i3 < b_l; i3++) {
           difference = a[i3] - borrow - b[i3];
           if (difference < 0) {
@@ -9140,7 +9140,7 @@ function requireBigInteger() {
         return new BigInteger2(value, sign);
       }
       function subtractSmall(a, b, sign) {
-        var l = a.length, r = new Array(l), carry = -b, base = BASE, i3, difference;
+        var l = a.length, r = new Array(l), carry = -b, base = BASE2, i3, difference;
         for (i3 = 0; i3 < l; i3++) {
           difference = a[i3] + carry;
           carry = Math.floor(difference / base);
@@ -9204,7 +9204,7 @@ function requireBigInteger() {
         return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
       };
       function multiplyLong(a, b) {
-        var a_l = a.length, b_l = b.length, l = a_l + b_l, r = createArray(l), base = BASE, product, carry, i3, a_i, b_j;
+        var a_l = a.length, b_l = b.length, l = a_l + b_l, r = createArray(l), base = BASE2, product, carry, i3, a_i, b_j;
         for (i3 = 0; i3 < a_l; ++i3) {
           a_i = a[i3];
           for (var j = 0; j < b_l; ++j) {
@@ -9219,7 +9219,7 @@ function requireBigInteger() {
         return r;
       }
       function multiplySmall(a, b) {
-        var l = a.length, r = new Array(l), base = BASE, carry = 0, product, i3;
+        var l = a.length, r = new Array(l), base = BASE2, carry = 0, product, i3;
         for (i3 = 0; i3 < l; i3++) {
           product = a[i3] * b + carry;
           carry = Math.floor(product / base);
@@ -9256,7 +9256,7 @@ function requireBigInteger() {
           if (b === 1) return this;
           if (b === -1) return this.negate();
           abs = Math.abs(b);
-          if (abs < BASE) {
+          if (abs < BASE2) {
             return new BigInteger2(multiplySmall(a, abs), sign);
           }
           b = smallToArray(abs);
@@ -9267,7 +9267,7 @@ function requireBigInteger() {
       };
       BigInteger2.prototype.times = BigInteger2.prototype.multiply;
       function multiplySmallAndArray(a, b, sign) {
-        if (a < BASE) {
+        if (a < BASE2) {
           return new BigInteger2(multiplySmall(b, a), sign);
         }
         return new BigInteger2(multiplyLong(b, smallToArray(a)), sign);
@@ -9293,7 +9293,7 @@ function requireBigInteger() {
       };
       NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
       function square(a) {
-        var l = a.length, r = createArray(l + l), base = BASE, product, carry, i3, a_i, a_j;
+        var l = a.length, r = createArray(l + l), base = BASE2, product, carry, i3, a_i, a_j;
         for (i3 = 0; i3 < l; i3++) {
           a_i = a[i3];
           carry = 0 - a_i * a_i;
@@ -9320,7 +9320,7 @@ function requireBigInteger() {
         return new NativeBigInt(this.value * this.value);
       };
       function divMod1(a, b) {
-        var a_l = a.length, b_l = b.length, base = BASE, result = createArray(b.length), divisorMostSignificantDigit = b[b_l - 1], lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)), remainder = multiplySmall(a, lambda), divisor = multiplySmall(b, lambda), quotientDigit, shift, carry, borrow, i3, l, q2;
+        var a_l = a.length, b_l = b.length, base = BASE2, result = createArray(b.length), divisorMostSignificantDigit = b[b_l - 1], lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)), remainder = multiplySmall(a, lambda), divisor = multiplySmall(b, lambda), quotientDigit, shift, carry, borrow, i3, l, q2;
         if (remainder.length <= a_l) remainder.push(0);
         divisor.push(0);
         divisorMostSignificantDigit = divisor[b_l - 1];
@@ -9366,7 +9366,7 @@ function requireBigInteger() {
         return [arrayToSmall(result), arrayToSmall(remainder)];
       }
       function divMod2(a, b) {
-        var a_l = a.length, b_l = b.length, result = [], part = [], base = BASE, guess, xlen, highx, highy, check;
+        var a_l = a.length, b_l = b.length, result = [], part = [], base = BASE2, guess, xlen, highx, highy, check;
         while (a_l) {
           part.unshift(a[--a_l]);
           trim(part);
@@ -9393,7 +9393,7 @@ function requireBigInteger() {
         return [arrayToSmall(result), arrayToSmall(part)];
       }
       function divModSmall(value, lambda) {
-        var length = value.length, quotient = createArray(length), base = BASE, i3, q2, remainder, divisor;
+        var length = value.length, quotient = createArray(length), base = BASE2, i3, q2, remainder, divisor;
         remainder = 0;
         for (i3 = length - 1; i3 >= 0; --i3) {
           divisor = remainder * base + value[i3];
@@ -9421,7 +9421,7 @@ function requireBigInteger() {
           if (b === 1) return [self2, Integer[0]];
           if (b == -1) return [self2.negate(), Integer[0]];
           var abs = Math.abs(b);
-          if (abs < BASE) {
+          if (abs < BASE2) {
             value = divModSmall(a, abs);
             quotient = arrayToSmall(value[0]);
             var remainder = value[1];
@@ -9800,10 +9800,10 @@ function requireBigInteger() {
         return new NativeBigInt(this.value - BigInt(1));
       };
       var powersOfTwo = [1];
-      while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
+      while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE2) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
       var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];
       function shift_isSmall(n) {
-        return Math.abs(n) <= BASE;
+        return Math.abs(n) <= BASE2;
       }
       BigInteger2.prototype.shiftLeft = function(v) {
         var n = parseValue(v).toJSNumber();
@@ -9888,9 +9888,9 @@ function requireBigInteger() {
         });
       };
       NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger2.prototype.xor;
-      var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
+      var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE2 & -BASE2) * (BASE2 & -BASE2) | LOBMASK_I;
       function roughLOB(n) {
-        var v = n.value, x = typeof v === "number" ? v | LOBMASK_I : typeof v === "bigint" ? v | BigInt(LOBMASK_I) : v[0] + v[1] * BASE | LOBMASK_BI;
+        var v = n.value, x = typeof v === "number" ? v | LOBMASK_I : typeof v === "bigint" ? v | BigInt(LOBMASK_I) : v[0] + v[1] * BASE2 | LOBMASK_BI;
         return x & -x;
       }
       function integerLogarithm(value, base) {
@@ -9965,15 +9965,15 @@ function requireBigInteger() {
         var low = min(a, b), high = max(a, b);
         var range3 = high.subtract(low).add(1);
         if (range3.isSmall) return low.add(Math.floor(usedRNG() * range3));
-        var digits = toBase(range3, BASE).value;
+        var digits = toBase(range3, BASE2).value;
         var result = [], restricted = true;
         for (var i3 = 0; i3 < digits.length; i3++) {
-          var top = restricted ? digits[i3] + (i3 + 1 < digits.length ? digits[i3 + 1] / BASE : 0) : BASE;
+          var top = restricted ? digits[i3] + (i3 + 1 < digits.length ? digits[i3 + 1] / BASE2 : 0) : BASE2;
           var digit = truncate(usedRNG() * top);
           result.push(digit);
           if (digit < digits[i3]) restricted = false;
         }
-        return low.add(Integer.fromArray(result, BASE, false));
+        return low.add(Integer.fromArray(result, BASE2, false));
       }
       var parseBase = function(text, base, alphabet, caseSensitive) {
         alphabet = alphabet || DEFAULT_ALPHABET;
@@ -10157,7 +10157,7 @@ function requireBigInteger() {
         if (supportsNativeBigInt) {
           return new NativeBigInt(BigInt(sign ? "-" + v : v));
         }
-        var r = [], max2 = v.length, l = LOG_BASE, min2 = max2 - l;
+        var r = [], max2 = v.length, l = LOG_BASE2, min2 = max2 - l;
         while (max2 > 0) {
           r.push(+v.slice(min2, max2));
           min2 -= l;
@@ -62271,6 +62271,1337 @@ function getSubTableQuickFillInfo(subTableFieldId, mobileTdIdGroups) {
   if (!subTableFieldId) return;
   return assignWidgetInfo(MobileFillTypeEnum.SUB_TABLE, { rowSubFieldKey: subTableFieldId });
 }
+var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 1e14, LOG_BASE = 14, MAX_SAFE_INTEGER$2 = 9007199254740991, POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], SQRT_BASE = 1e7, MAX = 1e9;
+function clone(configObject) {
+  var div, convertBase, parseNumeric, P2 = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
+    prefix: "",
+    groupSize: 3,
+    secondaryGroupSize: 0,
+    groupSeparator: ",",
+    decimalSeparator: ".",
+    fractionGroupSize: 0,
+    fractionGroupSeparator: " ",
+    // non-breaking space
+    suffix: ""
+  }, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = true;
+  function BigNumber2(v, b) {
+    var alphabet, c2, caseChanged, e, i2, isNum, len, str, x = this;
+    if (!(x instanceof BigNumber2)) return new BigNumber2(v, b);
+    if (b == null) {
+      if (v && v._isBigNumber === true) {
+        x.s = v.s;
+        if (!v.c || v.e > MAX_EXP) {
+          x.c = x.e = null;
+        } else if (v.e < MIN_EXP) {
+          x.c = [x.e = 0];
+        } else {
+          x.e = v.e;
+          x.c = v.c.slice();
+        }
+        return;
+      }
+      if ((isNum = typeof v == "number") && v * 0 == 0) {
+        x.s = 1 / v < 0 ? (v = -v, -1) : 1;
+        if (v === ~~v) {
+          for (e = 0, i2 = v; i2 >= 10; i2 /= 10, e++) ;
+          if (e > MAX_EXP) {
+            x.c = x.e = null;
+          } else {
+            x.e = e;
+            x.c = [v];
+          }
+          return;
+        }
+        str = String(v);
+      } else {
+        if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);
+        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+      }
+      if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
+      if ((i2 = str.search(/e/i)) > 0) {
+        if (e < 0) e = i2;
+        e += +str.slice(i2 + 1);
+        str = str.substring(0, i2);
+      } else if (e < 0) {
+        e = str.length;
+      }
+    } else {
+      intCheck(b, 2, ALPHABET.length, "Base");
+      if (b == 10 && alphabetHasNormalDecimalDigits) {
+        x = new BigNumber2(v);
+        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+      }
+      str = String(v);
+      if (isNum = typeof v == "number") {
+        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
+        x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
+        if (BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) {
+          throw Error(tooManyDigits + v);
+        }
+      } else {
+        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+      }
+      alphabet = ALPHABET.slice(0, b);
+      e = i2 = 0;
+      for (len = str.length; i2 < len; i2++) {
+        if (alphabet.indexOf(c2 = str.charAt(i2)) < 0) {
+          if (c2 == ".") {
+            if (i2 > e) {
+              e = len;
+              continue;
+            }
+          } else if (!caseChanged) {
+            if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {
+              caseChanged = true;
+              i2 = -1;
+              e = 0;
+              continue;
+            }
+          }
+          return parseNumeric(x, String(v), isNum, b);
+        }
+      }
+      isNum = false;
+      str = convertBase(str, b, 10, x.s);
+      if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
+      else e = str.length;
+    }
+    for (i2 = 0; str.charCodeAt(i2) === 48; i2++) ;
+    for (len = str.length; str.charCodeAt(--len) === 48; ) ;
+    if (str = str.slice(i2, ++len)) {
+      len -= i2;
+      if (isNum && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER$2 || v !== mathfloor(v))) {
+        throw Error(tooManyDigits + x.s * v);
+      }
+      if ((e = e - i2 - 1) > MAX_EXP) {
+        x.c = x.e = null;
+      } else if (e < MIN_EXP) {
+        x.c = [x.e = 0];
+      } else {
+        x.e = e;
+        x.c = [];
+        i2 = (e + 1) % LOG_BASE;
+        if (e < 0) i2 += LOG_BASE;
+        if (i2 < len) {
+          if (i2) x.c.push(+str.slice(0, i2));
+          for (len -= LOG_BASE; i2 < len; ) {
+            x.c.push(+str.slice(i2, i2 += LOG_BASE));
+          }
+          i2 = LOG_BASE - (str = str.slice(i2)).length;
+        } else {
+          i2 -= len;
+        }
+        for (; i2--; str += "0") ;
+        x.c.push(+str);
+      }
+    } else {
+      x.c = [x.e = 0];
+    }
+  }
+  BigNumber2.clone = clone;
+  BigNumber2.ROUND_UP = 0;
+  BigNumber2.ROUND_DOWN = 1;
+  BigNumber2.ROUND_CEIL = 2;
+  BigNumber2.ROUND_FLOOR = 3;
+  BigNumber2.ROUND_HALF_UP = 4;
+  BigNumber2.ROUND_HALF_DOWN = 5;
+  BigNumber2.ROUND_HALF_EVEN = 6;
+  BigNumber2.ROUND_HALF_CEIL = 7;
+  BigNumber2.ROUND_HALF_FLOOR = 8;
+  BigNumber2.EUCLID = 9;
+  BigNumber2.config = BigNumber2.set = function(obj) {
+    var p2, v;
+    if (obj != null) {
+      if (typeof obj == "object") {
+        if (obj.hasOwnProperty(p2 = "DECIMAL_PLACES")) {
+          v = obj[p2];
+          intCheck(v, 0, MAX, p2);
+          DECIMAL_PLACES = v;
+        }
+        if (obj.hasOwnProperty(p2 = "ROUNDING_MODE")) {
+          v = obj[p2];
+          intCheck(v, 0, 8, p2);
+          ROUNDING_MODE = v;
+        }
+        if (obj.hasOwnProperty(p2 = "EXPONENTIAL_AT")) {
+          v = obj[p2];
+          if (v && v.pop) {
+            intCheck(v[0], -MAX, 0, p2);
+            intCheck(v[1], 0, MAX, p2);
+            TO_EXP_NEG = v[0];
+            TO_EXP_POS = v[1];
+          } else {
+            intCheck(v, -MAX, MAX, p2);
+            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
+          }
+        }
+        if (obj.hasOwnProperty(p2 = "RANGE")) {
+          v = obj[p2];
+          if (v && v.pop) {
+            intCheck(v[0], -MAX, -1, p2);
+            intCheck(v[1], 1, MAX, p2);
+            MIN_EXP = v[0];
+            MAX_EXP = v[1];
+          } else {
+            intCheck(v, -MAX, MAX, p2);
+            if (v) {
+              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+            } else {
+              throw Error(bignumberError + p2 + " cannot be zero: " + v);
+            }
+          }
+        }
+        if (obj.hasOwnProperty(p2 = "CRYPTO")) {
+          v = obj[p2];
+          if (v === !!v) {
+            if (v) {
+              if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
+                CRYPTO = v;
+              } else {
+                CRYPTO = !v;
+                throw Error(bignumberError + "crypto unavailable");
+              }
+            } else {
+              CRYPTO = v;
+            }
+          } else {
+            throw Error(bignumberError + p2 + " not true or false: " + v);
+          }
+        }
+        if (obj.hasOwnProperty(p2 = "MODULO_MODE")) {
+          v = obj[p2];
+          intCheck(v, 0, 9, p2);
+          MODULO_MODE = v;
+        }
+        if (obj.hasOwnProperty(p2 = "POW_PRECISION")) {
+          v = obj[p2];
+          intCheck(v, 0, MAX, p2);
+          POW_PRECISION = v;
+        }
+        if (obj.hasOwnProperty(p2 = "FORMAT")) {
+          v = obj[p2];
+          if (typeof v == "object") FORMAT = v;
+          else throw Error(bignumberError + p2 + " not an object: " + v);
+        }
+        if (obj.hasOwnProperty(p2 = "ALPHABET")) {
+          v = obj[p2];
+          if (typeof v == "string" && !/^.?$|[+\-.\s]|(.).*\1/.test(v)) {
+            alphabetHasNormalDecimalDigits = v.slice(0, 10) == "0123456789";
+            ALPHABET = v;
+          } else {
+            throw Error(bignumberError + p2 + " invalid: " + v);
+          }
+        }
+      } else {
+        throw Error(bignumberError + "Object expected: " + obj);
+      }
+    }
+    return {
+      DECIMAL_PLACES,
+      ROUNDING_MODE,
+      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+      RANGE: [MIN_EXP, MAX_EXP],
+      CRYPTO,
+      MODULO_MODE,
+      POW_PRECISION,
+      FORMAT,
+      ALPHABET
+    };
+  };
+  BigNumber2.isBigNumber = function(v) {
+    if (!v || v._isBigNumber !== true) return false;
+    if (!BigNumber2.DEBUG) return true;
+    var i2, n, c2 = v.c, e = v.e, s = v.s;
+    out: if ({}.toString.call(c2) == "[object Array]") {
+      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+        if (c2[0] === 0) {
+          if (e === 0 && c2.length === 1) return true;
+          break out;
+        }
+        i2 = (e + 1) % LOG_BASE;
+        if (i2 < 1) i2 += LOG_BASE;
+        if (String(c2[0]).length == i2) {
+          for (i2 = 0; i2 < c2.length; i2++) {
+            n = c2[i2];
+            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;
+          }
+          if (n !== 0) return true;
+        }
+      }
+    } else if (c2 === null && e === null && (s === null || s === 1 || s === -1)) {
+      return true;
+    }
+    throw Error(bignumberError + "Invalid BigNumber: " + v);
+  };
+  BigNumber2.maximum = BigNumber2.max = function() {
+    return maxOrMin(arguments, -1);
+  };
+  BigNumber2.minimum = BigNumber2.min = function() {
+    return maxOrMin(arguments, 1);
+  };
+  BigNumber2.random = (function() {
+    var pow2_53 = 9007199254740992;
+    var random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
+      return mathfloor(Math.random() * pow2_53);
+    } : function() {
+      return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
+    };
+    return function(dp) {
+      var a, b, e, k, v, i2 = 0, c2 = [], rand = new BigNumber2(ONE);
+      if (dp == null) dp = DECIMAL_PLACES;
+      else intCheck(dp, 0, MAX);
+      k = mathceil(dp / LOG_BASE);
+      if (CRYPTO) {
+        if (crypto.getRandomValues) {
+          a = crypto.getRandomValues(new Uint32Array(k *= 2));
+          for (; i2 < k; ) {
+            v = a[i2] * 131072 + (a[i2 + 1] >>> 11);
+            if (v >= 9e15) {
+              b = crypto.getRandomValues(new Uint32Array(2));
+              a[i2] = b[0];
+              a[i2 + 1] = b[1];
+            } else {
+              c2.push(v % 1e14);
+              i2 += 2;
+            }
+          }
+          i2 = k / 2;
+        } else if (crypto.randomBytes) {
+          a = crypto.randomBytes(k *= 7);
+          for (; i2 < k; ) {
+            v = (a[i2] & 31) * 281474976710656 + a[i2 + 1] * 1099511627776 + a[i2 + 2] * 4294967296 + a[i2 + 3] * 16777216 + (a[i2 + 4] << 16) + (a[i2 + 5] << 8) + a[i2 + 6];
+            if (v >= 9e15) {
+              crypto.randomBytes(7).copy(a, i2);
+            } else {
+              c2.push(v % 1e14);
+              i2 += 7;
+            }
+          }
+          i2 = k / 7;
+        } else {
+          CRYPTO = false;
+          throw Error(bignumberError + "crypto unavailable");
+        }
+      }
+      if (!CRYPTO) {
+        for (; i2 < k; ) {
+          v = random53bitInt();
+          if (v < 9e15) c2[i2++] = v % 1e14;
+        }
+      }
+      k = c2[--i2];
+      dp %= LOG_BASE;
+      if (k && dp) {
+        v = POWS_TEN[LOG_BASE - dp];
+        c2[i2] = mathfloor(k / v) * v;
+      }
+      for (; c2[i2] === 0; c2.pop(), i2--) ;
+      if (i2 < 0) {
+        c2 = [e = 0];
+      } else {
+        for (e = -1; c2[0] === 0; c2.splice(0, 1), e -= LOG_BASE) ;
+        for (i2 = 1, v = c2[0]; v >= 10; v /= 10, i2++) ;
+        if (i2 < LOG_BASE) e -= LOG_BASE - i2;
+      }
+      rand.e = e;
+      rand.c = c2;
+      return rand;
+    };
+  })();
+  BigNumber2.sum = function() {
+    var i2 = 1, args = arguments, sum = new BigNumber2(args[0]);
+    for (; i2 < args.length; ) sum = sum.plus(args[i2++]);
+    return sum;
+  };
+  convertBase = /* @__PURE__ */ (function() {
+    var decimal = "0123456789";
+    function toBaseOut(str, baseIn, baseOut, alphabet) {
+      var j, arr = [0], arrL, i2 = 0, len = str.length;
+      for (; i2 < len; ) {
+        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn) ;
+        arr[0] += alphabet.indexOf(str.charAt(i2++));
+        for (j = 0; j < arr.length; j++) {
+          if (arr[j] > baseOut - 1) {
+            if (arr[j + 1] == null) arr[j + 1] = 0;
+            arr[j + 1] += arr[j] / baseOut | 0;
+            arr[j] %= baseOut;
+          }
+        }
+      }
+      return arr.reverse();
+    }
+    return function(str, baseIn, baseOut, sign, callerIsToString) {
+      var alphabet, d, e, k, r, x, xc, y, i2 = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
+      if (i2 >= 0) {
+        k = POW_PRECISION;
+        POW_PRECISION = 0;
+        str = str.replace(".", "");
+        y = new BigNumber2(baseIn);
+        x = y.pow(str.length - i2);
+        POW_PRECISION = k;
+        y.c = toBaseOut(
+          toFixedPoint(coeffToString(x.c), x.e, "0"),
+          10,
+          baseOut,
+          decimal
+        );
+        y.e = y.c.length;
+      }
+      xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));
+      e = k = xc.length;
+      for (; xc[--k] == 0; xc.pop()) ;
+      if (!xc[0]) return alphabet.charAt(0);
+      if (i2 < 0) {
+        --e;
+      } else {
+        x.c = xc;
+        x.e = e;
+        x.s = sign;
+        x = div(x, y, dp, rm, baseOut);
+        xc = x.c;
+        r = x.r;
+        e = x.e;
+      }
+      d = e + dp + 1;
+      i2 = xc[d];
+      k = baseOut / 2;
+      r = r || d < 0 || xc[d + 1] != null;
+      r = rm < 4 ? (i2 != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i2 > k || i2 == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));
+      if (d < 1 || !xc[0]) {
+        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
+      } else {
+        xc.length = d;
+        if (r) {
+          for (--baseOut; ++xc[--d] > baseOut; ) {
+            xc[d] = 0;
+            if (!d) {
+              ++e;
+              xc = [1].concat(xc);
+            }
+          }
+        }
+        for (k = xc.length; !xc[--k]; ) ;
+        for (i2 = 0, str = ""; i2 <= k; str += alphabet.charAt(xc[i2++])) ;
+        str = toFixedPoint(str, e, alphabet.charAt(0));
+      }
+      return str;
+    };
+  })();
+  div = /* @__PURE__ */ (function() {
+    function multiply(x, k, base) {
+      var m, temp, xlo, xhi, carry = 0, i2 = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
+      for (x = x.slice(); i2--; ) {
+        xlo = x[i2] % SQRT_BASE;
+        xhi = x[i2] / SQRT_BASE | 0;
+        m = khi * xlo + xhi * klo;
+        temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;
+        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
+        x[i2] = temp % base;
+      }
+      if (carry) x = [carry].concat(x);
+      return x;
+    }
+    function compare2(a, b, aL, bL) {
+      var i2, cmp;
+      if (aL != bL) {
+        cmp = aL > bL ? 1 : -1;
+      } else {
+        for (i2 = cmp = 0; i2 < aL; i2++) {
+          if (a[i2] != b[i2]) {
+            cmp = a[i2] > b[i2] ? 1 : -1;
+            break;
+          }
+        }
+      }
+      return cmp;
+    }
+    function subtract(a, b, aL, base) {
+      var i2 = 0;
+      for (; aL--; ) {
+        a[aL] -= i2;
+        i2 = a[aL] < b[aL] ? 1 : 0;
+        a[aL] = i2 * base + a[aL] - b[aL];
+      }
+      for (; !a[0] && a.length > 1; a.splice(0, 1)) ;
+    }
+    return function(x, y, dp, rm, base) {
+      var cmp, e, i2, more, n, prod, prodL, q2, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
+      if (!xc || !xc[0] || !yc || !yc[0]) {
+        return new BigNumber2(
+          // Return NaN if either NaN, or both Infinity or 0.
+          !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : (
+            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
+            xc && xc[0] == 0 || !yc ? s * 0 : s / 0
+          )
+        );
+      }
+      q2 = new BigNumber2(s);
+      qc = q2.c = [];
+      e = x.e - y.e;
+      s = dp + e + 1;
+      if (!base) {
+        base = BASE;
+        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
+        s = s / LOG_BASE | 0;
+      }
+      for (i2 = 0; yc[i2] == (xc[i2] || 0); i2++) ;
+      if (yc[i2] > (xc[i2] || 0)) e--;
+      if (s < 0) {
+        qc.push(1);
+        more = true;
+      } else {
+        xL = xc.length;
+        yL = yc.length;
+        i2 = 0;
+        s += 2;
+        n = mathfloor(base / (yc[0] + 1));
+        if (n > 1) {
+          yc = multiply(yc, n, base);
+          xc = multiply(xc, n, base);
+          yL = yc.length;
+          xL = xc.length;
+        }
+        xi = yL;
+        rem = xc.slice(0, yL);
+        remL = rem.length;
+        for (; remL < yL; rem[remL++] = 0) ;
+        yz = yc.slice();
+        yz = [0].concat(yz);
+        yc0 = yc[0];
+        if (yc[1] >= base / 2) yc0++;
+        do {
+          n = 0;
+          cmp = compare2(yc, rem, yL, remL);
+          if (cmp < 0) {
+            rem0 = rem[0];
+            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
+            n = mathfloor(rem0 / yc0);
+            if (n > 1) {
+              if (n >= base) n = base - 1;
+              prod = multiply(yc, n, base);
+              prodL = prod.length;
+              remL = rem.length;
+              while (compare2(prod, rem, prodL, remL) == 1) {
+                n--;
+                subtract(prod, yL < prodL ? yz : yc, prodL, base);
+                prodL = prod.length;
+                cmp = 1;
+              }
+            } else {
+              if (n == 0) {
+                cmp = n = 1;
+              }
+              prod = yc.slice();
+              prodL = prod.length;
+            }
+            if (prodL < remL) prod = [0].concat(prod);
+            subtract(rem, prod, remL, base);
+            remL = rem.length;
+            if (cmp == -1) {
+              while (compare2(yc, rem, yL, remL) < 1) {
+                n++;
+                subtract(rem, yL < remL ? yz : yc, remL, base);
+                remL = rem.length;
+              }
+            }
+          } else if (cmp === 0) {
+            n++;
+            rem = [0];
+          }
+          qc[i2++] = n;
+          if (rem[0]) {
+            rem[remL++] = xc[xi] || 0;
+          } else {
+            rem = [xc[xi]];
+            remL = 1;
+          }
+        } while ((xi++ < xL || rem[0] != null) && s--);
+        more = rem[0] != null;
+        if (!qc[0]) qc.splice(0, 1);
+      }
+      if (base == BASE) {
+        for (i2 = 1, s = qc[0]; s >= 10; s /= 10, i2++) ;
+        round(q2, dp + (q2.e = i2 + e * LOG_BASE - 1) + 1, rm, more);
+      } else {
+        q2.e = e;
+        q2.r = +more;
+      }
+      return q2;
+    };
+  })();
+  function format2(n, i2, rm, id) {
+    var c0, e, ne, len, str;
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+    if (!n.c) return n.toString();
+    c0 = n.c[0];
+    ne = n.e;
+    if (i2 == null) {
+      str = coeffToString(n.c);
+      str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
+    } else {
+      n = round(new BigNumber2(n), i2, rm);
+      e = n.e;
+      str = coeffToString(n.c);
+      len = str.length;
+      if (id == 1 || id == 2 && (i2 <= e || e <= TO_EXP_NEG)) {
+        for (; len < i2; str += "0", len++) ;
+        str = toExponential(str, e);
+      } else {
+        i2 -= ne + (id === 2 && e > ne);
+        str = toFixedPoint(str, e, "0");
+        if (e + 1 > len) {
+          if (--i2 > 0) for (str += "."; i2--; str += "0") ;
+        } else {
+          i2 += e - len;
+          if (i2 > 0) {
+            if (e + 1 == len) str += ".";
+            for (; i2--; str += "0") ;
+          }
+        }
+      }
+    }
+    return n.s < 0 && c0 ? "-" + str : str;
+  }
+  function maxOrMin(args, n) {
+    var k, y, i2 = 1, x = new BigNumber2(args[0]);
+    for (; i2 < args.length; i2++) {
+      y = new BigNumber2(args[i2]);
+      if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {
+        x = y;
+      }
+    }
+    return x;
+  }
+  function normalise(n, c2, e) {
+    var i2 = 1, j = c2.length;
+    for (; !c2[--j]; c2.pop()) ;
+    for (j = c2[0]; j >= 10; j /= 10, i2++) ;
+    if ((e = i2 + e * LOG_BASE - 1) > MAX_EXP) {
+      n.c = n.e = null;
+    } else if (e < MIN_EXP) {
+      n.c = [n.e = 0];
+    } else {
+      n.e = e;
+      n.c = c2;
+    }
+    return n;
+  }
+  parseNumeric = /* @__PURE__ */ (function() {
+    var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+    return function(x, str, isNum, b) {
+      var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
+      if (isInfinityOrNaN.test(s)) {
+        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+      } else {
+        if (!isNum) {
+          s = s.replace(basePrefix, function(m, p1, p2) {
+            base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
+            return !b || b == base ? p1 : m;
+          });
+          if (b) {
+            base = b;
+            s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
+          }
+          if (str != s) return new BigNumber2(s, base);
+        }
+        if (BigNumber2.DEBUG) {
+          throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
+        }
+        x.s = null;
+      }
+      x.c = x.e = null;
+    };
+  })();
+  function round(x, sd, rm, r) {
+    var d, i2, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
+    if (xc) {
+      out: {
+        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++) ;
+        i2 = sd - d;
+        if (i2 < 0) {
+          i2 += LOG_BASE;
+          j = sd;
+          n = xc[ni = 0];
+          rd = mathfloor(n / pows10[d - j - 1] % 10);
+        } else {
+          ni = mathceil((i2 + 1) / LOG_BASE);
+          if (ni >= xc.length) {
+            if (r) {
+              for (; xc.length <= ni; xc.push(0)) ;
+              n = rd = 0;
+              d = 1;
+              i2 %= LOG_BASE;
+              j = i2 - LOG_BASE + 1;
+            } else {
+              break out;
+            }
+          } else {
+            n = k = xc[ni];
+            for (d = 1; k >= 10; k /= 10, d++) ;
+            i2 %= LOG_BASE;
+            j = i2 - LOG_BASE + d;
+            rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
+          }
+        }
+        r = r || sd < 0 || // Are there any non-zero digits after the rounding digit?
+        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right
+        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
+        xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+        r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
+        (i2 > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
+        if (sd < 1 || !xc[0]) {
+          xc.length = 0;
+          if (r) {
+            sd -= x.e + 1;
+            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+            x.e = -sd || 0;
+          } else {
+            xc[0] = x.e = 0;
+          }
+          return x;
+        }
+        if (i2 == 0) {
+          xc.length = ni;
+          k = 1;
+          ni--;
+        } else {
+          xc.length = ni + 1;
+          k = pows10[LOG_BASE - i2];
+          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
+        }
+        if (r) {
+          for (; ; ) {
+            if (ni == 0) {
+              for (i2 = 1, j = xc[0]; j >= 10; j /= 10, i2++) ;
+              j = xc[0] += k;
+              for (k = 1; j >= 10; j /= 10, k++) ;
+              if (i2 != k) {
+                x.e++;
+                if (xc[0] == BASE) xc[0] = 1;
+              }
+              break;
+            } else {
+              xc[ni] += k;
+              if (xc[ni] != BASE) break;
+              xc[ni--] = 0;
+              k = 1;
+            }
+          }
+        }
+        for (i2 = xc.length; xc[--i2] === 0; xc.pop()) ;
+      }
+      if (x.e > MAX_EXP) {
+        x.c = x.e = null;
+      } else if (x.e < MIN_EXP) {
+        x.c = [x.e = 0];
+      }
+    }
+    return x;
+  }
+  function valueOf(n) {
+    var str, e = n.e;
+    if (e === null) return n.toString();
+    str = coeffToString(n.c);
+    str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0");
+    return n.s < 0 ? "-" + str : str;
+  }
+  P2.absoluteValue = P2.abs = function() {
+    var x = new BigNumber2(this);
+    if (x.s < 0) x.s = 1;
+    return x;
+  };
+  P2.comparedTo = function(y, b) {
+    return compare(this, new BigNumber2(y, b));
+  };
+  P2.decimalPlaces = P2.dp = function(dp, rm) {
+    var c2, n, v, x = this;
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+      return round(new BigNumber2(x), dp + x.e + 1, rm);
+    }
+    if (!(c2 = x.c)) return null;
+    n = ((v = c2.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
+    if (v = c2[v]) for (; v % 10 == 0; v /= 10, n--) ;
+    if (n < 0) n = 0;
+    return n;
+  };
+  P2.dividedBy = P2.div = function(y, b) {
+    return div(this, new BigNumber2(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+  };
+  P2.dividedToIntegerBy = P2.idiv = function(y, b) {
+    return div(this, new BigNumber2(y, b), 0, 1);
+  };
+  P2.exponentiatedBy = P2.pow = function(n, m) {
+    var half, isModExp, i2, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
+    n = new BigNumber2(n);
+    if (n.c && !n.isInteger()) {
+      throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
+    }
+    if (m != null) m = new BigNumber2(m);
+    nIsBig = n.e > 14;
+    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
+      y = new BigNumber2(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));
+      return m ? y.mod(m) : y;
+    }
+    nIsNeg = n.s < 0;
+    if (m) {
+      if (m.c ? !m.c[0] : !m.s) return new BigNumber2(NaN);
+      isModExp = !nIsNeg && x.isInteger() && m.isInteger();
+      if (isModExp) x = x.mod(m);
+    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7 : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {
+      k = x.s < 0 && isOdd(n) ? -0 : 0;
+      if (x.e > -1) k = 1 / k;
+      return new BigNumber2(nIsNeg ? 1 / k : k);
+    } else if (POW_PRECISION) {
+      k = mathceil(POW_PRECISION / LOG_BASE + 2);
+    }
+    if (nIsBig) {
+      half = new BigNumber2(0.5);
+      if (nIsNeg) n.s = 1;
+      nIsOdd = isOdd(n);
+    } else {
+      i2 = Math.abs(+valueOf(n));
+      nIsOdd = i2 % 2;
+    }
+    y = new BigNumber2(ONE);
+    for (; ; ) {
+      if (nIsOdd) {
+        y = y.times(x);
+        if (!y.c) break;
+        if (k) {
+          if (y.c.length > k) y.c.length = k;
+        } else if (isModExp) {
+          y = y.mod(m);
+        }
+      }
+      if (i2) {
+        i2 = mathfloor(i2 / 2);
+        if (i2 === 0) break;
+        nIsOdd = i2 % 2;
+      } else {
+        n = n.times(half);
+        round(n, n.e + 1, 1);
+        if (n.e > 14) {
+          nIsOdd = isOdd(n);
+        } else {
+          i2 = +valueOf(n);
+          if (i2 === 0) break;
+          nIsOdd = i2 % 2;
+        }
+      }
+      x = x.times(x);
+      if (k) {
+        if (x.c && x.c.length > k) x.c.length = k;
+      } else if (isModExp) {
+        x = x.mod(m);
+      }
+    }
+    if (isModExp) return y;
+    if (nIsNeg) y = ONE.div(y);
+    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+  };
+  P2.integerValue = function(rm) {
+    var n = new BigNumber2(this);
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+    return round(n, n.e + 1, rm);
+  };
+  P2.isEqualTo = P2.eq = function(y, b) {
+    return compare(this, new BigNumber2(y, b)) === 0;
+  };
+  P2.isFinite = function() {
+    return !!this.c;
+  };
+  P2.isGreaterThan = P2.gt = function(y, b) {
+    return compare(this, new BigNumber2(y, b)) > 0;
+  };
+  P2.isGreaterThanOrEqualTo = P2.gte = function(y, b) {
+    return (b = compare(this, new BigNumber2(y, b))) === 1 || b === 0;
+  };
+  P2.isInteger = function() {
+    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+  };
+  P2.isLessThan = P2.lt = function(y, b) {
+    return compare(this, new BigNumber2(y, b)) < 0;
+  };
+  P2.isLessThanOrEqualTo = P2.lte = function(y, b) {
+    return (b = compare(this, new BigNumber2(y, b))) === -1 || b === 0;
+  };
+  P2.isNaN = function() {
+    return !this.s;
+  };
+  P2.isNegative = function() {
+    return this.s < 0;
+  };
+  P2.isPositive = function() {
+    return this.s > 0;
+  };
+  P2.isZero = function() {
+    return !!this.c && this.c[0] == 0;
+  };
+  P2.minus = function(y, b) {
+    var i2, j, t, xLTy, x = this, a = x.s;
+    y = new BigNumber2(y, b);
+    b = y.s;
+    if (!a || !b) return new BigNumber2(NaN);
+    if (a != b) {
+      y.s = -b;
+      return x.plus(y);
+    }
+    var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+    if (!xe || !ye) {
+      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber2(yc ? x : NaN);
+      if (!xc[0] || !yc[0]) {
+        return yc[0] ? (y.s = -b, y) : new BigNumber2(xc[0] ? x : (
+          // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+          ROUNDING_MODE == 3 ? -0 : 0
+        ));
+      }
+    }
+    xe = bitFloor(xe);
+    ye = bitFloor(ye);
+    xc = xc.slice();
+    if (a = xe - ye) {
+      if (xLTy = a < 0) {
+        a = -a;
+        t = xc;
+      } else {
+        ye = xe;
+        t = yc;
+      }
+      t.reverse();
+      for (b = a; b--; t.push(0)) ;
+      t.reverse();
+    } else {
+      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
+      for (a = b = 0; b < j; b++) {
+        if (xc[b] != yc[b]) {
+          xLTy = xc[b] < yc[b];
+          break;
+        }
+      }
+    }
+    if (xLTy) {
+      t = xc;
+      xc = yc;
+      yc = t;
+      y.s = -y.s;
+    }
+    b = (j = yc.length) - (i2 = xc.length);
+    if (b > 0) for (; b--; xc[i2++] = 0) ;
+    b = BASE - 1;
+    for (; j > a; ) {
+      if (xc[--j] < yc[j]) {
+        for (i2 = j; i2 && !xc[--i2]; xc[i2] = b) ;
+        --xc[i2];
+        xc[j] += BASE;
+      }
+      xc[j] -= yc[j];
+    }
+    for (; xc[0] == 0; xc.splice(0, 1), --ye) ;
+    if (!xc[0]) {
+      y.s = ROUNDING_MODE == 3 ? -1 : 1;
+      y.c = [y.e = 0];
+      return y;
+    }
+    return normalise(y, xc, ye);
+  };
+  P2.modulo = P2.mod = function(y, b) {
+    var q2, s, x = this;
+    y = new BigNumber2(y, b);
+    if (!x.c || !y.s || y.c && !y.c[0]) {
+      return new BigNumber2(NaN);
+    } else if (!y.c || x.c && !x.c[0]) {
+      return new BigNumber2(x);
+    }
+    if (MODULO_MODE == 9) {
+      s = y.s;
+      y.s = 1;
+      q2 = div(x, y, 0, 3);
+      y.s = s;
+      q2.s *= s;
+    } else {
+      q2 = div(x, y, 0, MODULO_MODE);
+    }
+    y = x.minus(q2.times(y));
+    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;
+    return y;
+  };
+  P2.multipliedBy = P2.times = function(y, b) {
+    var c2, e, i2, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber2(y, b)).c;
+    if (!xc || !yc || !xc[0] || !yc[0]) {
+      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
+        y.c = y.e = y.s = null;
+      } else {
+        y.s *= x.s;
+        if (!xc || !yc) {
+          y.c = y.e = null;
+        } else {
+          y.c = [0];
+          y.e = 0;
+        }
+      }
+      return y;
+    }
+    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+    y.s *= x.s;
+    xcL = xc.length;
+    ycL = yc.length;
+    if (xcL < ycL) {
+      zc = xc;
+      xc = yc;
+      yc = zc;
+      i2 = xcL;
+      xcL = ycL;
+      ycL = i2;
+    }
+    for (i2 = xcL + ycL, zc = []; i2--; zc.push(0)) ;
+    base = BASE;
+    sqrtBase = SQRT_BASE;
+    for (i2 = ycL; --i2 >= 0; ) {
+      c2 = 0;
+      ylo = yc[i2] % sqrtBase;
+      yhi = yc[i2] / sqrtBase | 0;
+      for (k = xcL, j = i2 + k; j > i2; ) {
+        xlo = xc[--k] % sqrtBase;
+        xhi = xc[k] / sqrtBase | 0;
+        m = yhi * xlo + xhi * ylo;
+        xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c2;
+        c2 = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
+        zc[j--] = xlo % base;
+      }
+      zc[j] = c2;
+    }
+    if (c2) {
+      ++e;
+    } else {
+      zc.splice(0, 1);
+    }
+    return normalise(y, zc, e);
+  };
+  P2.negated = function() {
+    var x = new BigNumber2(this);
+    x.s = -x.s || null;
+    return x;
+  };
+  P2.plus = function(y, b) {
+    var t, x = this, a = x.s;
+    y = new BigNumber2(y, b);
+    b = y.s;
+    if (!a || !b) return new BigNumber2(NaN);
+    if (a != b) {
+      y.s = -b;
+      return x.minus(y);
+    }
+    var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+    if (!xe || !ye) {
+      if (!xc || !yc) return new BigNumber2(a / 0);
+      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber2(xc[0] ? x : a * 0);
+    }
+    xe = bitFloor(xe);
+    ye = bitFloor(ye);
+    xc = xc.slice();
+    if (a = xe - ye) {
+      if (a > 0) {
+        ye = xe;
+        t = yc;
+      } else {
+        a = -a;
+        t = xc;
+      }
+      t.reverse();
+      for (; a--; t.push(0)) ;
+      t.reverse();
+    }
+    a = xc.length;
+    b = yc.length;
+    if (a - b < 0) {
+      t = yc;
+      yc = xc;
+      xc = t;
+      b = a;
+    }
+    for (a = 0; b; ) {
+      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
+      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+    }
+    if (a) {
+      xc = [a].concat(xc);
+      ++ye;
+    }
+    return normalise(y, xc, ye);
+  };
+  P2.precision = P2.sd = function(sd, rm) {
+    var c2, n, v, x = this;
+    if (sd != null && sd !== !!sd) {
+      intCheck(sd, 1, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+      return round(new BigNumber2(x), sd, rm);
+    }
+    if (!(c2 = x.c)) return null;
+    v = c2.length - 1;
+    n = v * LOG_BASE + 1;
+    if (v = c2[v]) {
+      for (; v % 10 == 0; v /= 10, n--) ;
+      for (v = c2[0]; v >= 10; v /= 10, n++) ;
+    }
+    if (sd && x.e + 1 > n) n = x.e + 1;
+    return n;
+  };
+  P2.shiftedBy = function(k) {
+    intCheck(k, -MAX_SAFE_INTEGER$2, MAX_SAFE_INTEGER$2);
+    return this.times("1e" + k);
+  };
+  P2.squareRoot = P2.sqrt = function() {
+    var m, n, r, rep, t, x = this, c2 = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
+    if (s !== 1 || !c2 || !c2[0]) {
+      return new BigNumber2(!s || s < 0 && (!c2 || c2[0]) ? NaN : c2 ? x : 1 / 0);
+    }
+    s = Math.sqrt(+valueOf(x));
+    if (s == 0 || s == 1 / 0) {
+      n = coeffToString(c2);
+      if ((n.length + e) % 2 == 0) n += "0";
+      s = Math.sqrt(+n);
+      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
+      if (s == 1 / 0) {
+        n = "5e" + e;
+      } else {
+        n = s.toExponential();
+        n = n.slice(0, n.indexOf("e") + 1) + e;
+      }
+      r = new BigNumber2(n);
+    } else {
+      r = new BigNumber2(s + "");
+    }
+    if (r.c[0]) {
+      e = r.e;
+      s = e + dp;
+      if (s < 3) s = 0;
+      for (; ; ) {
+        t = r;
+        r = half.times(t.plus(div(x, t, dp, 1)));
+        if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {
+          if (r.e < e) --s;
+          n = n.slice(s - 3, s + 1);
+          if (n == "9999" || !rep && n == "4999") {
+            if (!rep) {
+              round(t, t.e + DECIMAL_PLACES + 2, 0);
+              if (t.times(t).eq(x)) {
+                r = t;
+                break;
+              }
+            }
+            dp += 4;
+            s += 4;
+            rep = 1;
+          } else {
+            if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
+              round(r, r.e + DECIMAL_PLACES + 2, 1);
+              m = !r.times(r).eq(x);
+            }
+            break;
+          }
+        }
+      }
+    }
+    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+  };
+  P2.toExponential = function(dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp++;
+    }
+    return format2(this, dp, rm, 1);
+  };
+  P2.toFixed = function(dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp = dp + this.e + 1;
+    }
+    return format2(this, dp, rm);
+  };
+  P2.toFormat = function(dp, rm, format3) {
+    var str, x = this;
+    if (format3 == null) {
+      if (dp != null && rm && typeof rm == "object") {
+        format3 = rm;
+        rm = null;
+      } else if (dp && typeof dp == "object") {
+        format3 = dp;
+        dp = rm = null;
+      } else {
+        format3 = FORMAT;
+      }
+    } else if (typeof format3 != "object") {
+      throw Error(bignumberError + "Argument not an object: " + format3);
+    }
+    str = x.toFixed(dp, rm);
+    if (x.c) {
+      var i2, arr = str.split("."), g1 = +format3.groupSize, g2 = +format3.secondaryGroupSize, groupSeparator = format3.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
+      if (g2) {
+        i2 = g1;
+        g1 = g2;
+        g2 = i2;
+        len -= i2;
+      }
+      if (g1 > 0 && len > 0) {
+        i2 = len % g1 || g1;
+        intPart = intDigits.substr(0, i2);
+        for (; i2 < len; i2 += g1) intPart += groupSeparator + intDigits.substr(i2, g1);
+        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i2);
+        if (isNeg) intPart = "-" + intPart;
+      }
+      str = fractionPart ? intPart + (format3.decimalSeparator || "") + ((g2 = +format3.fractionGroupSize) ? fractionPart.replace(
+        new RegExp("\\d{" + g2 + "}\\B", "g"),
+        "$&" + (format3.fractionGroupSeparator || "")
+      ) : fractionPart) : intPart;
+    }
+    return (format3.prefix || "") + str + (format3.suffix || "");
+  };
+  P2.toFraction = function(md) {
+    var d, d0, d1, d2, e, exp, n, n0, n1, q2, r, s, x = this, xc = x.c;
+    if (md != null) {
+      n = new BigNumber2(md);
+      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
+        throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
+      }
+    }
+    if (!xc) return new BigNumber2(x);
+    d = new BigNumber2(ONE);
+    n1 = d0 = new BigNumber2(ONE);
+    d1 = n0 = new BigNumber2(ONE);
+    s = coeffToString(xc);
+    e = d.e = s.length - x.e - 1;
+    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
+    md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;
+    exp = MAX_EXP;
+    MAX_EXP = 1 / 0;
+    n = new BigNumber2(s);
+    n0.c[0] = 0;
+    for (; ; ) {
+      q2 = div(n, d, 0, 1);
+      d2 = d0.plus(q2.times(d1));
+      if (d2.comparedTo(md) == 1) break;
+      d0 = d1;
+      d1 = d2;
+      n1 = n0.plus(q2.times(d2 = n1));
+      n0 = d2;
+      d = n.minus(q2.times(d2 = d));
+      n = d2;
+    }
+    d2 = div(md.minus(d0), d1, 0, 1);
+    n0 = n0.plus(d2.times(n1));
+    d0 = d0.plus(d2.times(d1));
+    n0.s = n1.s = x.s;
+    e = e * 2;
+    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+      div(n0, d0, e, ROUNDING_MODE).minus(x).abs()
+    ) < 1 ? [n1, d1] : [n0, d0];
+    MAX_EXP = exp;
+    return r;
+  };
+  P2.toNumber = function() {
+    return +valueOf(this);
+  };
+  P2.toPrecision = function(sd, rm) {
+    if (sd != null) intCheck(sd, 1, MAX);
+    return format2(this, sd, rm, 2);
+  };
+  P2.toString = function(b) {
+    var str, n = this, s = n.s, e = n.e;
+    if (e === null) {
+      if (s) {
+        str = "Infinity";
+        if (s < 0) str = "-" + str;
+      } else {
+        str = "NaN";
+      }
+    } else {
+      if (b == null) {
+        str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
+      } else if (b === 10 && alphabetHasNormalDecimalDigits) {
+        n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+        str = toFixedPoint(coeffToString(n.c), n.e, "0");
+      } else {
+        intCheck(b, 2, ALPHABET.length, "Base");
+        str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, true);
+      }
+      if (s < 0 && n.c[0]) str = "-" + str;
+    }
+    return str;
+  };
+  P2.valueOf = P2.toJSON = function() {
+    return valueOf(this);
+  };
+  P2._isBigNumber = true;
+  P2[Symbol.toStringTag] = "BigNumber";
+  P2[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = P2.valueOf;
+  if (configObject != null) BigNumber2.set(configObject);
+  return BigNumber2;
+}
+function bitFloor(n) {
+  var i2 = n | 0;
+  return n > 0 || n === i2 ? i2 : i2 - 1;
+}
+function coeffToString(a) {
+  var s, z, i2 = 1, j = a.length, r = a[0] + "";
+  for (; i2 < j; ) {
+    s = a[i2++] + "";
+    z = LOG_BASE - s.length;
+    for (; z--; s = "0" + s) ;
+    r += s;
+  }
+  for (j = r.length; r.charCodeAt(--j) === 48; ) ;
+  return r.slice(0, j + 1 || 1);
+}
+function compare(x, y) {
+  var a, b, xc = x.c, yc = y.c, i2 = x.s, j = y.s, k = x.e, l = y.e;
+  if (!i2 || !j) return null;
+  a = xc && !xc[0];
+  b = yc && !yc[0];
+  if (a || b) return a ? b ? 0 : -j : i2;
+  if (i2 != j) return i2;
+  a = i2 < 0;
+  b = k == l;
+  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
+  if (!b) return k > l ^ a ? 1 : -1;
+  j = (k = xc.length) < (l = yc.length) ? k : l;
+  for (i2 = 0; i2 < j; i2++) if (xc[i2] != yc[i2]) return xc[i2] > yc[i2] ^ a ? 1 : -1;
+  return k == l ? 0 : k > l ^ a ? 1 : -1;
+}
+function intCheck(n, min, max, name2) {
+  if (n < min || n > max || n !== mathfloor(n)) {
+    throw Error(bignumberError + (name2 || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
+  }
+}
+function isOdd(n) {
+  var k = n.c.length - 1;
+  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+}
+function toExponential(str, e) {
+  return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
+}
+function toFixedPoint(str, e, z) {
+  var len, zs;
+  if (e < 0) {
+    for (zs = z + "."; ++e; zs += z) ;
+    str = zs + str;
+  } else {
+    len = str.length;
+    if (++e > len) {
+      for (zs = z, e -= len; --e; zs += z) ;
+      str += zs;
+    } else if (e < len) {
+      str = str.slice(0, e) + "." + str.slice(e);
+    }
+  }
+  return str;
+}
+var BigNumber = clone();
 const isEmptyValue$1 = (value) => {
   return value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
 };
@@ -62390,6 +63721,13 @@ function isReferenceOptionActive(referenceInfo, rowFormData) {
     rowFormData
   );
 }
+const MAX_NUMERIC_DIGITS = 15;
+const NUMERIC_FIELD_TYPES = /* @__PURE__ */ new Set([
+  FIELD_TYPE.INTEGER,
+  FIELD_TYPE.LONG,
+  FIELD_TYPE.DOUBLE,
+  FIELD_TYPE.DECIMAL
+]);
 function filterRulesByTrigger(rules2, trigger) {
   return rules2.filter((rule) => {
     const ruleTrigger = rule.trigger;
@@ -62445,12 +63783,13 @@ function assembleRules(input) {
       }, buildError(validatorInfo, $t("sys.fieldLengthNotLessThan", { len: minlength })))
     );
   }
-  if (!isNil(maxlength)) {
+  const effectiveMaxlength = isNil(maxlength) && fieldType === FIELD_TYPE.TEXT ? 1024 : maxlength;
+  if (!isNil(effectiveMaxlength)) {
     RuleProps.push(
       createRule((_rule, value) => {
         if (isEmptyValue$1(value)) return true;
-        return String(value).length <= maxlength;
-      }, buildError(validatorInfo, $t("sys.fieldLengthNoMoreThan", { len: maxlength })))
+        return String(value).length <= effectiveMaxlength;
+      }, buildError(validatorInfo, $t("sys.fieldLengthNoMoreThan", { len: effectiveMaxlength })))
     );
   }
   if (regex) {
@@ -62477,6 +63816,19 @@ function assembleRules(input) {
       message: buildError(validatorInfo, $t("sys.fieldValueNeedFalse"))
     });
   }
+  const maxMode = maxValidateMode ?? RangeValidateMode.No_Validate;
+  const minMode = minValidateMode ?? RangeValidateMode.No_Validate;
+  const shouldValidateNumericLength = !enableRangeValidate || maxMode === RangeValidateMode.No_Validate || minMode === RangeValidateMode.No_Validate;
+  if (shouldValidateNumericLength && NUMERIC_FIELD_TYPES.has(fieldType ?? "")) {
+    RuleProps.push(
+      createRule((_rule, value) => {
+        if (isEmptyValue$1(value)) return true;
+        const raw = String(value).trim();
+        const text = /e/i.test(raw) ? new BigNumber(raw).toFixed() : raw;
+        return text.replace(/[+\-.]/g, "").length <= MAX_NUMERIC_DIGITS;
+      }, buildError(validatorInfo, $t("sys.fieldNumericDigitsNoMoreThan")))
+    );
+  }
   if (!enableRangeValidate) {
     return RuleProps;
   }
@@ -63554,7 +64906,7 @@ function newMessages() {
     pattern: {
       mismatch: "%s value %s does not match pattern %s"
     },
-    clone: function clone() {
+    clone: function clone2() {
       var cloned = JSON.parse(JSON.stringify(this));
       cloned.clone = this.clone;
       return cloned;
@@ -67867,27 +69219,27 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
       case "revo-grid":
         return import(
           /* webpackMode: "lazy" */
-          "./revo-grid.entry-ByZf-Mkh.js"
+          "./revo-grid.entry-DyC3Ie1V.js"
         ).then(processMod, consoleError);
       case "revogr-filter-panel":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-filter-panel.entry-CUJGzSbz.js"
+          "./revogr-filter-panel.entry-B6YKEctL.js"
         ).then(processMod, consoleError);
       case "revogr-attribution_7":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-attribution_7.entry-Bkbb15P7.js"
+          "./revogr-attribution_7.entry-BX3LvtVl.js"
         ).then(processMod, consoleError);
       case "revogr-clipboard_3":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-clipboard_3.entry-BAsnJv1y.js"
+          "./revogr-clipboard_3.entry-CIsl8Vf6.js"
         ).then(processMod, consoleError);
       case "revogr-data_4":
         return import(
           /* webpackMode: "lazy" */
-          "./revogr-data_4.entry-Cpmztqm8.js"
+          "./revogr-data_4.entry-DZN_LFSr.js"
         ).then(processMod, consoleError);
     }
   }
@@ -78152,7 +79504,7 @@ export {
   PlatformEnum as Z,
   LabelPosition as _,
   isSameFieldValue as a,
-  useNocodeFormWidget as a$,
+  validateReinspectionDate as a$,
   SignatureNumberTypeEnum as a0,
   SignatureTimeTypeEnum as a1,
   SignShowTypeEnum as a2,
@@ -78163,312 +79515,313 @@ export {
   buildUUID as a7,
   FieldIconMap as a8,
   normalizeFieldType as a9,
-  getSubTableTypeByRefModelType as aA,
-  EmptySymbol as aB,
-  ASSIGNMENTSTRATEGY_ENUM as aC,
-  Dependency_ENUM as aD,
-  EntityModelCategoryEnum as aE,
-  resolveLotDisplayLabel as aF,
-  CheckDsTypeEnum as aG,
-  DeviceLink as aH,
-  DeviceParamsTypeTitle as aI,
-  AITooltips as aJ,
-  DenoiseMethodOptions as aK,
-  BinarizeMethodOptions as aL,
-  ParamModelTypeEnum as aM,
-  JoinModelTypeEum as aN,
-  sqlUtils as aO,
-  useWidgetStaticAttrs as aP,
-  setSelectValidatorId as aQ,
-  setSelectAnnotationId as aR,
-  DateFormat as aS,
-  LOT_CONTAINER_ROLE as aT,
-  buildLotSnListQuery as aU,
-  renderUtils as aV,
-  NCB_PROVIDE as aW,
-  resolveLotRecordByValue as aX,
-  materialCheck as aY,
-  getLotLockedReason as aZ,
-  validateReinspectionDate as a_,
-  FieldSysVarDefaultValueEnum as aa,
-  CellWidgetViewState as ab,
-  DiagonalDirection as ac,
-  WidgetImageSizeMode as ad,
-  LineDirection as ae,
-  TimeDiffFormat as af,
-  DiagonalVertex as ag,
-  resolveDiagonalVertex as ah,
-  getThemeColorByTableType as ai,
-  ViewTypeEnum as aj,
-  useThrottleFn as ak,
-  noop as al,
-  isIOS as am,
-  isDynamicSubTablePanelType as an,
-  isFixedSubTablePanelType as ao,
-  ExpressionModeEnum as ap,
-  ReturnTypeEnum as aq,
-  ExpressionTabEnum as ar,
-  RangeValidateMode as as,
-  RangeCompareOp as at,
-  DecimalDisplayMode as au,
-  ImageDisplayModeEnum as av,
-  FormDesignEnum as aw,
-  BASIC_FIELD_TYPES as ax,
-  watchDebounced as ay,
-  getExclusiveBusinessTypeTokens as az,
+  getExclusiveBusinessTypeTokens as aA,
+  getSubTableTypeByRefModelType as aB,
+  EmptySymbol as aC,
+  ASSIGNMENTSTRATEGY_ENUM as aD,
+  Dependency_ENUM as aE,
+  EntityModelCategoryEnum as aF,
+  resolveLotDisplayLabel as aG,
+  CheckDsTypeEnum as aH,
+  DeviceLink as aI,
+  DeviceParamsTypeTitle as aJ,
+  AITooltips as aK,
+  DenoiseMethodOptions as aL,
+  BinarizeMethodOptions as aM,
+  ParamModelTypeEnum as aN,
+  JoinModelTypeEum as aO,
+  sqlUtils as aP,
+  useWidgetStaticAttrs as aQ,
+  setSelectValidatorId as aR,
+  setSelectAnnotationId as aS,
+  DateFormat as aT,
+  LOT_CONTAINER_ROLE as aU,
+  buildLotSnListQuery as aV,
+  renderUtils as aW,
+  NCB_PROVIDE as aX,
+  resolveLotRecordByValue as aY,
+  materialCheck as aZ,
+  getLotLockedReason as a_,
+  BigNumber as aa,
+  FieldSysVarDefaultValueEnum as ab,
+  CellWidgetViewState as ac,
+  DiagonalDirection as ad,
+  WidgetImageSizeMode as ae,
+  LineDirection as af,
+  TimeDiffFormat as ag,
+  DiagonalVertex as ah,
+  resolveDiagonalVertex as ai,
+  getThemeColorByTableType as aj,
+  ViewTypeEnum as ak,
+  useThrottleFn as al,
+  noop as am,
+  isIOS as an,
+  isDynamicSubTablePanelType as ao,
+  isFixedSubTablePanelType as ap,
+  ExpressionModeEnum as aq,
+  ReturnTypeEnum as ar,
+  ExpressionTabEnum as as,
+  RangeValidateMode as at,
+  RangeCompareOp as au,
+  DecimalDisplayMode as av,
+  ImageDisplayModeEnum as aw,
+  FormDesignEnum as ax,
+  BASIC_FIELD_TYPES as ay,
+  watchDebounced as az,
   companionLabelKey as b,
-  clearFormRules as b$,
-  BindCmpStyleEnum as b0,
-  getParseRuleInfo as b1,
-  getParseRuleValue as b2,
-  useCurrentPageFormState as b3,
-  STOCKTAKE_DIMENSION as b4,
-  F$5 as b5,
-  resolveStocktakeSelectApi as b6,
-  normalizeRefLoaderResult as b7,
-  normalizeProductionContainerOptions as b8,
-  buildProductionLotListQuery as b9,
-  FILL_FROM_INVENTORY_OPTION$1 as bA,
-  INVENTORY_BASE_FIELDS as bB,
-  resolveGroupByWarehouse as bC,
-  AUTO_LOAD_READONLY_SELECT_FIELDS as bD,
-  buildFillFromInventoryOption as bE,
-  calcFillData as bF,
-  resolveStocktakeInventoryApi as bG,
-  F$2 as bH,
-  FILL_FROM_INVENTORY_OPTION as bI,
-  extractKeywordFromQueryData as bJ,
-  composeProductionLotListQuery as bK,
-  F as bL,
-  isProductManuallyEditable as bM,
-  applyFillFromMfgOrderOption as bN,
-  applyFillFromOption as bO,
-  applyFillFromProductOption as bP,
-  MATERIAL_CONTAINER_ID as bQ,
-  F$9 as bR,
-  PRODUCT_QUICK_SEARCH_FIELDS as bS,
-  PRODUCT_QUICK_SEARCH_EXP as bT,
-  isProductManuallyEditable$1 as bU,
-  applyFillFromMaterialNoOption as bV,
-  applyFillFromProductOption$1 as bW,
-  F$8 as bX,
-  FILL_FROM_INVENTORY_OPTION$4 as bY,
-  settleAndValidateDisplay as bZ,
-  unregisterValidationContext as b_,
-  refUtils as ba,
-  transformUtils as bb,
-  buildDeviceFilterQuery as bc,
-  DEVICE_GROUP_QUERY_KEY as bd,
-  useOnlineFormTransformField2Component as be,
-  RenderModeEnum as bf,
-  useDependency as bg,
-  FormulaRuleFieldKeyEnum as bh,
-  formulaRuleFieldDict as bi,
-  resolveDesignPanelFeatures as bj,
-  BIZ_TABLE_CONFIG_SEED_TYPES as bk,
-  STOCKTAKE_DIMENSION_OPTIONS as bl,
-  getAllTableProfiles as bm,
-  isRepeatingSubTablePanelType as bn,
-  useNocodeEmitter as bo,
-  fetchHistoryConsume as bp,
-  isBomGranted as bq,
-  F$3 as br,
-  F$4 as bs,
-  runRowHandler as bt,
-  F$7 as bu,
-  F$6 as bv,
-  FILL_FROM_INVENTORY_OPTION$2 as bw,
-  FILL_FROM_PART_OPTION as bx,
-  FILL_FROM_INVENTORY_OPTION$3 as by,
-  TABLE_TYPE$8 as bz,
+  unregisterValidationContext as b$,
+  useNocodeFormWidget as b0,
+  BindCmpStyleEnum as b1,
+  getParseRuleInfo as b2,
+  getParseRuleValue as b3,
+  useCurrentPageFormState as b4,
+  STOCKTAKE_DIMENSION as b5,
+  F$5 as b6,
+  resolveStocktakeSelectApi as b7,
+  normalizeRefLoaderResult as b8,
+  normalizeProductionContainerOptions as b9,
+  TABLE_TYPE$8 as bA,
+  FILL_FROM_INVENTORY_OPTION$1 as bB,
+  INVENTORY_BASE_FIELDS as bC,
+  resolveGroupByWarehouse as bD,
+  AUTO_LOAD_READONLY_SELECT_FIELDS as bE,
+  buildFillFromInventoryOption as bF,
+  calcFillData as bG,
+  resolveStocktakeInventoryApi as bH,
+  F$2 as bI,
+  FILL_FROM_INVENTORY_OPTION as bJ,
+  extractKeywordFromQueryData as bK,
+  composeProductionLotListQuery as bL,
+  F as bM,
+  isProductManuallyEditable as bN,
+  applyFillFromMfgOrderOption as bO,
+  applyFillFromOption as bP,
+  applyFillFromProductOption as bQ,
+  MATERIAL_CONTAINER_ID as bR,
+  F$9 as bS,
+  PRODUCT_QUICK_SEARCH_FIELDS as bT,
+  PRODUCT_QUICK_SEARCH_EXP as bU,
+  isProductManuallyEditable$1 as bV,
+  applyFillFromMaterialNoOption as bW,
+  applyFillFromProductOption$1 as bX,
+  F$8 as bY,
+  FILL_FROM_INVENTORY_OPTION$4 as bZ,
+  settleAndValidateDisplay as b_,
+  buildProductionLotListQuery as ba,
+  refUtils as bb,
+  transformUtils as bc,
+  buildDeviceFilterQuery as bd,
+  DEVICE_GROUP_QUERY_KEY as be,
+  useOnlineFormTransformField2Component as bf,
+  RenderModeEnum as bg,
+  useDependency as bh,
+  FormulaRuleFieldKeyEnum as bi,
+  formulaRuleFieldDict as bj,
+  resolveDesignPanelFeatures as bk,
+  BIZ_TABLE_CONFIG_SEED_TYPES as bl,
+  STOCKTAKE_DIMENSION_OPTIONS as bm,
+  getAllTableProfiles as bn,
+  isRepeatingSubTablePanelType as bo,
+  useNocodeEmitter as bp,
+  fetchHistoryConsume as bq,
+  isBomGranted as br,
+  F$3 as bs,
+  F$4 as bt,
+  runRowHandler as bu,
+  F$7 as bv,
+  F$6 as bw,
+  FILL_FROM_INVENTORY_OPTION$2 as bx,
+  FILL_FROM_PART_OPTION as by,
+  FILL_FROM_INVENTORY_OPTION$3 as bz,
   companionIdKey as c,
-  recordSubtableRowDelete as c$,
-  registerValidationContext as c0,
-  requestFullValidation as c1,
-  requestDisplayValidation as c2,
-  closeValidatorPopovers as c3,
-  baseDataUtils as c4,
-  getRawFormRuleMeta as c5,
-  enrichFormChangeRowDetails as c6,
-  settleAfterModeSwitch as c7,
-  calcUtils as c8,
-  uuid2$1 as c9,
-  buildStableFieldLocation as cA,
-  deleteSubtableRow as cB,
-  detailsHaveFormChangeRowOps as cC,
-  extractFormChangeRowDetails as cD,
-  fetchCheckDsDataForTable as cE,
-  fetchCustomCheckDsData as cF,
-  fetchMedProCheckDsData as cG,
-  getCheckTableSnapshotKey as cH,
-  getFormChangeRowKey as cI,
-  getFormChangeRowOp as cJ,
-  getParseRuleConfig as cK,
-  getReinspectionDate as cL,
-  getSubTableQuickFillInfo as cM,
-  handleOldConfig as cN,
-  hasAnyCheckTableSnapshot as cO,
-  hasByTableCheckTableSnapshot as cP,
-  hasSharedCheckTableSnapshot as cQ,
-  insertSubtableRows as cR,
-  isAnnLocationSelected as cS,
-  isFormChangeGhostRow as cT,
-  isMedProSuite as cU,
-  isRowAddedInCurrentFormChange as cV,
-  jsonSchemaUtils as cW,
-  judgeUnique as cX,
-  migrateDiagonalDirectionToVertex as cY,
-  parseFrontConfig as cZ,
-  recordSubtableRowAdd as c_,
-  normalizeToArray as ca,
-  safeParseArray as cb,
-  BpmnNodeTypeEnum as cc,
-  mergeByMultiKey as cd,
-  commonUtils as ce,
-  getRowId as cf,
-  collectFormChangeFieldLocations as cg,
-  nextFormChangeRowViewHistoryId as ch,
-  BpmnSignatureTypeEnum as ci,
-  ButtonTypeEnum as cj,
-  CHECK_TABLE_MEDPRO_PROTOCOL_KEY as ck,
-  CodeRunner as cl,
-  Config_Fields as cm,
-  ControlStatusEnum as cn,
-  DEVICE_SEARCH_API as co,
-  DeviceStatus as cp,
-  EBR_PROVIDE_ENUM as cq,
-  EFieldBizTypeEnum as cr,
-  MobileFillTypeEnum as cs,
-  OfficeTypeEnum as ct,
-  PosEnum as cu,
-  SummaryApproveHisTypeEnum as cv,
-  applyCheckDsDataToRuntime as cw,
-  applyMedProCheckDsDataToRuntime as cx,
-  buildDeviceBaseQuery as cy,
-  buildFormChangeDisplayRows as cz,
+  recordSubtableRowAdd as c$,
+  clearFormRules as c0,
+  registerValidationContext as c1,
+  requestFullValidation as c2,
+  requestDisplayValidation as c3,
+  closeValidatorPopovers as c4,
+  baseDataUtils as c5,
+  getRawFormRuleMeta as c6,
+  enrichFormChangeRowDetails as c7,
+  settleAfterModeSwitch as c8,
+  calcUtils as c9,
+  buildFormChangeDisplayRows as cA,
+  buildStableFieldLocation as cB,
+  deleteSubtableRow as cC,
+  detailsHaveFormChangeRowOps as cD,
+  extractFormChangeRowDetails as cE,
+  fetchCheckDsDataForTable as cF,
+  fetchCustomCheckDsData as cG,
+  fetchMedProCheckDsData as cH,
+  getCheckTableSnapshotKey as cI,
+  getFormChangeRowKey as cJ,
+  getFormChangeRowOp as cK,
+  getParseRuleConfig as cL,
+  getReinspectionDate as cM,
+  getSubTableQuickFillInfo as cN,
+  handleOldConfig as cO,
+  hasAnyCheckTableSnapshot as cP,
+  hasByTableCheckTableSnapshot as cQ,
+  hasSharedCheckTableSnapshot as cR,
+  insertSubtableRows as cS,
+  isAnnLocationSelected as cT,
+  isFormChangeGhostRow as cU,
+  isMedProSuite as cV,
+  isRowAddedInCurrentFormChange as cW,
+  jsonSchemaUtils as cX,
+  judgeUnique as cY,
+  migrateDiagonalDirectionToVertex as cZ,
+  parseFrontConfig as c_,
+  uuid2$1 as ca,
+  normalizeToArray as cb,
+  safeParseArray as cc,
+  BpmnNodeTypeEnum as cd,
+  mergeByMultiKey as ce,
+  commonUtils as cf,
+  getRowId as cg,
+  collectFormChangeFieldLocations as ch,
+  nextFormChangeRowViewHistoryId as ci,
+  BpmnSignatureTypeEnum as cj,
+  ButtonTypeEnum as ck,
+  CHECK_TABLE_MEDPRO_PROTOCOL_KEY as cl,
+  CodeRunner as cm,
+  Config_Fields as cn,
+  ControlStatusEnum as co,
+  DEVICE_SEARCH_API as cp,
+  DeviceStatus as cq,
+  EBR_PROVIDE_ENUM as cr,
+  EFieldBizTypeEnum as cs,
+  MobileFillTypeEnum as ct,
+  OfficeTypeEnum as cu,
+  PosEnum as cv,
+  SummaryApproveHisTypeEnum as cw,
+  applyCheckDsDataToRuntime as cx,
+  applyMedProCheckDsDataToRuntime as cy,
+  buildDeviceBaseQuery as cz,
   isDataTableProfile as d,
-  DataStore as d$,
-  relocateDeletedRowsToEnd as d0,
-  requestMedProCheckDsData as d1,
-  requestNonMedProCheckDsData as d2,
-  resolveAnnotationFieldLocation as d3,
-  resolveFormChangeRowUi as d4,
-  resolveRowFormChangeMark as d5,
-  setSelectMobileTdId as d6,
-  stockCheck as d7,
-  useOnlineFormActionButton as d8,
-  assembleRules as d9,
-  createEvent as dA,
-  getColumnByProp as dB,
-  timeout as dC,
-  getVisibleSourceItem as dD,
-  getColumns as dE,
-  rowTypes as dF,
-  GroupingRowPlugin as dG,
-  StretchColumn as dH,
-  isStretchPlugin as dI,
-  AutoSizeColumnPlugin as dJ,
-  FilterPlugin as dK,
-  ExportFilePlugin as dL,
-  SortingPlugin as dM,
-  ColumnMovePlugin as dN,
-  ThemeService as dO,
-  h as dP,
-  Host as dQ,
-  getElement as dR,
-  BasePlugin as dS,
-  reduce as dT,
-  columnTypes as dU,
-  debounce$1 as dV,
-  RESIZE_INTERVAL as dW,
-  DimensionStore as dX,
-  gatherTrimmedItems as dY,
-  getColumnSizes as dZ,
-  getItemByIndex as d_,
-  deleteFormRule as da,
-  setFormRule as db,
-  isReferenceOptionActive as dc,
-  validateAllFields as dd,
-  runValidation as de,
-  ensureFrontRowKey as df,
-  FRONT_ROW_KEY as dg,
-  buildError as dh,
-  q as di,
-  groupFixedTableRows as dj,
-  QUICK_FILL_ALLOWED_FIELDS as dk,
-  processQuickFillRows as dl,
-  getIsGroupEmpty as dm,
-  tryOnScopeDispose as dn,
-  isClient as dp,
-  tryOnMounted as dq,
-  resolveUnref as dr,
-  isString as ds,
-  identity$1 as dt,
-  getAugmentedNamespace as du,
-  CardControlEnum as dv,
-  EntityModelTypeEnum as dw,
-  RecordNoGenerateEnum as dx,
-  TagTypeEnum as dy,
-  registerInstance as dz,
+  getItemByIndex as d$,
+  recordSubtableRowDelete as d0,
+  relocateDeletedRowsToEnd as d1,
+  requestMedProCheckDsData as d2,
+  requestNonMedProCheckDsData as d3,
+  resolveAnnotationFieldLocation as d4,
+  resolveFormChangeRowUi as d5,
+  resolveRowFormChangeMark as d6,
+  setSelectMobileTdId as d7,
+  stockCheck as d8,
+  useOnlineFormActionButton as d9,
+  registerInstance as dA,
+  createEvent as dB,
+  getColumnByProp as dC,
+  timeout as dD,
+  getVisibleSourceItem as dE,
+  getColumns as dF,
+  rowTypes as dG,
+  GroupingRowPlugin as dH,
+  StretchColumn as dI,
+  isStretchPlugin as dJ,
+  AutoSizeColumnPlugin as dK,
+  FilterPlugin as dL,
+  ExportFilePlugin as dM,
+  SortingPlugin as dN,
+  ColumnMovePlugin as dO,
+  ThemeService as dP,
+  h as dQ,
+  Host as dR,
+  getElement as dS,
+  BasePlugin as dT,
+  reduce as dU,
+  columnTypes as dV,
+  debounce$1 as dW,
+  RESIZE_INTERVAL as dX,
+  DimensionStore as dY,
+  gatherTrimmedItems as dZ,
+  getColumnSizes as d_,
+  assembleRules as da,
+  deleteFormRule as db,
+  setFormRule as dc,
+  isReferenceOptionActive as dd,
+  validateAllFields as de,
+  runValidation as df,
+  ensureFrontRowKey as dg,
+  FRONT_ROW_KEY as dh,
+  buildError as di,
+  q as dj,
+  groupFixedTableRows as dk,
+  QUICK_FILL_ALLOWED_FIELDS as dl,
+  processQuickFillRows as dm,
+  getIsGroupEmpty as dn,
+  tryOnScopeDispose as dp,
+  isClient as dq,
+  tryOnMounted as dr,
+  resolveUnref as ds,
+  isString as dt,
+  identity$1 as du,
+  getAugmentedNamespace as dv,
+  CardControlEnum as dw,
+  EntityModelTypeEnum as dx,
+  RecordNoGenerateEnum as dy,
+  TagTypeEnum as dz,
   getProfile as e,
-  getSourceItem as e0,
-  getSourceItemVirtualIndexByProp as e1,
-  getColumnType as e2,
-  setSourceByPhysicalIndex as e3,
-  setSourceByVirtualIndex as e4,
-  SelectionStore as e5,
-  cropCellToMax as e6,
-  nextCell as e7,
-  isRowType as e8,
-  ViewportStore as e9,
-  GROUP_EXPAND_BTN as eA,
-  DATA_ROW as eB,
-  isGroupingColumn as eC,
-  GROUP_COLUMN_PROP as eD,
-  getCellRaw as eE,
-  DATA_COL as eF,
-  CELL_CLASS as eG,
-  Build as eH,
-  isRowDragService as eI,
-  DRAG_ICON_CLASS as eJ,
-  DRAGGABLE_CLASS as eK,
-  getCellDataParsed as eL,
-  GROUP_EXPAND_EVENT as eM,
-  isGrouping as eN,
-  HEADER_ROW_CLASS as eO,
-  HEADER_ACTUAL_ROW_CLASS as eP,
-  ROW_FOCUSED_CLASS as eQ,
-  HEADER_SORTABLE_CLASS as eR,
-  MIN_COL_SIZE as eS,
-  FilterButton as eT,
-  HeaderCellRenderer as eU,
-  HEADER_CLASS as eV,
-  AndOrButton as ea,
-  ReorderButton as eb,
-  TrashButton as ec,
-  isFilterBtn as ed,
-  ColumnService as ee,
-  MOBILE_CLASS as ef,
-  SELECTION_BORDER_CLASS as eg,
-  getCellData as eh,
-  getCellEditor as ei,
-  getRange as ej,
-  isRangeSingleCell as ek,
-  codesLetter as el,
-  calculateRowHeaderSize as em,
-  ROW_HEADER_TYPE as en,
-  getScrollbarSize as eo,
-  FOCUS_CLASS as ep,
-  CELL_HANDLER_CLASS as eq,
-  TMP_SELECTION_BG_CLASS as er,
-  getItemByPosition as es,
-  EDIT_INPUT_WR as et,
-  keyValues as eu,
-  isObject as ev,
-  DRAGG_TEXT as ew,
-  PSEUDO_GROUP_ITEM as ex,
-  GROUP_EXPANDED as ey,
-  GROUP_DEPTH as ez,
+  DataStore as e0,
+  getSourceItem as e1,
+  getSourceItemVirtualIndexByProp as e2,
+  getColumnType as e3,
+  setSourceByPhysicalIndex as e4,
+  setSourceByVirtualIndex as e5,
+  SelectionStore as e6,
+  cropCellToMax as e7,
+  nextCell as e8,
+  isRowType as e9,
+  GROUP_DEPTH as eA,
+  GROUP_EXPAND_BTN as eB,
+  DATA_ROW as eC,
+  isGroupingColumn as eD,
+  GROUP_COLUMN_PROP as eE,
+  getCellRaw as eF,
+  DATA_COL as eG,
+  CELL_CLASS as eH,
+  Build as eI,
+  isRowDragService as eJ,
+  DRAG_ICON_CLASS as eK,
+  DRAGGABLE_CLASS as eL,
+  getCellDataParsed as eM,
+  GROUP_EXPAND_EVENT as eN,
+  isGrouping as eO,
+  HEADER_ROW_CLASS as eP,
+  HEADER_ACTUAL_ROW_CLASS as eQ,
+  ROW_FOCUSED_CLASS as eR,
+  HEADER_SORTABLE_CLASS as eS,
+  MIN_COL_SIZE as eT,
+  FilterButton as eU,
+  HeaderCellRenderer as eV,
+  HEADER_CLASS as eW,
+  ViewportStore as ea,
+  AndOrButton as eb,
+  ReorderButton as ec,
+  TrashButton as ed,
+  isFilterBtn as ee,
+  ColumnService as ef,
+  MOBILE_CLASS as eg,
+  SELECTION_BORDER_CLASS as eh,
+  getCellData as ei,
+  getCellEditor as ej,
+  getRange as ek,
+  isRangeSingleCell as el,
+  codesLetter as em,
+  calculateRowHeaderSize as en,
+  ROW_HEADER_TYPE as eo,
+  getScrollbarSize as ep,
+  FOCUS_CLASS as eq,
+  CELL_HANDLER_CLASS as er,
+  TMP_SELECTION_BG_CLASS as es,
+  getItemByPosition as et,
+  EDIT_INPUT_WR as eu,
+  keyValues as ev,
+  isObject as ew,
+  DRAGG_TEXT as ex,
+  PSEUDO_GROUP_ITEM as ey,
+  GROUP_EXPANDED as ez,
   isBusinessSubTableProfile as f,
   getAllDataProfiles as g,
   getProfileByTableType as h,