npm - @valkey/valkey-glide-darwin-arm64 - Versions diffs - 1.2.0 → 1.2.1-rc1 - Mend

@valkey/valkey-glide-darwin-arm64 1.2.0 → 1.2.1-rc1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (439) hide show

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/add.js CHANGED Viewed

@@ -2,17 +2,16 @@ import { computeValue } from "../../../core";
 import { assert, isDate } from "../../../util";
 const $add = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  let foundDate = false;
-  const result = args.reduce((acc, val) => {
-    if (isDate(val)) {
-      assert(!foundDate, "'$add' can only have one date value");
-      foundDate = true;
-      val = val.getTime();
+  let hasDate = false;
+  let sum = 0;
+  for (const n of args) {
+    if (isDate(n)) {
+      assert(!hasDate, "'$add' can only have one date value");
+      hasDate = true;
     }
-    acc += val;
-    return acc;
-  }, 0);
-  return foundDate ? new Date(result) : result;
+    sum += +n;
+  }
+  return hasDate ? new Date(sum) : sum;
 };
 export {
   $add

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/ceil.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $ceil = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(isNumber(n) || isNaN(n), "$ceil expression must resolve to a number.");
   return Math.ceil(n);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/exp.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $exp = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(isNumber(n) || isNaN(n), "$exp expression must resolve to a number.");
   return Math.exp(n);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/floor.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $floor = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(
     isNumber(n) || isNaN(n),
     "$floor expression must resolve to a number."

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/ln.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $ln = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(isNumber(n) || isNaN(n), "$ln expression must resolve to a number.");
   return Math.log(n);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/log.js CHANGED Viewed

@@ -4,8 +4,7 @@ const $log = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   const msg = "$log expression must resolve to array(2) of numbers";
   assert(isArray(args) && args.length === 2, msg);
-  if (args.some(isNil))
-    return null;
+  if (args.some(isNil)) return null;
   assert(args.some(isNaN) || args.every(isNumber), msg);
   return Math.log10(args[0]) / Math.log10(args[1]);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/log10.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $log10 = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(
     isNumber(n) || isNaN(n),
     "$log10 expression must resolve to a number."

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/round.js CHANGED Viewed

@@ -5,8 +5,7 @@ const $round = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   const num = args[0];
   const place = args[1];
-  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity)
-    return num;
+  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
   assert(isNumber(num), "$round expression must resolve to a number.");
   return truncate(num, place, true);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/sqrt.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isNil, isNumber } from "../../../util";
 const $sqrt = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
+  if (isNil(n)) return null;
   assert(
     isNumber(n) && n > 0 || isNaN(n),
     "$sqrt expression must resolve to non-negative number."

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/subtract.js CHANGED Viewed

@@ -1,7 +1,10 @@
 import { computeValue } from "../../../core";
+import { assert, isDate, isNumber } from "../../../util";
 const $subtract = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  return args[0] - args[1];
+  const [a, b] = computeValue(obj, expr, null, options);
+  if (isNumber(a) && isNumber(b) || isDate(a) && isDate(b)) return +a - +b;
+  if (isDate(a) && isNumber(b)) return new Date(+a - b);
+  assert(false, "$subtract: must resolve to number/date.");
 };
 export {
   $subtract

package/rust-client/node_modules/mingo/dist/esm/operators/expression/arithmetic/trunc.js CHANGED Viewed

@@ -5,8 +5,7 @@ const $trunc = (obj, expr, options) => {
   const arr = computeValue(obj, expr, null, options);
   const num = arr[0];
   const places = arr[1];
-  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity)
-    return num;
+  if (isNil(num) || isNaN(num) || Math.abs(num) === Infinity) return num;
   assert(isNumber(num), "$trunc expression must resolve to a number.");
   assert(
     isNil(places) || isNumber(places) && places > -20 && places < 100,

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/arrayElemAt.js CHANGED Viewed

@@ -1,13 +1,12 @@
 import { computeValue } from "../../../core";
-import { assert, isNil } from "../../../util";
+import { assert, isArray, isNil } from "../../../util";
 const $arrayElemAt = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   assert(
-    args instanceof Array && args.length === 2,
+    isArray(args) && args.length === 2,
     "$arrayElemAt expression must resolve to array(2)"
   );
-  if (args.some(isNil))
-    return null;
+  if (args.some(isNil)) return null;
   const index = args[1];
   const arr = args[0];
   if (index < 0 && Math.abs(index) <= arr.length) {

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/arrayToObject.js CHANGED Viewed

@@ -2,11 +2,10 @@ import { computeValue } from "../../../core";
 import { assert, has, isArray, isObject } from "../../../util";
 const $arrayToObject = (obj, expr, options) => {
   const arr = computeValue(obj, expr, null, options);
-  assert(isArray(arr), "$arrayToObject expression must resolve to an array");
+  assert(isArray(arr), "$arrayToObject: expression must resolve to an array");
   return arr.reduce((newObj, val) => {
-    while (isArray(val) && val.length === 1)
-      val = val[0];
-    if (val instanceof Array && val.length == 2) {
+    while (isArray(val) && val.length === 1) val = val[0];
+    if (isArray(val) && val.length == 2) {
       newObj[val[0]] = val[1];
     } else {
       const valObj = val;

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/concatArrays.js CHANGED Viewed

@@ -1,11 +1,17 @@
 import { computeValue } from "../../../core";
-import { assert, into, isArray, isNil } from "../../../util";
+import { assert, isArray, isNil } from "../../../util";
 const $concatArrays = (obj, expr, options) => {
-  const arr = computeValue(obj, expr, null, options);
-  assert(isArray(arr), "$concatArrays must resolve to an array");
-  if (arr.some(isNil))
-    return null;
-  return arr.reduce((acc, item) => into(acc, item), []);
+  const nArray = computeValue(obj, expr, null, options);
+  assert(isArray(nArray), "$concatArrays: input must resolve to an array");
+  let size = 0;
+  for (const arr of nArray) {
+    if (isNil(arr)) return null;
+    size += arr.length;
+  }
+  const result = new Array(size);
+  let i = 0;
+  for (const arr of nArray) for (const item of arr) result[i++] = item;
+  return result;
 };
 export {
   $concatArrays

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/filter.js CHANGED Viewed

@@ -2,9 +2,10 @@ import {
   ComputeOptions,
   computeValue
 } from "../../../core";
-import { assert, isArray, truthy } from "../../../util";
+import { assert, isArray, isNil, truthy } from "../../../util";
 const $filter = (obj, expr, options) => {
   const input = computeValue(obj, expr.input, null, options);
+  if (isNil(input)) return null;
   assert(isArray(input), "$filter 'input' expression must resolve to an array");
   const copts = ComputeOptions.init(options, obj);
   const k = expr.as || "this";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/first.js CHANGED Viewed

@@ -1,18 +1,15 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $first as __first } from "../../accumulator";
+import { computeValue } from "../../../core";
+import { assert, flatten, isArray, isNil } from "../../../util";
+import { $first as __first } from "../../accumulator/first";
 const $first = (obj, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  if (obj instanceof Array)
-    return __first(obj, expr, copts.update());
+  if (isArray(obj)) return __first(obj, expr, options);
   const arr = computeValue(obj, expr, null, options);
-  if (isNil(arr))
-    return null;
-  assert(isArray(arr), "Must resolve to an array/null or missing");
-  return __first(arr, "$$this", options);
+  if (isNil(arr)) return null;
+  assert(
+    isArray(arr) && arr.length > 0,
+    "$first must resolve to a non-empty array."
+  );
+  return flatten(arr)[0];
 };
 export {
   $first

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/firstN.js CHANGED Viewed

@@ -2,11 +2,9 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isNil } from "../../../util";
 import { $firstN as __firstN } from "../../accumulator/firstN";
 const $firstN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return __firstN(obj, expr, options);
+  if (isArray(obj)) return __firstN(obj, expr, options);
   const { input, n } = computeValue(obj, expr, null, options);
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "Must resolve to an array/null or missing");
   return __firstN(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/in.js CHANGED Viewed

@@ -3,7 +3,7 @@ import { assert, isArray, isEqual } from "../../../util";
 const $in = (obj, expr, options) => {
   const [item, arr] = computeValue(obj, expr, null, options);
   assert(isArray(arr), "$in second argument must be an array");
-  return arr.some(isEqual.bind(null, item));
+  return arr.some((v) => isEqual(v, item));
 };
 export {
   $in

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/indexOfArray.js CHANGED Viewed

@@ -2,19 +2,15 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isEqual, isNil } from "../../../util";
 const $indexOfArray = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  if (isNil(args))
-    return null;
+  if (isNil(args)) return null;
   let arr = args[0];
   const searchValue = args[1];
-  if (isNil(arr))
-    return null;
+  if (isNil(arr)) return null;
   assert(isArray(arr), "$indexOfArray expression must resolve to an array.");
   const start = args[2] || 0;
   let end = args[3];
-  if (isNil(end))
-    end = arr.length;
-  if (start > end)
-    return -1;
+  if (isNil(end)) end = arr.length;
+  if (start > end) return -1;
   assert(start >= 0 && end >= 0, "$indexOfArray expression is invalid");
   if (start > 0 || end < arr.length) {
     arr = arr.slice(start, end);
@@ -22,8 +18,7 @@ const $indexOfArray = (obj, expr, options) => {
   let index = -1;
   arr.some((v, i) => {
     const b = isEqual(v, searchValue);
-    if (b)
-      index = i;
+    if (b) index = i;
     return b;
   });
   return index + start;

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/isArray.js CHANGED Viewed

@@ -1,7 +1,6 @@
 import { computeValue } from "../../../core";
-const $isArray = (obj, expr, options) => {
-  return computeValue(obj, expr[0], null, options) instanceof Array;
-};
+import { isArray } from "../../../util";
+const $isArray = (obj, expr, options) => isArray(computeValue(obj, expr[0], null, options));
 export {
   $isArray
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/last.js CHANGED Viewed

@@ -1,18 +1,15 @@
-import {
-  ComputeOptions,
-  computeValue
-} from "../../../core";
-import { assert, isArray, isNil } from "../../../util";
-import { $last as __last } from "../../accumulator";
+import { computeValue } from "../../../core";
+import { assert, flatten, isArray, isNil } from "../../../util";
+import { $last as __last } from "../../accumulator/last";
 const $last = (obj, expr, options) => {
-  const copts = ComputeOptions.init(options);
-  if (obj instanceof Array)
-    return __last(obj, expr, copts.update());
+  if (isArray(obj)) return __last(obj, expr, options);
   const arr = computeValue(obj, expr, null, options);
-  if (isNil(arr))
-    return null;
-  assert(isArray(arr), "Must resolve to an array/null or missing");
-  return __last(arr, "$$this", options);
+  if (isNil(arr)) return null;
+  assert(
+    isArray(arr) && arr.length > 0,
+    "$last must resolve to a non-empty array."
+  );
+  return flatten(arr)[arr.length - 1];
 };
 export {
   $last

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/lastN.js CHANGED Viewed

@@ -2,11 +2,9 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isNil } from "../../../util";
 import { $lastN as __lastN } from "../../accumulator/lastN";
 const $lastN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return __lastN(obj, expr, options);
+  if (isArray(obj)) return __lastN(obj, expr, options);
   const { input, n } = computeValue(obj, expr, null, options);
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "Must resolve to an array/null or missing");
   return __lastN(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/map.js CHANGED Viewed

@@ -2,9 +2,10 @@ import {
   ComputeOptions,
   computeValue
 } from "../../../core";
-import { assert, isArray } from "../../../util";
+import { assert, isArray, isNil } from "../../../util";
 const $map = (obj, expr, options) => {
   const input = computeValue(obj, expr.input, null, options);
+  if (isNil(input)) return null;
   assert(isArray(input), `$map 'input' expression must resolve to an array`);
   const copts = ComputeOptions.init(options);
   const k = expr.as || "this";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/maxN.js CHANGED Viewed

@@ -2,11 +2,9 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isNil } from "../../../util";
 import { $maxN as __maxN } from "../../accumulator/maxN";
 const $maxN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return __maxN(obj, expr, options);
+  if (isArray(obj)) return __maxN(obj, expr, options);
   const { input, n } = computeValue(obj, expr, null, options);
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "Must resolve to an array/null or missing");
   return __maxN(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/minN.js CHANGED Viewed

@@ -2,11 +2,9 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isNil } from "../../../util";
 import { $minN as __minN } from "../../accumulator/minN";
 const $minN = (obj, expr, options) => {
-  if (obj instanceof Array)
-    return __minN(obj, expr, options);
+  if (isArray(obj)) return __minN(obj, expr, options);
   const { input, n } = computeValue(obj, expr, null, options);
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "Must resolve to an array/null or missing");
   return __minN(input, { n, input: "$$this" }, options);
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/reduce.js CHANGED Viewed

@@ -8,8 +8,7 @@ const $reduce = (obj, expr, options) => {
   const input = computeValue(obj, expr.input, null, copts);
   const initialValue = computeValue(obj, expr.initialValue, null, copts);
   const inExpr = expr["in"];
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "$reduce 'input' expression must resolve to an array");
   return input.reduce((acc, n) => {
     return computeValue(

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/reverseArray.js CHANGED Viewed

@@ -2,8 +2,7 @@ import { computeValue } from "../../../core";
 import { assert, isArray, isNil } from "../../../util";
 const $reverseArray = (obj, expr, options) => {
   const arr = computeValue(obj, expr, null, options);
-  if (isNil(arr))
-    return null;
+  if (isNil(arr)) return null;
   assert(isArray(arr), "$reverseArray expression must resolve to an array");
   const result = arr.slice(0);
   result.reverse();

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/sortArray.js CHANGED Viewed

@@ -3,16 +3,14 @@ import { computeValue } from "../../../core";
 import { assert, compare, isArray, isNil, isObject } from "../../../util";
 const $sortArray = (obj, expr, options) => {
   const { input, sortBy } = computeValue(obj, expr, null, options);
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(isArray(input), "$sortArray expression must resolve to an array");
   if (isObject(sortBy)) {
     return new Aggregator([{ $sort: sortBy }]).run(input);
   }
   const result = [...input];
   result.sort(compare);
-  if (sortBy === -1)
-    result.reverse();
+  if (sortBy === -1) result.reverse();
   return result;
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/expression/array/zip.js CHANGED Viewed

@@ -1,13 +1,9 @@
 import { computeValue } from "../../../core";
 import { assert, isArray, isBoolean, isNil } from "../../../util";
 const $zip = (obj, expr, options) => {
-  const inputs = computeValue(
-    obj,
-    expr.inputs,
-    null,
-    options
-  );
+  const inputs = computeValue(obj, expr.inputs, null, options);
   const useLongestLength = expr.useLongestLength || false;
+  if (isNil(inputs)) return null;
   assert(isArray(inputs), "'inputs' expression must resolve to an array");
   assert(isBoolean(useLongestLength), "'useLongestLength' must be a boolean");
   if (isArray(expr.defaults)) {
@@ -17,10 +13,8 @@ const $zip = (obj, expr, options) => {
     );
   }
   let zipCount = 0;
-  for (let i = 0, len = inputs.length; i < len; i++) {
-    const arr = inputs[i];
-    if (isNil(arr))
-      return null;
+  for (const arr of inputs) {
+    if (isNil(arr)) return null;
     assert(
       isArray(arr),
       "'inputs' expression values must resolve to an array or null"

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/_internal.js CHANGED Viewed

@@ -3,8 +3,7 @@ import { assert, isArray, isNil, isNumber } from "../../../util";
 const bitwise = (op, compute) => (obj, expr, options) => {
   assert(isArray(expr), `${op}: expression must be an array.`);
   const nums = computeValue(obj, expr, null, options);
-  if (nums.some(isNil))
-    return null;
+  if (nums.some(isNil)) return null;
   assert(
     nums.every(isNumber),
     `${op}: expression must evalue to array of numbers.`

package/rust-client/node_modules/mingo/dist/esm/operators/expression/bitwise/bitNot.js CHANGED Viewed

@@ -2,10 +2,8 @@ import { computeValue } from "../../../core";
 import { isNil, isNumber, MingoError } from "../../../util";
 const $bitNot = (obj, expr, options) => {
   const n = computeValue(obj, expr, null, options);
-  if (isNil(n))
-    return null;
-  if (isNumber(n))
-    return ~n;
+  if (isNil(n)) return null;
+  if (isNumber(n)) return ~n;
   throw new MingoError("$bitNot: expression must evaluate to a number.");
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/expression/boolean/not.js CHANGED Viewed

@@ -1,12 +1,10 @@
 import { computeValue } from "../../../core";
-import { ensureArray } from "../../../util";
+import { assert, ensureArray } from "../../../util";
 const $not = (obj, expr, options) => {
   const booleanExpr = ensureArray(expr);
-  if (booleanExpr.length == 0)
-    return false;
-  if (booleanExpr.length == 1)
-    return !computeValue(obj, booleanExpr[0], null, options);
-  throw "Expression $not takes exactly 1 argument";
+  if (booleanExpr.length == 0) return false;
+  assert(booleanExpr.length == 1, "Expression $not takes exactly 1 argument");
+  return !computeValue(obj, booleanExpr[0], null, options);
 };
 export {
   $not

package/rust-client/node_modules/mingo/dist/esm/operators/expression/comparison/cmp.js CHANGED Viewed

@@ -1,11 +1,12 @@
 import { computeValue } from "../../../core";
+import { assert, compare, isArray } from "../../../util";
 const $cmp = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  if (args[0] > args[1])
-    return 1;
-  if (args[0] < args[1])
-    return -1;
-  return 0;
+  assert(
+    isArray(args) && args.length == 2,
+    "$cmp: expression must resolve to array of size 2."
+  );
+  return compare(args[0], args[1]);
 };
 export {
   $cmp

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/cond.js CHANGED Viewed

@@ -1,11 +1,11 @@
 import { computeValue } from "../../../core";
-import { assert, isObject, truthy } from "../../../util";
+import { assert, isArray, isObject, truthy } from "../../../util";
 const $cond = (obj, expr, options) => {
   let ifExpr;
   let thenExpr;
   let elseExpr;
   const errorMsg = "$cond: invalid arguments";
-  if (expr instanceof Array) {
+  if (isArray(expr)) {
     assert(expr.length === 3, errorMsg);
     ifExpr = expr[0];
     thenExpr = expr[1];

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/ifNull.js CHANGED Viewed

@@ -2,7 +2,7 @@ import { computeValue } from "../../../core";
 import { isNil } from "../../../util";
 const $ifNull = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  return args.find((arg) => !isNil(arg));
+  return args.find((arg) => !isNil(arg)) ?? args[args.length - 1];
 };
 export {
   $ifNull

package/rust-client/node_modules/mingo/dist/esm/operators/expression/conditional/switch.js CHANGED Viewed

@@ -7,8 +7,7 @@ const $switch = (obj, expr, options) => {
       computeValue(obj, b.case, null, options),
       options.useStrictMode
     );
-    if (condition)
-      thenExpr = b.then;
+    if (condition) thenExpr = b.then;
     return condition;
   });
   return computeValue(