@bpmn-io/form-js-playground 1.24.0 → 1.25.0

package/dist/form-playground.umd.js

@@ -75,13 +75,13 @@
         i = [],
         r = [],
         o = m$2({}, u);
-      o.__v = u.__v + 1, l$2.vnode && l$2.vnode(o), q$3(n.__P, o, u, n.__n, n.__P.namespaceURI, 32 & u.__u ? [t] : null, i, null == t ? $$2(u) : t, !!(32 & u.__u), r), o.__v = u.__v, o.__.__k[o.__i] = o, D$3(i, o, r), u.__e = u.__ = null, o.__e != t && P$4(o);
+      o.__v = u.__v + 1, l$2.vnode && l$2.vnode(o), q$3(n.__P, o, u, n.__n, n.__P.namespaceURI, 32 & u.__u ? [t] : null, i, null == t ? $$2(u) : t, !!(32 & u.__u), r), o.__v = u.__v, o.__.__k[o.__i] = o, D$3(i, o, r), u.__e = u.__ = null, o.__e != t && P$3(o);
     }
   }
-  function P$4(n) {
+  function P$3(n) {
     if (null != (n = n.__) && null != n.__c) return n.__e = n.__c.base = null, n.__k.some(function (l) {
       if (null != l && null != l.__e) return n.__e = n.__c.base = l.__e;
-    }), P$4(n);
+    }), P$3(n);
   }
   function A$3(n) {
     (!n.__d && (n.__d = true) && i$2.push(n) && !H$2.__r++ || r$1 != l$2.debounceRendering) && ((r$1 = l$2.debounceRendering) || o$1)(H$2);
@@ -1901,10 +1901,10 @@
   };
 
   /*
-   *  big.js v7.0.1
+   *  big.js v5.2.2
    *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
-   *  Copyright (c) 2025 Michael Mclaughlin
-   *  https://github.com/MikeMcl/big.js/LICENCE.md
+   *  Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  https://github.com/MikeMcl/big.js/LICENCE
    */
 
   /************************************** EDITABLE DEFAULTS *****************************************/
@@ -1915,7 +1915,7 @@
    * The maximum number of decimal places (DP) of the results of operations involving division:
    * div and sqrt, and pow with negative exponents.
    */
-  var DP$1 = 20,
+  var DP = 20,
     // 0 to MAX_DP
 
     /*
@@ -1926,15 +1926,15 @@
      *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
      *  3  Away from zero.                                  (ROUND_UP)
      */
-    RM$1 = 1,
+    RM = 1,
     // 0, 1, 2 or 3
 
     // The maximum value of DP and Big.DP.
-    MAX_DP$1 = 1E6,
+    MAX_DP = 1E6,
     // 0 to 1000000
 
     // The maximum magnitude of the exponent argument to the pow method.
-    MAX_POWER$1 = 1E6,
+    MAX_POWER = 1E6,
     // 1 to 1000000
 
     /*
@@ -1942,42 +1942,36 @@
      * (JavaScript numbers: -7)
      * -1000000 is the minimum recommended exponent value of a Big.
      */
-    NE$1 = -7,
+    NE = -7,
     // 0 to -1000000
 
     /*
      * The positive exponent (PE) at and above which toString returns exponential notation.
      * (JavaScript numbers: 21)
-     * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.
+     * 1000000 is the maximum recommended exponent value of a Big.
+     * (This limit is not enforced or checked.)
      */
-    PE$1 = 21,
+    PE = 21,
     // 0 to 1000000
 
-    /*
-     * When true, an error will be thrown if a primitive number is passed to the Big constructor,
-     * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a
-     * primitive number without a loss of precision.
-     */
-    STRICT$1 = false,
-    // true or false
-
     /**************************************************************************************************/
 
     // Error messages.
-    NAME$1 = '[big.js] ',
-    INVALID$4 = NAME$1 + 'Invalid ',
-    INVALID_DP$1 = INVALID$4 + 'decimal places',
-    INVALID_RM$1 = INVALID$4 + 'rounding mode',
-    DIV_BY_ZERO$1 = NAME$1 + 'Division by zero',
+    NAME = '[big.js] ',
+    INVALID$3 = NAME + 'Invalid ',
+    INVALID_DP = INVALID$3 + 'decimal places',
+    INVALID_RM = INVALID$3 + 'rounding mode',
+    DIV_BY_ZERO = NAME + 'Division by zero',
     // The shared prototype object.
-    P$3 = {},
-    UNDEFINED$1 = void 0,
-    NUMERIC$1 = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+    P$2 = {},
+    UNDEFINED = void 0,
+    NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
 
   /*
    * Create and return a Big constructor.
+   *
    */
-  function _Big_$1() {
+  function _Big_() {
     /*
      * The Big constructor and exported function.
      * Create and return a new instance of a Big number object.
@@ -1988,9 +1982,7 @@
       var x = this;
 
       // Enable constructor usage without new.
-      if (!(x instanceof Big)) {
-        return n === UNDEFINED$1 && arguments.length === 0 ? _Big_$1() : new Big(n);
-      }
+      if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);
 
       // Duplicate.
       if (n instanceof Big) {
@@ -1998,31 +1990,21 @@
         x.e = n.e;
         x.c = n.c.slice();
       } else {
-        if (typeof n !== 'string') {
-          if (Big.strict === true && typeof n !== 'bigint') {
-            throw TypeError(INVALID$4 + 'value');
-          }
-
-          // Minus zero?
-          n = n === 0 && 1 / n < 0 ? '-0' : String(n);
-        }
-        parse$2(x, n);
+        parse$1(x, n);
       }
 
-      // Retain a reference to this Big constructor.
-      // Shadow Big.prototype.constructor which points to Object.
+      /*
+       * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
+       * points to Object.
+       */
       x.constructor = Big;
     }
-    Big.prototype = P$3;
-    Big.DP = DP$1;
-    Big.RM = RM$1;
-    Big.NE = NE$1;
-    Big.PE = PE$1;
-    Big.strict = STRICT$1;
-    Big.roundDown = 0;
-    Big.roundHalfUp = 1;
-    Big.roundHalfEven = 2;
-    Big.roundUp = 3;
+    Big.prototype = P$2;
+    Big.DP = DP;
+    Big.RM = RM;
+    Big.NE = NE;
+    Big.PE = PE;
+    Big.version = '5.2.2';
     return Big;
   }
 
@@ -2032,11 +2014,11 @@
    * x {Big} A Big number instance.
    * n {number|string} A numeric value.
    */
-  function parse$2(x, n) {
+  function parse$1(x, n) {
     var e, i, nl;
-    if (!NUMERIC$1.test(n)) {
-      throw Error(INVALID$4 + 'number');
-    }
+
+    // Minus zero?
+    if (n === 0 && 1 / n < 0) n = '-0';else if (!NUMERIC.test(n += '')) throw Error(INVALID$3 + 'number');
 
     // Determine sign.
     x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;
@@ -2074,52 +2056,60 @@
   }
 
   /*
-   * Round Big x to a maximum of sd significant digits using rounding mode rm.
+   * Round Big x to a maximum of dp decimal places using rounding mode rm.
+   * Called by stringify, P.div, P.round and P.sqrt.
    *
    * x {Big} The Big to round.
-   * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.
-   * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   * dp {number} Integer, 0 to MAX_DP inclusive.
+   * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
    * [more] {boolean} Whether the result of division was truncated.
    */
-  function round$1(x, sd, rm, more) {
-    var xc = x.c;
-    if (rm === UNDEFINED$1) rm = x.constructor.RM;
-    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {
-      throw Error(INVALID_RM$1);
-    }
-    if (sd < 1) {
-      more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED$1)));
-      xc.length = 1;
-      if (more) {
-        // 1, 0.1, 0.01, 0.001, 0.0001 etc.
-        x.e = x.e - sd + 1;
-        xc[0] = 1;
+  function round(x, dp, rm, more) {
+    var xc = x.c,
+      i = x.e + dp + 1;
+    if (i < xc.length) {
+      if (rm === 1) {
+        // xc[i] is the digit after the digit that may be rounded up.
+        more = xc[i] >= 5;
+      } else if (rm === 2) {
+        more = xc[i] > 5 || xc[i] == 5 && (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);
+      } else if (rm === 3) {
+        more = more || !!xc[0];
       } else {
-        // Zero.
-        xc[0] = x.e = 0;
-      }
-    } else if (sd < xc.length) {
-      // xc[sd] is the digit after the digit that may be rounded up.
-      more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED$1 || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]);
-
-      // Remove any digits after the required precision.
-      xc.length = sd;
-
-      // Round up?
-      if (more) {
-        // Rounding up may mean the previous digit has to be rounded up.
-        for (; ++xc[--sd] > 9;) {
-          xc[sd] = 0;
-          if (sd === 0) {
-            ++x.e;
-            xc.unshift(1);
-            break;
+        more = false;
+        if (rm !== 0) throw Error(INVALID_RM);
+      }
+      if (i < 1) {
+        xc.length = 1;
+        if (more) {
+          // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+          x.e = -dp;
+          xc[0] = 1;
+        } else {
+          // Zero.
+          xc[0] = x.e = 0;
+        }
+      } else {
+        // Remove any digits after the required decimal places.
+        xc.length = i--;
+
+        // Round up?
+        if (more) {
+          // Rounding up may mean the previous digit has to be rounded up.
+          for (; ++xc[i] > 9;) {
+            xc[i] = 0;
+            if (!i--) {
+              ++x.e;
+              xc.unshift(1);
+            }
           }
         }
-      }
 
-      // Remove trailing zeros.
-      for (sd = xc.length; !xc[--sd];) xc.pop();
+        // Remove trailing zeros.
+        for (i = xc.length; !xc[--i];) xc.pop();
+      }
+    } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
+      throw Error(INVALID_RM);
     }
     return x;
   }
