@devmm/puredocs-excel-formula 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -2358,9 +2358,11 @@ function datedif(a, c) {
 function registerLookup(r) {
   r.register("VLOOKUP", vlookup, 3, 4);
   r.register("HLOOKUP", hlookup, 3, 4);
+  r.register("XLOOKUP", xlookup, 3, 6);
   r.register("LOOKUP", lookup, 2, 3);
   r.register("INDEX", index_, 2, 3);
   r.register("MATCH", match, 2, 3);
+  r.register("XMATCH", xmatch, 2, 4);
   r.register("CHOOSE", choose, 2);
   r.register("ADDRESS", address, 2, 5);
   r.register("ROW", row, 0, 1);
@@ -2434,6 +2436,121 @@ function hlookup(a, c) {
   }
   return best >= 0 ? tbl.get(rowIdx, best) : FormulaValue.errorNA;
 }
+function wildcardRegex(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "~" && i + 1 < pattern.length) {
+      const next = pattern[++i];
+      out += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    } else if (ch === "*") out += ".*";
+    else if (ch === "?") out += ".";
+    else out += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${out}$`, "i");
+}
+function findMatch(n, get, lookupVal, matchMode, searchMode) {
+  if ((searchMode === 2 || searchMode === -2) && matchMode !== 2) {
+    const at = searchMode === 2 ? get : (j) => get(n - 1 - j);
+    let lo = 0, hi = n - 1, lastLE = -1, firstGE = -1;
+    while (lo <= hi) {
+      const mid2 = lo + hi >>> 1;
+      const cmp = FormulaValue.compare(at(mid2), lookupVal);
+      if (cmp === 0) return searchMode === 2 ? mid2 : n - 1 - mid2;
+      if (cmp < 0) {
+        lastLE = mid2;
+        lo = mid2 + 1;
+      } else {
+        firstGE = mid2;
+        hi = mid2 - 1;
+      }
+    }
+    const idx = matchMode === -1 ? lastLE : matchMode === 1 ? firstGE : -1;
+    return idx < 0 ? -1 : searchMode === 2 ? idx : n - 1 - idx;
+  }
+  const reverse = searchMode === -1;
+  const order = reverse ? Array.from({ length: n }, (_, k) => n - 1 - k) : Array.from({ length: n }, (_, k) => k);
+  if (matchMode === 2) {
+    const re = wildcardRegex(lookupVal.asText());
+    for (const i of order) if (re.test(get(i).asText())) return i;
+    return -1;
+  }
+  if (matchMode === 0) {
+    for (const i of order) if (FormulaValue.areEqual(get(i), lookupVal)) return i;
+    return -1;
+  }
+  let best = -1;
+  let bestVal = null;
+  for (const i of order) {
+    const v = get(i);
+    const cmp = FormulaValue.compare(v, lookupVal);
+    if (cmp === 0) return i;
+    if (matchMode === -1 && cmp < 0) {
+      if (bestVal === null || FormulaValue.compare(v, bestVal) > 0) {
+        best = i;
+        bestVal = v;
+      }
+    } else if (matchMode === 1 && cmp > 0) {
+      if (bestVal === null || FormulaValue.compare(v, bestVal) < 0) {
+        best = i;
+        bestVal = v;
+      }
+    }
+  }
+  return best;
+}
+function xlookup(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const lookupRaw = a[1].evaluate(c);
+  if (lookupRaw.isError) return lookupRaw;
+  const returnRaw = a[2].evaluate(c);
+  if (returnRaw.isError) return returnRaw;
+  const matchMode = a.length > 4 ? num2(a, c, 4) : { ok: true, n: 0 };
+  if (!matchMode.ok) return matchMode.e;
+  const searchMode = a.length > 5 ? num2(a, c, 5) : { ok: true, n: 1 };
+  if (!searchMode.ok) return searchMode.e;
+  const mm = Math.trunc(matchMode.n), sm = Math.trunc(searchMode.n);
+  const la = lookupRaw.isArray ? lookupRaw.arrayVal : ArrayValue.fromScalar(lookupRaw);
+  if (la.rows > 1 && la.columns > 1) return FormulaValue.errorValue;
+  const vertical = !(la.rows === 1 && la.columns > 1);
+  const n = vertical ? la.rows : la.columns;
+  const get = vertical ? (i) => la.get(i, 0) : (i) => la.get(0, i);
+  const idx = findMatch(n, get, lookupVal, mm, sm);
+  if (idx < 0) {
+    return a.length > 3 ? a[3].evaluate(c) : FormulaValue.errorNA;
+  }
+  const ret = returnRaw.isArray ? returnRaw.arrayVal : ArrayValue.fromScalar(returnRaw);
+  if (vertical) {
+    if (ret.rows !== n) return FormulaValue.errorValue;
+    if (ret.columns === 1) return ret.get(idx, 0);
+    const out2 = new ArrayValue(1, ret.columns);
+    for (let col = 0; col < ret.columns; col++) out2.set(0, col, ret.get(idx, col));
+    return FormulaValue.array(out2);
+  }
+  if (ret.columns !== n) return FormulaValue.errorValue;
+  if (ret.rows === 1) return ret.get(0, idx);
+  const out = new ArrayValue(ret.rows, 1);
+  for (let r = 0; r < ret.rows; r++) out.set(r, 0, ret.get(r, idx));
+  return FormulaValue.array(out);
+}
+function xmatch(a, c) {
+  const lookupVal = a[0].evaluate(c);
+  if (lookupVal.isError) return lookupVal;
+  const lookupRaw = a[1].evaluate(c);
+  if (lookupRaw.isError) return lookupRaw;
+  const matchMode = a.length > 2 ? num2(a, c, 2) : { ok: true, n: 0 };
+  if (!matchMode.ok) return matchMode.e;
+  const searchMode = a.length > 3 ? num2(a, c, 3) : { ok: true, n: 1 };
+  if (!searchMode.ok) return searchMode.e;
+  const la = lookupRaw.isArray ? lookupRaw.arrayVal : ArrayValue.fromScalar(lookupRaw);
+  if (la.rows > 1 && la.columns > 1) return FormulaValue.errorValue;
+  const vertical = !(la.rows === 1 && la.columns > 1);
+  const n = vertical ? la.rows : la.columns;
+  const get = vertical ? (i) => la.get(i, 0) : (i) => la.get(0, i);
+  const idx = findMatch(n, get, lookupVal, Math.trunc(matchMode.n), Math.trunc(searchMode.n));
+  return idx < 0 ? FormulaValue.errorNA : FormulaValue.number(idx + 1);
+}
 function index_(a, c) {
   const arrVal = a[0].evaluate(c);
   if (arrVal.isError) return arrVal;
@@ -2967,6 +3084,24 @@ function registerFinance(r) {
   r.register("PV", pv, 3, 5);
   r.register("NPV", npv, 2);
   r.register("IRR", irr, 1, 2);
+  r.register("RATE", rate, 3, 6);
+  r.register("NPER", nper, 3, 5);
+  r.register("XNPV", xnpv, 3, 3);
+  r.register("XIRR", xirr, 2, 3);
+  r.register("IPMT", ipmt, 4, 6);
+  r.register("PPMT", ppmt, 4, 6);
+}
+function pmtValue(r, n, pv2, fv2, type) {
+  if (r === 0) return -(pv2 + fv2) / n;
+  const pow = Math.pow(1 + r, n);
+  let payment = (-fv2 - pv2 * pow) * r / (pow - 1);
+  if (type === 1) payment /= 1 + r;
+  return payment;
+}
+function fvValue(r, n, pmt2, pv2, type) {
+  if (r === 0) return -(pv2 + pmt2 * n);
+  const pow = Math.pow(1 + r, n);
+  return -(pv2 * pow + pmt2 * (1 + r * type) * (pow - 1) / r);
 }
 function arg(a, c, idx, dflt) {
   if (idx >= a.length) return { ok: true, n: dflt };
@@ -2974,65 +3109,59 @@ function arg(a, c, idx, dflt) {
   return r.ok ? { ok: true, n: r.value } : { ok: false, e: r.error };
 }
 function pmt(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pvv = arg(a, c, 2, 0);
   if (!pvv.ok) return pvv.e;
   const fvv = arg(a, c, 3, 0);
   if (!fvv.ok) return fvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, present = pvv.n, future = fvv.n, t = type.n;
+  const r = rate2.n, n = nper2.n, present = pvv.n, future = fvv.n, t = type.n;
   if (n === 0) return FormulaValue.errorNum;
-  if (r === 0) return FormulaValue.number(-(present + future) / n);
-  const pow = Math.pow(1 + r, n);
-  let payment = (-future - present * pow) * r / (pow - 1);
-  if (t === 1) payment /= 1 + r;
-  return FormulaValue.number(payment);
+  return FormulaValue.number(pmtValue(r, n, present, future, t));
 }
 function fv(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pmtv = arg(a, c, 2, 0);
   if (!pmtv.ok) return pmtv.e;
   const pvv = arg(a, c, 3, 0);
   if (!pvv.ok) return pvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, payment = pmtv.n, present = pvv.n, t = type.n;
-  if (r === 0) return FormulaValue.number(-(present + payment * n));
-  const pow = Math.pow(1 + r, n);
-  return FormulaValue.number(-(present * pow + payment * (1 + r * t) * (pow - 1) / r));
+  const r = rate2.n, n = nper2.n, payment = pmtv.n, present = pvv.n, t = type.n;
+  return FormulaValue.number(fvValue(r, n, payment, present, t));
 }
 function pv(a, c) {
-  const rate = arg(a, c, 0, 0);
-  if (!rate.ok) return rate.e;
-  const nper = arg(a, c, 1, 0);
-  if (!nper.ok) return nper.e;
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const nper2 = arg(a, c, 1, 0);
+  if (!nper2.ok) return nper2.e;
   const pmtv = arg(a, c, 2, 0);
   if (!pmtv.ok) return pmtv.e;
   const fvv = arg(a, c, 3, 0);
   if (!fvv.ok) return fvv.e;
   const type = arg(a, c, 4, 0);
   if (!type.ok) return type.e;
-  const r = rate.n, n = nper.n, payment = pmtv.n, future = fvv.n, t = type.n;
+  const r = rate2.n, n = nper2.n, payment = pmtv.n, future = fvv.n, t = type.n;
   if (r === 0) return FormulaValue.number(-(future + payment * n));
   const pow = Math.pow(1 + r, n);
   return FormulaValue.number(-(future + payment * (1 + r * t) * (pow - 1) / r) / pow);
 }
 function npv(a, c) {
-  const rate = exports.FormulaHelper.evalDouble(a[0], c);
-  if (!rate.ok) return rate.error;
-  if (rate.value === -1) return FormulaValue.errorDiv0;
+  const rate2 = exports.FormulaHelper.evalDouble(a[0], c);
+  if (!rate2.ok) return rate2.error;
+  if (rate2.value === -1) return FormulaValue.errorDiv0;
   const flows = exports.FormulaHelper.collectNumbers(a.slice(1), c);
   if (!flows.ok) return flows.error;
   let total = 0;
   for (let i = 0; i < flows.values.length; i++) {
-    total += flows.values[i] / Math.pow(1 + rate.value, i + 1);
+    total += flows.values[i] / Math.pow(1 + rate2.value, i + 1);
   }
   return FormulaValue.number(total);
 }
@@ -3047,27 +3176,220 @@ function irr(a, c) {
     if (!g.ok) return g.error;
     guess = g.value;
   }
-  const npvAt = (rate2) => {
+  const npvAt = (rate3) => {
     let sum2 = 0;
-    for (let i = 0; i < flows.length; i++) sum2 += flows[i] / Math.pow(1 + rate2, i);
+    for (let i = 0; i < flows.length; i++) sum2 += flows[i] / Math.pow(1 + rate3, i);
     return sum2;
   };
-  let rate = guess;
+  let rate2 = guess;
+  for (let iter = 0; iter < 100; iter++) {
+    const f = npvAt(rate2);
+    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate2);
+    const h = 1e-6;
+    const deriv = (npvAt(rate2 + h) - f) / h;
+    if (deriv === 0) break;
+    const next = rate2 - f / deriv;
+    if (!isFinite(next) || next <= -1) break;
+    if (Math.abs(next - rate2) < 1e-9) {
+      rate2 = next;
+      break;
+    }
+    rate2 = next;
+  }
+  if (Math.abs(npvAt(rate2)) < 1e-6) return FormulaValue.number(rate2);
+  return FormulaValue.errorNum;
+}
+function tvm(r, n, pmt2, pv2, fv2, type) {
+  if (r === 0) return pv2 + pmt2 * n + fv2;
+  const pow = Math.pow(1 + r, n);
+  return pv2 * pow + pmt2 * (1 + r * type) * (pow - 1) / r + fv2;
+}
+function rate(a, c) {
+  const nper2 = arg(a, c, 0, 0);
+  if (!nper2.ok) return nper2.e;
+  const pmtv = arg(a, c, 1, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const pvv = arg(a, c, 2, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const gs = arg(a, c, 5, 0.1);
+  if (!gs.ok) return gs.e;
+  const n = nper2.n, pmt2 = pmtv.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0) return FormulaValue.errorNum;
+  let r = gs.n;
   for (let iter = 0; iter < 100; iter++) {
-    const f = npvAt(rate);
-    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate);
+    const f = tvm(r, n, pmt2, pv2, fv2, t);
+    if (Math.abs(f) < 1e-8) return FormulaValue.number(r);
     const h = 1e-6;
-    const deriv = (npvAt(rate + h) - f) / h;
+    const deriv = (tvm(r + h, n, pmt2, pv2, fv2, t) - f) / h;
     if (deriv === 0) break;
-    const next = rate - f / deriv;
+    const next = r - f / deriv;
     if (!isFinite(next) || next <= -1) break;
-    if (Math.abs(next - rate) < 1e-9) {
-      rate = next;
+    if (Math.abs(next - r) < 1e-10) {
+      r = next;
       break;
     }
-    rate = next;
+    r = next;
   }
-  if (Math.abs(npvAt(rate)) < 1e-6) return FormulaValue.number(rate);
+  if (Math.abs(tvm(r, n, pmt2, pv2, fv2, t)) < 1e-6) return FormulaValue.number(r);
+  return FormulaValue.errorNum;
+}
+function nper(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const pmtv = arg(a, c, 1, 0);
+  if (!pmtv.ok) return pmtv.e;
+  const pvv = arg(a, c, 2, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 3, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 4, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, pmt2 = pmtv.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (r === 0) {
+    if (pmt2 === 0) return FormulaValue.errorNum;
+    return FormulaValue.number(-(pv2 + fv2) / pmt2);
+  }
+  const adj = pmt2 * (1 + r * t);
+  const num5 = adj - fv2 * r;
+  const den = adj + pv2 * r;
+  if (den === 0 || num5 / den <= 0) return FormulaValue.errorNum;
+  const result = Math.log(num5 / den) / Math.log(1 + r);
+  if (!isFinite(result)) return FormulaValue.errorNum;
+  return FormulaValue.number(result);
+}
+function interestForPeriod(r, per, n, pv2, fv2, t) {
+  const pay = pmtValue(r, n, pv2, fv2, t);
+  if (t === 1) {
+    if (per === 1) return 0;
+    return fvValue(r, per - 2, pay, pv2, 1) * r / (1 + r);
+  }
+  return fvValue(r, per - 1, pay, pv2, 0) * r;
+}
+function ipmt(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const perv = arg(a, c, 1, 0);
+  if (!perv.ok) return perv.e;
+  const nper2 = arg(a, c, 2, 0);
+  if (!nper2.ok) return nper2.e;
+  const pvv = arg(a, c, 3, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 4, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 5, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, per = perv.n, n = nper2.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0 || per < 1 || per > n) return FormulaValue.errorNum;
+  return FormulaValue.number(interestForPeriod(r, per, n, pv2, fv2, t));
+}
+function ppmt(a, c) {
+  const rate2 = arg(a, c, 0, 0);
+  if (!rate2.ok) return rate2.e;
+  const perv = arg(a, c, 1, 0);
+  if (!perv.ok) return perv.e;
+  const nper2 = arg(a, c, 2, 0);
+  if (!nper2.ok) return nper2.e;
+  const pvv = arg(a, c, 3, 0);
+  if (!pvv.ok) return pvv.e;
+  const fvv = arg(a, c, 4, 0);
+  if (!fvv.ok) return fvv.e;
+  const type = arg(a, c, 5, 0);
+  if (!type.ok) return type.e;
+  const r = rate2.n, per = perv.n, n = nper2.n, pv2 = pvv.n, fv2 = fvv.n, t = type.n;
+  if (n === 0 || per < 1 || per > n) return FormulaValue.errorNum;
+  const pay = pmtValue(r, n, pv2, fv2, t);
+  return FormulaValue.number(pay - interestForPeriod(r, per, n, pv2, fv2, t));
+}
+function flatNumbers(node, c) {
+  const v = node.evaluate(c);
+  if (v.isError) return { ok: false, e: v };
+  const out = [];
+  const push = (item) => {
+    if (item.isError) return item;
+    const d = item.tryAsDouble();
+    if (!d.ok) return FormulaValue.errorValue;
+    out.push(d.value);
+    return null;
+  };
+  if (v.isArray) {
+    for (const item of v.arrayVal.values()) {
+      const err = push(item);
+      if (err) return { ok: false, e: err };
+    }
+  } else {
+    const err = push(v);
+    if (err) return { ok: false, e: err };
+  }
+  return { ok: true, values: out };
+}
+function xnpvAt(rate2, values, days2) {
+  let sum2 = 0;
+  for (let i = 0; i < values.length; i++) {
+    sum2 += values[i] / Math.pow(1 + rate2, days2[i] / 365);
+  }
+  return sum2;
+}
+function xnpv(a, c) {
+  const rateRes = exports.FormulaHelper.evalDouble(a[0], c);
+  if (!rateRes.ok) return rateRes.error;
+  const rate2 = rateRes.value;
+  if (rate2 <= -1) return FormulaValue.errorNum;
+  const valsRes = flatNumbers(a[1], c);
+  if (!valsRes.ok) return valsRes.e;
+  const datesRes = flatNumbers(a[2], c);
+  if (!datesRes.ok) return datesRes.e;
+  const values = valsRes.values;
+  const dates = datesRes.values;
+  if (values.length === 0 || values.length !== dates.length) return FormulaValue.errorNum;
+  const base = Math.trunc(dates[0]);
+  const days2 = dates.map((d) => Math.trunc(d) - base);
+  if (days2.some((d) => d < 0)) return FormulaValue.errorNum;
+  return FormulaValue.number(xnpvAt(rate2, values, days2));
+}
+function xirr(a, c) {
+  const valsRes = flatNumbers(a[0], c);
+  if (!valsRes.ok) return valsRes.e;
+  const datesRes = flatNumbers(a[1], c);
+  if (!datesRes.ok) return datesRes.e;
+  const values = valsRes.values;
+  const dates = datesRes.values;
+  if (values.length < 2 || values.length !== dates.length) return FormulaValue.errorNum;
+  let guess = 0.1;
+  if (a.length > 2) {
+    const g = exports.FormulaHelper.evalDouble(a[2], c);
+    if (!g.ok) return g.error;
+    guess = g.value;
+  }
+  const base = Math.trunc(dates[0]);
+  const days2 = dates.map((d) => Math.trunc(d) - base);
+  if (days2.some((d) => d < 0)) return FormulaValue.errorNum;
+  const derivAt = (rate3) => {
+    let sum2 = 0;
+    for (let i = 0; i < values.length; i++) {
+      const e = days2[i] / 365;
+      sum2 += -e * values[i] / Math.pow(1 + rate3, e + 1);
+    }
+    return sum2;
+  };
+  let rate2 = guess;
+  for (let iter = 0; iter < 100; iter++) {
+    const f = xnpvAt(rate2, values, days2);
+    if (Math.abs(f) < 1e-7) return FormulaValue.number(rate2);
+    const deriv = derivAt(rate2);
+    if (deriv === 0) break;
+    const next = rate2 - f / deriv;
+    if (!isFinite(next) || next <= -1) break;
+    if (Math.abs(next - rate2) < 1e-9) {
+      rate2 = next;
+      break;
+    }
+    rate2 = next;
+  }
+  if (Math.abs(xnpvAt(rate2, values, days2)) < 1e-6) return FormulaValue.number(rate2);
   return FormulaValue.errorNum;
 }
 
@@ -3405,10 +3727,17 @@ function registerArray(r) {
   r.register("SEQUENCE", sequence, 1, 4);
   r.register("UNIQUE", unique, 1, 3);
   r.register("SORT", sort, 1, 4);
+  r.register("SORTBY", sortBy, 2);
   r.register("FILTER", filter, 2, 3);
   r.register("MMULT", mmult, 2, 2);
   r.register("TEXTSPLIT", textSplit, 2, 6);
+  r.register("VSTACK", vstack, 1);
+  r.register("HSTACK", hstack, 1);
+  r.register("TOCOL", toCol, 1, 3);
+  r.register("TOROW", toRow, 1, 3);
 }
+var MAX_ROWS = 1048576;
+var MAX_COLS = 16384;
 var asArray2 = (v) => v.isArray ? v.arrayVal : ArrayValue.fromScalar(v);
 function fromRows(rows2) {
   const nr = rows2.length;
@@ -3455,26 +3784,53 @@ function sequence(a, c) {
   }
   return FormulaValue.array(arr);
 }
-function rowsEqual(x, y) {
-  if (x.length !== y.length) return false;
-  for (let i = 0; i < x.length; i++) if (!FormulaValue.areEqual(x[i], y[i])) return false;
-  return true;
+function cellKey(v) {
+  switch (v.kind) {
+    case "number":
+      return "n" + (v.numberValue === 0 ? "0" : String(v.numberValue));
+    case "text":
+      return "t" + v.textValue.toUpperCase();
+    // case-insensitive
+    case "boolean":
+      return v.booleanValue ? "b1" : "b0";
+    case "blank":
+      return "B";
+    case "error":
+      return "e" + v.errorCode;
+    default:
+      return "x";
+  }
 }
 function unique(a, c) {
   const v = a[0].evaluate(c);
   if (v.isError) return v;
   const byCol2 = a.length > 1 ? a[1].evaluate(c).coerceToBool().booleanValue : false;
   const exactlyOnce = a.length > 2 ? a[2].evaluate(c).coerceToBool().booleanValue : false;
-  let rows2 = toRows(byCol2 ? asArray2(v).transpose() : asArray2(v));
-  const counts = rows2.map((r) => rows2.filter((o) => rowsEqual(o, r)).length);
-  const seen = [];
+  const base = byCol2 ? asArray2(v).transpose() : asArray2(v);
+  const map = /* @__PURE__ */ new Map();
+  const order = [];
+  for (let r = 0; r < base.rows; r++) {
+    const cells = new Array(base.columns);
+    let key = "";
+    for (let col = 0; col < base.columns; col++) {
+      const cell = base.get(r, col);
+      cells[col] = cell;
+      const k = cellKey(cell);
+      key += k.length + ":" + k;
+    }
+    const hit = map.get(key);
+    if (hit) hit.count++;
+    else {
+      map.set(key, { cells, count: 1 });
+      order.push(key);
+    }
+  }
   const result = [];
-  rows2.forEach((r, i) => {
-    if (seen.some((o) => rowsEqual(o, r))) return;
-    seen.push(r);
-    if (exactlyOnce && counts[i] > 1) return;
-    result.push(r);
-  });
+  for (const key of order) {
+    const e = map.get(key);
+    if (exactlyOnce && e.count > 1) continue;
+    result.push(e.cells);
+  }
   if (result.length === 0) return FormulaValue.error(8 /* Calc */);
   const out = fromRows(result);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
@@ -3499,6 +3855,58 @@ function sort(a, c) {
   const out = fromRows(sorted);
   return byCol2 ? FormulaValue.array(out.arrayVal.transpose()) : out;
 }
+function sortBy(a, c) {
+  const v = a[0].evaluate(c);
+  if (v.isError) return v;
+  const data = asArray2(v);
+  const keys = [];
+  let i = 1;
+  while (i < a.length) {
+    const byVal = a[i].evaluate(c);
+    if (byVal.isError) return byVal;
+    i++;
+    let dir = 1;
+    if (i < a.length) {
+      const maybeOrder = a[i].evaluate(c);
+      if (maybeOrder.isError) return maybeOrder;
+      if (!maybeOrder.isArray && maybeOrder.isNumeric) {
+        const d = maybeOrder.tryAsDouble();
+        if (d.ok) {
+          dir = d.value < 0 ? -1 : 1;
+          i++;
+        }
+      }
+    }
+    keys.push({ vals: [...asArray2(byVal).values()], dir });
+  }
+  if (keys.length === 0) return FormulaValue.errorValue;
+  const n = keys[0].vals.length;
+  if (keys.some((k) => k.vals.length !== n)) return FormulaValue.errorValue;
+  const byRow2 = n === data.rows;
+  const byColumn = !byRow2 && n === data.columns;
+  if (!byRow2 && !byColumn) return FormulaValue.errorValue;
+  const perm = Array.from({ length: n }, (_, k) => k);
+  perm.sort((x, y) => {
+    for (const key of keys) {
+      const cmp = FormulaValue.compare(key.vals[x], key.vals[y]) * key.dir;
+      if (cmp !== 0) return cmp;
+    }
+    return x - y;
+  });
+  const out = new ArrayValue(data.rows, data.columns);
+  if (byRow2) {
+    for (let r = 0; r < data.rows; r++) {
+      const src = perm[r];
+      for (let col = 0; col < data.columns; col++) out.set(r, col, data.get(src, col));
+    }
+  } else {
+    for (let col = 0; col < data.columns; col++) {
+      const src = perm[col];
+      for (let r = 0; r < data.rows; r++) out.set(r, col, data.get(r, src));
+    }
+  }
+  return FormulaValue.array(out);
+}
 function filter(a, c) {
   const v = a[0].evaluate(c);
   if (v.isError) return v;
@@ -3580,6 +3988,89 @@ function textSplit(a, c) {
   });
   return fromRows(rows2);
 }
+function vstack(a, c) {
+  const parts = [];
+  let totalRows = 0, maxCols = 0;
+  for (const node of a) {
+    const arr = asArray2(node.evaluate(c));
+    parts.push(arr);
+    totalRows += arr.rows;
+    if (arr.columns > maxCols) maxCols = arr.columns;
+  }
+  if (totalRows > MAX_ROWS || maxCols > MAX_COLS) return FormulaValue.errorNum;
+  const out = new ArrayValue(totalRows, maxCols);
+  let rowOff = 0;
+  for (const arr of parts) {
+    for (let r = 0; r < arr.rows; r++) {
+      for (let col = 0; col < maxCols; col++) {
+        out.set(rowOff + r, col, col < arr.columns ? arr.get(r, col) : FormulaValue.errorNA);
+      }
+    }
+    rowOff += arr.rows;
+  }
+  return FormulaValue.array(out);
+}
+function hstack(a, c) {
+  const parts = [];
+  let totalCols = 0, maxRows = 0;
+  for (const node of a) {
+    const arr = asArray2(node.evaluate(c));
+    parts.push(arr);
+    totalCols += arr.columns;
+    if (arr.rows > maxRows) maxRows = arr.rows;
+  }
+  if (maxRows > MAX_ROWS || totalCols > MAX_COLS) return FormulaValue.errorNum;
+  const out = new ArrayValue(maxRows, totalCols);
+  let colOff = 0;
+  for (const arr of parts) {
+    for (let col = 0; col < arr.columns; col++) {
+      for (let r = 0; r < maxRows; r++) {
+        out.set(r, colOff + col, r < arr.rows ? arr.get(r, col) : FormulaValue.errorNA);
+      }
+    }
+    colOff += arr.columns;
+  }
+  return FormulaValue.array(out);
+}
+function flatten(a, c) {
+  const arr = asArray2(a[0].evaluate(c));
+  const ig = num4(a, c, 1, 0);
+  if (!ig.ok) return { ok: false, e: ig.e };
+  const ignore = Math.trunc(ig.n);
+  const byCol2 = a.length > 2 ? a[2].evaluate(c).coerceToBool().booleanValue : false;
+  const skip = (x) => (ignore & 1) !== 0 && x.isBlank || (ignore & 2) !== 0 && x.isError;
+  const values = [];
+  if (byCol2) {
+    for (let col = 0; col < arr.columns; col++)
+      for (let r = 0; r < arr.rows; r++) {
+        const x = arr.get(r, col);
+        if (!skip(x)) values.push(x);
+      }
+  } else {
+    for (let r = 0; r < arr.rows; r++)
+      for (let col = 0; col < arr.columns; col++) {
+        const x = arr.get(r, col);
+        if (!skip(x)) values.push(x);
+      }
+  }
+  return { ok: true, values };
+}
+function toCol(a, c) {
+  const f = flatten(a, c);
+  if (!f.ok) return f.e;
+  if (f.values.length === 0) return FormulaValue.errorNA;
+  const out = new ArrayValue(f.values.length, 1);
+  for (let i = 0; i < f.values.length; i++) out.set(i, 0, f.values[i]);
+  return FormulaValue.array(out);
+}
+function toRow(a, c) {
+  const f = flatten(a, c);
+  if (!f.ok) return f.e;
+  if (f.values.length === 0) return FormulaValue.errorNA;
+  const out = new ArrayValue(1, f.values.length);
+  for (let i = 0; i < f.values.length; i++) out.set(0, i, f.values[i]);
+  return FormulaValue.array(out);
+}
 
 // src/function-registry.ts
 var _default, _functions, _FunctionRegistry_instances, registerBuiltIns_fn;
@@ -4382,8 +4873,8 @@ writeResult_fn = function(e) {
     for (let dc = 0; dc < cols && !collides; dc++) {
       if (dr === 0 && dc === 0) continue;
       const r = e.row + dr, c = e.col + dc;
-      const cellKey = keyOf(e.sheet, puredocsExcel.cellRefFromRowCol(r, c));
-      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey, e.sheetName, puredocsExcel.cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
+      const cellKey2 = keyOf(e.sheet, puredocsExcel.cellRefFromRowCol(r, c));
+      if (__privateMethod(this, _RecalcEngine_instances, isOccupied_fn).call(this, cellKey2, e.sheetName, puredocsExcel.cellRefFromRowCol(r, c), anchorKey, prevSpill)) {
         collides = true;
       }
     }
@@ -4404,9 +4895,9 @@ writeResult_fn = function(e) {
       __privateGet(this, _model).setCellValue(e.sheetName, ref, arr.get(dr, dc).toObject());
       changed.push({ sheet: e.sheet, row: r, col: c });
       if (dr !== 0 || dc !== 0) {
-        const cellKey = keyOf(e.sheet, ref);
-        newSpill.add(cellKey);
-        __privateGet(this, _spillOwner).set(cellKey, anchorKey);
+        const cellKey2 = keyOf(e.sheet, ref);
+        newSpill.add(cellKey2);
+        __privateGet(this, _spillOwner).set(cellKey2, anchorKey);
       }
     }
   }
@@ -4426,11 +4917,11 @@ writeResult_fn = function(e) {
   };
 };
 /** Whether a target cell already holds content that blocks a spill. */
-isOccupied_fn = function(cellKey, sheetName, ref, anchorKey, prevSpill) {
-  if (__privateGet(this, _formulas).has(cellKey) && cellKey !== anchorKey) return true;
-  const owner = __privateGet(this, _spillOwner).get(cellKey);
+isOccupied_fn = function(cellKey2, sheetName, ref, anchorKey, prevSpill) {
+  if (__privateGet(this, _formulas).has(cellKey2) && cellKey2 !== anchorKey) return true;
+  const owner = __privateGet(this, _spillOwner).get(cellKey2);
   if (owner && owner !== anchorKey) return true;
-  if (prevSpill.has(cellKey)) return false;
+  if (prevSpill.has(cellKey2)) return false;
   const v = __privateGet(this, _model).getCellValue(sheetName, ref);
   return v !== null && v !== void 0 && v !== "";
 };
@@ -4438,10 +4929,10 @@ isOccupied_fn = function(cellKey, sheetName, ref, anchorKey, prevSpill) {
 clearSpill_fn = function(anchorKey, changed) {
   const spill = __privateGet(this, _spills).get(anchorKey);
   if (!spill) return;
-  for (const cellKey of spill) {
-    const cell = parseKey(cellKey);
+  for (const cellKey2 of spill) {
+    const cell = parseKey(cellKey2);
     __privateGet(this, _model).setCellValue(__privateGet(this, _sheetNames).get(cell.sheet) ?? cell.sheet, cell.ref, null);
-    __privateGet(this, _spillOwner).delete(cellKey);
+    __privateGet(this, _spillOwner).delete(cellKey2);
     changed.push({ sheet: cell.sheet, row: cell.row, col: cell.col });
   }
   __privateGet(this, _spills).delete(anchorKey);