@vuu-ui/vuu-utils 0.8.22-debug → 0.8.23-debug

package/esm/index.js

@@ -97,7 +97,64 @@ function boxContainsPoint(rect, x, y) {
   }
 }
 
-// src/filter-utils.ts
+// src/filters/filterAsQuery.ts
+var filterValue = (value) => typeof value === "string" ? `"${value}"` : value;
+var quotedStrings = (value) => typeof value === "string" ? `"${value}"` : value;
+var removeOuterMostParentheses = (s) => s.replace(/^\((.*)\)$/, "$1");
+var filterAsQuery = (f, opts) => {
+  return removeOuterMostParentheses(filterAsQueryCore(f, opts));
+};
+var filterAsQueryCore = (f, opts) => {
+  if (isMultiClauseFilter(f)) {
+    const multiClauseFilter = f.filters.map((filter) => filterAsQueryCore(filter, opts)).join(` ${f.op} `);
+    return `(${multiClauseFilter})`;
+  } else if (isMultiValueFilter(f)) {
+    return `${f.column} ${f.op} [${f.values.map(quotedStrings).join(",")}]`;
+  } else {
+    return singleValueFilterAsQuery(f, opts);
+  }
+};
+function singleValueFilterAsQuery(f, opts) {
+  var _a;
+  const column = (_a = opts == null ? void 0 : opts.columnsByName) == null ? void 0 : _a[f.column];
+  if (column && isDateTimeColumn(column)) {
+    return dateFilterAsQuery(f);
+  } else {
+    return defaultSingleValueFilterAsQuery(f);
+  }
+}
+var ONE_DAY_IN_MILIS = 1e3 * 60 * 60 * 24;
+function dateFilterAsQuery(f) {
+  switch (f.op) {
+    case "=": {
+      const filters = [
+        { op: ">=", column: f.column, value: f.value },
+        {
+          op: "<",
+          column: f.column,
+          value: f.value + ONE_DAY_IN_MILIS
+        }
+      ];
+      return filterAsQueryCore({ op: "and", filters });
+    }
+    case "!=": {
+      const filters = [
+        { op: "<", column: f.column, value: f.value },
+        {
+          op: ">=",
+          column: f.column,
+          value: f.value + ONE_DAY_IN_MILIS
+        }
+      ];
+      return filterAsQueryCore({ op: "or", filters });
+    }
+    default:
+      return defaultSingleValueFilterAsQuery(f);
+  }
+}
+var defaultSingleValueFilterAsQuery = (f) => `${f.column} ${f.op} ${filterValue(f.value)}`;
+
+// src/filters/utils.ts
 var singleValueFilterOps = /* @__PURE__ */ new Set([
   "=",
   "!=",
@@ -120,17 +177,6 @@ var isCompleteFilter = (filter) => isSingleValueFilter(filter) && filter.column
 function isMultiClauseFilter(f) {
   return f !== void 0 && (f.op === "and" || f.op === "or");
 }
-var filterValue = (value) => typeof value === "string" ? `"${value}"` : value;
-var quotedStrings = (value) => typeof value === "string" ? `"${value}"` : value;
-var filterAsQuery = (f) => {
-  if (isMultiClauseFilter(f)) {
-    return f.filters.map((filter) => filterAsQuery(filter)).join(` ${f.op} `);
-  } else if (isMultiValueFilter(f)) {
-    return `${f.column} ${f.op} [${f.values.map(quotedStrings).join(",")}]`;
-  } else {
-    return `${f.column} ${f.op} ${filterValue(f.value)}`;
-  }
-};
 var removeColumnFromFilter = (column, filter) => {
   if (isMultiClauseFilter(filter)) {
     const [clause1, clause2] = filter.filters;
@@ -147,6 +193,9 @@ var removeColumnFromFilter = (column, filter) => {
 // src/column-utils.ts
 var SORT_ASC = "asc";
 var NO_HEADINGS = [];
+var DEFAULT_COL_WIDTH = 100;
+var DEFAULT_MAX_WIDTH = 250;
+var DEFAULT_MIN_WIDTH = 50;
 var AggregationType = {
   Average: 2,
   Count: 3,
@@ -171,9 +220,6 @@ var numericTypes = ["int", "long", "double"];
 var getDefaultAlignment = (serverDataType) => serverDataType === void 0 ? "left" : numericTypes.includes(serverDataType) ? "right" : "left";
 var isValidColumnAlignment = (v) => v === "left" || v === "right";
 var isValidPinLocation = (v) => isValidColumnAlignment(v) || v === "floating" || v === "";
-var isKeyedColumn = (column) => {
-  return typeof column.key === "number";
-};
 var fromServerDataType = (serverDataType) => {
   switch (serverDataType) {
     case "double":
@@ -219,8 +265,6 @@ function buildColumnMap(columns) {
     return columns.reduce((map, column, i) => {
       if (typeof column === "string") {
         map[column] = start + i;
-      } else if (isKeyedColumn(column)) {
-        map[column.name] = column.key;
       } else {
         map[column.name] = start + i;
       }
@@ -318,7 +362,6 @@ function extractGroupColumn(columns, groupBy, confirmed = true) {
       };
     });
     const groupCol = {
-      key: -1,
       name: "group-col",
       heading: ["group-col"],
       isGroup: true,
@@ -332,9 +375,9 @@ function extractGroupColumn(columns, groupBy, confirmed = true) {
 }
 var isGroupColumn = (column) => column.isGroup === true;
 var isJsonAttribute = (value) => typeof value === "string" && value.endsWith("+");
-var isJsonGroup = (column, row) => {
+var isJsonGroup = (column, row, columnMap) => {
   var _a;
-  return ((_a = column.type) == null ? void 0 : _a.name) === "json" && isJsonAttribute(row[column.key]);
+  return ((_a = column.type) == null ? void 0 : _a.name) === "json" && isJsonAttribute(row[columnMap[column.name]]);
 };
 var isJsonColumn = (column) => {
   var _a;
@@ -387,6 +430,27 @@ var sortPinnedColumns = (columns) => {
     return allColumns;
   }
 };
+var measurePinnedColumns = (columns, selectionEndSize) => {
+  let pinnedWidthLeft = 0;
+  let pinnedWidthRight = 0;
+  let unpinnedWidth = 0;
+  for (const column of columns) {
+    const { hidden, pin, width } = column;
+    const visibleWidth = hidden ? 0 : width;
+    if (pin === "left") {
+      pinnedWidthLeft += visibleWidth;
+    } else if (pin === "right") {
+      pinnedWidthRight += visibleWidth;
+    } else {
+      unpinnedWidth += visibleWidth;
+    }
+  }
+  return {
+    pinnedWidthLeft: pinnedWidthLeft + selectionEndSize,
+    pinnedWidthRight: pinnedWidthRight + selectionEndSize,
+    unpinnedWidth
+  };
+};
 var getTableHeadings = (columns) => {
   if (columns.some(hasHeadings)) {
     const maxHeadingDepth = columns.reduce(
@@ -419,6 +483,8 @@ var getTableHeadings = (columns) => {
 };
 var getColumnStyle = ({
   pin,
+  // the 4 is `selectionEndSize`, unfortunate if we need to be passed it from cell
+  // need to think about how to make this available
   pinnedOffset = pin === "left" ? 0 : 4,
   width
 }) => pin === "left" ? {
@@ -578,25 +644,29 @@ var getColumnsInViewport = (columns, vpStart, vpEnd) => {
   var _a;
   const visibleColumns = [];
   let preSpan = 0;
-  for (let offset = 0, i = 0; i < columns.length; i++) {
+  let rightPinnedOnly = false;
+  for (let columnOffset = 0, i = 0; i < columns.length; i++) {
     const column = columns[i];
     if (column.hidden) {
       continue;
-    } else if (offset + column.width < vpStart) {
+    } else if (rightPinnedOnly) {
+      if (column.pin === "right") {
+        visibleColumns.push(column);
+      }
+    } else if (columnOffset + column.width < vpStart) {
       if (column.pin === "left") {
         visibleColumns.push(column);
-      } else if (offset + column.width + ((_a = columns[i + 1]) == null ? void 0 : _a.width) > vpStart) {
+      } else if (columnOffset + column.width + ((_a = columns[i + 1]) == null ? void 0 : _a.width) > vpStart) {
         visibleColumns.push(column);
       } else {
         preSpan += column.width;
       }
-    } else if (offset > vpEnd) {
-      visibleColumns.push(column);
-      break;
+    } else if (columnOffset > vpEnd) {
+      rightPinnedOnly = true;
     } else {
       visibleColumns.push(column);
     }
-    offset += column.width;
+    columnOffset += column.width;
   }
   return [visibleColumns, preSpan];
 };
@@ -609,15 +679,15 @@ var visibleColumnAtIndex = (columns, index) => {
   }
 };
 var { DEPTH, IS_LEAF } = metadataKeys;
-var getGroupValueAndOffset = (columns, row) => {
+var getGroupValueAndOffset = (columns, row, columnMap) => {
   const { [DEPTH]: depth, [IS_LEAF]: isLeaf } = row;
   if (isLeaf || depth > columns.length) {
     return [null, depth === null ? 0 : Math.max(0, depth - 1)];
   } else if (depth === 0) {
     return ["$root", 0];
   } else {
-    const { key, valueFormatter } = columns[depth - 1];
-    const value = valueFormatter(row[key]);
+    const { name, valueFormatter } = columns[depth - 1];
+    const value = valueFormatter(row[columnMap[name]]);
     return [value, depth - 1];
   }
 };
@@ -780,6 +850,130 @@ var getColumnByName = (schema, name) => {
     }
   }
 };
+function applyWidthToColumns(columns, options) {
+  const {
+    availableWidth = 0,
+    columnLayout = "Static",
+    defaultWidth = DEFAULT_COL_WIDTH,
+    defaultMinWidth = DEFAULT_MIN_WIDTH,
+    defaultMaxWidth = DEFAULT_MAX_WIDTH
+    // defaultFlex = DEFAULT_FLEX,
+  } = options;
+  if (columnLayout === "Static") {
+    return columns.map((column) => {
+      if (typeof column.width === "number") {
+        return column;
+      } else {
+        return {
+          ...column,
+          width: defaultWidth
+        };
+      }
+    });
+  } else if (columnLayout === "Fit") {
+    const { totalMinWidth, totalMaxWidth, totalWidth, flexCount } = columns.reduce(
+      (aggregated, column) => {
+        const { totalMinWidth: totalMinWidth2, totalMaxWidth: totalMaxWidth2, totalWidth: totalWidth2, flexCount: flexCount2 } = aggregated;
+        const {
+          minWidth = defaultMinWidth,
+          maxWidth = defaultMaxWidth,
+          width = defaultWidth,
+          flex = 0
+        } = column;
+        return {
+          totalMinWidth: totalMinWidth2 + minWidth,
+          totalMaxWidth: totalMaxWidth2 + maxWidth,
+          totalWidth: totalWidth2 + width,
+          flexCount: flexCount2 + flex
+        };
+      },
+      { totalMinWidth: 0, totalMaxWidth: 0, totalWidth: 0, flexCount: 0 }
+    );
+    if (totalMinWidth > availableWidth || totalMaxWidth < availableWidth) {
+      return columns;
+    } else if (totalWidth > availableWidth) {
+      const excessWidth = totalWidth - availableWidth;
+      const inFlexMode = flexCount > 0;
+      let excessWidthPerColumn = excessWidth / (flexCount || columns.length);
+      let columnsNotYetAtMinWidth = columns.length;
+      let unassignedExcess = 0;
+      let newColumns = columns.map((column) => {
+        const {
+          minWidth = defaultMinWidth,
+          width = defaultWidth,
+          flex = 0
+        } = column;
+        if (inFlexMode && flex === 0) {
+          return column;
+        }
+        const adjustedWidth = width - excessWidthPerColumn;
+        if (adjustedWidth < minWidth) {
+          columnsNotYetAtMinWidth -= 1;
+          unassignedExcess += minWidth - adjustedWidth;
+          return { ...column, width: minWidth };
+        } else {
+          return { ...column, width: adjustedWidth };
+        }
+      });
+      if (unassignedExcess === 0) {
+        return newColumns;
+      } else {
+        excessWidthPerColumn = unassignedExcess / columnsNotYetAtMinWidth;
+        newColumns = newColumns.map((column) => {
+          const adjustedWidth = column.width - excessWidthPerColumn;
+          if (column.width !== column.minWidth) {
+            return { ...column, width: adjustedWidth };
+          } else {
+            return column;
+          }
+        });
+        return newColumns;
+      }
+    } else if (totalWidth < availableWidth) {
+      {
+        const additionalWidth = availableWidth - totalWidth;
+        const inFlexMode = flexCount > 0;
+        let additionalWidthPerColumn = additionalWidth / (flexCount || columns.length);
+        let newColumns = columns.map((column) => {
+          const {
+            maxWidth = defaultMaxWidth,
+            width = defaultWidth,
+            flex = 0
+          } = column;
+          if (inFlexMode && flex === 0) {
+            return column;
+          }
+          const adjustedWidth = width + additionalWidthPerColumn;
+          if (adjustedWidth > maxWidth) {
+            return { ...column, width: maxWidth };
+          } else {
+            return { ...column, width: adjustedWidth, canStretch: true };
+          }
+        });
+        const unassignedAdditionalColumnWidth = additionalWidth - newColumns.reduce((sum, col) => sum + col.width, 0);
+        const columnsNotYetAtMaxWidth = newColumns.filter(
+          (col) => col.canStretch
+        ).length;
+        if (unassignedAdditionalColumnWidth > columnsNotYetAtMaxWidth) {
+          additionalWidthPerColumn = unassignedAdditionalColumnWidth / columnsNotYetAtMaxWidth;
+          newColumns = newColumns.map((column) => {
+            if (column.canStretch) {
+              const adjustedWidth = Math.min(
+                column.width + additionalWidthPerColumn
+              );
+              return { ...column, width: adjustedWidth };
+            } else {
+              return column;
+            }
+          });
+        }
+        return newColumns.map(({ canStretch, ...column }) => column);
+      }
+    }
+  }
+  return columns;
+}
+var dataAndColumnUnchanged = (p, p1) => p.column === p1.column && p.column.valueFormatter(p.row[p.columnMap[p.column.name]]) === p1.column.valueFormatter(p1.row[p1.columnMap[p1.column.name]]);
 
 // src/cookie-utils.ts
 var getCookieValue = (name) => {
@@ -881,31 +1075,34 @@ function getEditRuleValidator(name) {
 
 // src/range-utils.ts
 var NULL_RANGE = { from: 0, to: 0 };
-function getFullRange({ from, to }, bufferSize = 0, rowCount = Number.MAX_SAFE_INTEGER) {
-  if (bufferSize === 0) {
-    if (rowCount < from) {
+var rangesAreSame = (r1, r2) => {
+  return (r1 == null ? void 0 : r1.from) === (r2 == null ? void 0 : r2.from) && (r1 == null ? void 0 : r1.to) === (r2 == null ? void 0 : r2.to);
+};
+function getFullRange({ from, to }, bufferSize = 0, totalRowCount = Number.MAX_SAFE_INTEGER) {
+  if (from === 0 && to === 0) {
+    return { from, to };
+  } else if (bufferSize === 0) {
+    if (totalRowCount < from) {
       return { from: 0, to: 0 };
     } else {
-      return { from, to: Math.min(to, rowCount) };
+      return { from, to: Math.min(to, totalRowCount) };
     }
   } else if (from === 0) {
-    return { from, to: Math.min(to + bufferSize, rowCount) };
+    return { from, to: Math.min(to + bufferSize, totalRowCount) };
   } else {
-    const rangeSize = to - from;
-    const buff = Math.round(bufferSize / 2);
-    const shortfallBefore = from - buff < 0;
-    const shortFallAfter = rowCount - (to + buff) < 0;
-    if (shortfallBefore && shortFallAfter) {
-      return { from: 0, to: rowCount };
+    const shortfallBefore = from - bufferSize < 0;
+    const shortfallAfter = totalRowCount - (to + bufferSize) < 0;
+    if (shortfallBefore && shortfallAfter) {
+      return { from: 0, to: totalRowCount };
     } else if (shortfallBefore) {
-      return { from: 0, to: rangeSize + bufferSize };
-    } else if (shortFallAfter) {
+      return { from: 0, to: to + bufferSize };
+    } else if (shortfallAfter) {
       return {
-        from: Math.max(0, rowCount - (rangeSize + bufferSize)),
-        to: rowCount
+        from: Math.max(0, from - bufferSize),
+        to: totalRowCount
       };
     } else {
-      return { from: from - buff, to: to + buff };
+      return { from: from - bufferSize, to: to + bufferSize };
     }
   }
 }
@@ -1000,7 +1197,7 @@ var DataWindow = class {
   }
   getData(from, to) {
     var _a;
-    const { from: clientFrom, to: clientTo } = this.range;
+    const { from: clientFrom } = this.range;
     const startOffset = Math.max(0, from - clientFrom);
     const endOffset = Math.min(to - clientFrom, (_a = this.rowCount) != null ? _a : to);
     return this.data.slice(startOffset, endOffset);
@@ -1208,6 +1405,812 @@ var withConfigDefaults = (config) => {
   }
 };
 
+// ../../node_modules/@internationalized/date/node_modules/@swc/helpers/esm/_check_private_redeclaration.js
+function _check_private_redeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+// ../../node_modules/@internationalized/date/node_modules/@swc/helpers/esm/_class_private_field_init.js
+function _class_private_field_init(obj, privateMap, value) {
+  _check_private_redeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+
+// ../../node_modules/@internationalized/date/dist/import.mjs
+function $2b4dce13dd5a17fa$export$842a2cf37af977e1(amount, numerator) {
+  return amount - numerator * Math.floor(amount / numerator);
+}
+var $3b62074eb05584b2$var$EPOCH = 1721426;
+function $3b62074eb05584b2$export$f297eb839006d339(era, year, month, day) {
+  year = $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year);
+  let y1 = year - 1;
+  let monthOffset = -2;
+  if (month <= 2)
+    monthOffset = 0;
+  else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year))
+    monthOffset = -1;
+  return $3b62074eb05584b2$var$EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
+}
+function $3b62074eb05584b2$export$553d7fa8e3805fc0(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year) {
+  return era === "BC" ? 1 - year : year;
+}
+function $3b62074eb05584b2$export$4475b7e617eb123c(year) {
+  let era = "AD";
+  if (year <= 0) {
+    era = "BC";
+    year = 1 - year;
+  }
+  return [
+    era,
+    year
+  ];
+}
+var $3b62074eb05584b2$var$daysInMonth = {
+  standard: [
+    31,
+    28,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+  ],
+  leapyear: [
+    31,
+    29,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+  ]
+};
+var $3b62074eb05584b2$export$80ee6245ec4f29ec = class {
+  fromJulianDay(jd) {
+    let jd0 = jd;
+    let depoch = jd0 - $3b62074eb05584b2$var$EPOCH;
+    let quadricent = Math.floor(depoch / 146097);
+    let dqc = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(depoch, 146097);
+    let cent = Math.floor(dqc / 36524);
+    let dcent = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dqc, 36524);
+    let quad = Math.floor(dcent / 1461);
+    let dquad = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dcent, 1461);
+    let yindex = Math.floor(dquad / 365);
+    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+    let [era, year] = $3b62074eb05584b2$export$4475b7e617eb123c(extendedYear);
+    let yearDay = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, 1, 1);
+    let leapAdj = 2;
+    if (jd0 < $3b62074eb05584b2$export$f297eb839006d339(era, year, 3, 1))
+      leapAdj = 0;
+    else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year))
+      leapAdj = 1;
+    let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+    let day = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, month, 1) + 1;
+    return new (0, $35ea8db9cb2ccb90$export$99faa760c7908e4f)(era, year, month, day);
+  }
+  toJulianDay(date) {
+    return $3b62074eb05584b2$export$f297eb839006d339(date.era, date.year, date.month, date.day);
+  }
+  getDaysInMonth(date) {
+    return $3b62074eb05584b2$var$daysInMonth[$3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? "leapyear" : "standard"][date.month - 1];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getMonthsInYear(date) {
+    return 12;
+  }
+  getDaysInYear(date) {
+    return $3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? 366 : 365;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getYearsInEra(date) {
+    return 9999;
+  }
+  getEras() {
+    return [
+      "BC",
+      "AD"
+    ];
+  }
+  isInverseEra(date) {
+    return date.era === "BC";
+  }
+  balanceDate(date) {
+    if (date.year <= 0) {
+      date.era = date.era === "BC" ? "AD" : "BC";
+      date.year = 1 - date.year;
+    }
+  }
+  constructor() {
+    this.identifier = "gregory";
+  }
+};
+function $14e0f24ef4ac5c92$export$68781ddf31c0090f(a, b) {
+  return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
+}
+function $14e0f24ef4ac5c92$export$c19a80a9721b80f6(a, b) {
+  return $14e0f24ef4ac5c92$var$timeToMs(a) - $14e0f24ef4ac5c92$var$timeToMs(b);
+}
+function $14e0f24ef4ac5c92$var$timeToMs(a) {
+  return a.hour * 36e5 + a.minute * 6e4 + a.second * 1e3 + a.millisecond;
+}
+var $14e0f24ef4ac5c92$var$localTimeZone = null;
+function $14e0f24ef4ac5c92$export$aa8b41735afcabd2() {
+  if ($14e0f24ef4ac5c92$var$localTimeZone == null)
+    $14e0f24ef4ac5c92$var$localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return $14e0f24ef4ac5c92$var$localTimeZone;
+}
+function $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date) {
+  date = $11d87f3f76e88657$export$b4a036af3fc0b032(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+  let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(date.era, date.year);
+  return $11d87f3f76e88657$var$epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, millisecond) {
+  let date = /* @__PURE__ */ new Date();
+  date.setUTCHours(hour, minute, second, millisecond);
+  date.setUTCFullYear(year, month - 1, day);
+  return date.getTime();
+}
+function $11d87f3f76e88657$export$59c99f3515d3493f(ms, timeZone) {
+  if (timeZone === "UTC")
+    return 0;
+  if (ms > 0 && timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)())
+    return new Date(ms).getTimezoneOffset() * -6e4;
+  let { year, month, day, hour, minute, second } = $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone);
+  let utc = $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, 0);
+  return utc - Math.floor(ms / 1e3) * 1e3;
+}
+var $11d87f3f76e88657$var$formattersByTimeZone = /* @__PURE__ */ new Map();
+function $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone) {
+  let formatter = $11d87f3f76e88657$var$formattersByTimeZone.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour12: false,
+      era: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+    $11d87f3f76e88657$var$formattersByTimeZone.set(timeZone, formatter);
+  }
+  let parts = formatter.formatToParts(new Date(ms));
+  let namedParts = {};
+  for (let part of parts)
+    if (part.type !== "literal")
+      namedParts[part.type] = part.value;
+  return {
+    // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
+    year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
+    month: +namedParts.month,
+    day: +namedParts.day,
+    hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
+    minute: +namedParts.minute,
+    second: +namedParts.second
+  };
+}
+var $11d87f3f76e88657$var$DAYMILLIS = 864e5;
+function $11d87f3f76e88657$var$getValidWallTimes(date, timeZone, earlier, later) {
+  let found = earlier === later ? [
+    earlier
+  ] : [
+    earlier,
+    later
+  ];
+  return found.filter((absolute) => $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute));
+}
+function $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute) {
+  let parts = $11d87f3f76e88657$var$getTimeZoneParts(absolute, timeZone);
+  return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
+}
+function $11d87f3f76e88657$export$5107c82f94518f5c(date, timeZone, disambiguation = "compatible") {
+  let dateTime = $11d87f3f76e88657$export$b21e0b124e224484(date);
+  if (timeZone === "UTC")
+    return $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
+  if (timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)() && disambiguation === "compatible") {
+    dateTime = $11d87f3f76e88657$export$b4a036af3fc0b032(dateTime, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+    let date2 = /* @__PURE__ */ new Date();
+    let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(dateTime.era, dateTime.year);
+    date2.setFullYear(year, dateTime.month - 1, dateTime.day);
+    date2.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+    return date2.getTime();
+  }
+  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
+  let offsetBefore = $11d87f3f76e88657$export$59c99f3515d3493f(ms - $11d87f3f76e88657$var$DAYMILLIS, timeZone);
+  let offsetAfter = $11d87f3f76e88657$export$59c99f3515d3493f(ms + $11d87f3f76e88657$var$DAYMILLIS, timeZone);
+  let valid = $11d87f3f76e88657$var$getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+  if (valid.length === 1)
+    return valid[0];
+  if (valid.length > 1)
+    switch (disambiguation) {
+      case "compatible":
+      case "earlier":
+        return valid[0];
+      case "later":
+        return valid[valid.length - 1];
+      case "reject":
+        throw new RangeError("Multiple possible absolute times found");
+    }
+  switch (disambiguation) {
+    case "earlier":
+      return Math.min(ms - offsetBefore, ms - offsetAfter);
+    case "compatible":
+    case "later":
+      return Math.max(ms - offsetBefore, ms - offsetAfter);
+    case "reject":
+      throw new RangeError("No such absolute time found");
+  }
+}
+function $11d87f3f76e88657$export$e67a095c620b86fe(dateTime, timeZone, disambiguation = "compatible") {
+  return new Date($11d87f3f76e88657$export$5107c82f94518f5c(dateTime, timeZone, disambiguation));
+}
+function $11d87f3f76e88657$export$b21e0b124e224484(date, time) {
+  let hour = 0, minute = 0, second = 0, millisecond = 0;
+  if ("timeZone" in date)
+    ({ hour, minute, second, millisecond } = date);
+  else if ("hour" in date && !time)
+    return date;
+  if (time)
+    ({ hour, minute, second, millisecond } = time);
+  return new (0, $35ea8db9cb2ccb90$export$ca871e8dbb80966f)(date.calendar, date.era, date.year, date.month, date.day, hour, minute, second, millisecond);
+}
+function $11d87f3f76e88657$export$b4a036af3fc0b032(date, calendar) {
+  if (date.calendar.identifier === calendar.identifier)
+    return date;
+  let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+  let copy = date.copy();
+  copy.calendar = calendar;
+  copy.era = calendarDate.era;
+  copy.year = calendarDate.year;
+  copy.month = calendarDate.month;
+  copy.day = calendarDate.day;
+  (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(copy);
+  return copy;
+}
+function $735220c2d4774dd3$export$e16d8520af44a096(date, duration) {
+  let mutableDate = date.copy();
+  let days = "hour" in mutableDate ? $735220c2d4774dd3$var$addTimeFields(mutableDate, duration) : 0;
+  $735220c2d4774dd3$var$addYears(mutableDate, duration.years || 0);
+  if (mutableDate.calendar.balanceYearMonth)
+    mutableDate.calendar.balanceYearMonth(mutableDate, date);
+  mutableDate.month += duration.months || 0;
+  $735220c2d4774dd3$var$balanceYearMonth(mutableDate);
+  $735220c2d4774dd3$var$constrainMonthDay(mutableDate);
+  mutableDate.day += (duration.weeks || 0) * 7;
+  mutableDate.day += duration.days || 0;
+  mutableDate.day += days;
+  $735220c2d4774dd3$var$balanceDay(mutableDate);
+  if (mutableDate.calendar.balanceDate)
+    mutableDate.calendar.balanceDate(mutableDate);
+  if (mutableDate.year < 1) {
+    mutableDate.year = 1;
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
+  if (mutableDate.year > maxYear) {
+    var _mutableDate_calendar, _mutableDate_calendar_isInverseEra;
+    let isInverseEra = (_mutableDate_calendar_isInverseEra = (_mutableDate_calendar = mutableDate.calendar).isInverseEra) === null || _mutableDate_calendar_isInverseEra === void 0 ? void 0 : _mutableDate_calendar_isInverseEra.call(_mutableDate_calendar, mutableDate);
+    mutableDate.year = maxYear;
+    mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
+    mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  if (mutableDate.month < 1) {
+    mutableDate.month = 1;
+    mutableDate.day = 1;
+  }
+  let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
+  if (mutableDate.month > maxMonth) {
+    mutableDate.month = maxMonth;
+    mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
+  }
+  mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+  return mutableDate;
+}
+function $735220c2d4774dd3$var$addYears(date, years) {
+  var _date_calendar, _date_calendar_isInverseEra;
+  if ((_date_calendar_isInverseEra = (_date_calendar = date.calendar).isInverseEra) === null || _date_calendar_isInverseEra === void 0 ? void 0 : _date_calendar_isInverseEra.call(_date_calendar, date))
+    years = -years;
+  date.year += years;
+}
+function $735220c2d4774dd3$var$balanceYearMonth(date) {
+  while (date.month < 1) {
+    $735220c2d4774dd3$var$addYears(date, -1);
+    date.month += date.calendar.getMonthsInYear(date);
+  }
+  let monthsInYear = 0;
+  while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+    date.month -= monthsInYear;
+    $735220c2d4774dd3$var$addYears(date, 1);
+  }
+}
+function $735220c2d4774dd3$var$balanceDay(date) {
+  while (date.day < 1) {
+    date.month--;
+    $735220c2d4774dd3$var$balanceYearMonth(date);
+    date.day += date.calendar.getDaysInMonth(date);
+  }
+  while (date.day > date.calendar.getDaysInMonth(date)) {
+    date.day -= date.calendar.getDaysInMonth(date);
+    date.month++;
+    $735220c2d4774dd3$var$balanceYearMonth(date);
+  }
+}
+function $735220c2d4774dd3$var$constrainMonthDay(date) {
+  date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+function $735220c2d4774dd3$export$c4e2ecac49351ef2(date) {
+  if (date.calendar.constrainDate)
+    date.calendar.constrainDate(date);
+  date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+  $735220c2d4774dd3$var$constrainMonthDay(date);
+}
+function $735220c2d4774dd3$export$3e2544e88a25bff8(duration) {
+  let inverseDuration = {};
+  for (let key in duration)
+    if (typeof duration[key] === "number")
+      inverseDuration[key] = -duration[key];
+  return inverseDuration;
+}
+function $735220c2d4774dd3$export$4e2d2ead65e5f7e3(date, duration) {
+  return $735220c2d4774dd3$export$e16d8520af44a096(date, $735220c2d4774dd3$export$3e2544e88a25bff8(duration));
+}
+function $735220c2d4774dd3$export$adaa4cf7ef1b65be(date, fields) {
+  let mutableDate = date.copy();
+  if (fields.era != null)
+    mutableDate.era = fields.era;
+  if (fields.year != null)
+    mutableDate.year = fields.year;
+  if (fields.month != null)
+    mutableDate.month = fields.month;
+  if (fields.day != null)
+    mutableDate.day = fields.day;
+  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutableDate);
+  return mutableDate;
+}
+function $735220c2d4774dd3$export$e5d5e1c1822b6e56(value, fields) {
+  let mutableValue = value.copy();
+  if (fields.hour != null)
+    mutableValue.hour = fields.hour;
+  if (fields.minute != null)
+    mutableValue.minute = fields.minute;
+  if (fields.second != null)
+    mutableValue.second = fields.second;
+  if (fields.millisecond != null)
+    mutableValue.millisecond = fields.millisecond;
+  $735220c2d4774dd3$export$7555de1e070510cb(mutableValue);
+  return mutableValue;
+}
+function $735220c2d4774dd3$var$balanceTime(time) {
+  time.second += Math.floor(time.millisecond / 1e3);
+  time.millisecond = $735220c2d4774dd3$var$nonNegativeMod(time.millisecond, 1e3);
+  time.minute += Math.floor(time.second / 60);
+  time.second = $735220c2d4774dd3$var$nonNegativeMod(time.second, 60);
+  time.hour += Math.floor(time.minute / 60);
+  time.minute = $735220c2d4774dd3$var$nonNegativeMod(time.minute, 60);
+  let days = Math.floor(time.hour / 24);
+  time.hour = $735220c2d4774dd3$var$nonNegativeMod(time.hour, 24);
+  return days;
+}
+function $735220c2d4774dd3$export$7555de1e070510cb(time) {
+  time.millisecond = Math.max(0, Math.min(time.millisecond, 1e3));
+  time.second = Math.max(0, Math.min(time.second, 59));
+  time.minute = Math.max(0, Math.min(time.minute, 59));
+  time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+function $735220c2d4774dd3$var$nonNegativeMod(a, b) {
+  let result = a % b;
+  if (result < 0)
+    result += b;
+  return result;
+}
+function $735220c2d4774dd3$var$addTimeFields(time, duration) {
+  time.hour += duration.hours || 0;
+  time.minute += duration.minutes || 0;
+  time.second += duration.seconds || 0;
+  time.millisecond += duration.milliseconds || 0;
+  return $735220c2d4774dd3$var$balanceTime(time);
+}
+function $735220c2d4774dd3$export$d52ced6badfb9a4c(value, field, amount, options) {
+  let mutable = value.copy();
+  switch (field) {
+    case "era": {
+      let eras = value.calendar.getEras();
+      let eraIndex = eras.indexOf(value.era);
+      if (eraIndex < 0)
+        throw new Error("Invalid era: " + value.era);
+      eraIndex = $735220c2d4774dd3$var$cycleValue(eraIndex, amount, 0, eras.length - 1, options === null || options === void 0 ? void 0 : options.round);
+      mutable.era = eras[eraIndex];
+      $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
+      break;
+    }
+    case "year":
+      var _mutable_calendar, _mutable_calendar_isInverseEra;
+      if ((_mutable_calendar_isInverseEra = (_mutable_calendar = mutable.calendar).isInverseEra) === null || _mutable_calendar_isInverseEra === void 0 ? void 0 : _mutable_calendar_isInverseEra.call(_mutable_calendar, mutable))
+        amount = -amount;
+      mutable.year = $735220c2d4774dd3$var$cycleValue(value.year, amount, -Infinity, 9999, options === null || options === void 0 ? void 0 : options.round);
+      if (mutable.year === -Infinity)
+        mutable.year = 1;
+      if (mutable.calendar.balanceYearMonth)
+        mutable.calendar.balanceYearMonth(mutable, value);
+      break;
+    case "month":
+      mutable.month = $735220c2d4774dd3$var$cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "day":
+      mutable.day = $735220c2d4774dd3$var$cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options === null || options === void 0 ? void 0 : options.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field);
+  }
+  if (value.calendar.balanceDate)
+    value.calendar.balanceDate(mutable);
+  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
+  return mutable;
+}
+function $735220c2d4774dd3$export$dd02b3e0007dfe28(value, field, amount, options) {
+  let mutable = value.copy();
+  switch (field) {
+    case "hour": {
+      let hours = value.hour;
+      let min = 0;
+      let max = 23;
+      if ((options === null || options === void 0 ? void 0 : options.hourCycle) === 12) {
+        let isPM = hours >= 12;
+        min = isPM ? 12 : 0;
+        max = isPM ? 23 : 11;
+      }
+      mutable.hour = $735220c2d4774dd3$var$cycleValue(hours, amount, min, max, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    }
+    case "minute":
+      mutable.minute = $735220c2d4774dd3$var$cycleValue(value.minute, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "second":
+      mutable.second = $735220c2d4774dd3$var$cycleValue(value.second, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    case "millisecond":
+      mutable.millisecond = $735220c2d4774dd3$var$cycleValue(value.millisecond, amount, 0, 999, options === null || options === void 0 ? void 0 : options.round);
+      break;
+    default:
+      throw new Error("Unsupported field " + field);
+  }
+  return mutable;
+}
+function $735220c2d4774dd3$var$cycleValue(value, amount, min, max, round = false) {
+  if (round) {
+    value += Math.sign(amount);
+    if (value < min)
+      value = max;
+    let div = Math.abs(amount);
+    if (amount > 0)
+      value = Math.ceil(value / div) * div;
+    else
+      value = Math.floor(value / div) * div;
+    if (value > max)
+      value = min;
+  } else {
+    value += amount;
+    if (value < min)
+      value = max - (min - value - 1);
+    else if (value > max)
+      value = min + (value - max - 1);
+  }
+  return value;
+}
+var $fae977aafc393c5c$var$requiredDurationTimeGroups = [
+  "hours",
+  "minutes",
+  "seconds"
+];
+var $fae977aafc393c5c$var$requiredDurationGroups = [
+  "years",
+  "months",
+  "weeks",
+  "days",
+  ...$fae977aafc393c5c$var$requiredDurationTimeGroups
+];
+function $fae977aafc393c5c$export$f59dee82248f5ad4(time) {
+  return `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}:${String(time.second).padStart(2, "0")}${time.millisecond ? String(time.millisecond / 1e3).slice(1) : ""}`;
+}
+function $fae977aafc393c5c$export$60dfd74aa96791bd(date) {
+  let gregorianDate = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
+  return `${String(gregorianDate.year).padStart(4, "0")}-${String(gregorianDate.month).padStart(2, "0")}-${String(gregorianDate.day).padStart(2, "0")}`;
+}
+function $fae977aafc393c5c$export$4223de14708adc63(date) {
+  return `${$fae977aafc393c5c$export$60dfd74aa96791bd(date)}T${$fae977aafc393c5c$export$f59dee82248f5ad4(date)}`;
+}
+function $35ea8db9cb2ccb90$var$shiftArgs(args) {
+  let calendar = typeof args[0] === "object" ? args.shift() : new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)();
+  let era;
+  if (typeof args[0] === "string")
+    era = args.shift();
+  else {
+    let eras = calendar.getEras();
+    era = eras[eras.length - 1];
+  }
+  let year = args.shift();
+  let month = args.shift();
+  let day = args.shift();
+  return [
+    calendar,
+    era,
+    year,
+    month,
+    day
+  ];
+}
+var $35ea8db9cb2ccb90$var$_type = /* @__PURE__ */ new WeakMap();
+var $35ea8db9cb2ccb90$export$99faa760c7908e4f = class _$35ea8db9cb2ccb90$export$99faa760c7908e4f {
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era)
+      return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.era, this.year, this.month, this.day);
+    else
+      return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.year, this.month, this.day);
+  }
+  /** Returns a new `CalendarDate` with the given duration added to it. */
+  add(duration) {
+    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+  subtract(duration) {
+    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
+  }
+  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)(this, fields);
+  }
+  /**
+  * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+  * When the resulting value reaches the limits of the field, it wraps around.
+  */
+  cycle(field, amount, options) {
+    return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field, amount, options);
+  }
+  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
+  toDate(timeZone) {
+    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return (0, $fae977aafc393c5c$export$60dfd74aa96791bd)(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    return (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
+  }
+  constructor(...args) {
+    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type, {
+      writable: true,
+      value: void 0
+    });
+    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
+  }
+};
+var $35ea8db9cb2ccb90$var$_type2 = /* @__PURE__ */ new WeakMap();
+var $35ea8db9cb2ccb90$export$ca871e8dbb80966f = class _$35ea8db9cb2ccb90$export$ca871e8dbb80966f {
+  /** Returns a copy of this date. */
+  copy() {
+    if (this.era)
+      return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+    else
+      return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration added to it. */
+  add(duration) {
+    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+  subtract(duration) {
+    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
+  }
+  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
+  set(fields) {
+    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)((0, $735220c2d4774dd3$export$e5d5e1c1822b6e56)(this, fields), fields);
+  }
+  /**
+  * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+  * When the resulting value reaches the limits of the field, it wraps around.
+  */
+  cycle(field, amount, options) {
+    switch (field) {
+      case "era":
+      case "year":
+      case "month":
+      case "day":
+        return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field, amount, options);
+      default:
+        return (0, $735220c2d4774dd3$export$dd02b3e0007dfe28)(this, field, amount, options);
+    }
+  }
+  /** Converts the date to a native JavaScript Date object in the given time zone. */
+  toDate(timeZone, disambiguation) {
+    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone, disambiguation);
+  }
+  /** Converts the date to an ISO 8601 formatted string. */
+  toString() {
+    return (0, $fae977aafc393c5c$export$4223de14708adc63)(this);
+  }
+  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
+  compare(b) {
+    let res = (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
+    if (res === 0)
+      return (0, $14e0f24ef4ac5c92$export$c19a80a9721b80f6)(this, (0, $11d87f3f76e88657$export$b21e0b124e224484)(b));
+    return res;
+  }
+  constructor(...args) {
+    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type2, {
+      writable: true,
+      value: void 0
+    });
+    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
+    this.calendar = calendar;
+    this.era = era;
+    this.year = year;
+    this.month = month;
+    this.day = day;
+    this.hour = args.shift() || 0;
+    this.minute = args.shift() || 0;
+    this.second = args.shift() || 0;
+    this.millisecond = args.shift() || 0;
+    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
+  }
+};
+var $7c5f6fbf42389787$var$HOUR_PARTS = 1080;
+var $7c5f6fbf42389787$var$DAY_PARTS = 24 * $7c5f6fbf42389787$var$HOUR_PARTS;
+var $7c5f6fbf42389787$var$MONTH_DAYS = 29;
+var $7c5f6fbf42389787$var$MONTH_FRACT = 12 * $7c5f6fbf42389787$var$HOUR_PARTS + 793;
+var $7c5f6fbf42389787$var$MONTH_PARTS = $7c5f6fbf42389787$var$MONTH_DAYS * $7c5f6fbf42389787$var$DAY_PARTS + $7c5f6fbf42389787$var$MONTH_FRACT;
+var $fb18d541ea1ad717$var$formatterCache = /* @__PURE__ */ new Map();
+var $fb18d541ea1ad717$export$ad991b66133851cf = class {
+  /** Formats a date as a string according to the locale and format options passed to the constructor. */
+  format(value) {
+    return this.formatter.format(value);
+  }
+  /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+  formatToParts(value) {
+    return this.formatter.formatToParts(value);
+  }
+  /** Formats a date range as a string. */
+  formatRange(start, end) {
+    if (typeof this.formatter.formatRange === "function")
+      return this.formatter.formatRange(start, end);
+    if (end < start)
+      throw new RangeError("End date must be >= start date");
+    return `${this.formatter.format(start)} \u2013 ${this.formatter.format(end)}`;
+  }
+  /** Formats a date range as an array of parts. */
+  formatRangeToParts(start, end) {
+    if (typeof this.formatter.formatRangeToParts === "function")
+      return this.formatter.formatRangeToParts(start, end);
+    if (end < start)
+      throw new RangeError("End date must be >= start date");
+    let startParts = this.formatter.formatToParts(start);
+    let endParts = this.formatter.formatToParts(end);
+    return [
+      ...startParts.map((p) => ({
+        ...p,
+        source: "startRange"
+      })),
+      {
+        type: "literal",
+        value: " \u2013 ",
+        source: "shared"
+      },
+      ...endParts.map((p) => ({
+        ...p,
+        source: "endRange"
+      }))
+    ];
+  }
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions() {
+    let resolvedOptions = this.formatter.resolvedOptions();
+    if ($fb18d541ea1ad717$var$hasBuggyResolvedHourCycle()) {
+      if (!this.resolvedHourCycle)
+        this.resolvedHourCycle = $fb18d541ea1ad717$var$getResolvedHourCycle(resolvedOptions.locale, this.options);
+      resolvedOptions.hourCycle = this.resolvedHourCycle;
+      resolvedOptions.hour12 = this.resolvedHourCycle === "h11" || this.resolvedHourCycle === "h12";
+    }
+    if (resolvedOptions.calendar === "ethiopic-amete-alem")
+      resolvedOptions.calendar = "ethioaa";
+    return resolvedOptions;
+  }
+  constructor(locale, options = {}) {
+    this.formatter = $fb18d541ea1ad717$var$getCachedDateFormatter(locale, options);
+    this.options = options;
+  }
+};
+var $fb18d541ea1ad717$var$hour12Preferences = {
+  true: {
+    // Only Japanese uses the h11 style for 12 hour time. All others use h12.
+    ja: "h11"
+  },
+  false: {}
+};
+function $fb18d541ea1ad717$var$getCachedDateFormatter(locale, options = {}) {
+  if (typeof options.hour12 === "boolean" && $fb18d541ea1ad717$var$hasBuggyHour12Behavior()) {
+    options = {
+      ...options
+    };
+    let pref = $fb18d541ea1ad717$var$hour12Preferences[String(options.hour12)][locale.split("-")[0]];
+    let defaultHourCycle = options.hour12 ? "h12" : "h23";
+    options.hourCycle = pref !== null && pref !== void 0 ? pref : defaultHourCycle;
+    delete options.hour12;
+  }
+  let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+  if ($fb18d541ea1ad717$var$formatterCache.has(cacheKey))
+    return $fb18d541ea1ad717$var$formatterCache.get(cacheKey);
+  let numberFormatter = new Intl.DateTimeFormat(locale, options);
+  $fb18d541ea1ad717$var$formatterCache.set(cacheKey, numberFormatter);
+  return numberFormatter;
+}
+var $fb18d541ea1ad717$var$_hasBuggyHour12Behavior = null;
+function $fb18d541ea1ad717$var$hasBuggyHour12Behavior() {
+  if ($fb18d541ea1ad717$var$_hasBuggyHour12Behavior == null)
+    $fb18d541ea1ad717$var$_hasBuggyHour12Behavior = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      hour12: false
+    }).format(new Date(2020, 2, 3, 0)) === "24";
+  return $fb18d541ea1ad717$var$_hasBuggyHour12Behavior;
+}
+var $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle = null;
+function $fb18d541ea1ad717$var$hasBuggyResolvedHourCycle() {
+  if ($fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle == null)
+    $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle = new Intl.DateTimeFormat("fr", {
+      hour: "numeric",
+      hour12: false
+    }).resolvedOptions().hourCycle === "h12";
+  return $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle;
+}
+function $fb18d541ea1ad717$var$getResolvedHourCycle(locale, options) {
+  if (!options.timeStyle && !options.hour)
+    return void 0;
+  locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, "");
+  locale += (locale.includes("-u-") ? "" : "-u") + "-nu-latn";
+  let formatter = $fb18d541ea1ad717$var$getCachedDateFormatter(locale, {
+    ...options,
+    timeZone: void 0
+    // use local timezone
+  });
+  let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find((p) => p.type === "hour").value, 10);
+  let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find((p) => p.type === "hour").value, 10);
+  if (min === 0 && max === 23)
+    return "h23";
+  if (min === 24 && max === 23)
+    return "h24";
+  if (min === 0 && max === 11)
+    return "h11";
+  if (min === 12 && max === 11)
+    return "h12";
+  throw new Error("Unexpected hour cycle result");
+}
+
 // src/ts-utils.ts
 function isNotNullOrUndefined(value) {
   return value !== void 0 && value !== null;
@@ -1265,8 +2268,11 @@ function getFormatConfigs(pattern) {
   ];
 }
 function formatDate(pattern) {
-  const dateTimeFormats = getFormatConfigs(pattern).filter(isNotNullOrUndefined).map((c) => Intl.DateTimeFormat(c.locale, c.options));
-  return (d) => dateTimeFormats.map((dtf) => dtf.format(d)).join(" ");
+  const formatters = getFormatConfigs(pattern).filter(isNotNullOrUndefined).map((c) => getDateFormatter(c.locale, c.options));
+  return (d) => formatters.map((f) => f.format(d)).join(" ");
+}
+function getDateFormatter(locale, options) {
+  return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, options);
 }
 
 // src/date/types.ts