@@ -2127,14 +2117,45 @@
   /*
    * Return a string representing the value of Big x in normal or exponential notation.
    * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
-   */
-  function stringify$1(x, doExponential, isNonzero) {
-    var e = x.e,
-      s = x.c.join(''),
-      n = s.length;
+   *
+   * x {Big}
+   * id? {number} Caller id.
+   *         1 toExponential
+   *         2 toFixed
+   *         3 toPrecision
+   *         4 valueOf
+   * n? {number|undefined} Caller's argument.
+   * k? {number|undefined}
+   */
+  function stringify(x, id, n, k) {
+    var e,
+      s,
+      Big = x.constructor,
+      z = !x.c[0];
+    if (n !== UNDEFINED) {
+      if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
+        throw Error(id == 3 ? INVALID$3 + 'precision' : INVALID_DP);
+      }
+      x = new Big(x);
+
+      // The index of the digit that may be rounded up.
+      n = k - x.e;
+
+      // Round?
+      if (x.c.length > ++k) round(x, n, Big.RM);
+
+      // toFixed: recalculate k as x.e may have changed if value rounded up.
+      if (id == 2) k = x.e + n + 1;
+
+      // Append zeros?
+      for (; x.c.length < k;) x.c.push(0);
+    }
+    e = x.e;
+    s = x.c.join('');
+    n = s.length;
 
     // Exponential notation?
-    if (doExponential) {
+    if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {
       s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
 
       // Normal notation.
@@ -2142,15 +2163,11 @@
       for (; ++e;) s = '0' + s;
       s = '0.' + s;
     } else if (e > 0) {
-      if (++e > n) {
-        for (e -= n; e--;) s += '0';
-      } else if (e < n) {
-        s = s.slice(0, e) + '.' + s.slice(e);
-      }
+      if (++e > n) for (e -= n; e--;) s += '0';else if (e < n) s = s.slice(0, e) + '.' + s.slice(e);
     } else if (n > 1) {
       s = s.charAt(0) + '.' + s.slice(1);
     }
-    return x.s < 0 && isNonzero ? '-' + s : s;
+    return x.s < 0 && (!z || id == 4) ? '-' + s : s;
   }
 
   // Prototype/instance methods
@@ -2158,7 +2175,7 @@
   /*
    * Return a new Big whose value is the absolute value of this Big.
    */
-  P$3.abs = function () {
+  P$2.abs = function () {
     var x = new this.constructor(this);
     x.s = 1;
     return x;
@@ -2168,8 +2185,8 @@
    * Return 1 if the value of this Big is greater than the value of Big y,
    *       -1 if the value of this Big is less than the value of Big y, or
    *        0 if they have the same value.
-   */
-  P$3.cmp = function (y) {
+  */
+  P$2.cmp = function (y) {
     var isneg,
       x = this,
       xc = x.c,
@@ -2203,7 +2220,7 @@
    * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
    * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
    */
-  P$3.div = function (y) {
+  P$2.div = function (y) {
     var x = this,
       Big = x.constructor,
       a = x.c,
@@ -2212,21 +2229,13 @@
       // divisor
       k = x.s == y.s ? 1 : -1,
       dp = Big.DP;
-    if (dp !== ~~dp || dp < 0 || dp > MAX_DP$1) {
-      throw Error(INVALID_DP$1);
-    }
+    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);
 
     // Divisor is zero?
-    if (!b[0]) {
-      throw Error(DIV_BY_ZERO$1);
-    }
+    if (!b[0]) throw Error(DIV_BY_ZERO);
 
     // Dividend is 0? Return +-0.
-    if (!a[0]) {
-      y.s = k;
-      y.c = [y.e = 0];
-      return y;
-    }
+    if (!a[0]) return new Big(k * 0);
     var bl,
       bt,
       n,
@@ -2242,10 +2251,10 @@
       // quotient
       qc = q.c = [],
       qi = 0,
-      p = dp + (q.e = x.e - y.e) + 1; // precision of the result
+      d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result
 
     q.s = k;
-    k = p < 0 ? 0 : p;
+    k = d < 0 ? 0 : d;
 
     // Create version of divisor with leading zero.
     bz.unshift(0);
@@ -2291,33 +2300,32 @@
 
       // Update the remainder.
       if (r[0] && cmp) r[rl] = a[ai] || 0;else r = [a[ai]];
-    } while ((ai++ < al || r[0] !== UNDEFINED$1) && k--);
+    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
 
     // Leading zero? Do not remove if result is simply zero (qi == 1).
     if (!qc[0] && qi != 1) {
       // There can't be more than one zero.
       qc.shift();
       q.e--;
-      p--;
     }
 
     // Round?
-    if (qi > p) round$1(q, p, Big.RM, r[0] !== UNDEFINED$1);
+    if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);
     return q;
   };
 
   /*
    * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
    */
-  P$3.eq = function (y) {
-    return this.cmp(y) === 0;
+  P$2.eq = function (y) {
+    return !this.cmp(y);
   };
 
   /*
    * Return true if the value of this Big is greater than the value of Big y, otherwise return
    * false.
    */
-  P$3.gt = function (y) {
+  P$2.gt = function (y) {
     return this.cmp(y) > 0;
   };
 
@@ -2325,14 +2333,14 @@
    * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
    * return false.
    */
-  P$3.gte = function (y) {
+  P$2.gte = function (y) {
     return this.cmp(y) > -1;
   };
 
   /*
    * Return true if the value of this Big is less than the value of Big y, otherwise return false.
    */
-  P$3.lt = function (y) {
+  P$2.lt = function (y) {
     return this.cmp(y) < 0;
   };
 
@@ -2340,14 +2348,14 @@
    * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
    * return false.
    */
-  P$3.lte = function (y) {
+  P$2.lte = function (y) {
     return this.cmp(y) < 1;
   };
 
   /*
    * Return a new Big whose value is the value of this Big minus the value of Big y.
    */
-  P$3.minus = P$3.sub = function (y) {
+  P$2.minus = P$2.sub = function (y) {
     var i,
       j,
       t,
@@ -2369,14 +2377,8 @@
 
     // Either zero?
     if (!xc[0] || !yc[0]) {
-      if (yc[0]) {
-        y.s = -b;
-      } else if (xc[0]) {
-        y = new Big(x);
-      } else {
-        y.s = 1;
-      }
-      return y;
+      // y is non-zero? x is non-zero? Or both are zero.
+      return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);
     }
 
     // Determine which is the bigger number. Prepend zeros to equalise exponents.
@@ -2449,15 +2451,13 @@
   /*
    * Return a new Big whose value is the value of this Big modulo the value of Big y.
    */
-  P$3.mod = function (y) {
+  P$2.mod = function (y) {
     var ygtx,
       x = this,
       Big = x.constructor,
       a = x.s,
       b = (y = new Big(y)).s;
-    if (!y.c[0]) {
-      throw Error(DIV_BY_ZERO$1);
-    }
+    if (!y.c[0]) throw Error(DIV_BY_ZERO);
     x.s = y.s = 1;
     ygtx = y.cmp(x) == 1;
     x.s = a;
@@ -2472,29 +2472,19 @@
     return this.minus(x.times(y));
   };
 
-  /*
-   * Return a new Big whose value is the value of this Big negated.
-   */
-  P$3.neg = function () {
-    var x = new this.constructor(this);
-    x.s = -x.s;
-    return x;
-  };
-
   /*
    * Return a new Big whose value is the value of this Big plus the value of Big y.
    */
-  P$3.plus = P$3.add = function (y) {
-    var e,
-      k,
-      t,
+  P$2.plus = P$2.add = function (y) {
+    var t,
       x = this,
-      Big = x.constructor;
-    y = new Big(y);
+      Big = x.constructor,
+      a = x.s,
+      b = (y = new Big(y)).s;
 
     // Signs differ?
-    if (x.s != y.s) {
-      y.s = -y.s;
+    if (a != b) {
+      y.s = -b;
       return x.minus(y);
     }
     var xe = x.e,
@@ -2502,31 +2492,22 @@
       ye = y.e,
       yc = y.c;
 
-    // Either zero?
-    if (!xc[0] || !yc[0]) {
-      if (!yc[0]) {
-        if (xc[0]) {
-          y = new Big(x);
-        } else {
-          y.s = x.s;
-        }
-      }
-      return y;
-    }
+    // Either zero? y is non-zero? x is non-zero? Or both are zero.
+    if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);
     xc = xc.slice();
 
     // Prepend zeros to equalise exponents.
     // Note: reverse faster than unshifts.
-    if (e = xe - ye) {
-      if (e > 0) {
+    if (a = xe - ye) {
+      if (a > 0) {
         ye = xe;
         t = yc;
       } else {
-        e = -e;
+        a = -a;
         t = xc;
       }
       t.reverse();
-      for (; e--;) t.push(0);
+      for (; a--;) t.push(0);
       t.reverse();
     }
 
@@ -2536,20 +2517,20 @@
       yc = xc;
       xc = t;
     }
-    e = yc.length;
+    a = yc.length;
 
     // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
-    for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
+    for (b = 0; a; xc[a] %= 10) b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;
 
     // No need to check for zero, as +x + +y != 0 && -x + -y != 0
 
-    if (k) {
-      xc.unshift(k);
+    if (b) {
+      xc.unshift(b);
       ++ye;
     }
 
     // Remove trailing zeros.
-    for (e = xc.length; xc[--e] === 0;) xc.pop();
+    for (a = xc.length; xc[--a] === 0;) xc.pop();
     y.c = xc;
     y.e = ye;
     return y;
@@ -2562,14 +2543,12 @@
    *
    * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
    */
-  P$3.pow = function (n) {
+  P$2.pow = function (n) {
     var x = this,
-      one = new x.constructor('1'),
+      one = new x.constructor(1),
       y = one,
       isneg = n < 0;
-    if (n !== ~~n || n < -MAX_POWER$1 || n > MAX_POWER$1) {
-      throw Error(INVALID$4 + 'exponent');
-    }
+    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID$3 + 'exponent');
     if (isneg) n = -n;
     for (;;) {
       if (n & 1) y = y.times(x);
@@ -2581,40 +2560,26 @@
   };
 
   /*
-   * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd
-   * significant digits using rounding mode rm, or Big.RM if rm is not specified.
-   *
-   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P$3.prec = function (sd, rm) {
-    if (sd !== ~~sd || sd < 1 || sd > MAX_DP$1) {
-      throw Error(INVALID$4 + 'precision');
-    }
-    return round$1(new this.constructor(this), sd, rm);
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places
-   * using rounding mode rm, or Big.RM if rm is not specified.
-   * If dp is negative, round to an integer which is a multiple of 10**-dp.
+   * Return a new Big whose value is the value of this Big rounded using rounding mode rm
+   * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
+   * multiple of 10**-dp.
    * If dp is not specified, round to 0 decimal places.
+   * If rm is not specified, use Big.RM.
    *
    * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
    */
-  P$3.round = function (dp, rm) {
-    if (dp === UNDEFINED$1) dp = 0;else if (dp !== ~~dp || dp < -MAX_DP$1 || dp > MAX_DP$1) {
-      throw Error(INVALID_DP$1);
-    }
-    return round$1(new this.constructor(this), dp + this.e + 1, rm);
+  P$2.round = function (dp, rm) {
+    var Big = this.constructor;
+    if (dp === UNDEFINED) dp = 0;else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
+    return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
   };
 
   /*
    * Return a new Big whose value is the square root of the value of this Big, rounded, if
    * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
    */
-  P$3.sqrt = function () {
+  P$2.sqrt = function () {
     var r,
       c,
       t,
@@ -2622,18 +2587,16 @@
       Big = x.constructor,
       s = x.s,
       e = x.e,
-      half = new Big('0.5');
+      half = new Big(0.5);
 
     // Zero?
     if (!x.c[0]) return new Big(x);
 
     // Negative?
-    if (s < 0) {
-      throw Error(NAME$1 + 'No square root');
-    }
+    if (s < 0) throw Error(NAME + 'No square root');
 
     // Estimate.
-    s = Math.sqrt(+stringify$1(x, true, true));
+    s = Math.sqrt(x + '');
 
     // Math.sqrt underflow/overflow?
     // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
@@ -2642,9 +2605,9 @@
       if (!(c.length + e & 1)) c += '0';
       s = Math.sqrt(c);
       e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
-      r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
+      r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
     } else {
-      r = new Big(s + '');
+      r = new Big(s);
     }
     e = r.e + (Big.DP += 4);
 
@@ -2653,13 +2616,13 @@
       t = r;
       r = half.times(t.plus(x.div(t)));
     } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
-    return round$1(r, (Big.DP -= 4) + r.e + 1, Big.RM);
+    return round(r, Big.DP -= 4, Big.RM);
   };
 
   /*
    * Return a new Big whose value is the value of this Big times the value of Big y.
    */
-  P$3.times = P$3.mul = function (y) {
+  P$2.times = P$2.mul = function (y) {
     var c,
       x = this,
       Big = x.constructor,
@@ -2674,10 +2637,7 @@
     y.s = x.s == y.s ? 1 : -1;
 
     // Return signed 0 if either 0.
-    if (!xc[0] || !yc[0]) {
-      y.c = [y.e = 0];
-      return y;
-    }
+    if (!xc[0] || !yc[0]) return new Big(y.s * 0);
 
     // Initialise exponent of result as x.e + y.e.
     y.e = i + j;
@@ -2710,7 +2670,7 @@
         // carry
         b = b / 10 | 0;
       }
-      c[j] = b;
+      c[j] = (c[j] + b) % 10;
     }
 
     // Increment result exponent if there is a final carry, otherwise remove leading zero.
@@ -2723,48 +2683,37 @@
   };
 
   /*
-   * Return a string representing the value of this Big in exponential notation rounded to dp fixed
-   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
+   * Return a string representing the value of this Big in exponential notation to dp fixed decimal
+   * places and rounded using Big.RM.
    *
-   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   * dp? {number} Integer, 0 to MAX_DP inclusive.
    */
-  P$3.toExponential = function (dp, rm) {
-    var x = this,
-      n = x.c[0];
-    if (dp !== UNDEFINED$1) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP$1) {
-        throw Error(INVALID_DP$1);
-      }
-      x = round$1(new x.constructor(x), ++dp, rm);
-      for (; x.c.length < dp;) x.c.push(0);
-    }
-    return stringify$1(x, true, !!n);
+  P$2.toExponential = function (dp) {
+    return stringify(this, 1, dp, dp);
   };
 
   /*
-   * Return a string representing the value of this Big in normal notation rounded to dp fixed
-   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
+   * Return a string representing the value of this Big in normal notation to dp fixed decimal
+   * places and rounded using Big.RM.
    *
-   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
+   * dp? {number} Integer, 0 to MAX_DP inclusive.
    *
    * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
    * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
    */
-  P$3.toFixed = function (dp, rm) {
-    var x = this,
-      n = x.c[0];
-    if (dp !== UNDEFINED$1) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP$1) {
-        throw Error(INVALID_DP$1);
-      }
-      x = round$1(new x.constructor(x), dp + x.e + 1, rm);
+  P$2.toFixed = function (dp) {
+    return stringify(this, 2, dp, this.e + dp);
+  };
 
-      // x.e may have changed if the value is rounded up.
-      for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);
-    }
-    return stringify$1(x, false, !!n);
+  /*
+   * Return a string representing the value of this Big rounded to sd significant digits using
+   * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
+   * the integer part of the value in normal notation.
+   *
+   * sd {number} Integer, 1 to MAX_DP inclusive.
+   */
+  P$2.toPrecision = function (sd) {
+    return stringify(this, 3, sd, sd - 1);
   };
 
   /*
@@ -2773,47 +2722,8 @@
    * Big.PE, or a negative exponent equal to or less than Big.NE.
    * Omit the sign for negative zero.
    */
-  P$3.toJSON = P$3.toString = function () {
-    var x = this,
-      Big = x.constructor;
-    return stringify$1(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);
-  };
-  if (typeof Symbol !== "undefined") {
-    P$3[Symbol.for('nodejs.util.inspect.custom')] = P$3.toJSON;
-  }
-
-  /*
-   * Return the value of this Big as a primitive number.
-   */
-  P$3.toNumber = function () {
-    var n = +stringify$1(this, true, true);
-    if (this.constructor.strict === true && !this.eq(n.toString())) {
-      throw Error(NAME$1 + 'Imprecise conversion');
-    }
-    return n;
-  };
-
-  /*
-   * Return a string representing the value of this Big rounded to sd significant digits using
-   * rounding mode rm, or Big.RM if rm is not specified.
-   * Use exponential notation if sd is less than the number of digits necessary to represent
-   * the integer part of the value in normal notation.
-   *
-   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P$3.toPrecision = function (sd, rm) {
-    var x = this,
-      Big = x.constructor,
-      n = x.c[0];
-    if (sd !== UNDEFINED$1) {
-      if (sd !== ~~sd || sd < 1 || sd > MAX_DP$1) {
-        throw Error(INVALID$4 + 'precision');
-      }
-      x = round$1(new Big(x), sd, rm);
-      for (; x.c.length < sd;) x.c.push(0);
-    }
-    return stringify$1(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);
+  P$2.toString = function () {
+    return stringify(this);
   };
 
   /*
@@ -2822,18 +2732,13 @@
    * Big.PE, or a negative exponent equal to or less than Big.NE.
    * Include the sign for negative zero.
    */
-  P$3.valueOf = function () {
-    var x = this,
-      Big = x.constructor;
-    if (Big.strict === true) {
-      throw Error(NAME$1 + 'valueOf disallowed');
-    }
-    return stringify$1(x, x.e <= Big.NE || x.e >= Big.PE, true);
+  P$2.valueOf = P$2.toJSON = function () {
+    return stringify(this, 4);
   };
 
   // Export
 
-  var Big$1 = _Big_$1();
+  var Big = _Big_();
 
   var f = 0;
   function u(e, t, n, o, i, u) {
@@ -8503,7 +8408,7 @@
       }, zone || mergedZone, next];
     }, [{}, null, 1]).slice(0, 2);
   }
-  function parse$1(s, ...patterns) {
+  function parse(s, ...patterns) {
     if (s == null) {
       return [null, null];
     }
@@ -8674,26 +8579,26 @@
    */
 
   function parseISODate(s) {
-    return parse$1(s, [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset], [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime], [isoTimeCombinedRegex, extractISOTimeAndOffset]);
+    return parse(s, [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset], [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime], [isoTimeCombinedRegex, extractISOTimeAndOffset]);
   }
   function parseRFC2822Date(s) {
-    return parse$1(preprocessRFC2822(s), [rfc2822, extractRFC2822]);
+    return parse(preprocessRFC2822(s), [rfc2822, extractRFC2822]);
   }
   function parseHTTPDate(s) {
-    return parse$1(s, [rfc1123, extractRFC1123Or850], [rfc850, extractRFC1123Or850], [ascii, extractASCII]);
+    return parse(s, [rfc1123, extractRFC1123Or850], [rfc850, extractRFC1123Or850], [ascii, extractASCII]);
   }
   function parseISODuration(s) {
-    return parse$1(s, [isoDuration, extractISODuration]);
+    return parse(s, [isoDuration, extractISODuration]);
   }
   const extractISOTimeOnly = combineExtractors(extractISOTime);
   function parseISOTimeOnly(s) {
-    return parse$1(s, [isoTimeOnly, extractISOTimeOnly]);
+    return parse(s, [isoTimeOnly, extractISOTimeOnly]);
   }
   const sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex);
   const sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex);
   const extractISOTimeOffsetAndIANAZone = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
   function parseSQL(s) {
-    return parse$1(s, [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]);
+    return parse(s, [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]);
   }
   const INVALID$2 = "Invalid Duration";
 
@@ -11093,7 +10998,7 @@
     const resolvedOpts = df.resolvedOptions();
     return parts.map(p => tokenForPart(p, formatOpts, resolvedOpts));
   }
-  const INVALID$3 = "Invalid DateTime";
+  const INVALID = "Invalid DateTime";
   const MAX_DATE = 8.64e15;
   function unsupportedZone(zone) {
     return new Invalid("unsupported zone", `the zone "${zone.name}" is not supported`);
@@ -12805,7 +12710,7 @@
      * @return {string}
      */
     toFormat(fmt, opts = {}) {
-      return this.isValid ? Formatter.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID$3;
+      return this.isValid ? Formatter.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID;
     }
 
     /**
@@ -12828,7 +12733,7 @@
      * @return {string}
      */
     toLocaleString(formatOpts = DATE_SHORT, opts = {}) {
-      return this.isValid ? Formatter.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID$3;
+      return this.isValid ? Formatter.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID;
     }
 
     /**
@@ -13036,7 +12941,7 @@
      * @return {string}
      */
     toString() {
-      return this.isValid ? this.toISO() : INVALID$3;
+      return this.isValid ? this.toISO() : INVALID;
     }
 
     /**
@@ -15764,7 +15669,7 @@
       return W$1(n, t, e);
     }), n.__c && n.__c.__P === t && (n.__e && e.appendChild(n.__e), n.__c.__e = true, n.__c.__P = e)), n;
   }
-  function P$2() {
+  function P$1() {
     this.__u = 0, this.o = null, this.__b = null;
   }
   function j$1(n) {
@@ -15777,7 +15682,7 @@
   l$2.unmount = function (n) {
     var t = n.__c;
     t && (t.__z = true), t && t.__R && t.__R(), t && 32 & n.__u && (n.type = null), U$1 && U$1(n);
-  }, (P$2.prototype = new C$2()).__c = function (n, t) {
+  }, (P$1.prototype = new C$2()).__c = function (n, t) {
     var e = t.__c,
       r = this;
     null == r.o && (r.o = []), r.o.push(e);
@@ -15804,9 +15709,9 @@
     r.__u++ || 32 & t.__u || r.setState({
       __a: r.__b = r.__v.__k[0]
     }), n.then(i, i);
-  }, P$2.prototype.componentWillUnmount = function () {
+  }, P$1.prototype.componentWillUnmount = function () {
     this.o = [];
-  }, P$2.prototype.render = function (n, e) {
+  }, P$1.prototype.render = function (n, e) {
     if (this.__b) {
       if (this.__v.__k) {
         var r = document.createElement("div"),
@@ -28835,7 +28740,7 @@ ${e}</tr>
       return n;
     }
   };
-  var P$1 = class P {
+  var P = class {
     options;
     block;
     constructor(e) {
@@ -28872,7 +28777,7 @@ ${e}</tr>
     TextRenderer = L$1;
     Lexer = x;
     Tokenizer = w;
-    Hooks = P$1;
+    Hooks = P;
     constructor(...e) {
       this.use(...e);
     }
@@ -28958,15 +28863,15 @@ ${e}</tr>
           s.tokenizer = r;
         }
         if (n.hooks) {
-          let r = this.defaults.hooks || new P$1();
+          let r = this.defaults.hooks || new P();
           for (let i in n.hooks) {
             if (!(i in r)) throw new Error(`hook '${i}' does not exist`);
             if (["options", "block"].includes(i)) continue;
             let o = i,
               u = n.hooks[o],
               a = r[o];
-            P$1.passThroughHooks.has(i) ? r[o] = c => {
-              if (this.defaults.async && P$1.passThroughHooksRespectAsync.has(i)) return (async () => {
+            P.passThroughHooks.has(i) ? r[o] = c => {
+              if (this.defaults.async && P.passThroughHooksRespectAsync.has(i)) return (async () => {
                 let k = await u.call(r, c);
                 return a.call(r, k);
               })();
@@ -29076,7 +28981,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   g.Lexer = x;
   g.lexer = x.lex;
   g.Tokenizer = w;
-  g.Hooks = P$1;
+  g.Hooks = P;
   g.parse = g;
   g.options;
     g.setOptions;
@@ -29109,7 +29014,26 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         // if using special depth accessors, use a more complex extraction
         return Array.from(_smartExtractVariableNames(node, depth, specialDepthAccessors));
       }
-      if (depth === 0 && node.name === 'VariableName') return [node.variableName];
+      if (depth === 0 && node.name === 'VariableName') return [_cleanupVariableName(node.variableName)];
+
+      // skip function names - the function name is the only direct VariableName child of a
+      // FunctionInvocation (arguments are nested under Positional/NamedParameters), so drop it
+      if (node.name === 'FunctionInvocation') {
+        const args = node.children.filter(child => child.name !== 'VariableName');
+        return args.reduce((acc, child) => acc.concat(_unfoldVariables(child)), []);
+      }
+
+      // skip type names in instance of expressions
+      if (node.name === 'Type') {
+        return [];
+      }
+
+      // handle quantified (some...satisfies) and for expressions - exclude bound iteration variables
+      if (node.name === 'QuantifiedExpression' || node.name === 'ForExpression') {
+        const boundNames = _collectBoundVariableNames(node);
+        const variables = node.children.reduce((acc, child) => acc.concat(_unfoldVariables(child)), []);
+        return variables.filter(name => !boundNames.includes(name));
+      }
 
       // for any other kind of node, traverse its children and flatten the result
       if (node.children) {
@@ -29234,6 +29158,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         if (node.type.name === 'VariableName') {
           nodeRepresentation.variableName = feelString.slice(node.from, node.to);
         }
+        if (node.type.name === 'Name') {
+          nodeRepresentation.variableName = feelString.slice(node.from, node.to);
+        }
         stack.push(nodeRepresentation);
       },
       leave: () => {
@@ -29282,6 +29209,53 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     iterate(tree);
     return flattenedExpressionTree;
   };
+
+  /**
+   * FEEL keywords that may be incorrectly absorbed into variable names by the parser.
+   * For example, `variable1 not in (...)` parses as VariableName "variable1 not".
+   */
+  const FEEL_TRAILING_KEYWORDS = ['not'];
+
+  /**
+   * Cleans up a variable name by stripping trailing FEEL keywords that the parser
+   * may have incorrectly included as part of the variable name.
+   *
+   * @param {string} variableName - The raw variable name from the parse tree.
+   * @returns {string} The cleaned variable name.
+   */
+  const _cleanupVariableName = variableName => {
+    for (const keyword of FEEL_TRAILING_KEYWORDS) {
+      if (variableName.endsWith(' ' + keyword)) {
+        return variableName.slice(0, -(keyword.length + 1));
+      }
+    }
+    return variableName;
+  };
+
+  /**
+   * Collects the names of variables bound by iteration constructs (e.g. `for x in ...`, `some x in ...`).
+   * These are locally scoped and should be excluded from the extracted variable set.
+   *
+   * @param {Object} node - A QuantifiedExpression or ForExpression node.
+   * @returns {string[]} The bound variable names.
+   */
+  const _collectBoundVariableNames = node => {
+    const boundNames = [];
+    const collect = n => {
+      if (n.name === 'InExpression') {
+        // The Name node inside an InExpression is the bound iteration variable
+        const nameNode = n.children.find(child => child.name === 'Name');
+        if (nameNode && nameNode.variableName) {
+          boundNames.push(nameNode.variableName);
+        }
+      }
+      if (n.children) {
+        n.children.forEach(collect);
+      }
+    };
+    collect(node);
+    return boundNames;
+  };
   class FeelExpressionLanguage {
     constructor(eventBus) {
       this._eventBus = eventBus;
@@ -32979,7 +32953,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     })));
   };
   function countDecimals$1(number) {
-    const num = Big$1(number);
+    const num = Big(number);
     if (num.toString() === num.toFixed(0)) return 0;
     return num.toFixed().split('.')[1].length || 0;
   }
@@ -33098,15 +33072,15 @@ Please report this to https://github.com/markedjs/marked.`, e) {
 
     // caches the value an increment/decrement operation will be based on
     const incrementAmount = T$3(() => {
-      if (incrementValue) return Big$1(incrementValue);
-      if (decimalDigits) return Big$1(`1e-${decimalDigits}`);
-      return Big$1('1');
+      if (incrementValue) return Big(incrementValue);
+      if (decimalDigits) return Big(`1e-${decimalDigits}`);
+      return Big('1');
     }, [decimalDigits, incrementValue]);
     const increment = () => {
       if (readonly) {
         return;
       }
-      const base = isValidNumber$1(cachedValue) ? Big$1(cachedValue) : Big$1(0);
+      const base = isValidNumber$1(cachedValue) ? Big(cachedValue) : Big(0);
       const stepFlooredValue = base.minus(base.mod(incrementAmount));
 
       // note: toFixed() behaves differently in big.js
@@ -33116,7 +33090,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
       if (readonly) {
         return;
       }
-      const base = isValidNumber$1(cachedValue) ? Big$1(cachedValue) : Big$1(0);
+      const base = isValidNumber$1(cachedValue) ? Big(cachedValue) : Big(0);
       const offset = base.mod(incrementAmount);
       if (offset.cmp(0) === 0) {
         // if we're already on a valid step, decrement
@@ -35291,11 +35265,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           if (!isValidDocumentEndpoint(finalEndpoint)) {
             return null;
           }
-          const requestInit = getDocumentRequestInit(documentEndpointBuilder, document);
           return u(DocumentRenderer, {
             documentMetadata: document,
+            documentEndpointBuilder: documentEndpointBuilder,
             endpoint: finalEndpoint,
-            requestInit: requestInit,
             maxHeight: maxHeight,
             domId: `${domId}-${index}`
           }, document.documentId);
@@ -35477,9 +35450,9 @@ Please report this to https://github.com/markedjs/marked.`, e) {
    *
    * @param {Object} props
    * @param {DocumentMetadata} props.documentMetadata
+   * @param {DocumentEndpointBuilder | null} props.documentEndpointBuilder
    * @param {string} props.endpoint
    * @param {string} props.domId
-   * @param {RequestInit|undefined} props.requestInit
    * @param {number|undefined} props.maxHeight
    *
    * @returns {import("preact").JSX.Element}
@@ -35487,10 +35460,10 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   function DocumentRenderer(props) {
     const {
       documentMetadata,
+      documentEndpointBuilder,
       endpoint,
       maxHeight,
-      domId,
-      requestInit
+      domId
     } = props;
     const {
       metadata
@@ -35498,6 +35471,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const [hasError, setHasError] = d$1(false);
     const ref = A$2(null);
     const isInViewport = useInViewport(ref);
+    const onError = q$2(() => setHasError(true), []);
+    const requestInit = T$3(() => getDocumentRequestInit(documentEndpointBuilder, documentMetadata), [documentEndpointBuilder, documentMetadata]);
     const singleDocumentContainerClassName = `fjs-${type$k}-single-document-container`;
     const errorMessageId = `${domId}-error-message`;
     const errorMessage = 'Unable to download document';
@@ -35513,14 +35488,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           url: endpoint,
           alt: metadata.fileName,
           requestInit: requestInit,
-          onError: () => setHasError(true)
+          onError: onError
         }), u(DownloadButton, {
           endpoint: endpoint,
           fileName: metadata.fileName,
           requestInit: requestInit,
-          onDownloadError: () => {
-            setHasError(true);
-          }
+          onDownloadError: onError
         }), hasError ? u(Errors, {
           id: errorMessageId,
           errors: [errorMessage]
@@ -35538,7 +35511,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           url: endpoint,
           fileName: metadata.fileName,
           requestInit: requestInit,
-          onError: () => setHasError(true),
+          onError: onError,
           errorMessageId: errorMessageId
         })
       });
@@ -35559,9 +35532,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         endpoint: endpoint,
         fileName: metadata.fileName,
         requestInit: requestInit,
-        onDownloadError: () => {
-          setHasError(true);
-        }
+        onDownloadError: onError
       })]
     });
   }
