@lotics/app-sdk 0.120.2 → 0.121.0

package/dist/{chunk-NZXJENJ2.js → chunk-MK4DBY6R.js}

@@ -185,28 +185,651 @@ function bandOf(tiers, figure) {
   return { min: tiers[at - 1] ?? null, max: tiers[at] ?? null };
 }
 
-// ../shared/src/utils.ts
-function decimalPlaces(value) {
-  if (Number.isInteger(value)) return 0;
-  const [mantissa = "", exponent = "0"] = String(value).split("e");
-  const fraction = mantissa.split(".")[1]?.length ?? 0;
-  return Math.max(0, fraction - Number(exponent));
+// ../../node_modules/big.js/big.mjs
+var DP = 20;
+var RM = 1;
+var MAX_DP = 1e6;
+var MAX_POWER = 1e6;
+var NE = -7;
+var PE = 21;
+var STRICT = false;
+var NAME = "[big.js] ";
+var INVALID = NAME + "Invalid ";
+var INVALID_DP = INVALID + "decimal places";
+var INVALID_RM = INVALID + "rounding mode";
+var DIV_BY_ZERO = NAME + "Division by zero";
+var P = {};
+var UNDEFINED = void 0;
+var NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+function _Big_() {
+  function Big2(n) {
+    var x = this;
+    if (!(x instanceof Big2)) {
+      return n === UNDEFINED && arguments.length === 0 ? _Big_() : new Big2(n);
+    }
+    if (n instanceof Big2) {
+      x.s = n.s;
+      x.e = n.e;
+      x.c = n.c.slice();
+    } else {
+      if (typeof n !== "string") {
+        if (Big2.strict === true && typeof n !== "bigint") {
+          throw TypeError(INVALID + "value");
+        }
+        n = n === 0 && 1 / n < 0 ? "-0" : String(n);
+      }
+      parse(x, n);
+    }
+    x.constructor = Big2;
+  }
+  Big2.prototype = P;
+  Big2.DP = DP;
+  Big2.RM = RM;
+  Big2.NE = NE;
+  Big2.PE = PE;
+  Big2.strict = STRICT;
+  Big2.roundDown = 0;
+  Big2.roundHalfUp = 1;
+  Big2.roundHalfEven = 2;
+  Big2.roundUp = 3;
+  return Big2;
+}
+function parse(x, n) {
+  var e, i, nl;
+  if (!NUMERIC.test(n)) {
+    throw Error(INVALID + "number");
+  }
+  x.s = n.charAt(0) == "-" ? (n = n.slice(1), -1) : 1;
+  if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");
+  if ((i = n.search(/e/i)) > 0) {
+    if (e < 0) e = i;
+    e += +n.slice(i + 1);
+    n = n.substring(0, i);
+  } else if (e < 0) {
+    e = n.length;
+  }
+  nl = n.length;
+  for (i = 0; i < nl && n.charAt(i) == "0"; ) ++i;
+  if (i == nl) {
+    x.c = [x.e = 0];
+  } else {
+    for (; nl > 0 && n.charAt(--nl) == "0"; ) ;
+    x.e = e - i - 1;
+    x.c = [];
+    for (e = 0; i <= nl; ) x.c[e++] = +n.charAt(i++);
+  }
+  return x;
+}
+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) {
+      x.e = x.e - sd + 1;
+      xc[0] = 1;
+    } else {
+      xc[0] = x.e = 0;
+    }
+  } else if (sd < xc.length) {
+    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]);
+    xc.length = sd;
+    if (more) {
+      for (; ++xc[--sd] > 9; ) {
+        xc[sd] = 0;
+        if (sd === 0) {
+          ++x.e;
+          xc.unshift(1);
+          break;
+        }
+      }
+    }
+    for (sd = xc.length; !xc[--sd]; ) xc.pop();
+  }
+  return x;
+}
+function stringify(x, doExponential, isNonzero) {
+  var e = x.e, s = x.c.join(""), n = s.length;
+  if (doExponential) {
+    s = s.charAt(0) + (n > 1 ? "." + s.slice(1) : "") + (e < 0 ? "e" : "e+") + e;
+  } 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;
+}
+P.abs = function() {
+  var x = new this.constructor(this);
+  x.s = 1;
+  return x;
+};
+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;
+  if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
+  if (i != j) return i;
+  isneg = i < 0;
+  if (k != l) return k > l ^ isneg ? 1 : -1;
+  j = (k = xc.length) < (l = yc.length) ? k : l;
+  for (i = -1; ++i < j; ) {
+    if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
+  }
+  return k == l ? 0 : k > l ^ isneg ? 1 : -1;
+};
+P.div = function(y) {
+  var x = this, Big2 = x.constructor, a = x.c, b = (y = new Big2(y)).c, k = x.s == y.s ? 1 : -1, dp = Big2.DP;
+  if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
+    throw Error(INVALID_DP);
+  }
+  if (!b[0]) {
+    throw Error(DIV_BY_ZERO);
+  }
+  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), rl = r.length, q = y, qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1;
+  q.s = k;
+  k = p < 0 ? 0 : p;
+  bz.unshift(0);
+  for (; rl++ < bl; ) r.push(0);
+  do {
+    for (n = 0; n < 10; n++) {
+      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 (cmp < 0) {
+        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;
+      }
+    }
+    qc[qi++] = cmp ? n : ++n;
+    if (r[0] && cmp) r[rl] = a[ai] || 0;
+    else r = [a[ai]];
+  } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
+  if (!qc[0] && qi != 1) {
+    qc.shift();
+    q.e--;
+    p--;
+  }
+  if (qi > p) round(q, p, Big2.RM, r[0] !== UNDEFINED);
+  return q;
+};
+P.eq = function(y) {
+  return this.cmp(y) === 0;
+};
+P.gt = function(y) {
+  return this.cmp(y) > 0;
+};
+P.gte = function(y) {
+  return this.cmp(y) > -1;
+};
+P.lt = function(y) {
+  return this.cmp(y) < 0;
+};
+P.lte = function(y) {
+  return this.cmp(y) < 1;
+};
+P.minus = P.sub = function(y) {
+  var i, j, t, xlty, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(y)).s;
+  if (a != b) {
+    y.s = -b;
+    return x.plus(y);
+  }
+  var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;
+  if (!xc[0] || !yc[0]) {
+    if (yc[0]) {
+      y.s = -b;
+    } else if (xc[0]) {
+      y = new Big2(x);
+    } else {
+      y.s = 1;
+    }
+    return y;
+  }
+  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 = 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;
+      }
+    }
+  }
+  if (xlty) {
+    t = xc;
+    xc = yc;
+    yc = t;
+    y.s = -y.s;
+  }
+  if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--; ) xc[i++] = 0;
+  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];
+  }
+  for (; xc[--b] === 0; ) xc.pop();
+  for (; xc[0] === 0; ) {
+    xc.shift();
+    --ye;
+  }
+  if (!xc[0]) {
+    y.s = 1;
+    xc = [ye = 0];
+  }
+  y.c = xc;
+  y.e = ye;
+  return y;
+};
+P.mod = function(y) {
+  var ygtx, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(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 Big2(x);
+  a = Big2.DP;
+  b = Big2.RM;
+  Big2.DP = Big2.RM = 0;
+  x = x.div(y);
+  Big2.DP = a;
+  Big2.RM = b;
+  return this.minus(x.times(y));
+};
+P.neg = function() {
+  var x = new this.constructor(this);
+  x.s = -x.s;
+  return x;
+};
+P.plus = P.add = function(y) {
+  var e, k, t, x = this, Big2 = x.constructor;
+  y = new Big2(y);
+  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;
+  if (!xc[0] || !yc[0]) {
+    if (!yc[0]) {
+      if (xc[0]) {
+        y = new Big2(x);
+      } else {
+        y.s = x.s;
+      }
+    }
+    return y;
+  }
+  xc = xc.slice();
+  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();
+  }
+  if (xc.length - yc.length < 0) {
+    t = yc;
+    yc = xc;
+    xc = t;
+  }
+  e = yc.length;
+  for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
+  if (k) {
+    xc.unshift(k);
+    ++ye;
+  }
+  for (e = xc.length; xc[--e] === 0; ) xc.pop();
+  y.c = xc;
+  y.e = ye;
+  return y;
+};
+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;
+};
+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);
+};
+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);
+};
+P.sqrt = function() {
+  var r, c, t, x = this, Big2 = x.constructor, s = x.s, e = x.e, half = new Big2("0.5");
+  if (!x.c[0]) return new Big2(x);
+  if (s < 0) {
+    throw Error(NAME + "No square root");
+  }
+  s = Math.sqrt(+stringify(x, true, true));
+  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 Big2((s == 1 / 0 ? "5e" : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e);
+  } else {
+    r = new Big2(s + "");
+  }
+  e = r.e + (Big2.DP += 4);
+  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, (Big2.DP -= 4) + r.e + 1, Big2.RM);
+};
+P.times = P.mul = function(y) {
+  var c, x = this, Big2 = x.constructor, xc = x.c, yc = (y = new Big2(y)).c, a = xc.length, b = yc.length, i = x.e, j = y.e;
+  y.s = x.s == y.s ? 1 : -1;
+  if (!xc[0] || !yc[0]) {
+    y.c = [y.e = 0];
+    return y;
+  }
+  y.e = i + j;
+  if (a < b) {
+    c = xc;
+    xc = yc;
+    yc = c;
+    j = a;
+    a = b;
+    b = j;
+  }
+  for (c = new Array(j = a + b); j--; ) c[j] = 0;
+  for (i = b; i--; ) {
+    b = 0;
+    for (j = a + i; j > i; ) {
+      b = c[j] + yc[i] * xc[j - i - 1] + b;
+      c[j--] = b % 10;
+      b = b / 10 | 0;
+    }
+    c[j] = b;
+  }
+  if (b) ++y.e;
+  else c.shift();
+  for (i = c.length; !c[--i]; ) c.pop();
+  y.c = c;
+  return y;
+};
+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);
+};
+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);
+    for (dp = dp + x.e + 1; x.c.length < dp; ) x.c.push(0);
+  }
+  return stringify(x, false, !!n);
+};
+P.toJSON = P.toString = function() {
+  var x = this, Big2 = x.constructor;
+  return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, !!x.c[0]);
+};
+if (typeof Symbol !== "undefined") {
+  P[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = P.toJSON;
+}
+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;
+};
+P.toPrecision = function(sd, rm) {
+  var x = this, Big2 = x.constructor, n = x.c[0];
+  if (sd !== UNDEFINED) {
+    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
+      throw Error(INVALID + "precision");
+    }
+    x = round(new Big2(x), sd, rm);
+    for (; x.c.length < sd; ) x.c.push(0);
+  }
+  return stringify(x, sd <= x.e || x.e <= Big2.NE || x.e >= Big2.PE, !!n);
+};
+P.valueOf = function() {
+  var x = this, Big2 = x.constructor;
+  if (Big2.strict === true) {
+    throw Error(NAME + "valueOf disallowed");
+  }
+  return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, true);
+};
+var Big = _Big_();
+var big_default = Big;
+
+// ../shared/src/decimal.ts
+var DIVISION_DIGITS = 24;
+var ROUNDING_PLACES = 1e6;
+var POWER_DIGITS = 300;
+var SIGNIFICANT_DIGITS = 15;
+var SHORT_DIGITS = 12;
+var WHOLE_DIGITS_LIMIT = 10 ** SIGNIFICANT_DIGITS;
+var DIVISION_SCALES = [10, 100, 1e3, 1e4, 1e5, 1e6];
+var Decimal = big_default();
+Decimal.DP = DIVISION_DIGITS;
+Decimal.RM = big_default.roundDown;
+var QUOTIENT_STEP = new Decimal(`1e-${DIVISION_DIGITS}`);
+function takesFloat(left, right) {
+  return !Number.isFinite(left) || !Number.isFinite(right) || left === 0 || right === 0;
+}
+function isExactInteger(left, right, result) {
+  return Number.isSafeInteger(left) && Number.isSafeInteger(right) && Number.isSafeInteger(result);
+}
+function isInexact(value, decimal) {
+  return decimal.c.length > SHORT_DIGITS && !Number.isSafeInteger(value);
+}
+function settled(result, inexact) {
+  if (!inexact) return result;
+  const reading = result.prec(SIGNIFICANT_DIGITS, big_default.roundHalfUp);
+  return reading.c.length <= SHORT_DIGITS ? reading : result;
+}
+function addDecimal(left, right) {
+  const float = left + right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const augend = new Decimal(left);
+  const addend = new Decimal(right);
+  return settled(augend.plus(addend), isInexact(left, augend) || isInexact(right, addend)).toNumber();
+}
+function subtractDecimal(left, right) {
+  const float = left - right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const minuend = new Decimal(left);
+  const subtrahend = new Decimal(right);
+  return settled(minuend.minus(subtrahend), isInexact(left, minuend) || isInexact(right, subtrahend)).toNumber();
+}
+function multiplyDecimal(left, right) {
+  return product(left, right, true);
+}
+function multiplyExactly(left, right) {
+  return product(left, right, false);
+}
+function product(left, right, settles) {
+  const float = left * right;
+  if (takesFloat(left, right) || isExactInteger(left, right, float)) return float;
+  const multiplicand = new Decimal(left);
+  const multiplier = new Decimal(right);
+  return settled(multiplicand.times(multiplier), settles && (isInexact(left, multiplicand) || isInexact(right, multiplier))).toNumber();
+}
+function divideDecimal(left, right) {
+  if (takesFloat(left, right) || Number.isSafeInteger(left) && Number.isSafeInteger(right)) return left / right;
+  const scaled = scaledQuotient(left, right);
+  if (scaled !== void 0) return scaled;
+  const dividend = new Decimal(left);
+  const divisor = new Decimal(right);
+  return quotient(dividend, divisor, isInexact(left, dividend) || isInexact(right, divisor));
+}
+function scaledQuotient(left, right) {
+  for (const scale2 of DIVISION_SCALES) {
+    const dividend = Math.round(left * scale2);
+    if (Math.abs(dividend) >= WHOLE_DIGITS_LIMIT || dividend / scale2 !== left) continue;
+    const divisor = Math.round(right * scale2);
+    if (Math.abs(divisor) < WHOLE_DIGITS_LIMIT && divisor / scale2 === right) return dividend / divisor;
+  }
+  return void 0;
+}
+function moduloDecimal(left, right) {
+  if (takesFloat(left, right)) return left % right;
+  const remainder = new Decimal(left).mod(right);
+  if (remainder.eq(0)) return left < 0 ? -0 : 0;
+  return remainder.toNumber();
+}
+function readAtSignificantDigits(value) {
+  if (Number.isInteger(value) || !Number.isFinite(value)) return value;
+  if (Math.abs(value) >= WHOLE_DIGITS_LIMIT) return Math.sign(value) * Math.round(Math.abs(value));
+  return Number(value.toPrecision(SIGNIFICANT_DIGITS));
+}
+function compareDecimal(left, right) {
+  if (left === right) return 0;
+  if (Number.isNaN(left) || Number.isNaN(right)) return NaN;
+  const leftRead = readAtSignificantDigits(left);
+  const rightRead = readAtSignificantDigits(right);
+  if (leftRead === rightRead) return 0;
+  return leftRead < rightRead ? -1 : 1;
 }
 function sumDecimal(values, divisor = 1) {
-  const float = values.reduce((total2, value) => total2 + value, 0) / divisor;
-  if (!values.every(Number.isFinite)) return float;
-  const factor = 10 ** values.reduce((places, value) => Math.max(places, decimalPlaces(value)), 0);
-  const scaled = values.map((value) => Math.round(value * factor));
-  const total = scaled.reduce((sum, value) => sum + value, 0);
-  const exact = Number.isSafeInteger(total) && scaled.every((one, index) => Number.isSafeInteger(one) && one / factor === values[index]);
-  return exact ? total / (factor * divisor) : float;
+  if (!values.every(Number.isFinite) || !Number.isFinite(divisor) || divisor === 0) {
+    return values.reduce((total2, value) => total2 + value, 0) / divisor;
+  }
+  const { total, inexact } = isWithinSafeIntegers(values) ? { total: new Decimal(values.reduce((sum, value) => sum + value, 0)), inexact: false } : totalOf(values);
+  if (total.eq(0)) return 0;
+  if (divisor === 1) return total.toNumber();
+  const by = new Decimal(divisor);
+  return quotient(total, by, inexact || isInexact(divisor, by));
+}
+function totalOf(values) {
+  let total = new Decimal(0);
+  let inexact = false;
+  for (const value of values) {
+    const term = new Decimal(value);
+    inexact ||= isInexact(value, term);
+    total = total.plus(term);
+  }
+  return { total: settled(total, inexact), inexact };
+}
+function isWithinSafeIntegers(values) {
+  return values.every(Number.isSafeInteger) && values.reduce((magnitude, value) => magnitude + Math.abs(value), 0) <= Number.MAX_SAFE_INTEGER;
 }
