@ni/nimble-components 29.7.2 → 29.7.3

package/dist/all-components-bundle.js

@@ -16280,7 +16280,7 @@
 
   /**
    * Do not edit directly
-   * Generated on Thu, 27 Jun 2024 17:09:09 GMT
+   * Generated on Mon, 01 Jul 2024 20:00:46 GMT
    */
 
   const Information100DarkUi = "#a46eff";
@@ -26760,7 +26760,7 @@
       /**
       Find the index and inner offset corresponding to a given relative
       position in this fragment. The result object will be reused
-      (overwritten) the next time the function is called. (Not public.)
+      (overwritten) the next time the function is called. @internal
       */
       findIndex(pos, round = -1) {
           if (pos == 0)
@@ -27549,17 +27549,29 @@
       @internal
       */
       static resolveCached(doc, pos) {
-          for (let i = 0; i < resolveCache.length; i++) {
-              let cached = resolveCache[i];
-              if (cached.pos == pos && cached.doc == doc)
-                  return cached;
+          let cache = resolveCache.get(doc);
+          if (cache) {
+              for (let i = 0; i < cache.elts.length; i++) {
+                  let elt = cache.elts[i];
+                  if (elt.pos == pos)
+                      return elt;
+              }
+          }
+          else {
+              resolveCache.set(doc, cache = new ResolveCache);
           }
-          let result = resolveCache[resolveCachePos] = ResolvedPos.resolve(doc, pos);
-          resolveCachePos = (resolveCachePos + 1) % resolveCacheSize;
+          let result = cache.elts[cache.i] = ResolvedPos.resolve(doc, pos);
+          cache.i = (cache.i + 1) % resolveCacheSize;
           return result;
       }
   }
-  let resolveCache = [], resolveCachePos = 0, resolveCacheSize = 12;
+  class ResolveCache {
+      constructor() {
+          this.elts = [];
+          this.i = 0;
+      }
+  }
+  const resolveCacheSize = 12, resolveCache = new WeakMap();
   /**
   Represents a flat range of content, i.e. one that starts and
   ends in the same node.
@@ -27991,7 +28003,7 @@
       static fromJSON(schema, json) {
           if (!json)
               throw new RangeError("Invalid input for Node.fromJSON");
-          let marks = null;
+          let marks = undefined;
           if (json.marks) {
               if (!Array.isArray(json.marks))
                   throw new RangeError("Invalid mark data for Node.fromJSON");
@@ -28663,7 +28675,7 @@
       }
       /**
       Returns true if the given fragment is valid content for this node
-      type with the given attributes.
+      type.
       */
       validContent(content) {
           let result = this.contentMatch.matchFragment(content);
@@ -28995,11 +29007,17 @@
           @internal
           */
           this.styles = [];
+          let matchedStyles = this.matchedStyles = [];
           rules.forEach(rule => {
-              if (isTagRule(rule))
+              if (isTagRule(rule)) {
                   this.tags.push(rule);
-              else if (isStyleRule(rule))
+              }
+              else if (isStyleRule(rule)) {
+                  let prop = /[^=]*/.exec(rule.style)[0];
+                  if (matchedStyles.indexOf(prop) < 0)
+                      matchedStyles.push(prop);
                   this.styles.push(rule);
+              }
           });
           // Only normalize list elements when lists in the schema can't directly contain themselves
           this.normalizeLists = !this.tags.some(r => {
@@ -29249,10 +29267,10 @@
               this.addElement(dom);
       }
       withStyleRules(dom, f) {
-          let style = dom.getAttribute("style");
-          if (!style)
+          let style = dom.style;
+          if (!style || !style.length)
               return f();
-          let marks = this.readStyles(parseStyles(style));
+          let marks = this.readStyles(dom.style);
           if (!marks)
               return; // A style with ignore: true
           let [addMarks, removeMarks] = marks, top = this.top;
@@ -29361,28 +29379,36 @@
       // had a rule with `ignore` set.
       readStyles(styles) {
           let add = Mark$1.none, remove = Mark$1.none;
-          for (let i = 0; i < styles.length; i += 2) {
-              for (let after = undefined;;) {
-                  let rule = this.parser.matchStyle(styles[i], styles[i + 1], this, after);
-                  if (!rule)
-                      break;
-                  if (rule.ignore)
-                      return null;
-                  if (rule.clearMark) {
-                      this.top.pendingMarks.concat(this.top.activeMarks).forEach(m => {
-                          if (rule.clearMark(m))
-                              remove = m.addToSet(remove);
-                      });
-                  }
-                  else {
-                      add = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add);
-                  }
-                  if (rule.consuming === false)
-                      after = rule;
-                  else
-                      break;
+          // Because many properties will only show up in 'normalized' form
+          // in `style.item` (i.e. text-decoration becomes
+          // text-decoration-line, text-decoration-color, etc), we directly
+          // query the styles mentioned in our rules instead of iterating
+          // over the items.
+          if (styles.length)
+              for (let i = 0; i < this.parser.matchedStyles.length; i++) {
+                  let name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
+                  if (value)
+                      for (let after = undefined;;) {
+                          let rule = this.parser.matchStyle(name, value, this, after);
+                          if (!rule)
+                              break;
+                          if (rule.ignore)
+                              return null;
+                          if (rule.clearMark) {
+                              this.top.pendingMarks.concat(this.top.activeMarks).forEach(m => {
+                                  if (rule.clearMark(m))
+                                      remove = m.addToSet(remove);
+                              });
+                          }
+                          else {
+                              add = this.parser.schema.marks[rule.mark].create(rule.attrs).addToSet(add);
+                          }
+                          if (rule.consuming === false)
+                              after = rule;
+                          else
+                              break;
+                      }
               }
-          }
           return [add, remove];
       }
       // Look up a handler for the given node. If none are found, return
@@ -29666,13 +29692,6 @@
   function matches(dom, selector) {
       return (dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector).call(dom, selector);
   }
-  // Tokenize a style attribute into property/value pairs.
-  function parseStyles(style) {
-      let re = /\s*([\w-]+)\s*:\s*([^;]+)/g, m, result = [];
-      while (m = re.exec(style))
-          result.push(m[1], m[2].trim());
-      return result;
-  }
   function copy$1(obj) {
       let copy = {};
       for (let prop in obj)
@@ -63197,13 +63216,13 @@ img.ProseMirror-separator {
         return isTop ? 'top' : isBottom ? 'bottom' : false;
       };
       row.getPinnedIndex = () => {
-        var _table$_getPinnedRows, _visiblePinnedRowIds$;
+        var _ref4, _visiblePinnedRowIds$;
         const position = row.getIsPinned();
         if (!position) return -1;
-        const visiblePinnedRowIds = (_table$_getPinnedRows = table._getPinnedRows(position)) == null ? void 0 : _table$_getPinnedRows.map(_ref4 => {
+        const visiblePinnedRowIds = (_ref4 = position === 'top' ? table.getTopRows() : table.getBottomRows()) == null ? void 0 : _ref4.map(_ref5 => {
           let {
             id
-          } = _ref4;
+          } = _ref5;
           return id;
         });
         return (_visiblePinnedRowIds$ = visiblePinnedRowIds == null ? void 0 : visiblePinnedRowIds.indexOf(row.id)) != null ? _visiblePinnedRowIds$ : -1;
@@ -63224,7 +63243,7 @@ img.ProseMirror-separator {
         }
         return Boolean((_pinningState$positio = pinningState[position]) == null ? void 0 : _pinningState$positio.length);
       };
-      table._getPinnedRows = memo$1(position => [table.getRowModel().rows, table.getState().rowPinning[position], position], (visibleRows, pinnedRowIds, position) => {
+      table._getPinnedRows = (visibleRows, pinnedRowIds, position) => {
         var _table$options$keepPi;
         const rows = ((_table$options$keepPi = table.options.keepPinnedRows) != null ? _table$options$keepPi : true) ?
         //get all rows that are pinned even if they would not be otherwise visible
@@ -63239,9 +63258,9 @@ img.ProseMirror-separator {
           ...d,
           position
         }));
-      }, getMemoOptions(table.options, 'debugRows', '_getPinnedRows'));
-      table.getTopRows = () => table._getPinnedRows('top');
-      table.getBottomRows = () => table._getPinnedRows('bottom');
+      };
+      table.getTopRows = memo$1(() => [table.getRowModel().rows, table.getState().rowPinning.top], (allRows, topPinnedRowIds) => table._getPinnedRows(allRows, topPinnedRowIds, 'top'), getMemoOptions(table.options, 'debugRows', 'getTopRows'));
+      table.getBottomRows = memo$1(() => [table.getRowModel().rows, table.getState().rowPinning.bottom], (allRows, bottomPinnedRowIds) => table._getPinnedRows(allRows, bottomPinnedRowIds, 'bottom'), getMemoOptions(table.options, 'debugRows', 'getBottomRows'));
       table.getCenterRows = memo$1(() => [table.getRowModel().rows, table.getState().rowPinning.top, table.getState().rowPinning.bottom], (allRows, top, bottom) => {
         const topAndBottom = new Set([...(top != null ? top : []), ...(bottom != null ? bottom : [])]);
         return allRows.filter(d => !topAndBottom.has(d.id));
@@ -66373,8 +66392,7 @@ focus outline in that case.
     return () => {
       var _a, _b, _c, _d;
       let depTime;
-      if (opts.key && ((_a = opts.debug) == null ? void 0 : _a.call(opts)))
-        depTime = Date.now();
+      if (opts.key && ((_a = opts.debug) == null ? void 0 : _a.call(opts))) depTime = Date.now();
       const newDeps = getDeps();
       const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep);
       if (!depsChanged) {
@@ -66382,8 +66400,7 @@ focus outline in that case.
       }
       deps = newDeps;
       let resultTime;
-      if (opts.key && ((_b = opts.debug) == null ? void 0 : _b.call(opts)))
-        resultTime = Date.now();
+      if (opts.key && ((_b = opts.debug) == null ? void 0 : _b.call(opts))) resultTime = Date.now();
       result = fn(...newDeps);
       if (opts.key && ((_c = opts.debug) == null ? void 0 : _c.call(opts))) {
         const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
@@ -66420,11 +66437,11 @@ focus outline in that case.
     }
   }
   const approxEqual = (a, b) => Math.abs(a - b) < 1;
-  const debounce = (fn, ms) => {
+  const debounce = (targetWindow, fn, ms) => {
     let timeoutId;
     return function(...args) {
-      clearTimeout(timeoutId);
-      timeoutId = setTimeout(() => fn.apply(this, args), ms);
+      targetWindow.clearTimeout(timeoutId);
+      timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
     };
   };
 
@@ -66443,16 +66460,20 @@ focus outline in that case.
     if (!element) {
       return;
     }
+    const targetWindow = instance.targetWindow;
+    if (!targetWindow) {
+      return;
+    }
     const handler = (rect) => {
       const { width, height } = rect;
       cb({ width: Math.round(width), height: Math.round(height) });
     };
     handler(element.getBoundingClientRect());
-    if (typeof ResizeObserver === "undefined") {
+    if (!targetWindow.ResizeObserver) {
       return () => {
       };
     }
-    const observer = new ResizeObserver((entries) => {
+    const observer = new targetWindow.ResizeObserver((entries) => {
       const entry = entries[0];
       if (entry == null ? void 0 : entry.borderBoxSize) {
         const box = entry.borderBoxSize[0];
@@ -66477,10 +66498,18 @@ focus outline in that case.
     if (!element) {
       return;
     }
+    const targetWindow = instance.targetWindow;
+    if (!targetWindow) {
+      return;
+    }
     let offset = 0;
-    const fallback = supportsScrollend ? () => void 0 : debounce(() => {
-      cb(offset, false);
-    }, instance.options.isScrollingResetDelay);
+    const fallback = supportsScrollend ? () => void 0 : debounce(
+      targetWindow,
+      () => {
+        cb(offset, false);
+      },
+      instance.options.isScrollingResetDelay
+    );
     const createHandler = (isScrolling) => () => {
       offset = element[instance.options.horizontal ? "scrollLeft" : "scrollTop"];
       fallback();
@@ -66525,28 +66554,31 @@ focus outline in that case.
     constructor(opts) {
       this.unsubs = [];
       this.scrollElement = null;
+      this.targetWindow = null;
       this.isScrolling = false;
       this.scrollToIndexTimeoutId = null;
       this.measurementsCache = [];
       this.itemSizeCache = /* @__PURE__ */ new Map();
       this.pendingMeasuredCacheIndexes = [];
+      this.scrollRect = null;
+      this.scrollOffset = null;
       this.scrollDirection = null;
       this.scrollAdjustments = 0;
-      this.measureElementCache = /* @__PURE__ */ new Map();
+      this.elementsCache = /* @__PURE__ */ new Map();
       this.observer = /* @__PURE__ */ (() => {
         let _ro = null;
         const get = () => {
           if (_ro) {
             return _ro;
-          } else if (typeof ResizeObserver !== "undefined") {
-            return _ro = new ResizeObserver((entries) => {
-              entries.forEach((entry) => {
-                this._measureElement(entry.target, entry);
-              });
-            });
-          } else {
+          }
+          if (!this.targetWindow || !this.targetWindow.ResizeObserver) {
             return null;
           }
+          return _ro = new this.targetWindow.ResizeObserver((entries) => {
+            entries.forEach((entry) => {
+              this._measureElement(entry.target, entry);
+            });
+          });
         };
         return {
           disconnect: () => {
@@ -66566,8 +66598,7 @@ focus outline in that case.
       this.range = null;
       this.setOptions = (opts2) => {
         Object.entries(opts2).forEach(([key, value]) => {
-          if (typeof value === "undefined")
-            delete opts2[key];
+          if (typeof value === "undefined") delete opts2[key];
         });
         this.options = {
           debug: false,
@@ -66590,6 +66621,7 @@ focus outline in that case.
           initialMeasurementsCache: [],
           lanes: 1,
           isScrollingResetDelay: 150,
+          enabled: true,
           ...opts2
         };
       };
@@ -66608,20 +66640,31 @@ focus outline in that case.
         this.unsubs.filter(Boolean).forEach((d) => d());
         this.unsubs = [];
         this.scrollElement = null;
+        this.targetWindow = null;
+        this.observer.disconnect();
+        this.elementsCache.clear();
       };
       this._didMount = () => {
-        this.measureElementCache.forEach(this.observer.observe);
         return () => {
-          this.observer.disconnect();
           this.cleanup();
         };
       };
       this._willUpdate = () => {
-        const scrollElement = this.options.getScrollElement();
+        var _a;
+        const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
         if (this.scrollElement !== scrollElement) {
           this.cleanup();
+          if (!scrollElement) {
+            this.notify(false, false);
+            return;
+          }
           this.scrollElement = scrollElement;
-          this._scrollToOffset(this.scrollOffset, {
+          if (this.scrollElement && "ownerDocument" in this.scrollElement) {
+            this.targetWindow = this.scrollElement.ownerDocument.defaultView;
+          } else {
+            this.targetWindow = ((_a = this.scrollElement) == null ? void 0 : _a.window) ?? null;
+          }
+          this._scrollToOffset(this.getScrollOffset(), {
             adjustments: void 0,
             behavior: void 0
           });
@@ -66634,7 +66677,7 @@ focus outline in that case.
           this.unsubs.push(
             this.options.observeElementOffset(this, (offset, isScrolling) => {
               this.scrollAdjustments = 0;
-              this.scrollDirection = isScrolling ? this.scrollOffset < offset ? "forward" : "backward" : null;
+              this.scrollDirection = isScrolling ? this.getScrollOffset() < offset ? "forward" : "backward" : null;
               this.scrollOffset = offset;
               const prevIsScrolling = this.isScrolling;
               this.isScrolling = isScrolling;
@@ -66644,28 +66687,21 @@ focus outline in that case.
         }
       };
       this.getSize = () => {
+        if (!this.options.enabled) {
+          this.scrollRect = null;
+          return 0;
+        }
+        this.scrollRect = this.scrollRect ?? this.options.initialRect;
         return this.scrollRect[this.options.horizontal ? "width" : "height"];
       };
-      this.getMeasurementOptions = memo(
-        () => [
-          this.options.count,
-          this.options.paddingStart,
-          this.options.scrollMargin,
-          this.options.getItemKey
-        ],
-        (count, paddingStart, scrollMargin, getItemKey) => {
-          this.pendingMeasuredCacheIndexes = [];
-          return {
-            count,
-            paddingStart,
-            scrollMargin,
-            getItemKey
-          };
-        },
-        {
-          key: false
+      this.getScrollOffset = () => {
+        if (!this.options.enabled) {
+          this.scrollOffset = null;
+          return 0;
         }
-      );
+        this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
+        return this.scrollOffset;
+      };
       this.getFurthestMeasurement = (measurements, index) => {
         const furthestMeasurementsFound = /* @__PURE__ */ new Map();
         const furthestMeasurements = /* @__PURE__ */ new Map();
@@ -66693,13 +66729,74 @@ focus outline in that case.
           return a.end - b.end;
         })[0] : void 0;
       };
+      this.getMeasurementOptions = memo(
+        () => [
+          this.options.count,
+          this.options.paddingStart,
+          this.options.scrollMargin,
+          this.options.getItemKey,
+          this.options.enabled
+        ],
+        (count, paddingStart, scrollMargin, getItemKey, enabled) => {
+          this.pendingMeasuredCacheIndexes = [];
+          return {
+            count,
+            paddingStart,
+            scrollMargin,
+            getItemKey,
+            enabled
+          };
+        },
+        {
+          key: false
+        }
+      );
       this.getMeasurements = memo(
         () => [this.getMeasurementOptions(), this.itemSizeCache],
-        ({ count, paddingStart, scrollMargin, getItemKey }, itemSizeCache) => {
+        ({ count, paddingStart, scrollMargin, getItemKey, enabled }, itemSizeCache) => {
+          var _a;
+          if (!enabled) {
+            this.measurementsCache = [];
+            this.itemSizeCache.clear();
+            return [];
+          }
+          if (this.measurementsCache.length === 0) {
+            this.measurementsCache = this.options.initialMeasurementsCache;
+            this.measurementsCache.forEach((item) => {
+              this.itemSizeCache.set(item.key, item.size);
+            });
+          }
           const min = this.pendingMeasuredCacheIndexes.length > 0 ? Math.min(...this.pendingMeasuredCacheIndexes) : 0;
           this.pendingMeasuredCacheIndexes = [];
           const measurements = this.measurementsCache.slice(0, min);
           for (let i = min; i < count; i++) {
+            let measureElement2 = (_a = this.measurementsCache[i]) == null ? void 0 : _a.measureElement;
+            if (!measureElement2) {
+              measureElement2 = (node) => {
+                const key2 = getItemKey(i);
+                const prevNode = this.elementsCache.get(key2);
+                if (!node) {
+                  if (prevNode) {
+                    this.observer.unobserve(prevNode);
+                    this.elementsCache.delete(key2);
+                  }
+                  return;
+                }
+                if (prevNode !== node) {
+                  if (prevNode) {
+                    this.observer.unobserve(prevNode);
+                  }
+                  this.observer.observe(node);
+                  this.elementsCache.set(key2, node);
+                }
+                if (node.isConnected) {
+                  this.resizeItem(
+                    i,
+                    this.options.measureElement(node, void 0, this)
+                  );
+                }
+              };
+            }
             const key = getItemKey(i);
             const furthestMeasurement = this.options.lanes === 1 ? measurements[i - 1] : this.getFurthestMeasurement(measurements, i);
             const start = furthestMeasurement ? furthestMeasurement.end + this.options.gap : paddingStart + scrollMargin;
@@ -66713,7 +66810,8 @@ focus outline in that case.
               size,
               end,
               key,
-              lane
+              lane,
+              measureElement: measureElement2
             };
           }
           this.measurementsCache = measurements;
@@ -66725,7 +66823,7 @@ focus outline in that case.
         }
       );
       this.calculateRange = memo(
-        () => [this.getMeasurements(), this.getSize(), this.scrollOffset],
+        () => [this.getMeasurements(), this.getSize(), this.getScrollOffset()],
         (measurements, outerSize, scrollOffset) => {
           return this.range = measurements.length > 0 && outerSize > 0 ? calculateRange({
             measurements,
@@ -66770,36 +66868,40 @@ focus outline in that case.
         return parseInt(indexStr, 10);
       };
       this._measureElement = (node, entry) => {
-        const item = this.measurementsCache[this.indexFromElement(node)];
+        const i = this.indexFromElement(node);
+        const item = this.getMeasurements()[i];
         if (!item || !node.isConnected) {
-          this.measureElementCache.forEach((cached, key) => {
+          this.elementsCache.forEach((cached, key) => {
             if (cached === node) {
               this.observer.unobserve(node);
-              this.measureElementCache.delete(key);
+              this.elementsCache.delete(key);
             }
           });
           return;
         }
-        const prevNode = this.measureElementCache.get(item.key);
+        const prevNode = this.elementsCache.get(item.key);
         if (prevNode !== node) {
           if (prevNode) {
             this.observer.unobserve(prevNode);
           }
           this.observer.observe(node);
-          this.measureElementCache.set(item.key, node);
+          this.elementsCache.set(item.key, node);
         }
-        const measuredItemSize = this.options.measureElement(node, entry, this);
-        this.resizeItem(item, measuredItemSize);
+        this.resizeItem(i, this.options.measureElement(node, entry, this));
       };
-      this.resizeItem = (item, size) => {
+      this.resizeItem = (index, size) => {
+        const item = this.getMeasurements()[index];
+        if (!item) {
+          return;
+        }
         const itemSize = this.itemSizeCache.get(item.key) ?? item.size;
         const delta = size - itemSize;
         if (delta !== 0) {
-          if (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.scrollOffset + this.scrollAdjustments) {
+          if (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this) : item.start < this.getScrollOffset() + this.scrollAdjustments) {
             if (this.options.debug) {
               console.info("correction", delta);
             }
-            this._scrollToOffset(this.scrollOffset, {
+            this._scrollToOffset(this.getScrollOffset(), {
               adjustments: this.scrollAdjustments += delta,
               behavior: void 0
             });
@@ -66833,6 +66935,9 @@ focus outline in that case.
       );
       this.getVirtualItemForOffset = (offset) => {
         const measurements = this.getMeasurements();
+        if (measurements.length === 0) {
+          return void 0;
+        }
         return notUndefined(
           measurements[findNearestBinarySearch(
             0,
@@ -66844,10 +66949,11 @@ focus outline in that case.
       };
       this.getOffsetForAlignment = (toOffset, align) => {
         const size = this.getSize();
+        const scrollOffset = this.getScrollOffset();
         if (align === "auto") {
-          if (toOffset <= this.scrollOffset) {
+          if (toOffset <= scrollOffset) {
             align = "start";
-          } else if (toOffset >= this.scrollOffset + size) {
+          } else if (toOffset >= scrollOffset + size) {
             align = "end";
           } else {
             align = "start";
@@ -66862,28 +66968,33 @@ focus outline in that case.
         }
         const scrollSizeProp = this.options.horizontal ? "scrollWidth" : "scrollHeight";
         const scrollSize = this.scrollElement ? "document" in this.scrollElement ? this.scrollElement.document.documentElement[scrollSizeProp] : this.scrollElement[scrollSizeProp] : 0;
-        const maxOffset = scrollSize - this.getSize();
+        const maxOffset = scrollSize - size;
         return Math.max(Math.min(maxOffset, toOffset), 0);
       };
       this.getOffsetForIndex = (index, align = "auto") => {
         index = Math.max(0, Math.min(index, this.options.count - 1));
-        const measurement = notUndefined(this.getMeasurements()[index]);
+        const item = this.getMeasurements()[index];
+        if (!item) {
+          return void 0;
+        }
+        const size = this.getSize();
+        const scrollOffset = this.getScrollOffset();
         if (align === "auto") {
-          if (measurement.end >= this.scrollOffset + this.getSize() - this.options.scrollPaddingEnd) {
+          if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) {
             align = "end";
-          } else if (measurement.start <= this.scrollOffset + this.options.scrollPaddingStart) {
+          } else if (item.start <= scrollOffset + this.options.scrollPaddingStart) {
             align = "start";
           } else {
-            return [this.scrollOffset, align];
+            return [scrollOffset, align];
           }
         }
-        const toOffset = align === "end" ? measurement.end + this.options.scrollPaddingEnd : measurement.start - this.options.scrollPaddingStart;
+        const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
         return [this.getOffsetForAlignment(toOffset, align), align];
       };
-      this.isDynamicMode = () => this.measureElementCache.size > 0;
+      this.isDynamicMode = () => this.elementsCache.size > 0;
       this.cancelScrollToIndex = () => {
-        if (this.scrollToIndexTimeoutId !== null) {
-          clearTimeout(this.scrollToIndexTimeoutId);
+        if (this.scrollToIndexTimeoutId !== null && this.targetWindow) {
+          this.targetWindow.clearTimeout(this.scrollToIndexTimeoutId);
           this.scrollToIndexTimeoutId = null;
         }
       };
@@ -66907,17 +67018,21 @@ focus outline in that case.
             "The `smooth` scroll behavior is not fully supported with dynamic size."
           );
         }
-        const [toOffset, align] = this.getOffsetForIndex(index, initialAlign);
-        this._scrollToOffset(toOffset, { adjustments: void 0, behavior });
-        if (behavior !== "smooth" && this.isDynamicMode()) {
-          this.scrollToIndexTimeoutId = setTimeout(() => {
+        const offsetAndAlign = this.getOffsetForIndex(index, initialAlign);
+        if (!offsetAndAlign) return;
+        const [offset, align] = offsetAndAlign;
+        this._scrollToOffset(offset, { adjustments: void 0, behavior });
+        if (behavior !== "smooth" && this.isDynamicMode() && this.targetWindow) {
+          this.scrollToIndexTimeoutId = this.targetWindow.setTimeout(() => {
             this.scrollToIndexTimeoutId = null;
-            const elementInDOM = this.measureElementCache.has(
+            const elementInDOM = this.elementsCache.has(
               this.options.getItemKey(index)
             );
             if (elementInDOM) {
-              const [toOffset2] = this.getOffsetForIndex(index, align);
-              if (!approxEqual(toOffset2, this.scrollOffset)) {
+              const [latestOffset] = notUndefined(
+                this.getOffsetForIndex(index, align)
+              );
+              if (!approxEqual(latestOffset, this.getScrollOffset())) {
                 this.scrollToIndex(index, { align, behavior });
               }
             } else {
@@ -66933,7 +67048,7 @@ focus outline in that case.
             "The `smooth` scroll behavior is not fully supported with dynamic size."
           );
         }
-        this._scrollToOffset(this.scrollOffset + delta, {
+        this._scrollToOffset(this.getScrollOffset() + delta, {
           adjustments: void 0,
           behavior
         });
@@ -66963,13 +67078,6 @@ focus outline in that case.
         (_b = (_a = this.options).onChange) == null ? void 0 : _b.call(_a, this, false);
       };
       this.setOptions(opts);
-      this.scrollRect = this.options.initialRect;
-      this.scrollOffset = typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset;
-      this.measurementsCache = this.options.initialMeasurementsCache;
-      this.measurementsCache.forEach((item) => {
-        this.itemSizeCache.set(item.key, item.size);
-      });
-      this.notify(false, false);
     }
   };
   const findNearestBinarySearch = (low, high, getCurrentValue, value) => {
@@ -67040,7 +67148,10 @@ focus outline in that case.
       connect() {
           this.viewportResizeObserver.observe(this.table.viewport);
           this.updateVirtualizer();
-          this.table.viewport.scrollTo({ top: this.virtualizer.scrollOffset });
+          const scrollOffset = this.virtualizer.scrollOffset;
+          if (scrollOffset !== null) {
+              this.table.viewport.scrollTo({ top: scrollOffset });
+          }
       }
       disconnect() {
           this.viewportResizeObserver.disconnect();