@@ -37741,8 +37712,8 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         errors.push('Value is expected to ' + (decimalDigits === 0 ? 'be an integer' : `have at most ${decimalDigits} decimal digit${decimalDigits > 1 ? 's' : ''}`) + '.');
       }
       if (increment) {
-        const bigValue = Big$1(value);
-        const bigIncrement = Big$1(increment);
+        const bigValue = Big(value);
+        const bigIncrement = Big(increment);
         const offset = bigValue.mod(bigIncrement);
         if (offset.cmp(0) !== 0) {
           const previousValue = bigValue.minus(offset);
@@ -37768,7 +37739,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     if ('min' in validation && (value || value === 0)) {
       try {
-        if (Big$1(value).lt(Big$1(validation.min))) {
+        if (Big(value).lt(Big(validation.min))) {
           errors.push(`Field must have minimum value of ${validation.min}.`);
         }
       } catch {
@@ -37777,7 +37748,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     }
     if ('max' in validation && (value || value === 0)) {
       try {
-        if (Big$1(value).gt(Big$1(validation.max))) {
+        if (Big(value).gt(Big(validation.max))) {
           errors.push(`Field must have maximum value of ${validation.max}.`);
         }
       } catch {
@@ -71681,941 +71652,6 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     return trap;
   };
 
-  /*
-   *  big.js v7.0.1
-   *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
-   *  Copyright (c) 2025 Michael Mclaughlin
-   *  https://github.com/MikeMcl/big.js/LICENCE.md
-   */
-
-  /************************************** EDITABLE DEFAULTS *****************************************/
-
-  // The default values below must be integers within the stated ranges.
-
-  /*
-   * The maximum number of decimal places (DP) of the results of operations involving division:
-   * div and sqrt, and pow with negative exponents.
-   */
-  var DP = 20,
-    // 0 to MAX_DP
-
-    /*
-     * The rounding mode (RM) used when rounding to the above decimal places.
-     *
-     *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)
-     *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)
-     *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
-     *  3  Away from zero.                                  (ROUND_UP)
-     */
-    RM = 1,
-    // 0, 1, 2 or 3
-
-    // The maximum value of DP and Big.DP.
-    MAX_DP = 1E6,
-    // 0 to 1000000
-
-    // The maximum magnitude of the exponent argument to the pow method.
-    MAX_POWER = 1E6,
-    // 1 to 1000000
-
-    /*
-     * The negative exponent (NE) at and beneath which toString returns exponential notation.
-     * (JavaScript numbers: -7)
-     * -1000000 is the minimum recommended exponent value of a Big.
-     */
-    NE = -7,
-    // 0 to -1000000
-
-    /*
-     * The positive exponent (PE) at and above which toString returns exponential notation.
-     * (JavaScript numbers: 21)
-     * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.
-     */
-    PE = 21,
-    // 0 to 1000000
-
-    /*
-     * When true, an error will be thrown if a primitive number is passed to the Big constructor,
-     * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a
-     * primitive number without a loss of precision.
-     */
-    STRICT = false,
-    // true or false
-
-    /**************************************************************************************************/
-
-    // Error messages.
-    NAME = '[big.js] ',
-    INVALID = NAME + 'Invalid ',
-    INVALID_DP = INVALID + 'decimal places',
-    INVALID_RM = INVALID + 'rounding mode',
-    DIV_BY_ZERO = NAME + 'Division by zero',
-    // The shared prototype object.
-    P = {},
-    UNDEFINED = void 0,
-    NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
-
-  /*
-   * Create and return a Big constructor.
-   */
-  function _Big_() {
-    /*
-     * The Big constructor and exported function.
-     * Create and return a new instance of a Big number object.
-     *
-     * n {number|string|Big} A numeric value.
-     */
-    function Big(n) {
-      var x = this;
-
-      // Enable constructor usage without new.
-      if (!(x instanceof Big)) {
-        return n === UNDEFINED && arguments.length === 0 ? _Big_() : new Big(n);
-      }
-
-      // Duplicate.
-      if (n instanceof Big) {
-        x.s = n.s;
-        x.e = n.e;
-        x.c = n.c.slice();
-      } else {
-        if (typeof n !== 'string') {
-          if (Big.strict === true && typeof n !== 'bigint') {
-            throw TypeError(INVALID + 'value');
-          }
-
-          // Minus zero?
-          n = n === 0 && 1 / n < 0 ? '-0' : String(n);
-        }
-        parse(x, n);
-      }
-
-      // Retain a reference to this Big constructor.
-      // Shadow Big.prototype.constructor which points to Object.
-      x.constructor = Big;
-    }
-    Big.prototype = P;
-    Big.DP = DP;
-    Big.RM = RM;
-    Big.NE = NE;
-    Big.PE = PE;
-    Big.strict = STRICT;
-    Big.roundDown = 0;
-    Big.roundHalfUp = 1;
-    Big.roundHalfEven = 2;
-    Big.roundUp = 3;
-    return Big;
-  }
-
-  /*
-   * Parse the number or string value passed to a Big constructor.
-   *
-   * x {Big} A Big number instance.
-   * n {number|string} A numeric value.
-   */
-  function parse(x, n) {
-    var e, i, nl;
-    if (!NUMERIC.test(n)) {
-      throw Error(INVALID + 'number');
-    }
-
-    // Determine sign.
-    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;
-
-    // Decimal point?
-    if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');
-
-    // Exponential form?
-    if ((i = n.search(/e/i)) > 0) {
-      // Determine exponent.
-      if (e < 0) e = i;
-      e += +n.slice(i + 1);
-      n = n.substring(0, i);
-    } else if (e < 0) {
-      // Integer.
-      e = n.length;
-    }
-    nl = n.length;
-
-    // Determine leading zeros.
-    for (i = 0; i < nl && n.charAt(i) == '0';) ++i;
-    if (i == nl) {
-      // Zero.
-      x.c = [x.e = 0];
-    } else {
-      // Determine trailing zeros.
-      for (; nl > 0 && n.charAt(--nl) == '0';);
-      x.e = e - i - 1;
-      x.c = [];
-
-      // Convert string to array of digits without leading/trailing zeros.
-      for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
-    }
-    return x;
-  }
-
-  /*
-   * Round Big x to a maximum of sd significant digits using rounding mode rm.
-   *
-   * x {Big} The Big to round.
-   * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.
-   * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   * [more] {boolean} Whether the result of division was truncated.
-   */
-  function round(x, sd, rm, more) {
-    var xc = x.c;
-    if (rm === UNDEFINED) rm = x.constructor.RM;
-    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {
-      throw Error(INVALID_RM);
-    }
-    if (sd < 1) {
-      more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
-      xc.length = 1;
-      if (more) {
-        // 1, 0.1, 0.01, 0.001, 0.0001 etc.
-        x.e = x.e - sd + 1;
-        xc[0] = 1;
-      } else {
-        // Zero.
-        xc[0] = x.e = 0;
-      }
-    } else if (sd < xc.length) {
-      // xc[sd] is the digit after the digit that may be rounded up.
-      more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]);
-
-      // Remove any digits after the required precision.
-      xc.length = sd;
-
-      // Round up?
-      if (more) {
-        // Rounding up may mean the previous digit has to be rounded up.
-        for (; ++xc[--sd] > 9;) {
-          xc[sd] = 0;
-          if (sd === 0) {
-            ++x.e;
-            xc.unshift(1);
-            break;
-          }
-        }
-      }
-
-      // Remove trailing zeros.
-      for (sd = xc.length; !xc[--sd];) xc.pop();
-    }
-    return x;
-  }
-
-  /*
-   * Return a string representing the value of Big x in normal or exponential notation.
-   * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
-   */
-  function stringify(x, doExponential, isNonzero) {
-    var e = x.e,
-      s = x.c.join(''),
-      n = s.length;
-
-    // Exponential notation?
-    if (doExponential) {
-      s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;
-
-      // Normal notation.
-    } else if (e < 0) {
-      for (; ++e;) s = '0' + s;
-      s = '0.' + s;
-    } else if (e > 0) {
-      if (++e > n) {
-        for (e -= n; e--;) s += '0';
-      } else if (e < n) {
-        s = s.slice(0, e) + '.' + s.slice(e);
-      }
-    } else if (n > 1) {
-      s = s.charAt(0) + '.' + s.slice(1);
-    }
-    return x.s < 0 && isNonzero ? '-' + s : s;
-  }
-
-  // Prototype/instance methods
-
-  /*
-   * Return a new Big whose value is the absolute value of this Big.
-   */
-  P.abs = function () {
-    var x = new this.constructor(this);
-    x.s = 1;
-    return x;
-  };
-
-  /*
-   * Return 1 if the value of this Big is greater than the value of Big y,
-   *       -1 if the value of this Big is less than the value of Big y, or
-   *        0 if they have the same value.
-   */
-  P.cmp = function (y) {
-    var isneg,
-      x = this,
-      xc = x.c,
-      yc = (y = new x.constructor(y)).c,
-      i = x.s,
-      j = y.s,
-      k = x.e,
-      l = y.e;
-
-    // Either zero?
-    if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
-
-    // Signs differ?
-    if (i != j) return i;
-    isneg = i < 0;
-
-    // Compare exponents.
-    if (k != l) return k > l ^ isneg ? 1 : -1;
-    j = (k = xc.length) < (l = yc.length) ? k : l;
-
-    // Compare digit by digit.
-    for (i = -1; ++i < j;) {
-      if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
-    }
-
-    // Compare lengths.
-    return k == l ? 0 : k > l ^ isneg ? 1 : -1;
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
-   * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
-   */
-  P.div = function (y) {
-    var x = this,
-      Big = x.constructor,
-      a = x.c,
-      // dividend
-      b = (y = new Big(y)).c,
-      // divisor
-      k = x.s == y.s ? 1 : -1,
-      dp = Big.DP;
-    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-      throw Error(INVALID_DP);
-    }
-
-    // Divisor is zero?
-    if (!b[0]) {
-      throw Error(DIV_BY_ZERO);
-    }
-
-    // Dividend is 0? Return +-0.
-    if (!a[0]) {
-      y.s = k;
-      y.c = [y.e = 0];
-      return y;
-    }
-    var bl,
-      bt,
-      n,
-      cmp,
-      ri,
-      bz = b.slice(),
-      ai = bl = b.length,
-      al = a.length,
-      r = a.slice(0, bl),
-      // remainder
-      rl = r.length,
-      q = y,
-      // quotient
-      qc = q.c = [],
-      qi = 0,
-      p = dp + (q.e = x.e - y.e) + 1; // precision of the result
-
-    q.s = k;
-    k = p < 0 ? 0 : p;
-
-    // Create version of divisor with leading zero.
-    bz.unshift(0);
-
-    // Add zeros to make remainder as long as divisor.
-    for (; rl++ < bl;) r.push(0);
-    do {
-      // n is how many times the divisor goes into current remainder.
-      for (n = 0; n < 10; n++) {
-        // Compare divisor and remainder.
-        if (bl != (rl = r.length)) {
-          cmp = bl > rl ? 1 : -1;
-        } else {
-          for (ri = -1, cmp = 0; ++ri < bl;) {
-            if (b[ri] != r[ri]) {
-              cmp = b[ri] > r[ri] ? 1 : -1;
-              break;
-            }
-          }
-        }
-
-        // If divisor < remainder, subtract divisor from remainder.
-        if (cmp < 0) {
-          // Remainder can't be more than 1 digit longer than divisor.
-          // Equalise lengths using divisor with extra leading zero?
-          for (bt = rl == bl ? b : bz; rl;) {
-            if (r[--rl] < bt[rl]) {
-              ri = rl;
-              for (; ri && !r[--ri];) r[ri] = 9;
-              --r[ri];
-              r[rl] += 10;
-            }
-            r[rl] -= bt[rl];
-          }
-          for (; !r[0];) r.shift();
-        } else {
-          break;
-        }
-      }
-
-      // Add the digit n to the result array.
-      qc[qi++] = cmp ? n : ++n;
-
-      // Update the remainder.
-      if (r[0] && cmp) r[rl] = a[ai] || 0;else r = [a[ai]];
-    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
-
-    // Leading zero? Do not remove if result is simply zero (qi == 1).
-    if (!qc[0] && qi != 1) {
-      // There can't be more than one zero.
-      qc.shift();
-      q.e--;
-      p--;
-    }
-
-    // Round?
-    if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);
-    return q;
-  };
-
-  /*
-   * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
-   */
-  P.eq = function (y) {
-    return this.cmp(y) === 0;
-  };
-
-  /*
-   * Return true if the value of this Big is greater than the value of Big y, otherwise return
-   * false.
-   */
-  P.gt = function (y) {
-    return this.cmp(y) > 0;
-  };
-
-  /*
-   * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
-   * return false.
-   */
-  P.gte = function (y) {
-    return this.cmp(y) > -1;
-  };
-
-  /*
-   * Return true if the value of this Big is less than the value of Big y, otherwise return false.
-   */
-  P.lt = function (y) {
-    return this.cmp(y) < 0;
-  };
-
-  /*
-   * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
-   * return false.
-   */
-  P.lte = function (y) {
-    return this.cmp(y) < 1;
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big minus the value of Big y.
-   */
-  P.minus = P.sub = function (y) {
-    var i,
-      j,
-      t,
-      xlty,
-      x = this,
-      Big = x.constructor,
-      a = x.s,
-      b = (y = new Big(y)).s;
-
-    // Signs differ?
-    if (a != b) {
-      y.s = -b;
-      return x.plus(y);
-    }
-    var xc = x.c.slice(),
-      xe = x.e,
-      yc = y.c,
-      ye = y.e;
-
-    // Either zero?
-    if (!xc[0] || !yc[0]) {
-      if (yc[0]) {
-        y.s = -b;
-      } else if (xc[0]) {
-        y = new Big(x);
-      } else {
-        y.s = 1;
-      }
-      return y;
-    }
-
-    // Determine which is the bigger number. Prepend zeros to equalise exponents.
-    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 {
-      // Exponents equal. Check digit by digit.
-      j = ((xlty = xc.length < yc.length) ? xc : yc).length;
-      for (a = b = 0; b < j; b++) {
-        if (xc[b] != yc[b]) {
-          xlty = xc[b] < yc[b];
-          break;
-        }
-      }
-    }
-
-    // x < y? Point xc to the array of the bigger number.
-    if (xlty) {
-      t = xc;
-      xc = yc;
-      yc = t;
-      y.s = -y.s;
-    }
-
-    /*
-     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
-     * needs to start at yc.length.
-     */
-    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;
-
-    // Subtract yc from xc.
-    for (b = i; j > a;) {
-      if (xc[--j] < yc[j]) {
-        for (i = j; i && !xc[--i];) xc[i] = 9;
-        --xc[i];
-        xc[j] += 10;
-      }
-      xc[j] -= yc[j];
-    }
-
-    // Remove trailing zeros.
-    for (; xc[--b] === 0;) xc.pop();
-
-    // Remove leading zeros and adjust exponent accordingly.
-    for (; xc[0] === 0;) {
-      xc.shift();
-      --ye;
-    }
-    if (!xc[0]) {
-      // n - n = +0
-      y.s = 1;
-
-      // Result must be zero.
-      xc = [ye = 0];
-    }
-    y.c = xc;
-    y.e = ye;
-    return y;
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big modulo the value of Big y.
-   */
-  P.mod = function (y) {
-    var ygtx,
-      x = this,
-      Big = x.constructor,
-      a = x.s,
-      b = (y = new Big(y)).s;
-    if (!y.c[0]) {
-      throw Error(DIV_BY_ZERO);
-    }
-    x.s = y.s = 1;
-    ygtx = y.cmp(x) == 1;
-    x.s = a;
-    y.s = b;
-    if (ygtx) return new Big(x);
-    a = Big.DP;
-    b = Big.RM;
-    Big.DP = Big.RM = 0;
-    x = x.div(y);
-    Big.DP = a;
-    Big.RM = b;
-    return this.minus(x.times(y));
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big negated.
-   */
-  P.neg = function () {
-    var x = new this.constructor(this);
-    x.s = -x.s;
-    return x;
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big plus the value of Big y.
-   */
-  P.plus = P.add = function (y) {
-    var e,
-      k,
-      t,
-      x = this,
-      Big = x.constructor;
-    y = new Big(y);
-
-    // Signs differ?
-    if (x.s != y.s) {
-      y.s = -y.s;
-      return x.minus(y);
-    }
-    var xe = x.e,
-      xc = x.c,
-      ye = y.e,
-      yc = y.c;
-
-    // Either zero?
-    if (!xc[0] || !yc[0]) {
-      if (!yc[0]) {
-        if (xc[0]) {
-          y = new Big(x);
-        } else {
-          y.s = x.s;
-        }
-      }
-      return y;
-    }
-    xc = xc.slice();
-
-    // Prepend zeros to equalise exponents.
-    // Note: reverse faster than unshifts.
-    if (e = xe - ye) {
-      if (e > 0) {
-        ye = xe;
-        t = yc;
-      } else {
-        e = -e;
-        t = xc;
-      }
-      t.reverse();
-      for (; e--;) t.push(0);
-      t.reverse();
-    }
-
-    // Point xc to the longer array.
-    if (xc.length - yc.length < 0) {
-      t = yc;
-      yc = xc;
-      xc = t;
-    }
-    e = yc.length;
-
-    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
-    for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
-
-    // No need to check for zero, as +x + +y != 0 && -x + -y != 0
-
-    if (k) {
-      xc.unshift(k);
-      ++ye;
-    }
-
-    // Remove trailing zeros.
-    for (e = xc.length; xc[--e] === 0;) xc.pop();
-    y.c = xc;
-    y.e = ye;
-    return y;
-  };
-
-  /*
-   * Return a Big whose value is the value of this Big raised to the power n.
-   * If n is negative, round to a maximum of Big.DP decimal places using rounding
-   * mode Big.RM.
-   *
-   * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
-   */
-  P.pow = function (n) {
-    var x = this,
-      one = new x.constructor('1'),
-      y = one,
-      isneg = n < 0;
-    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {
-      throw Error(INVALID + 'exponent');
-    }
-    if (isneg) n = -n;
-    for (;;) {
-      if (n & 1) y = y.times(x);
-      n >>= 1;
-      if (!n) break;
-      x = x.times(x);
-    }
-    return isneg ? one.div(y) : y;
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd
-   * significant digits using rounding mode rm, or Big.RM if rm is not specified.
-   *
-   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P.prec = function (sd, rm) {
-    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
-      throw Error(INVALID + 'precision');
-    }
-    return round(new this.constructor(this), sd, rm);
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places
-   * using rounding mode rm, or Big.RM if rm is not specified.
-   * If dp is negative, round to an integer which is a multiple of 10**-dp.
-   * If dp is not specified, round to 0 decimal places.
-   *
-   * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P.round = function (dp, rm) {
-    if (dp === UNDEFINED) dp = 0;else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {
-      throw Error(INVALID_DP);
-    }
-    return round(new this.constructor(this), dp + this.e + 1, rm);
-  };
-
-  /*
-   * Return a new Big whose value is the square root of the value of this Big, rounded, if
-   * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
-   */
-  P.sqrt = function () {
-    var r,
-      c,
-      t,
-      x = this,
-      Big = x.constructor,
-      s = x.s,
-      e = x.e,
-      half = new Big('0.5');
-
-    // Zero?
-    if (!x.c[0]) return new Big(x);
-
-    // Negative?
-    if (s < 0) {
-      throw Error(NAME + 'No square root');
-    }
-
-    // Estimate.
-    s = Math.sqrt(+stringify(x, true, true));
-
-    // Math.sqrt underflow/overflow?
-    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
-    if (s === 0 || s === 1 / 0) {
-      c = x.c.join('');
-      if (!(c.length + e & 1)) c += '0';
-      s = Math.sqrt(c);
-      e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
-      r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
-    } else {
-      r = new Big(s + '');
-    }
-    e = r.e + (Big.DP += 4);
-
-    // Newton-Raphson iteration.
-    do {
-      t = r;
-      r = half.times(t.plus(x.div(t)));
-    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));
-    return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);
-  };
-
-  /*
-   * Return a new Big whose value is the value of this Big times the value of Big y.
-   */
-  P.times = P.mul = function (y) {
-    var c,
-      x = this,
-      Big = x.constructor,
-      xc = x.c,
-      yc = (y = new Big(y)).c,
-      a = xc.length,
-      b = yc.length,
-      i = x.e,
-      j = y.e;
-
-    // Determine sign of result.
-    y.s = x.s == y.s ? 1 : -1;
-
-    // Return signed 0 if either 0.
-    if (!xc[0] || !yc[0]) {
-      y.c = [y.e = 0];
-      return y;
-    }
-
-    // Initialise exponent of result as x.e + y.e.
-    y.e = i + j;
-
-    // If array xc has fewer digits than yc, swap xc and yc, and lengths.
-    if (a < b) {
-      c = xc;
-      xc = yc;
-      yc = c;
-      j = a;
-      a = b;
-      b = j;
-    }
-
-    // Initialise coefficient array of result with zeros.
-    for (c = new Array(j = a + b); j--;) c[j] = 0;
-
-    // Multiply.
-
-    // i is initially xc.length.
-    for (i = b; i--;) {
-      b = 0;
-
-      // a is yc.length.
-      for (j = a + i; j > i;) {
-        // Current sum of products at this digit position, plus carry.
-        b = c[j] + yc[i] * xc[j - i - 1] + b;
-        c[j--] = b % 10;
-
-        // carry
-        b = b / 10 | 0;
-      }
-      c[j] = b;
-    }
-
-    // Increment result exponent if there is a final carry, otherwise remove leading zero.
-    if (b) ++y.e;else c.shift();
-
-    // Remove trailing zeros.
-    for (i = c.length; !c[--i];) c.pop();
-    y.c = c;
-    return y;
-  };
-
-  /*
-   * Return a string representing the value of this Big in exponential notation rounded to dp fixed
-   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
-   *
-   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P.toExponential = function (dp, rm) {
-    var x = this,
-      n = x.c[0];
-    if (dp !== UNDEFINED) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-        throw Error(INVALID_DP);
-      }
-      x = round(new x.constructor(x), ++dp, rm);
-      for (; x.c.length < dp;) x.c.push(0);
-    }
-    return stringify(x, true, !!n);
-  };
-
-  /*
-   * Return a string representing the value of this Big in normal notation rounded to dp fixed
-   * decimal places using rounding mode rm, or Big.RM if rm is not specified.
-   *
-   * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   *
-   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
-   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
-   */
-  P.toFixed = function (dp, rm) {
-    var x = this,
-      n = x.c[0];
-    if (dp !== UNDEFINED) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-        throw Error(INVALID_DP);
-      }
-      x = round(new x.constructor(x), dp + x.e + 1, rm);
-
-      // x.e may have changed if the value is rounded up.
-      for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);
-    }
-    return stringify(x, false, !!n);
-  };
-
-  /*
-   * Return a string representing the value of this Big.
-   * Return exponential notation if this Big has a positive exponent equal to or greater than
-   * Big.PE, or a negative exponent equal to or less than Big.NE.
-   * Omit the sign for negative zero.
-   */
-  P.toJSON = P.toString = function () {
-    var x = this,
-      Big = x.constructor;
-    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);
-  };
-  if (typeof Symbol !== "undefined") {
-    P[Symbol.for('nodejs.util.inspect.custom')] = P.toJSON;
-  }
-
-  /*
-   * Return the value of this Big as a primitive number.
-   */
-  P.toNumber = function () {
-    var n = +stringify(this, true, true);
-    if (this.constructor.strict === true && !this.eq(n.toString())) {
-      throw Error(NAME + 'Imprecise conversion');
-    }
-    return n;
-  };
-
-  /*
-   * Return a string representing the value of this Big rounded to sd significant digits using
-   * rounding mode rm, or Big.RM if rm is not specified.
-   * Use exponential notation if sd is less than the number of digits necessary to represent
-   * the integer part of the value in normal notation.
-   *
-   * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.
-   * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).
-   */
-  P.toPrecision = function (sd, rm) {
-    var x = this,
-      Big = x.constructor,
-      n = x.c[0];
-    if (sd !== UNDEFINED) {
-      if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
-        throw Error(INVALID + 'precision');
-      }
-      x = round(new Big(x), sd, rm);
-      for (; x.c.length < sd;) x.c.push(0);
-    }
-    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);
-  };
-
-  /*
-   * Return a string representing the value of this Big.
-   * Return exponential notation if this Big has a positive exponent equal to or greater than
-   * Big.PE, or a negative exponent equal to or less than Big.NE.
-   * Include the sign for negative zero.
-   */
-  P.valueOf = function () {
-    var x = this,
-      Big = x.constructor;
-    if (Big.strict === true) {
-      throw Error(NAME + 'valueOf disallowed');
-    }
-    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);
-  };
-
-  // Export
-
-  var Big = _Big_();
-
   var FN_REF = '__fn';
   var DEFAULT_PRIORITY$4 = 1000;
   var slice = Array.prototype.slice;