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

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/_internal.js

@@ -1,58 +1,76 @@
 import { computeValue } from "../../../core";
-import { isDate, isNil, isNumber } from "../../../util";
-const COMMON_YEAR_DAYS_OFFSET = [
-  0,
-  31,
-  59,
-  90,
-  120,
-  151,
-  181,
-  212,
-  243,
-  273,
-  304,
-  334
+import { isDate, isNil, isNumber, MingoError } from "../../../util";
+const LEAP_YEAR_REF_POINT = -1e9;
+const DAYS_PER_WEEK = 7;
+const isLeapYear = (y) => (y & 3) == 0 && (y % 100 != 0 || y % 400 == 0);
+const DAYS_IN_YEAR = [
+  365,
+  366
+  /*leap*/
 ];
-const LEAP_YEAR_DAYS_OFFSET = [
-  0,
-  31,
-  60,
-  91,
-  121,
-  152,
-  182,
-  213,
-  244,
-  274,
-  305,
-  335
+const daysInYear = (year) => DAYS_IN_YEAR[+isLeapYear(year)];
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const daysInMonth = (d) => DAYS_IN_MONTH[d.getUTCMonth()] + Number(
+  d.getUTCMonth() === 1 && isLeapYear(d.getUTCFullYear())
+);
+const YEAR_DAYS_OFFSET = [
+  [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
+  [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]
+  /*leap*/
 ];
+const dayOfYear = (d) => YEAR_DAYS_OFFSET[+isLeapYear(d.getUTCFullYear())][d.getUTCMonth()] + d.getUTCDate();
+const isoWeekday = (date, startOfWeek = "sun") => {
+  const dow = date.getUTCDay() || 7;
+  return (dow - ISO_WEEKDAY_MAP[startOfWeek] + DAYS_PER_WEEK) % DAYS_PER_WEEK;
+};
 const p = (y) => (y + Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400)) % 7;
 const weeks = (y) => 52 + Number(p(y) == 4 || p(y - 1) == 3);
-const isLeapYear = (year) => (year & 3) == 0 && (year % 100 != 0 || year % 400 == 0);
-const getDayOfYear = (d) => (isLeapYear(d.getUTCFullYear()) ? LEAP_YEAR_DAYS_OFFSET : COMMON_YEAR_DAYS_OFFSET)[d.getUTCMonth()] + d.getUTCDate();
 function isoWeek(d) {
-  const w = Math.floor((10 + getDayOfYear(d) - (d.getUTCDay() || 7)) / 7);
-  if (w < 1)
-    return weeks(d.getUTCFullYear() - 1);
-  if (w > weeks(d.getUTCFullYear()))
-    return 1;
+  const dow = d.getUTCDay() || 7;
+  const w = Math.floor((10 + dayOfYear(d) - dow) / 7);
+  if (w < 1) return weeks(d.getUTCFullYear() - 1);
+  if (w > weeks(d.getUTCFullYear())) return 1;
   return w;
 }
 function isoWeekYear(d) {
-  return d.getUTCFullYear() - Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);
+  return d.getUTCFullYear() - Number(d.getUTCMonth() === 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);
 }
 const MINUTES_PER_HOUR = 60;
 const MILLIS_PER_DAY = 1e3 * 60 * 60 * 24;
-const DURATION_IN_MILLIS = {
-  week: MILLIS_PER_DAY * 7,
+const TIMEUNIT_IN_MILLIS = {
+  week: MILLIS_PER_DAY * DAYS_PER_WEEK,
   day: MILLIS_PER_DAY,
   hour: 1e3 * 60 * 60,
   minute: 1e3 * 60,
   second: 1e3,
   millisecond: 1
 };
+const DAYS_OF_WEEK = [
+  "monday",
+  "mon",
+  "tuesday",
+  "tue",
+  "wednesday",
+  "wed",
+  "thursday",
+  "thu",
+  "friday",
+  "fri",
+  "saturday",
+  "sat",
+  "sunday",
+  "sun"
+];
+const DAYS_OF_WEEK_SET = new Set(DAYS_OF_WEEK);
+const ISO_WEEKDAY_MAP = Object.freeze({
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6,
+  sun: 7
+});
 const DATE_FORMAT = "%Y-%m-%dT%H:%M:%S.%LZ";
 const DATE_PART_INTERVAL = [
   ["year", 0, 9999],
@@ -63,7 +81,7 @@ const DATE_PART_INTERVAL = [
   ["second", 0, 59],
   ["millisecond", 0, 999]
 ];
-const DATE_SYM_TABLE = {
+const DATE_SYM_TABLE = Object.freeze({
   "%Y": { name: "year", padding: 4, re: /([0-9]{4})/ },
   "%G": { name: "year", padding: 4, re: /([0-9]{4})/ },
   "%m": { name: "month", padding: 2, re: /(0[1-9]|1[012])/ },
@@ -82,13 +100,20 @@ const DATE_SYM_TABLE = {
   },
   "%Z": { name: "minuteOffset", padding: 3, re: /([+-][0-9]{3})/ }
   // "%%": "%",
-};
+});
+const TIMEZONE_RE = /^[a-zA-Z_]+\/[a-zA-Z_]+$/;
 function parseTimezone(tzstr) {
-  if (isNil(tzstr))
-    return 0;
+  if (isNil(tzstr)) return 0;
+  if (TIMEZONE_RE.test(tzstr)) {
+    const date = /* @__PURE__ */ new Date();
+    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+    const tzDate = new Date(date.toLocaleString("en-US", { timeZone: tzstr }));
+    return (tzDate.getTime() - utcDate.getTime()) / 6e4;
+  }
   const m = DATE_SYM_TABLE["%z"].re.exec(tzstr);
-  if (!m)
-    throw Error(`invalid or location-based timezone '${tzstr}' not supported`);
+  if (!m) {
+    throw new MingoError(`Timezone '${tzstr}' is invalid or not supported`);
+  }
   const hr = parseInt(m[2]) || 0;
   const min = parseInt(m[3]) || 0;
   return (Math.abs(hr * MINUTES_PER_HOUR) + min) * (hr < 0 ? -1 : 1);
@@ -100,11 +125,10 @@ function adjustDate(d, minuteOffset) {
   d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);
 }
 function computeDate(obj, expr, options) {
+  if (isDate(obj)) return obj;
   const d = computeValue(obj, expr, null, options);
-  if (isDate(d))
-    return new Date(d);
-  if (isNumber(d))
-    return new Date(d * 1e3);
+  if (isDate(d)) return new Date(d);
+  if (isNumber(d)) return new Date(d * 1e3);
   if (d.date) {
     const date = isDate(d.date) ? new Date(d.date) : new Date(d.date * 1e3);
     if (d.timezone) {
@@ -112,36 +136,91 @@ function computeDate(obj, expr, options) {
     }
     return date;
   }
-  throw Error(`cannot convert ${expr?.toString()} to date`);
+  throw Error(`cannot convert ${JSON.stringify(expr)} to date`);
 }
 function padDigits(n, digits) {
   return new Array(Math.max(digits - String(n).length + 1, 0)).join("0") + n.toString();
 }
-function regexQuote(s) {
-  "^.-*?$".split("").forEach((c) => {
-    s = s.replace(c, `\\${c}`);
-  });
-  return s;
-}
-function regexStrip(s) {
-  return s.replace(/^\//, "").replace(/\/$/, "");
+const leapYearsSinceReferencePoint = (year) => {
+  const yearsSinceReferencePoint = year - LEAP_YEAR_REF_POINT;
+  return Math.trunc(yearsSinceReferencePoint / 4) - Math.trunc(yearsSinceReferencePoint / 100) + Math.trunc(yearsSinceReferencePoint / 400);
+};
+function daysBetweenYears(startYear, endYear) {
+  return Math.trunc(
+    leapYearsSinceReferencePoint(endYear - 1) - leapYearsSinceReferencePoint(startYear - 1) + (endYear - startYear) * DAYS_IN_YEAR[0]
+  );
 }
+const dateDiffYear = (start, end) => end.getUTCFullYear() - start.getUTCFullYear();
+const dateDiffMonth = (start, end) => end.getUTCMonth() - start.getUTCMonth() + dateDiffYear(start, end) * 12;
+const dateDiffQuarter = (start, end) => {
+  const a = Math.trunc(start.getUTCMonth() / 3);
+  const b = Math.trunc(end.getUTCMonth() / 3);
+  return b - a + dateDiffYear(start, end) * 4;
+};
+const dateDiffDay = (start, end) => dayOfYear(end) - dayOfYear(start) + daysBetweenYears(start.getUTCFullYear(), end.getUTCFullYear());
+const dateDiffWeek = (start, end, startOfWeek) => {
+  const wk = (startOfWeek || "sun").substring(0, 3);
+  return Math.trunc(
+    (dateDiffDay(start, end) + isoWeekday(start, wk) - isoWeekday(end, wk)) / DAYS_PER_WEEK
+  );
+};
+const dateDiffHour = (start, end) => end.getUTCHours() - start.getUTCHours() + dateDiffDay(start, end) * 24;
+const addMonth = (d, amount) => {
+  const m = d.getUTCMonth() + amount;
+  const yearOffset = Math.floor(m / 12);
+  if (m < 0) {
+    const month = m % 12 + 12;
+    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());
+  } else {
+    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());
+  }
+};
+const dateAdd = (date, unit, amount, _timezone) => {
+  const d = new Date(date);
+  switch (unit) {
+    case "year":
+      d.setUTCFullYear(d.getUTCFullYear() + amount);
+      break;
+    case "quarter":
+      addMonth(d, 3 * amount);
+      break;
+    case "month":
+      addMonth(d, amount);
+      break;
+    default:
+      d.setTime(d.getTime() + TIMEUNIT_IN_MILLIS[unit] * amount);
+  }
+  return d;
+};
 export {
   DATE_FORMAT,
   DATE_PART_INTERVAL,
   DATE_SYM_TABLE,
-  DURATION_IN_MILLIS,
+  DAYS_OF_WEEK,
+  DAYS_OF_WEEK_SET,
+  DAYS_PER_WEEK,
+  LEAP_YEAR_REF_POINT,
   MILLIS_PER_DAY,
   MINUTES_PER_HOUR,
+  TIMEUNIT_IN_MILLIS,
   adjustDate,
   computeDate,
+  dateAdd,
+  dateDiffDay,
+  dateDiffHour,
+  dateDiffMonth,
+  dateDiffQuarter,
+  dateDiffWeek,
+  dateDiffYear,
+  dayOfYear,
+  daysBetweenYears,
+  daysInMonth,
+  daysInYear,
   formatTimezone,
-  getDayOfYear,
   isLeapYear,
   isoWeek,
   isoWeekYear,
+  isoWeekday,
   padDigits,
-  parseTimezone,
-  regexQuote,
-  regexStrip
+  parseTimezone
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateAdd.js

@@ -1,42 +1,9 @@
 import { computeValue } from "../../../core";
-import {
-  adjustDate,
-  computeDate,
-  DURATION_IN_MILLIS,
-  parseTimezone
-} from "./_internal";
+import { dateAdd } from "./_internal";
 const $dateAdd = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  const d = computeDate(obj, expr.startDate, options);
-  switch (args.unit) {
-    case "year":
-      d.setUTCFullYear(d.getUTCFullYear() + args.amount);
-      break;
-    case "quarter":
-      addMonth(d, 3 * args.amount);
-      break;
-    case "month":
-      addMonth(d, args.amount);
-      break;
-    default:
-      d.setTime(d.getTime() + DURATION_IN_MILLIS[args.unit] * args.amount);
-  }
-  if (args.timezone) {
-    const tz = parseTimezone(args.timezone);
-    adjustDate(d, tz);
-  }
-  return d;
+  return dateAdd(args.startDate, args.unit, args.amount, args.timezone);
 };
-function addMonth(d, amount) {
-  const m = d.getUTCMonth() + amount;
-  const yearOffset = Math.floor(m / 12);
-  if (m < 0) {
-    const month = m % 12 + 12;
-    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, month, d.getUTCDate());
-  } else {
-    d.setUTCFullYear(d.getUTCFullYear() + yearOffset, m % 12, d.getUTCDate());
-  }
-}
 export {
   $dateAdd
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateDiff.js

@@ -1,32 +1,54 @@
 import { computeValue } from "../../../core";
-import { computeDate, DURATION_IN_MILLIS } from "./_internal";
+import {
+  adjustDate,
+  dateDiffDay,
+  dateDiffHour,
+  dateDiffMonth,
+  dateDiffQuarter,
+  dateDiffWeek,
+  dateDiffYear,
+  parseTimezone,
+  TIMEUNIT_IN_MILLIS
+} from "./_internal";
 const $dateDiff = (obj, expr, options) => {
-  const args = computeValue(obj, expr, null, options);
-  const d1 = computeDate(obj, expr.startDate, options);
-  const d2 = computeDate(obj, expr.endDate, options);
-  let diff;
-  switch (args.unit) {
+  const { startDate, endDate, unit, timezone, startOfWeek } = computeValue(
+    obj,
+    expr,
+    null,
+    options
+  );
+  const d1 = new Date(startDate);
+  const d2 = new Date(endDate);
+  const minuteOffset = parseTimezone(timezone);
+  adjustDate(d1, minuteOffset);
+  adjustDate(d2, minuteOffset);
+  switch (unit) {
     case "year":
+      return dateDiffYear(d1, d2);
     case "quarter":
+      return dateDiffQuarter(d1, d2);
     case "month":
-      diff = diffYQM(d1, d2, args.unit);
-      break;
+      return dateDiffMonth(d1, d2);
+    case "week":
+      return dateDiffWeek(d1, d2, startOfWeek);
+    case "day":
+      return dateDiffDay(d1, d2);
+    case "hour":
+      return dateDiffHour(d1, d2);
+    case "minute":
+      d1.setUTCSeconds(0);
+      d1.setUTCMilliseconds(0);
+      d2.setUTCSeconds(0);
+      d2.setUTCMilliseconds(0);
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / TIMEUNIT_IN_MILLIS[unit]
+      );
     default:
-      diff = (d2.getTime() - d1.getTime()) / DURATION_IN_MILLIS[args.unit];
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / TIMEUNIT_IN_MILLIS[unit]
+      );
   }
-  return diff;
 };
-const unitMonths = {
-  year: 12,
-  quarter: 3,
-  month: 1
-};
-function diffYQM(d1, d2, unit) {
-  let months = (d2.getUTCFullYear() - d1.getUTCFullYear()) * 12;
-  months -= d1.getUTCMonth();
-  months += d2.getUTCMonth();
-  return Math.trunc(months / unitMonths[unit]);
-}
 export {
   $dateDiff
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateFromParts.js

@@ -20,10 +20,8 @@ const $dateFromParts = (obj, expr, options) => {
     let part = (args[k] || 0) + remainder;
     remainder = 0;
     const limit = max + 1;
-    if (k == "hour")
-      part += Math.floor(minuteOffset / MINUTES_PER_HOUR) * -1;
-    if (k == "minute")
-      part += minuteOffset % MINUTES_PER_HOUR * -1;
+    if (k == "hour") part += Math.floor(minuteOffset / MINUTES_PER_HOUR) * -1;
+    if (k == "minute") part += minuteOffset % MINUTES_PER_HOUR * -1;
     if (part < min) {
       const delta = min - part;
       remainder = -1 * Math.ceil(delta / limit);

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateFromString.js

@@ -5,9 +5,7 @@ import {
   DATE_FORMAT,
   DATE_SYM_TABLE,
   MINUTES_PER_HOUR,
-  parseTimezone,
-  regexQuote,
-  regexStrip
+  parseTimezone
 } from "./_internal";
 const buildMap = (letters, sign) => {
   const h = {};
@@ -19,13 +17,20 @@ const TZ_LETTER_OFFSETS = {
   ...buildMap("NOPQRSTUVWXY", -1),
   Z: 0
 };
+const regexStrip = (s) => s.replace(/^\//, "").replace(/\/$/, "");
+const REGEX_SPECIAL_CHARS = ["^", ".", "-", "*", "?", "$"];
+const regexQuote = (s) => {
+  REGEX_SPECIAL_CHARS.forEach((c) => {
+    s = s.replace(c, `\\${c}`);
+  });
+  return s;
+};
 const $dateFromString = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   args.format = args.format || DATE_FORMAT;
   args.onNull = args.onNull || null;
   let dateString = args.dateString;
-  if (isNil(dateString))
-    return args.onNull;
+  if (isNil(dateString)) return args.onNull;
   const separators = args.format.split(/%[YGmdHMSLuVzZ]/);
   separators.reverse();
   const matches = args.format.match(
@@ -61,12 +66,9 @@ const $dateFromString = (obj, expr, options) => {
   const d = new Date(
     Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0)
   );
-  if (!isNil(dateParts.hour))
-    d.setUTCHours(dateParts.hour);
-  if (!isNil(dateParts.minute))
-    d.setUTCMinutes(dateParts.minute);
-  if (!isNil(dateParts.second))
-    d.setUTCSeconds(dateParts.second);
+  if (!isNil(dateParts.hour)) d.setUTCHours(dateParts.hour);
+  if (!isNil(dateParts.minute)) d.setUTCMinutes(dateParts.minute);
+  if (!isNil(dateParts.second)) d.setUTCSeconds(dateParts.second);
   if (!isNil(dateParts.millisecond))
     d.setUTCMilliseconds(dateParts.millisecond);
   adjustDate(d, -minuteOffset);

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateToString.js

@@ -34,10 +34,8 @@ const DATE_FUNCTIONS = {
 };
 const $dateToString = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
-  if (isNil(args.onNull))
-    args.onNull = null;
-  if (isNil(args.date))
-    return args.onNull;
+  if (isNil(args.onNull)) args.onNull = null;
+  if (isNil(args.date)) return args.onNull;
   const date = computeDate(obj, args.date, options);
   let format = args.format || DATE_FORMAT;
   const minuteOffset = parseTimezone(args.timezone);

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dateTrunc.js

@@ -0,0 +1,97 @@
+import { computeValue } from "../../../core";
+import { TIME_UNITS } from "../../../types";
+import { assert, isDate, isNil } from "../../../util";
+import {
+  adjustDate,
+  dateAdd,
+  dateDiffDay,
+  dateDiffMonth,
+  dateDiffQuarter,
+  dateDiffWeek,
+  dateDiffYear,
+  DAYS_OF_WEEK_SET,
+  DAYS_PER_WEEK,
+  isoWeekday,
+  parseTimezone,
+  TIMEUNIT_IN_MILLIS
+} from "./_internal";
+const REF_DATE_MILLIS = 9466848e5;
+const distanceToBinLowerBound = (value, binSize) => {
+  let remainder = value % binSize;
+  if (remainder < 0) {
+    remainder += binSize;
+  }
+  return remainder;
+};
+const DATE_DIFF_FN = {
+  day: dateDiffDay,
+  month: dateDiffMonth,
+  quarter: dateDiffQuarter,
+  year: dateDiffYear
+};
+const $dateTrunc = (obj, expr, options) => {
+  const {
+    date,
+    unit,
+    binSize: optBinSize,
+    timezone,
+    startOfWeek: optStartOfWeek
+  } = computeValue(obj, expr, null, options);
+  if (isNil(date) || isNil(unit)) return null;
+  const startOfWeek = (optStartOfWeek ?? "sun").toLowerCase().substring(0, 3);
+  assert(
+    isDate(date),
+    "$dateTrunc: 'date' must resolve to a valid Date object."
+  );
+  assert(TIME_UNITS.includes(unit), "$dateTrunc: unit is invalid.");
+  assert(
+    unit != "week" || DAYS_OF_WEEK_SET.has(startOfWeek),
+    `$dateTrunc: startOfWeek '${startOfWeek}' is not a valid.`
+  );
+  assert(
+    isNil(optBinSize) || optBinSize > 0,
+    "$dateTrunc requires 'binSize' to be greater than 0, but got value 0."
+  );
+  const binSize = optBinSize ?? 1;
+  switch (unit) {
+    case "millisecond":
+    case "second":
+    case "minute":
+    case "hour": {
+      const binSizeMillis = binSize * TIMEUNIT_IN_MILLIS[unit];
+      const shiftedDate = date.getTime() - REF_DATE_MILLIS;
+      return new Date(
+        date.getTime() - distanceToBinLowerBound(shiftedDate, binSizeMillis)
+      );
+    }
+    default: {
+      assert(binSize <= 1e11, "dateTrunc unsupported binSize value");
+      const d = new Date(date);
+      const refPointDate = new Date(REF_DATE_MILLIS);
+      let distanceFromRefPoint = 0;
+      if (unit == "week") {
+        const refPointDayOfWeek = isoWeekday(refPointDate, startOfWeek);
+        const daysToAdjustBy = (DAYS_PER_WEEK - refPointDayOfWeek) % DAYS_PER_WEEK;
+        refPointDate.setTime(
+          refPointDate.getTime() + daysToAdjustBy * TIMEUNIT_IN_MILLIS.day
+        );
+        distanceFromRefPoint = dateDiffWeek(refPointDate, d, startOfWeek);
+      } else {
+        distanceFromRefPoint = DATE_DIFF_FN[unit](refPointDate, d);
+      }
+      const binLowerBoundFromRefPoint = distanceFromRefPoint - distanceToBinLowerBound(distanceFromRefPoint, binSize);
+      const newDate = dateAdd(
+        refPointDate,
+        unit,
+        binLowerBoundFromRefPoint,
+        timezone
+      );
+      const minuteOffset = parseTimezone(timezone);
+      adjustDate(newDate, -minuteOffset);
+      return newDate;
+    }
+  }
+};
+export {
+  $dateTrunc
+};

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/dayOfYear.js

@@ -1,6 +1,6 @@
-import { computeDate, getDayOfYear } from "./_internal";
+import { computeDate, dayOfYear } from "./_internal";
 const $dayOfYear = (obj, expr, options) => {
-  return getDayOfYear(computeDate(obj, expr, options));
+  return dayOfYear(computeDate(obj, expr, options));
 };
 export {
   $dayOfYear

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/index.js

@@ -5,6 +5,7 @@ export * from "./dateFromString";
 export * from "./dateSubtract";
 export * from "./dateToParts";
 export * from "./dateToString";
+export * from "./dateTrunc";
 export * from "./dayOfMonth";
 export * from "./dayOfWeek";
 export * from "./dayOfYear";

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/isoWeekYear.js

@@ -1,8 +1,5 @@
-import { computeDate } from "./_internal";
-const $isoWeekYear = (obj, expr, options) => {
-  const d = computeDate(obj, expr, options);
-  return d.getUTCFullYear() - Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);
-};
+import { computeDate, isoWeekYear } from "./_internal";
+const $isoWeekYear = (obj, expr, options) => isoWeekYear(computeDate(obj, expr, options));
 export {
   $isoWeekYear
 };

package/rust-client/node_modules/mingo/dist/esm/operators/expression/date/week.js

@@ -4,8 +4,7 @@ const $week = (obj, expr, options) => {
   const result = isoWeek(d);
   if (d.getUTCDay() > 0 && d.getUTCDate() == 1 && d.getUTCMonth() == 0)
     return 0;
-  if (d.getUTCDay() == 0)
-    return result + 1;
+  if (d.getUTCDay() == 0) return result + 1;
   return result;
 };
 export {

package/rust-client/node_modules/mingo/dist/esm/operators/expression/misc/getField.js

@@ -3,8 +3,7 @@ import { assert, isNil, isObject, isString } from "../../../util";
 const $getField = (obj, expr, options) => {
   const args = computeValue(obj, expr, null, options);
   const [field, input] = isObject(args) ? [args.field, args.input || obj] : [args, obj];
-  if (isNil(input))
-    return null;
+  if (isNil(input)) return null;
   assert(
     isObject(input),
     "$getField expression 'input' must evaluate to an object"

package/rust-client/node_modules/mingo/dist/esm/operators/expression/object/mergeObjects.js

@@ -1,8 +1,15 @@
 import { computeValue } from "../../../core";
-import { into } from "../../../util";
+import { isNil } from "../../../util";
 const $mergeObjects = (obj, expr, options) => {
-  const docs = computeValue(obj, expr, null, options);
-  return docs instanceof Array ? docs.reduce((memo, o) => into(memo, o), {}) : {};
+  const docs = computeValue(obj, expr, null, options) ?? [];
+  const acc = {};
+  for (const o of docs) {
+    if (isNil(o)) continue;
+    for (const k of Object.keys(o)) {
+      if (o[k] !== void 0) acc[k] = o[k];
+    }
+  }
+  return acc;
 };
 export {
   $mergeObjects

package/rust-client/node_modules/mingo/dist/esm/operators/expression/object/objectToArray.js

@@ -1,8 +1,12 @@
 import { computeValue } from "../../../core";
-import { assert, isObject } from "../../../util";
+import { assert, isNil, isObject, typeOf } from "../../../util";
 const $objectToArray = (obj, expr, options) => {
   const val = computeValue(obj, expr, null, options);
-  assert(isObject(val), "$objectToArray expression must resolve to an object");
+  if (isNil(val)) return null;
+  assert(
+    isObject(val),
+    `$objectToArray requires a document input, found: ${typeOf(val)}`
+  );
   const entries = Object.entries(val);
   const result = new Array(entries.length);
   let i = 0;