@@ -1288,7 +2294,12 @@ var isDatePattern = (pattern) => supportedDatePatterns.includes(pattern);
 var isTimePattern = (pattern) => supportedTimePatterns.includes(pattern);
 var isDateTimePattern = (pattern) => isDatePattern(pattern == null ? void 0 : pattern.date) || isTimePattern(pattern == null ? void 0 : pattern.time);
 
-// src/date/helpers.ts
+// src/date/utils.ts
+function toCalendarDate(d) {
+  return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(d.getFullYear(), d.getMonth() + 1, d.getDate());
+}
+
+// src/date/dateTimePattern.ts
 var defaultPatternsByType = {
   time: "hh:mm:ss",
   date: "dd.mm.yyyy"
@@ -1888,60 +2899,81 @@ var Space2 = " ";
 var Tab = "Tab";
 
 // src/keyset.ts
+var EMPTY2 = [];
 var KeySet = class {
   constructor(range) {
     this.keys = /* @__PURE__ */ new Map();
-    this.free = [];
     this.nextKeyValue = 0;
-    this.reset(range);
+    this.range = range;
+    this.init(range);
   }
-  next() {
-    if (this.free.length > 0) {
-      return this.free.shift();
+  next(free = EMPTY2) {
+    if (free.length > 0) {
+      return free.shift();
     } else {
       return this.nextKeyValue++;
     }
   }
-  reset({ from, to }) {
+  init({ from, to }) {
+    this.keys.clear();
+    this.nextKeyValue = 0;
+    for (let rowIndex = from; rowIndex < to; rowIndex++) {
+      const nextKeyValue = this.next();
+      this.keys.set(rowIndex, nextKeyValue);
+    }
+    return true;
+  }
+  reset(range) {
+    const { from, to } = range;
+    const newSize = to - from;
+    const currentSize = this.range.to - this.range.from;
+    this.range = range;
+    if (currentSize > newSize) {
+      return this.init(range);
+    }
+    const freeKeys = [];
     this.keys.forEach((keyValue, rowIndex) => {
       if (rowIndex < from || rowIndex >= to) {
-        this.free.push(keyValue);
+        freeKeys.push(keyValue);
         this.keys.delete(rowIndex);
       }
     });
-    const size2 = to - from;
-    if (this.keys.size + this.free.length > size2) {
-      this.free.length = Math.max(0, size2 - this.keys.size);
-    }
     for (let rowIndex = from; rowIndex < to; rowIndex++) {
       if (!this.keys.has(rowIndex)) {
-        const nextKeyValue = this.next();
+        const nextKeyValue = this.next(freeKeys);
         this.keys.set(rowIndex, nextKeyValue);
       }
     }
-    if (this.nextKeyValue > this.keys.size) {
-      this.nextKeyValue = this.keys.size;
-    }
+    return false;
   }
   keyFor(rowIndex) {
     const key = this.keys.get(rowIndex);
     if (key === void 0) {
       console.log(`key not found
         keys: ${this.toDebugString()}
-        free : ${this.free.join(",")}  
       `);
       throw Error(`KeySet, no key found for rowIndex ${rowIndex}`);
     }
     return key;
   }
   toDebugString() {
-    return Array.from(this.keys.entries()).map(([k, v]) => `${k}=>${v}`).join(",");
+    return `${this.keys.size} keys
+${Array.from(this.keys.entries()).sort(([key1], [key2]) => key1 - key2).map(([k, v]) => `${k}=>${v}`).join(",")}]
+`;
   }
 };
 
 // src/menu-utils.ts
 var isGroupMenuItemDescriptor = (menuItem) => menuItem !== void 0 && "children" in menuItem;
 
+// src/module-utils.ts
+var isModule = (entity) => entity !== void 0 && typeof entity !== "function";
+var assertModuleExportsAtLeastOneComponent = (module) => {
+  if (module && Object.values(module).every((item) => isModule(item))) {
+    throw Error("module file, no components");
+  }
+};
+
 // src/nanoid/index.ts
 var uuid = (size2 = 21) => {
   let id = "";
@@ -1961,6 +2993,23 @@ var uuid = (size2 = 21) => {
   return id;
 };
 
+// src/react-utils.ts
+import { Children, isValidElement } from "react";
+var EMPTY_ARRAY = [];
+var asReactElements = (children) => {
+  const isArray = Array.isArray(children);
+  const count = isArray ? children.length : Children.count(children);
+  if (isArray && children.every(isValidElement)) {
+    return children;
+  } else if (count === 1 && !isArray && isValidElement(children)) {
+    return [children];
+  } else if (count > 1) {
+    return children;
+  } else {
+    return EMPTY_ARRAY;
+  }
+};
+
 // src/perf-utils.ts
 function debounce(callback, timeInterval) {
   let timeout;
@@ -2000,9 +3049,9 @@ var actualRowPositioning = (rowHeight) => [
   false
 ];
 var virtualRowPositioning = (rowHeight, virtualisedExtent, pctScrollTop) => [
-  (row) => {
+  (row, offset = 0) => {
     const rowOffset = pctScrollTop.current * virtualisedExtent;
-    return row[IDX] * rowHeight - rowOffset;
+    return (row[IDX] - offset) * rowHeight - rowOffset;
   },
   /*
     Return index position of closest row 
@@ -2335,7 +3384,7 @@ var wordify = (text) => {
 // src/ThemeProvider.tsx
 import {
   createContext,
-  isValidElement,
+  isValidElement as isValidElement2,
   cloneElement,
   useContext
 } from "react";
@@ -2395,7 +3444,7 @@ var useThemeAttributes = (themeAttributes) => {
 };
 var createThemedChildren = (children, theme, themeMode, density) => {
   var _a;
-  if (isValidElement(children)) {
+  if (isValidElement2(children)) {
     return cloneElement(children, {
       className: clsx_default(
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -2503,11 +3552,16 @@ export {
   applyGroupByToColumns,
   applySort,
   applySortToColumns,
+  applyWidthToColumns,
+  asReactElements,
+  assertModuleExportsAtLeastOneComponent,
   boxContainsPoint,
   buildColumnMap,
   columnsChanged,
   configChanged,
   createEl,
+  dataAndColumnUnchanged,
+  dateTimePattern,
   debounce,
   defaultPatternsByType,
   defaultValueFormatter,
@@ -2520,7 +3574,6 @@ export {
   fallbackDateTimePattern,
   filterAsQuery,
   filterChanged,
-  filterValue,
   findColumn,
   flattenColumnGroup,
   focusFirstFocusableElement,
@@ -2545,6 +3598,7 @@ export {
   getColumnsInViewport,
   getConfigurationEditor,
   getCookieValue,
+  getDateFormatter,
   getDefaultAlignment,
   getDefaultColumnType,
   getEditRuleValidator,
@@ -2595,9 +3649,9 @@ export {
   isJsonAttribute,
   isJsonColumn,
   isJsonGroup,
-  isKeyedColumn,
   isLookupRenderer,
   isMappedValueTypeRenderer,
+  isModule,
   isMultiClauseFilter,
   isMultiValueFilter,
   isNamedFilter,
@@ -2635,6 +3689,7 @@ export {
   lastWord,
   logger,
   mapSortCriteria,
+  measurePinnedColumns,
   messageHasResult,
   metadataKeys,
   moveColumnTo,
@@ -2643,8 +3698,8 @@ export {
   numericFormatter,
   partition,
   projectUpdates,
-  quotedStrings,
   rangeNewItems,
+  rangesAreSame,
   registerComponent,
   registerConfigurationEditor,
   removeColumnFromFilter,
@@ -2663,6 +3718,7 @@ export {
   subscribedOnly,
   supportedDateTimePatterns,
   throttle,
+  toCalendarDate,
   toColumnDescriptor,
   toDataSourceColumns,
   updateColumn,