-function sample(arr) {
-  if (arr.length === 0) return void 0;
-  return arr[Math.floor(Math.random() * arr.length)];
+function roundDecimal(value, places) {
+  if (!Number.isFinite(value) || value === 0 || !Number.isInteger(places) || Math.abs(places) > ROUNDING_PLACES) {
+    const multiplier = Math.pow(10, places);
+    return Math.sign(value) * Math.round(Math.abs(value) * multiplier) / multiplier;
+  }
+  const rounded = new Decimal(value).round(places, big_default.roundHalfUp);
+  if (rounded.eq(0)) return value < 0 ? -0 : 0;
+  return rounded.toNumber();
+}
+function percentOf(part, total) {
+  return roundDecimal(divideDecimal(multiplyDecimal(part, 100), total), 0);
+}
+function fixedDecimal(value, places) {
+  if (!Number.isFinite(value) || Math.abs(value) >= 1e21) return value.toFixed(places);
+  return new Decimal(value).toFixed(places, big_default.roundHalfUp);
+}
+function powerDecimal(base, exponent) {
+  const float = Math.pow(base, exponent);
+  if (takesFloat(base, exponent) || !Number.isInteger(exponent)) return float;
+  const decimal = new Decimal(base);
+  if (decimal.c.length * Math.abs(exponent) > POWER_DIGITS) return float;
+  const inexact = isInexact(base, decimal);
+  const power = settled(decimal.pow(Math.abs(exponent)), inexact);
+  return exponent > 0 ? power.toNumber() : quotient(new Decimal(1), power, inexact);
+}
+function quotient(dividend, divisor, inexact) {
+  const sign = dividend.s === divisor.s ? 1 : -1;
+  const numerator = coefficientOf(dividend);
+  const denominator = coefficientOf(divisor);
+  for (let carried = 0; ; carried = carried * 2 + DIVISION_DIGITS) {
+    const scaled = new Decimal(`${numerator.digits}e${carried}`);
+    const low = scaled.div(denominator.digits);
+    const exponent = numerator.exponent - denominator.exponent - carried;
+    if (inexact) {
+      const short = settled(low, true);
+      if (short !== low) return sign * Number(`${short.toFixed()}e${exponent}`);
+    }
+    const lowNumber = Number(`${low.toFixed()}e${exponent}`);
+    const highNumber = Number(`${low.plus(QUOTIENT_STEP).toFixed()}e${exponent}`);
+    if (lowNumber === highNumber || low.times(denominator.digits).eq(scaled)) return sign * lowNumber;
+  }
 }
-function assertNever(value) {
-  throw new Error(`Unhandled union member: ${JSON.stringify(value)}`);
+function coefficientOf(decimal) {
+  const [digits = "", exponent = "0"] = decimal.abs().toExponential().split("e");
+  return { digits, exponent: Number(exponent) };
 }
 
 // ../shared/src/schemas/read_row.ts
@@ -1033,6 +1656,7 @@ function rpcStandalone(op, payload) {
     case "comments.counts":
       return rejectCommentsStandalone();
     case "activity.list":
+    case "activity.undo":
       return Promise.reject(new Error("A record's activity is available only in embedded apps \u2014 a signed-in member is required."));
     case "recording.start":
     case "recording.stop":
@@ -1242,9 +1866,18 @@ export {
   tiersAscend,
   bandKey,
   bandOf,
+  addDecimal,
+  subtractDecimal,
+  multiplyDecimal,
+  multiplyExactly,
+  divideDecimal,
+  moduloDecimal,
+  compareDecimal,
   sumDecimal,
-  sample,
-  assertNever,
+  roundDecimal,
+  percentOf,
+  fixedDecimal,
+  powerDecimal,
   AGGREGATE_COUNT_COLUMN,
   AGGREGATE_SUM_COLUMN,
   aggregateRows,

package/dist/index.d.ts

@@ -11,9 +11,9 @@ export type { ExportedFile } from "./shared_types.js";
 export type { AttachedFile, AttachmentPiles, AttachmentPilesOptions, AttachmentsOptions, AttachmentsState } from "./attachments.js";
 export { useComments, useCommentCounts } from "./comments.js";
 export type { AppComment, AppCommentAuthor, AppCommentFile, CommentsState, UseCommentsArgs, CommentCountsState, UseCommentCountsArgs, } from "./comments.js";
-export { useRecordActivity } from "./activity.js";
+export { undoRecordChange, useRecordActivity } from "./activity.js";
 export type { RecordActivityOptions, RecordActivityState } from "./activity.js";
-export type { ActivityActor, ActivityActorKind, ActivityChange, ActivityComment, ActivityEntry, ActivityValue, RecordActivityPage, } from "./shared_types.js";
+export type { ActivityActor, ActivityActorKind, ActivityChange, ActivityComment, ActivityEntry, ActivityUndoResult, ActivityValue, RecordActivityPage, UndoKeptReason, } from "./shared_types.js";
 export { useAppContext, useViewer, useWorkspaceCurrency, useWorkspaceTimezone } from "./viewer.js";
 export type { AppAbsence } from "./shared_types.js";
 export { useRecording, useRecordings } from "./recording.js";