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

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

@@ -20,77 +20,108 @@ __export(internal_exports, {
   DATE_FORMAT: () => DATE_FORMAT,
   DATE_PART_INTERVAL: () => DATE_PART_INTERVAL,
   DATE_SYM_TABLE: () => DATE_SYM_TABLE,
-  DURATION_IN_MILLIS: () => DURATION_IN_MILLIS,
+  DAYS_OF_WEEK: () => DAYS_OF_WEEK,
+  DAYS_OF_WEEK_SET: () => DAYS_OF_WEEK_SET,
+  DAYS_PER_WEEK: () => DAYS_PER_WEEK,
+  LEAP_YEAR_REF_POINT: () => LEAP_YEAR_REF_POINT,
   MILLIS_PER_DAY: () => MILLIS_PER_DAY,
   MINUTES_PER_HOUR: () => MINUTES_PER_HOUR,
+  TIMEUNIT_IN_MILLIS: () => TIMEUNIT_IN_MILLIS,
   adjustDate: () => adjustDate,
   computeDate: () => computeDate,
+  dateAdd: () => dateAdd,
+  dateDiffDay: () => dateDiffDay,
+  dateDiffHour: () => dateDiffHour,
+  dateDiffMonth: () => dateDiffMonth,
+  dateDiffQuarter: () => dateDiffQuarter,
+  dateDiffWeek: () => dateDiffWeek,
+  dateDiffYear: () => dateDiffYear,
+  dayOfYear: () => dayOfYear,
+  daysBetweenYears: () => daysBetweenYears,
+  daysInMonth: () => daysInMonth,
+  daysInYear: () => daysInYear,
   formatTimezone: () => formatTimezone,
-  getDayOfYear: () => getDayOfYear,
   isLeapYear: () => isLeapYear,
   isoWeek: () => isoWeek,
   isoWeekYear: () => isoWeekYear,
+  isoWeekday: () => isoWeekday,
   padDigits: () => padDigits,
-  parseTimezone: () => parseTimezone,
-  regexQuote: () => regexQuote,
-  regexStrip: () => regexStrip
+  parseTimezone: () => parseTimezone
 });
 module.exports = __toCommonJS(internal_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
-const COMMON_YEAR_DAYS_OFFSET = [
-  0,
-  31,
-  59,
-  90,
-  120,
-  151,
-  181,
-  212,
-  243,
-  273,
-  304,
-  334
+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],
@@ -101,7 +132,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])/ },
@@ -120,13 +151,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 ((0, import_util.isNil)(tzstr))
-    return 0;
+  if ((0, import_util.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 import_util.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);
@@ -138,11 +176,10 @@ function adjustDate(d, minuteOffset) {
   d.setUTCMinutes(d.getUTCMinutes() + minuteOffset);
 }
 function computeDate(obj, expr, options) {
+  if ((0, import_util.isDate)(obj)) return obj;
   const d = (0, import_core.computeValue)(obj, expr, null, options);
-  if ((0, import_util.isDate)(d))
-    return new Date(d);
-  if ((0, import_util.isNumber)(d))
-    return new Date(d * 1e3);
+  if ((0, import_util.isDate)(d)) return new Date(d);
+  if ((0, import_util.isNumber)(d)) return new Date(d * 1e3);
   if (d.date) {
     const date = (0, import_util.isDate)(d.date) ? new Date(d.date) : new Date(d.date * 1e3);
     if (d.timezone) {
@@ -150,37 +187,92 @@ 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;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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/cjs/operators/expression/date/dateAdd.js

@@ -24,36 +24,8 @@ var import_core = require("../../../core");
 var import_internal = require("./_internal");
 const $dateAdd = (obj, expr, options) => {
   const args = (0, import_core.computeValue)(obj, expr, null, options);
-  const d = (0, import_internal.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() + import_internal.DURATION_IN_MILLIS[args.unit] * args.amount);
-  }
-  if (args.timezone) {
-    const tz = (0, import_internal.parseTimezone)(args.timezone);
-    (0, import_internal.adjustDate)(d, tz);
-  }
-  return d;
+  return (0, import_internal.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());
-  }
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $dateAdd

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

@@ -23,32 +23,44 @@ module.exports = __toCommonJS(dateDiff_exports);
 var import_core = require("../../../core");
 var import_internal = require("./_internal");
 const $dateDiff = (obj, expr, options) => {
-  const args = (0, import_core.computeValue)(obj, expr, null, options);
-  const d1 = (0, import_internal.computeDate)(obj, expr.startDate, options);
-  const d2 = (0, import_internal.computeDate)(obj, expr.endDate, options);
-  let diff;
-  switch (args.unit) {
+  const { startDate, endDate, unit, timezone, startOfWeek } = (0, import_core.computeValue)(
+    obj,
+    expr,
+    null,
+    options
+  );
+  const d1 = new Date(startDate);
+  const d2 = new Date(endDate);
+  const minuteOffset = (0, import_internal.parseTimezone)(timezone);
+  (0, import_internal.adjustDate)(d1, minuteOffset);
+  (0, import_internal.adjustDate)(d2, minuteOffset);
+  switch (unit) {
     case "year":
+      return (0, import_internal.dateDiffYear)(d1, d2);
     case "quarter":
+      return (0, import_internal.dateDiffQuarter)(d1, d2);
     case "month":
-      diff = diffYQM(d1, d2, args.unit);
-      break;
+      return (0, import_internal.dateDiffMonth)(d1, d2);
+    case "week":
+      return (0, import_internal.dateDiffWeek)(d1, d2, startOfWeek);
+    case "day":
+      return (0, import_internal.dateDiffDay)(d1, d2);
+    case "hour":
+      return (0, import_internal.dateDiffHour)(d1, d2);
+    case "minute":
+      d1.setUTCSeconds(0);
+      d1.setUTCMilliseconds(0);
+      d2.setUTCSeconds(0);
+      d2.setUTCMilliseconds(0);
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / import_internal.TIMEUNIT_IN_MILLIS[unit]
+      );
     default:
-      diff = (d2.getTime() - d1.getTime()) / import_internal.DURATION_IN_MILLIS[args.unit];
+      return Math.round(
+        (d2.getTime() - d1.getTime()) / import_internal.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]);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $dateDiff

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

@@ -37,10 +37,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 / import_internal.MINUTES_PER_HOUR) * -1;
-    if (k == "minute")
-      part += minuteOffset % import_internal.MINUTES_PER_HOUR * -1;
+    if (k == "hour") part += Math.floor(minuteOffset / import_internal.MINUTES_PER_HOUR) * -1;
+    if (k == "minute") part += minuteOffset % import_internal.MINUTES_PER_HOUR * -1;
     if (part < min) {
       const delta = min - part;
       remainder = -1 * Math.ceil(delta / limit);

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

@@ -33,13 +33,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 = (0, import_core.computeValue)(obj, expr, null, options);
   args.format = args.format || import_internal.DATE_FORMAT;
   args.onNull = args.onNull || null;
   let dateString = args.dateString;
-  if ((0, import_util.isNil)(dateString))
-    return args.onNull;
+  if ((0, import_util.isNil)(dateString)) return args.onNull;
   const separators = args.format.split(/%[YGmdHMSLuVzZ]/);
   separators.reverse();
   const matches = args.format.match(
@@ -56,7 +63,7 @@ const $dateFromString = (obj, expr, options) => {
       if (m2 !== null) {
         dateParts[props.name] = /^\d+$/.exec(m2[0]) ? parseInt(m2[0]) : m2[0];
         dateString = dateString.substr(0, m2.index) + dateString.substr(m2.index + m2[0].length);
-        expectedPattern += (0, import_internal.regexQuote)(delimiter) + (0, import_internal.regexStrip)(props.re.toString());
+        expectedPattern += regexQuote(delimiter) + regexStrip(props.re.toString());
       } else {
         dateParts[props.name] = null;
       }
@@ -75,12 +82,9 @@ const $dateFromString = (obj, expr, options) => {
   const d = new Date(
     Date.UTC(dateParts.year, dateParts.month - 1, dateParts.day, 0, 0, 0)
   );
-  if (!(0, import_util.isNil)(dateParts.hour))
-    d.setUTCHours(dateParts.hour);
-  if (!(0, import_util.isNil)(dateParts.minute))
-    d.setUTCMinutes(dateParts.minute);
-  if (!(0, import_util.isNil)(dateParts.second))
-    d.setUTCSeconds(dateParts.second);
+  if (!(0, import_util.isNil)(dateParts.hour)) d.setUTCHours(dateParts.hour);
+  if (!(0, import_util.isNil)(dateParts.minute)) d.setUTCMinutes(dateParts.minute);
+  if (!(0, import_util.isNil)(dateParts.second)) d.setUTCSeconds(dateParts.second);
   if (!(0, import_util.isNil)(dateParts.millisecond))
     d.setUTCMilliseconds(dateParts.millisecond);
   (0, import_internal.adjustDate)(d, -minuteOffset);

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

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

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

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dateTrunc_exports = {};
+__export(dateTrunc_exports, {
+  $dateTrunc: () => $dateTrunc
+});
+module.exports = __toCommonJS(dateTrunc_exports);
+var import_core = require("../../../core");
+var import_types = require("../../../types");
+var import_util = require("../../../util");
+var import_internal = require("./_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: import_internal.dateDiffDay,
+  month: import_internal.dateDiffMonth,
+  quarter: import_internal.dateDiffQuarter,
+  year: import_internal.dateDiffYear
+};
+const $dateTrunc = (obj, expr, options) => {
+  const {
+    date,
+    unit,
+    binSize: optBinSize,
+    timezone,
+    startOfWeek: optStartOfWeek
+  } = (0, import_core.computeValue)(obj, expr, null, options);
+  if ((0, import_util.isNil)(date) || (0, import_util.isNil)(unit)) return null;
+  const startOfWeek = (optStartOfWeek ?? "sun").toLowerCase().substring(0, 3);
+  (0, import_util.assert)(
+    (0, import_util.isDate)(date),
+    "$dateTrunc: 'date' must resolve to a valid Date object."
+  );
+  (0, import_util.assert)(import_types.TIME_UNITS.includes(unit), "$dateTrunc: unit is invalid.");
+  (0, import_util.assert)(
+    unit != "week" || import_internal.DAYS_OF_WEEK_SET.has(startOfWeek),
+    `$dateTrunc: startOfWeek '${startOfWeek}' is not a valid.`
+  );
+  (0, import_util.assert)(
+    (0, import_util.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 * import_internal.TIMEUNIT_IN_MILLIS[unit];
+      const shiftedDate = date.getTime() - REF_DATE_MILLIS;
+      return new Date(
+        date.getTime() - distanceToBinLowerBound(shiftedDate, binSizeMillis)
+      );
+    }
+    default: {
+      (0, import_util.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 = (0, import_internal.isoWeekday)(refPointDate, startOfWeek);
+        const daysToAdjustBy = (import_internal.DAYS_PER_WEEK - refPointDayOfWeek) % import_internal.DAYS_PER_WEEK;
+        refPointDate.setTime(
+          refPointDate.getTime() + daysToAdjustBy * import_internal.TIMEUNIT_IN_MILLIS.day
+        );
+        distanceFromRefPoint = (0, import_internal.dateDiffWeek)(refPointDate, d, startOfWeek);
+      } else {
+        distanceFromRefPoint = DATE_DIFF_FN[unit](refPointDate, d);
+      }
+      const binLowerBoundFromRefPoint = distanceFromRefPoint - distanceToBinLowerBound(distanceFromRefPoint, binSize);
+      const newDate = (0, import_internal.dateAdd)(
+        refPointDate,
+        unit,
+        binLowerBoundFromRefPoint,
+        timezone
+      );
+      const minuteOffset = (0, import_internal.parseTimezone)(timezone);
+      (0, import_internal.adjustDate)(newDate, -minuteOffset);
+      return newDate;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  $dateTrunc
+});

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

@@ -22,7 +22,7 @@ __export(dayOfYear_exports, {
 module.exports = __toCommonJS(dayOfYear_exports);
 var import_internal = require("./_internal");
 const $dayOfYear = (obj, expr, options) => {
-  return (0, import_internal.getDayOfYear)((0, import_internal.computeDate)(obj, expr, options));
+  return (0, import_internal.dayOfYear)((0, import_internal.computeDate)(obj, expr, options));
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -21,6 +21,7 @@ __reExport(date_exports, require("./dateFromString"), module.exports);
 __reExport(date_exports, require("./dateSubtract"), module.exports);
 __reExport(date_exports, require("./dateToParts"), module.exports);
 __reExport(date_exports, require("./dateToString"), module.exports);
+__reExport(date_exports, require("./dateTrunc"), module.exports);
 __reExport(date_exports, require("./dayOfMonth"), module.exports);
 __reExport(date_exports, require("./dayOfWeek"), module.exports);
 __reExport(date_exports, require("./dayOfYear"), module.exports);
@@ -43,6 +44,7 @@ __reExport(date_exports, require("./year"), module.exports);
   ...require("./dateSubtract"),
   ...require("./dateToParts"),
   ...require("./dateToString"),
+  ...require("./dateTrunc"),
   ...require("./dayOfMonth"),
   ...require("./dayOfWeek"),
   ...require("./dayOfYear"),

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

@@ -21,10 +21,7 @@ __export(isoWeekYear_exports, {
 });
 module.exports = __toCommonJS(isoWeekYear_exports);
 var import_internal = require("./_internal");
-const $isoWeekYear = (obj, expr, options) => {
-  const d = (0, import_internal.computeDate)(obj, expr, options);
-  return d.getUTCFullYear() - Number(d.getUTCMonth() == 0 && d.getUTCDate() == 1 && d.getUTCDay() < 1);
-};
+const $isoWeekYear = (obj, expr, options) => (0, import_internal.isoWeekYear)((0, import_internal.computeDate)(obj, expr, options));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   $isoWeekYear

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

@@ -26,8 +26,7 @@ const $week = (obj, expr, options) => {
   const result = (0, import_internal.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;
 };
 // Annotate the CommonJS export names for ESM import in node:

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

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

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

@@ -23,8 +23,15 @@ module.exports = __toCommonJS(mergeObjects_exports);
 var import_core = require("../../../core");
 var import_util = require("../../../util");
 const $mergeObjects = (obj, expr, options) => {
-  const docs = (0, import_core.computeValue)(obj, expr, null, options);
-  return docs instanceof Array ? docs.reduce((memo, o) => (0, import_util.into)(memo, o), {}) : {};
+  const docs = (0, import_core.computeValue)(obj, expr, null, options) ?? [];
+  const acc = {};
+  for (const o of docs) {
+    if ((0, import_util.isNil)(o)) continue;
+    for (const k of Object.keys(o)) {
+      if (o[k] !== void 0) acc[k] = o[k];
+    }
+  }
+  return acc;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {