@virtual-content/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1395 @@
+// src/fenwick-tree.ts
+var EPSILON = 1e-9;
+var FenwickTree = class {
+  constructor(values) {
+    this.values = new Array(values.length).fill(0);
+    this.tree = new Array(values.length + 1).fill(0);
+    for (let index = 0; index < values.length; index += 1) {
+      this.add(index, values[index] ?? 0);
+    }
+  }
+  get size() {
+    return this.values.length;
+  }
+  get(index) {
+    if (!this.hasIndex(index)) {
+      return 0;
+    }
+    return this.values[index] ?? 0;
+  }
+  add(index, delta) {
+    if (!this.hasIndex(index) || !Number.isFinite(delta) || delta === 0) {
+      return;
+    }
+    this.values[index] = (this.values[index] ?? 0) + delta;
+    let cursor = index + 1;
+    while (cursor < this.tree.length) {
+      this.tree[cursor] = (this.tree[cursor] ?? 0) + delta;
+      cursor += cursor & -cursor;
+    }
+  }
+  set(index, value) {
+    if (!this.hasIndex(index) || !Number.isFinite(value)) {
+      return 0;
+    }
+    const previous = this.values[index] ?? 0;
+    const delta = value - previous;
+    this.add(index, delta);
+    return delta;
+  }
+  sum(endExclusive) {
+    let cursor = clampInteger(endExclusive, 0, this.values.length);
+    let total = 0;
+    while (cursor > 0) {
+      total += this.tree[cursor] ?? 0;
+      cursor -= cursor & -cursor;
+    }
+    return total;
+  }
+  total() {
+    return this.sum(this.values.length);
+  }
+  lowerBound(offset) {
+    if (this.values.length === 0) {
+      return -1;
+    }
+    let target = clampNumber(offset, 0, Math.max(0, this.total() - EPSILON));
+    let index = 0;
+    let bit = 1 << this.values.length.toString(2).length - 1;
+    while (bit !== 0) {
+      const nextIndex = index + bit;
+      const nextValue = this.tree[nextIndex] ?? 0;
+      if (nextIndex <= this.values.length && nextValue <= target) {
+        target -= nextValue;
+        index = nextIndex;
+      }
+      bit >>= 1;
+    }
+    return Math.min(index, this.values.length - 1);
+  }
+  hasIndex(index) {
+    return Number.isInteger(index) && index >= 0 && index < this.values.length;
+  }
+};
+function clampInteger(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function clampNumber(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+
+// src/geometry.ts
+function createPoint(x = 0, y = 0) {
+  return { x: normalizeNumber(x), y: normalizeNumber(y) };
+}
+function createRect(x = 0, y = 0, width = 0, height = 0) {
+  return {
+    x: normalizeNumber(x),
+    y: normalizeNumber(y),
+    width: normalizeSize(width),
+    height: normalizeSize(height)
+  };
+}
+function rectEndX(rect) {
+  return rect.x + rect.width;
+}
+function rectEndY(rect) {
+  return rect.y + rect.height;
+}
+function rectsIntersect(a, b) {
+  return a.x < rectEndX(b) && rectEndX(a) > b.x && a.y < rectEndY(b) && rectEndY(a) > b.y;
+}
+function expandRect(rect, overscan, axis) {
+  const before = normalizeSize(overscan.before);
+  const after = normalizeSize(overscan.after);
+  if (axis === "horizontal") {
+    return createRect(rect.x - before, rect.y, rect.width + before + after, rect.height);
+  }
+  if (axis === "both") {
+    return createRect(rect.x - before, rect.y - before, rect.width + before + after, rect.height + before + after);
+  }
+  return createRect(rect.x, rect.y - before, rect.width, rect.height + before + after);
+}
+function rectFromScrollPoint(point, size) {
+  return createRect(point.x, point.y, size.width, size.height);
+}
+function mainStart(rect, direction) {
+  return direction === "horizontal" ? rect.x : rect.y;
+}
+function mainSize(rect, direction) {
+  return direction === "horizontal" ? rect.width : rect.height;
+}
+function crossSize(rect, direction) {
+  return direction === "horizontal" ? rect.height : rect.width;
+}
+function rectFromMainCross(params) {
+  const crossStart2 = normalizeNumber(params.crossStart ?? 0);
+  const resolvedMainStart = normalizeNumber(params.mainStart);
+  const resolvedMainSize = normalizeSize(params.mainSize);
+  const resolvedCrossSize = normalizeSize(params.crossSize ?? 0);
+  return params.direction === "horizontal" ? createRect(resolvedMainStart, crossStart2, resolvedMainSize, resolvedCrossSize) : createRect(crossStart2, resolvedMainStart, resolvedCrossSize, resolvedMainSize);
+}
+function pointFromMainCross(params) {
+  const main = normalizeNumber(params.main);
+  const cross = normalizeNumber(params.cross ?? 0);
+  return params.direction === "horizontal" ? { x: main, y: cross } : { x: cross, y: main };
+}
+function unionRect(rects) {
+  if (rects.length === 0) {
+    return createRect();
+  }
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = 0;
+  let maxY = 0;
+  for (const rect of rects) {
+    minX = Math.min(minX, rect.x);
+    minY = Math.min(minY, rect.y);
+    maxX = Math.max(maxX, rectEndX(rect));
+    maxY = Math.max(maxY, rectEndY(rect));
+  }
+  return createRect(Math.min(0, minX), Math.min(0, minY), maxX - Math.min(0, minX), maxY - Math.min(0, minY));
+}
+function normalizeNumber(value) {
+  return Number.isFinite(value) ? value : 0;
+}
+function normalizeSize(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+
+// src/size-model.ts
+var SizeModel = class {
+  constructor(options) {
+    this.keys = [];
+    this.measured = [];
+    this.measuredSizesByKey = /* @__PURE__ */ new Map();
+    this.tree = new FenwickTree([]);
+    this.keyToIndex = /* @__PURE__ */ new Map();
+    this.countValue = normalizeCount(options.count);
+    this.estimateSize = options.estimateSize;
+    this.getKey = options.getKey;
+    this.minSize = normalizeMinSize(options.minSize);
+    this.rebuild();
+  }
+  get count() {
+    return this.countValue;
+  }
+  setCount(count) {
+    const nextCount = normalizeCount(count);
+    if (nextCount === this.countValue) {
+      return;
+    }
+    this.countValue = nextCount;
+    this.rebuild();
+  }
+  keyOf(index) {
+    return this.keys[index];
+  }
+  indexOfKey(key) {
+    return this.keyToIndex.get(key) ?? -1;
+  }
+  sizeOf(index) {
+    return this.tree.get(index);
+  }
+  isMeasured(index) {
+    return this.measured[index] ?? false;
+  }
+  startOf(index) {
+    return this.tree.sum(index);
+  }
+  endOf(index) {
+    return this.tree.sum(index + 1);
+  }
+  spacedStartOf(index, spacing) {
+    return this.startOf(index) + spacingStart(spacing) + Math.max(0, index) * spacingGap(spacing);
+  }
+  spacedEndOf(index, spacing) {
+    return this.spacedStartOf(index, spacing) + this.sizeOf(index);
+  }
+  totalSize() {
+    return this.tree.total();
+  }
+  spacedTotalSize(spacing) {
+    const count = this.countValue;
+    return this.tree.total() + spacingStart(spacing) + spacingEnd(spacing) + Math.max(0, count - 1) * spacingGap(spacing);
+  }
+  lowerBound(offset) {
+    return this.tree.lowerBound(offset);
+  }
+  spacedLowerBound(offset, spacing) {
+    if (this.countValue === 0) {
+      return 0;
+    }
+    const gap = spacingGap(spacing);
+    const paddingStart = spacingStart(spacing);
+    const target = offset - paddingStart;
+    if (target <= 0 || gap === 0) {
+      return this.lowerBound(Math.max(0, target));
+    }
+    let low = 0;
+    let high = this.countValue - 1;
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      if (this.endOf(mid) + mid * gap > target) {
+        high = mid;
+      } else {
+        low = mid + 1;
+      }
+    }
+    return low;
+  }
+  measure(key, index, size) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.countValue) {
+      return { delta: 0, changed: false, stale: true, size: 0 };
+    }
+    const currentKey = this.keys[index];
+    if (currentKey !== key) {
+      return { delta: 0, changed: false, stale: true, size: this.sizeOf(index) };
+    }
+    const nextSize = this.normalizeSize(size);
+    this.measuredSizesByKey.set(key, nextSize);
+    this.measured[index] = true;
+    const delta = this.tree.set(index, nextSize);
+    return {
+      delta,
+      changed: delta !== 0,
+      stale: false,
+      size: nextSize
+    };
+  }
+  resetMeasurements(keys) {
+    if (keys === void 0) {
+      this.measuredSizesByKey.clear();
+    } else {
+      for (const key of keys) {
+        this.measuredSizesByKey.delete(key);
+      }
+    }
+    this.rebuild();
+  }
+  rebuild() {
+    const keys = [];
+    const sizes = [];
+    const measured = [];
+    const keyToIndex = /* @__PURE__ */ new Map();
+    for (let index = 0; index < this.countValue; index += 1) {
+      const key = this.getKey(index);
+      const measuredSize = this.measuredSizesByKey.get(key);
+      keys.push(key);
+      keyToIndex.set(key, index);
+      measured.push(measuredSize !== void 0);
+      sizes.push(measuredSize ?? this.normalizeSize(this.estimateSize(index)));
+    }
+    this.keys = keys;
+    this.measured = measured;
+    this.keyToIndex = keyToIndex;
+    this.tree = new FenwickTree(sizes);
+  }
+  normalizeSize(size) {
+    if (!Number.isFinite(size)) {
+      return this.minSize;
+    }
+    return Math.max(this.minSize, size);
+  }
+};
+function normalizeCount(count) {
+  if (!Number.isFinite(count)) {
+    return 0;
+  }
+  return Math.max(0, Math.trunc(count));
+}
+function normalizeMinSize(minSize) {
+  if (!Number.isFinite(minSize) || minSize === void 0) {
+    return 1;
+  }
+  return Math.max(Number.EPSILON, minSize);
+}
+function spacingGap(spacing) {
+  return normalizeSpacing(spacing?.gap ?? 0);
+}
+function spacingStart(spacing) {
+  return normalizeSpacing(spacing?.paddingStart ?? 0);
+}
+function spacingEnd(spacing) {
+  return normalizeSpacing(spacing?.paddingEnd ?? 0);
+}
+function normalizeSpacing(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+
+// src/range.ts
+function resolveOverscan(overscan, budget) {
+  if (typeof overscan === "number") {
+    const value = normalizeOverscanValue(overscan);
+    return {
+      before: value,
+      after: value,
+      maxItems: normalizeOptionalPositiveNumber(budget?.maxItems),
+      maxPx: normalizeOptionalPositiveNumber(budget?.maxPx)
+    };
+  }
+  return {
+    before: normalizeOverscanValue(overscan?.before ?? 0),
+    after: normalizeOverscanValue(overscan?.after ?? 0),
+    maxItems: normalizeOptionalPositiveNumber(budget?.maxItems),
+    maxPx: normalizeOptionalPositiveNumber(budget?.maxPx)
+  };
+}
+function materializeRange(params) {
+  const { sizes, scrollOffset, viewportSize, overscan, centerIndex, centerStart, spacing } = params;
+  const maxItems = params.maxItems ?? overscan.maxItems ?? Number.POSITIVE_INFINITY;
+  const maxPx = params.maxPx ?? overscan.maxPx ?? Number.POSITIVE_INFINITY;
+  if (sizes.count === 0 || centerIndex < 0) {
+    return { rangeStart: 0, rangeEnd: 0, items: [] };
+  }
+  const totalSize = sizes.spacedTotalSize(spacing);
+  const renderStart = Math.max(0, scrollOffset - overscan.before);
+  const renderEnd = Math.min(totalSize, scrollOffset + viewportSize + overscan.after);
+  const gap = normalizeSpacing2(spacing?.gap ?? 0);
+  let rangeStart = centerIndex;
+  let cursorStart = centerStart;
+  let rangeEnd = centerIndex + 1;
+  let cursorEnd = sizes.spacedEndOf(centerIndex, spacing);
+  while (rangeStart > 0 && cursorStart > renderStart) {
+    const previousSize = sizes.sizeOf(rangeStart - 1);
+    if (rangeEndCount(rangeStart - 1, rangeEnd) > maxItems) {
+      break;
+    }
+    if (cursorEndSpan(cursorStart - gap - previousSize, cursorEnd) > maxPx) {
+      break;
+    }
+    rangeStart -= 1;
+    cursorStart -= gap + previousSize;
+  }
+  while (rangeEnd < sizes.count && cursorEnd < renderEnd) {
+    const nextSize = sizes.sizeOf(rangeEnd);
+    if (rangeEndCount(rangeStart, rangeEnd + 1) > maxItems) {
+      break;
+    }
+    if (cursorEndSpan(cursorStart, cursorEnd + gap + nextSize) > maxPx) {
+      break;
+    }
+    cursorEnd += gap + nextSize;
+    rangeEnd += 1;
+  }
+  const items = [];
+  let itemStart = cursorStart;
+  for (let index = rangeStart; index < rangeEnd; index += 1) {
+    const size = sizes.sizeOf(index);
+    const key = sizes.keyOf(index);
+    if (key === void 0) {
+      continue;
+    }
+    const offsetFromCenter = itemStart - centerStart;
+    items.push(params.createItem?.(index, key, itemStart, size, offsetFromCenter, sizes.isMeasured(index)) ?? {
+      index,
+      key,
+      rect: createRect(0, itemStart, 0, size),
+      start: itemStart,
+      size,
+      end: itemStart + size,
+      offsetFromCenter,
+      isMeasured: sizes.isMeasured(index)
+    });
+    itemStart += size + gap;
+  }
+  return { rangeStart, rangeEnd, items };
+}
+function rangeEndCount(start, end) {
+  return end - start;
+}
+function cursorEndSpan(start, end) {
+  return end - start;
+}
+function normalizeOverscanValue(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+function normalizeOptionalPositiveNumber(value) {
+  if (value === void 0 || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeSpacing2(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+
+// src/spacing.ts
+function resolveLayoutGap(gap) {
+  if (typeof gap === "number") {
+    const value = normalizeSpacingValue(gap);
+    return { main: value, cross: value };
+  }
+  return {
+    main: normalizeSpacingValue(gap?.main ?? 0),
+    cross: normalizeSpacingValue(gap?.cross ?? 0)
+  };
+}
+function resolveLayoutPadding(padding) {
+  if (typeof padding === "number") {
+    const value = normalizeSpacingValue(padding);
+    return {
+      mainStart: value,
+      mainEnd: value,
+      crossStart: value,
+      crossEnd: value
+    };
+  }
+  return {
+    mainStart: normalizeSpacingValue(padding?.mainStart ?? 0),
+    mainEnd: normalizeSpacingValue(padding?.mainEnd ?? 0),
+    crossStart: normalizeSpacingValue(padding?.crossStart ?? 0),
+    crossEnd: normalizeSpacingValue(padding?.crossEnd ?? 0)
+  };
+}
+function normalizeSpacingValue(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+
+// src/linear-band-engine.ts
+var LinearBandEngine = class {
+  constructor(options) {
+    this.crossSizes = [];
+    this.direction = options.layout.direction ?? "vertical";
+    this.estimateRect = resolveEstimateRect(options, this.direction);
+    this.configuredCrossSize = normalizeOptionalSize(options.layout.crossSize);
+    this.gap = resolveLayoutGap(options.layout.gap);
+    this.padding = resolveLayoutPadding(options.layout.padding);
+    this.sizes = new SizeModel({
+      count: options.count,
+      getKey: options.getKey,
+      minSize: options.minSize,
+      estimateSize: (index) => mainSize(this.estimateRect(index), this.direction)
+    });
+    this.rebuildCrossSizes();
+  }
+  get count() {
+    return this.sizes.count;
+  }
+  setCount(count) {
+    this.sizes.setCount(count);
+    this.rebuildCrossSizes();
+  }
+  keyOf(index) {
+    return this.sizes.keyOf(index);
+  }
+  indexOfKey(key) {
+    return this.sizes.indexOfKey(key);
+  }
+  getTotalRect() {
+    const totalMain = this.totalMainSize();
+    let totalCross = 0;
+    for (const size of this.crossSizes) {
+      totalCross = Math.max(totalCross, size);
+    }
+    totalCross += this.padding.crossStart + this.padding.crossEnd;
+    return this.direction === "horizontal" ? createRect(0, 0, totalMain, totalCross) : createRect(0, 0, totalCross, totalMain);
+  }
+  getVisibleItems(viewport, overscan) {
+    if (this.sizes.count === 0) {
+      return [];
+    }
+    const scrollOffset = this.direction === "horizontal" ? viewport.x : viewport.y;
+    const viewportSize = this.direction === "horizontal" ? viewport.width : viewport.height;
+    const centerIndex = this.sizes.spacedLowerBound(clampNumber2(scrollOffset + viewportSize / 2, 0, Math.max(0, this.totalMainSize() - Number.EPSILON)), this.spacing());
+    const centerStart = this.sizes.spacedStartOf(centerIndex, this.spacing());
+    return materializeRange({
+      sizes: this.sizes,
+      scrollOffset,
+      viewportSize,
+      overscan,
+      centerIndex,
+      centerStart,
+      spacing: this.spacing(),
+      createItem: (index, key, start, size, offsetFromCenter, isMeasured) => this.createItem(index, key, start, size, offsetFromCenter, isMeasured)
+    }).items;
+  }
+  getItemRect(index) {
+    if (index < 0 || index >= this.sizes.count) {
+      return void 0;
+    }
+    return this.rectFor(index, this.sizes.spacedStartOf(index, this.spacing()), this.sizes.sizeOf(index));
+  }
+  getItemMainStart(index) {
+    return this.sizes.spacedStartOf(index, this.spacing());
+  }
+  getItemMainSize(index) {
+    return this.sizes.sizeOf(index);
+  }
+  isMeasured(index) {
+    return this.sizes.isMeasured(index);
+  }
+  measureItem(index, key, rect) {
+    const current = this.getItemRect(index) ?? createRect();
+    const nextRect = { ...current, ...rect };
+    const measurement = this.sizes.measure(key, index, mainSize(nextRect, this.direction));
+    if (!measurement.stale) {
+      this.crossSizes[index] = Math.max(0, this.direction === "horizontal" ? nextRect.height : nextRect.width);
+    }
+    return {
+      delta: measurement.delta,
+      changed: measurement.changed || !measurement.stale && this.crossSizes[index] !== (this.direction === "horizontal" ? current.height : current.width),
+      stale: measurement.stale,
+      rect: this.getItemRect(index) ?? current
+    };
+  }
+  resetMeasurements(keys) {
+    this.sizes.resetMeasurements(keys);
+    this.rebuildCrossSizes();
+  }
+  getScrollTarget(index, align, viewport) {
+    if (this.sizes.count === 0) {
+      return createPoint();
+    }
+    const targetIndex = clampInteger2(index, 0, this.sizes.count - 1);
+    const itemStart = this.sizes.spacedStartOf(targetIndex, this.spacing());
+    const itemSize = this.sizes.sizeOf(targetIndex);
+    const itemEnd = itemStart + itemSize;
+    const viewportStart = this.direction === "horizontal" ? viewport.x : viewport.y;
+    const viewportSize = this.direction === "horizontal" ? viewport.width : viewport.height;
+    let main = itemStart;
+    if ((align === "auto" || align === "nearest") && itemStart >= viewportStart && itemEnd <= viewportStart + viewportSize) {
+      main = viewportStart;
+    } else if (align === "end" || (align === "auto" || align === "nearest") && itemEnd > viewportStart + viewportSize) {
+      main = itemEnd - viewportSize;
+    } else if (align === "center") {
+      main = itemStart + itemSize / 2 - viewportSize / 2;
+    }
+    const totalMain = this.totalMainSize();
+    main = clampNumber2(main, 0, Math.max(0, totalMain - viewportSize));
+    return pointFromMainCross({
+      direction: this.direction,
+      main,
+      cross: this.direction === "horizontal" ? viewport.y : viewport.x
+    });
+  }
+  locateCenter(viewportCenter, lastIndex, lastViewportCenter, recenterThreshold) {
+    const mainCenter = this.direction === "horizontal" ? viewportCenter.x : viewportCenter.y;
+    const lastMainCenter = lastViewportCenter === void 0 ? void 0 : this.direction === "horizontal" ? lastViewportCenter.x : lastViewportCenter.y;
+    if (lastIndex < 0 || lastMainCenter === void 0) {
+      return { index: this.locateAbsolute(mainCenter), mode: "initial" };
+    }
+    if (Math.abs(mainCenter - lastMainCenter) > recenterThreshold) {
+      return { index: this.locateAbsolute(mainCenter), mode: "recenter" };
+    }
+    return { index: this.locateTracked(mainCenter, lastIndex), mode: "tracked" };
+  }
+  locateAbsolute(mainCenter) {
+    return this.sizes.spacedLowerBound(clampNumber2(mainCenter, 0, Math.max(0, this.totalMainSize() - Number.EPSILON)), this.spacing());
+  }
+  locateTracked(mainCenter, lastIndex) {
+    const target = clampNumber2(mainCenter, 0, Math.max(0, this.totalMainSize() - Number.EPSILON));
+    let index = clampInteger2(lastIndex, 0, this.sizes.count - 1);
+    let start = this.sizes.spacedStartOf(index, this.spacing());
+    let size = this.sizes.sizeOf(index);
+    const gap = this.gap.main;
+    while (index > 0 && target < start) {
+      index -= 1;
+      size = this.sizes.sizeOf(index);
+      start -= size + gap;
+    }
+    while (index < this.sizes.count - 1 && target >= start + size) {
+      start += size + gap;
+      index += 1;
+      size = this.sizes.sizeOf(index);
+    }
+    return index;
+  }
+  createItem(index, key, start, size, offsetFromCenter, isMeasured) {
+    const rect = this.rectFor(index, start, size);
+    return {
+      index,
+      key,
+      rect,
+      start,
+      size,
+      end: start + size,
+      offsetFromCenter,
+      isMeasured
+    };
+  }
+  rectFor(index, start, size) {
+    return rectFromMainCross({
+      direction: this.direction,
+      mainStart: start,
+      mainSize: size,
+      crossStart: this.padding.crossStart,
+      crossSize: this.crossSizes[index] ?? 0
+    });
+  }
+  spacing() {
+    return {
+      gap: this.gap.main,
+      paddingStart: this.padding.mainStart,
+      paddingEnd: this.padding.mainEnd
+    };
+  }
+  totalMainSize() {
+    return this.sizes.spacedTotalSize(this.spacing());
+  }
+  rebuildCrossSizes() {
+    this.crossSizes = Array.from({ length: this.sizes.count }, (_, index) => {
+      if (this.configuredCrossSize !== void 0) {
+        return this.configuredCrossSize;
+      }
+      const rect = this.estimateRect(index);
+      return Math.max(0, this.direction === "horizontal" ? rect.height : rect.width);
+    });
+  }
+};
+function resolveEstimateRect(options, direction) {
+  return (index) => normalizeEstimateRect(options.estimateRect(index), direction);
+}
+function normalizeEstimateRect(rect, direction) {
+  const fallbackMain = mainSize(rect, direction);
+  return direction === "horizontal" ? createRect(rect.x, rect.y, fallbackMain, rect.height) : createRect(rect.x, rect.y, rect.width, fallbackMain);
+}
+function clampNumber2(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function clampInteger2(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function normalizeOptionalSize(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(0, value);
+}
+
+// src/spatial-rect-engine.ts
+var SpatialRectEngine = class {
+  constructor(options) {
+    this.keys = [];
+    this.sourceRects = [];
+    this.rects = [];
+    this.measured = [];
+    this.measuredRectsByKey = /* @__PURE__ */ new Map();
+    this.keyToIndex = /* @__PURE__ */ new Map();
+    this.countValue = normalizeCount2(options.count);
+    this.getKey = options.getKey;
+    this.estimateRect = options.estimateRect;
+    this.mode = options.layout?.mode === "masonry" ? "masonry" : "free";
+    this.direction = options.layout?.direction ?? "vertical";
+    this.lanes = normalizeCount2(options.layout?.lanes ?? 1) || 1;
+    this.gap = resolveLayoutGap(options.layout?.gap);
+    this.padding = resolveLayoutPadding(options.layout?.padding);
+    this.minSize = normalizeSize2(options.minSize ?? 1) || Number.EPSILON;
+    this.rebuild();
+  }
+  get count() {
+    return this.countValue;
+  }
+  setCount(count) {
+    const next = normalizeCount2(count);
+    if (next === this.countValue) {
+      return;
+    }
+    this.countValue = next;
+    this.rebuild();
+  }
+  keyOf(index) {
+    return this.keys[index];
+  }
+  indexOfKey(key) {
+    return this.keyToIndex.get(key) ?? -1;
+  }
+  getTotalRect() {
+    const contentRect = unionRect(this.rects);
+    const trailingX = this.direction === "horizontal" ? this.padding.mainEnd : this.padding.crossEnd;
+    const trailingY = this.direction === "horizontal" ? this.padding.crossEnd : this.padding.mainEnd;
+    const minimumWidth = this.direction === "horizontal" ? this.padding.mainStart : this.padding.crossStart;
+    const minimumHeight = this.direction === "horizontal" ? this.padding.crossStart : this.padding.mainStart;
+    return createRect(
+      0,
+      0,
+      Math.max(minimumWidth, contentRect.width) + trailingX,
+      Math.max(minimumHeight, contentRect.height) + trailingY
+    );
+  }
+  getVisibleItems(viewport, overscan) {
+    const queryRect = expandRect(viewport, overscan, "both");
+    const items = [];
+    const maxItems = overscan.maxItems ?? Number.POSITIVE_INFINITY;
+    for (let index = 0; index < this.rects.length; index += 1) {
+      if (items.length >= maxItems) {
+        break;
+      }
+      const rect = this.rects[index];
+      const key = this.keys[index];
+      if (key === void 0 || !rectsIntersect(rect, queryRect)) {
+        continue;
+      }
+      items.push(this.createItem(index, key, rect));
+    }
+    return items;
+  }
+  getItemRect(index) {
+    return this.rects[index];
+  }
+  getItemMainStart(index) {
+    const rect = this.rects[index];
+    return rect === void 0 ? 0 : mainStart(rect, this.direction);
+  }
+  getItemMainSize(index) {
+    const rect = this.rects[index];
+    return rect === void 0 ? 0 : mainSize(rect, this.direction);
+  }
+  isMeasured(index) {
+    return this.measured[index] ?? false;
+  }
+  measureItem(index, key, rect) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.countValue) {
+      return { delta: 0, changed: false, stale: true, rect: createRect() };
+    }
+    if (this.keys[index] !== key) {
+      return { delta: 0, changed: false, stale: true, rect: this.rects[index] ?? createRect() };
+    }
+    const previousSource = this.sourceRects[index] ?? normalizeRect(this.estimateRect(index), this.minSize);
+    const previous = this.rects[index] ?? createRect();
+    const nextSource = normalizeRect(mergeMeasuredSourceRect(previousSource, rect), this.minSize);
+    this.measuredRectsByKey.set(key, nextSource);
+    this.rebuild();
+    const current = this.rects[index] ?? this.placeFreeRect(nextSource);
+    return {
+      delta: mainSize(current, this.direction) - mainSize(previous, this.direction),
+      changed: !sameRect(previous, current),
+      stale: false,
+      rect: current
+    };
+  }
+  resetMeasurements(keys) {
+    if (keys === void 0) {
+      this.measuredRectsByKey.clear();
+    } else {
+      for (const key of keys) {
+        this.measuredRectsByKey.delete(key);
+      }
+    }
+    this.rebuild();
+  }
+  getScrollTarget(index, align, viewport) {
+    const rect = this.rects[clampInteger3(index, 0, Math.max(0, this.rects.length - 1))];
+    if (rect === void 0) {
+      return createPoint();
+    }
+    const total = this.getTotalRect();
+    let x = rect.x;
+    let y = rect.y;
+    if (align === "center") {
+      x = rect.x + rect.width / 2 - viewport.width / 2;
+      y = rect.y + rect.height / 2 - viewport.height / 2;
+    } else if (align === "end") {
+      x = rect.x + rect.width - viewport.width;
+      y = rect.y + rect.height - viewport.height;
+    } else if (align === "auto" || align === "nearest") {
+      x = nearestAxisTarget(rect.x, rect.x + rect.width, viewport.x, viewport.x + viewport.width);
+      y = nearestAxisTarget(rect.y, rect.y + rect.height, viewport.y, viewport.y + viewport.height);
+    }
+    return createPoint(
+      clampNumber3(x, 0, Math.max(0, total.width - viewport.width)),
+      clampNumber3(y, 0, Math.max(0, total.height - viewport.height))
+    );
+  }
+  locateCenter(viewportCenter) {
+    if (this.rects.length === 0) {
+      return { index: -1, mode: "initial" };
+    }
+    let bestIndex = 0;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < this.rects.length; index += 1) {
+      const rect = this.rects[index];
+      const dx = rect.x + rect.width / 2 - viewportCenter.x;
+      const dy = rect.y + rect.height / 2 - viewportCenter.y;
+      const distance = dx * dx + dy * dy;
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestIndex = index;
+      }
+    }
+    return { index: bestIndex, mode: "recenter" };
+  }
+  rebuild() {
+    const keys = [];
+    const measured = [];
+    const keyToIndex = /* @__PURE__ */ new Map();
+    const sourceRects = [];
+    const rects = [];
+    const laneMainStarts = Array.from({ length: this.lanes }, () => this.padding.mainStart);
+    for (let index = 0; index < this.countValue; index += 1) {
+      const key = this.getKey(index);
+      const measuredRect = this.measuredRectsByKey.get(key);
+      const sourceRect = normalizeRect(measuredRect ?? this.estimateRect(index), this.minSize);
+      const rect = this.mode === "masonry" ? this.placeMasonryRect(sourceRect, laneMainStarts) : this.placeFreeRect(sourceRect);
+      keys.push(key);
+      measured.push(measuredRect !== void 0);
+      keyToIndex.set(key, index);
+      sourceRects.push(sourceRect);
+      rects.push(rect);
+    }
+    this.keys = keys;
+    this.measured = measured;
+    this.keyToIndex = keyToIndex;
+    this.sourceRects = sourceRects;
+    this.rects = rects;
+  }
+  placeMasonryRect(rect, laneMainStarts) {
+    const lane = indexOfMin(laneMainStarts);
+    const itemMainSize = mainSize(rect, this.direction);
+    const itemCrossSize = crossSize(rect, this.direction);
+    const itemCrossStart = this.padding.crossStart + crossStart(rect, this.direction) + lane * (itemCrossSize + this.gap.cross);
+    const itemMainStart = laneMainStarts[lane];
+    laneMainStarts[lane] = itemMainStart + itemMainSize + this.gap.main;
+    return rectFromMainCross({
+      direction: this.direction,
+      mainStart: itemMainStart,
+      mainSize: itemMainSize,
+      crossStart: itemCrossStart,
+      crossSize: itemCrossSize
+    });
+  }
+  placeFreeRect(rect) {
+    return this.direction === "horizontal" ? createRect(rect.x + this.padding.mainStart, rect.y + this.padding.crossStart, rect.width, rect.height) : createRect(rect.x + this.padding.crossStart, rect.y + this.padding.mainStart, rect.width, rect.height);
+  }
+  createItem(index, key, rect) {
+    return {
+      index,
+      key,
+      rect,
+      start: mainStart(rect, this.direction),
+      size: mainSize(rect, this.direction),
+      end: mainStart(rect, this.direction) + mainSize(rect, this.direction),
+      offsetFromCenter: 0,
+      isMeasured: this.measured[index] ?? false
+    };
+  }
+};
+function normalizeRect(rect, minSize) {
+  return createRect(rect.x, rect.y, Math.max(minSize, rect.width), Math.max(minSize, rect.height));
+}
+function mergeMeasuredSourceRect(source, measurement) {
+  return createRect(
+    source.x,
+    source.y,
+    measurement.width ?? source.width,
+    measurement.height ?? source.height
+  );
+}
+function crossStart(rect, direction) {
+  return direction === "horizontal" ? rect.y : rect.x;
+}
+function sameRect(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function indexOfMin(values) {
+  let selected = 0;
+  for (let index = 1; index < values.length; index += 1) {
+    if (values[index] < values[selected]) {
+      selected = index;
+    }
+  }
+  return selected;
+}
+function normalizeCount2(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.trunc(value));
+}
+function normalizeSize2(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+function clampNumber3(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function nearestAxisTarget(itemStart, itemEnd, viewportStart, viewportEnd) {
+  if (itemStart >= viewportStart && itemEnd <= viewportEnd) {
+    return viewportStart;
+  }
+  if (itemEnd > viewportEnd) {
+    return itemEnd - (viewportEnd - viewportStart);
+  }
+  return itemStart;
+}
+function clampInteger3(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+
+// src/anchor.ts
+function makeAnchor(snapshot) {
+  if (snapshot.centerIndex < 0 || snapshot.centerKey === void 0) {
+    return void 0;
+  }
+  return {
+    key: snapshot.centerKey,
+    index: snapshot.centerIndex,
+    offsetInsideItem: snapshot.viewportCenter - snapshot.centerStart,
+    offsetInsideRect: snapshot.centerRect === void 0 ? void 0 : {
+      x: snapshot.viewportCenterPoint.x - snapshot.centerRect.x,
+      y: snapshot.viewportCenterPoint.y - snapshot.centerRect.y
+    }
+  };
+}
+
+// src/virtualizer.ts
+var Virtualizer = class {
+  constructor(options) {
+    this.viewportRect = createRect();
+    this.scrollPoint = createPoint();
+    this.scrollVelocity = 0;
+    this.scrollDirection = 0;
+    this.lastCenterIndex = -1;
+    this.lastLocateMode = "initial";
+    this.scrollAxis = options.scroll.axis;
+    this.layoutMode = options.layout.mode;
+    this.layoutDirection = options.layout.direction ?? "vertical";
+    this.measurementAxes = options.measurement.axes;
+    this.engine = this.layoutMode === "masonry" || this.layoutMode === "free" ? new SpatialRectEngine(options) : new LinearBandEngine(options);
+    const adaptiveOptions = typeof options.range?.adaptive === "object" ? options.range.adaptive : void 0;
+    this.baseOverscan = resolveOverscan(adaptiveOptions?.base ?? options.range?.overscan, {
+      maxItems: options.range?.maxItems,
+      maxPx: options.range?.maxPx
+    });
+    this.adaptiveRange = resolveAdaptiveRange(options.range?.adaptive, this.baseOverscan);
+    this.recenterThreshold = normalizeOptionalPositiveNumber2(options.sync?.recenterThreshold);
+    this.scrollPoint = this.clampScrollPoint(resolveInitialScrollPoint(options.scroll));
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+  }
+  setViewport(size) {
+    const normalized = normalizeNonNegativeNumber(size);
+    if (this.scrollAxis === "horizontal") {
+      this.setViewportRect(createRect(this.scrollPoint.x, this.scrollPoint.y, normalized, this.viewportRect.height));
+    } else {
+      this.setViewportRect(createRect(this.scrollPoint.x, this.scrollPoint.y, this.viewportRect.width, normalized));
+    }
+  }
+  setViewportRect(rect) {
+    this.viewportRect = createRect(this.scrollPoint.x, this.scrollPoint.y, rect.width, rect.height);
+    this.scrollPoint = this.clampScrollPoint(this.scrollPoint);
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+  }
+  setScrollOffset(offset, timestamp = now()) {
+    const next = this.scrollAxis === "horizontal" ? createPoint(offset, this.scrollPoint.y) : createPoint(this.scrollPoint.x, offset);
+    this.setScrollPoint(next, timestamp);
+  }
+  setScrollPoint(point, timestamp = now()) {
+    const nextPoint = this.clampScrollPoint(point);
+    this.updateScrollVelocity(nextPoint, timestamp);
+    this.scrollPoint = nextPoint;
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+  }
+  recenter(offsetOrPoint = this.scrollPoint) {
+    const point = typeof offsetOrPoint === "number" ? this.scrollAxis === "horizontal" ? createPoint(offsetOrPoint, this.scrollPoint.y) : createPoint(this.scrollPoint.x, offsetOrPoint) : offsetOrPoint;
+    this.scrollPoint = this.clampScrollPoint(point);
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+    this.resetScrollVelocity();
+    const located = this.locateCenter();
+    this.lastCenterIndex = located.index;
+    this.lastViewportCenter = this.getViewportCenterPoint();
+    this.lastLocateMode = "recenter";
+  }
+  setCount(count) {
+    this.engine.setCount(count);
+    this.scrollPoint = this.clampScrollPoint(this.scrollPoint);
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+    this.lastCenterIndex = Math.min(this.lastCenterIndex, this.engine.count - 1);
+    if (this.engine.count === 0) {
+      this.lastCenterIndex = -1;
+      this.lastViewportCenter = void 0;
+    }
+  }
+  setMeasuredSize(key, index, size) {
+    const rect = this.engine.getItemRect(index);
+    const nextRect = this.isHorizontalLayoutDirection() ? { width: size, height: rect?.height } : { width: rect?.width, height: size };
+    return this.setMeasuredRect(key, index, nextRect);
+  }
+  setMeasuredRect(key, index, rect) {
+    const before = this.getSnapshot();
+    const anchor = makeAnchor(before);
+    const measurement = this.engine.measureItem(index, key, rect);
+    this.scrollPoint = this.clampScrollPoint(this.scrollPoint);
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+    const correctedScrollPoint = anchor === void 0 ? this.scrollPoint : this.getScrollPointForAnchor(anchor);
+    return {
+      delta: measurement.delta,
+      changed: measurement.changed,
+      stale: measurement.stale,
+      size: mainSize(measurement.rect, this.layoutDirection),
+      rect: measurement.rect,
+      correctedScrollOffset: this.projectScrollOffset(correctedScrollPoint),
+      correctedScrollPoint
+    };
+  }
+  resetMeasurements(keys) {
+    this.engine.resetMeasurements(keys);
+    this.scrollPoint = this.clampScrollPoint(this.scrollPoint);
+    this.viewportRect = rectFromScrollPoint(this.scrollPoint, this.viewportRect);
+  }
+  getState() {
+    const snapshot = this.getSnapshot();
+    const { items: _items, ...state } = snapshot;
+    return state;
+  }
+  getSnapshot() {
+    const overscan = this.resolveCurrentOverscan();
+    const totalRect = this.engine.getTotalRect();
+    const viewportCenterPoint = this.getViewportCenterPoint();
+    if (this.engine.count === 0) {
+      return this.createSnapshot({
+        overscan,
+        totalRect,
+        viewportCenterPoint,
+        centerIndex: -1,
+        centerRect: void 0,
+        items: []
+      });
+    }
+    const located = this.locateCenter();
+    const centerIndex = located.index;
+    const centerRect = this.engine.getItemRect(centerIndex);
+    const items = this.engine.getVisibleItems(this.viewportRect, overscan);
+    this.lastCenterIndex = centerIndex;
+    this.lastViewportCenter = viewportCenterPoint;
+    this.lastLocateMode = located.mode;
+    return this.createSnapshot({
+      overscan,
+      totalRect,
+      viewportCenterPoint,
+      centerIndex,
+      centerRect,
+      items
+    });
+  }
+  makeAnchor(snapshot = this.getSnapshot()) {
+    return makeAnchor(snapshot);
+  }
+  getScrollOffsetForAnchor(anchor) {
+    return this.projectScrollOffset(this.getScrollPointForAnchor(anchor));
+  }
+  getScrollPointForAnchor(anchor) {
+    const resolvedIndex = this.resolveAnchorIndex(anchor);
+    if (resolvedIndex < 0) {
+      return createPoint();
+    }
+    const rect = this.engine.getItemRect(resolvedIndex);
+    if (rect === void 0) {
+      return createPoint();
+    }
+    const offset = anchor.offsetInsideRect ?? {
+      x: 0,
+      y: anchor.offsetInsideItem
+    };
+    return this.clampScrollPoint(createPoint(
+      rect.x + offset.x - this.viewportRect.width / 2,
+      rect.y + offset.y - this.viewportRect.height / 2
+    ));
+  }
+  scrollToIndex(index, align = "auto") {
+    return this.projectScrollOffset(this.getScrollTarget(index, align));
+  }
+  scrollToItem(index, align = "auto") {
+    return this.getScrollTarget(index, align);
+  }
+  getScrollTarget(index, align = "auto") {
+    return this.engine.getScrollTarget(index, align, this.viewportRect);
+  }
+  resolveScrollTarget(target) {
+    if ("index" in target) {
+      return this.getScrollTarget(target.index, target.align ?? "auto");
+    }
+    if ("key" in target) {
+      const index = this.engine.indexOfKey(target.key);
+      return index < 0 ? this.scrollPoint : this.getScrollTarget(index, target.align ?? "auto");
+    }
+    if ("offset" in target) {
+      return this.scrollAxis === "horizontal" ? this.scrollToPoint(createPoint(target.offset, this.scrollPoint.y)) : this.scrollToPoint(createPoint(this.scrollPoint.x, target.offset));
+    }
+    if ("rect" in target) {
+      return this.scrollToRect(target.rect, target.align ?? "auto");
+    }
+    return this.scrollToPoint(target.point);
+  }
+  scrollToPoint(point) {
+    return this.clampScrollPoint(point);
+  }
+  scrollToRect(rect, align = "auto") {
+    const viewport = this.viewportRect;
+    let x = rect.x;
+    let y = rect.y;
+    if (align === "center") {
+      x = rect.x + rect.width / 2 - viewport.width / 2;
+      y = rect.y + rect.height / 2 - viewport.height / 2;
+    } else if (align === "end") {
+      x = rect.x + rect.width - viewport.width;
+      y = rect.y + rect.height - viewport.height;
+    } else if (align === "auto" || align === "nearest") {
+      x = nearestAxisTarget2(rect.x, rect.x + rect.width, viewport.x, viewport.x + viewport.width);
+      y = nearestAxisTarget2(rect.y, rect.y + rect.height, viewport.y, viewport.y + viewport.height);
+    }
+    return this.scrollToPoint(createPoint(x, y));
+  }
+  getDebugState() {
+    const overscan = this.resolveCurrentOverscan();
+    return {
+      lastCenterIndex: this.lastCenterIndex,
+      lastViewportCenter: this.projectPoint(this.lastViewportCenter),
+      lastLocateMode: this.lastLocateMode,
+      scrollVelocity: this.scrollVelocity,
+      scrollDirection: this.scrollDirection,
+      overscanBefore: overscan.before,
+      overscanAfter: overscan.after,
+      adaptiveRangeActive: overscan.active
+    };
+  }
+  createSnapshot(params) {
+    const centerStart = params.centerIndex >= 0 ? this.engine.getItemMainStart(params.centerIndex) : 0;
+    const centerSize = params.centerIndex >= 0 ? this.engine.getItemMainSize(params.centerIndex) : 0;
+    const rangeStart = params.items.length === 0 ? 0 : Math.min(...params.items.map((item) => item.index));
+    const rangeEnd = params.items.length === 0 ? 0 : Math.max(...params.items.map((item) => item.index)) + 1;
+    return {
+      count: this.engine.count,
+      scrollAxis: this.scrollAxis,
+      layoutMode: this.layoutMode,
+      measurementAxes: this.measurementAxes,
+      viewportSize: this.projectViewportSize(),
+      viewportRect: this.viewportRect,
+      scrollOffset: this.projectScrollOffset(this.scrollPoint),
+      scrollPoint: this.scrollPoint,
+      viewportCenter: this.projectPoint(params.viewportCenterPoint) ?? 0,
+      viewportCenterPoint: params.viewportCenterPoint,
+      centerIndex: params.centerIndex,
+      centerKey: params.centerIndex >= 0 ? this.engine.keyOf(params.centerIndex) : void 0,
+      centerStart,
+      centerSize,
+      centerRect: params.centerRect,
+      rangeStart,
+      rangeEnd,
+      totalSize: this.projectTotalSize(params.totalRect),
+      totalRect: params.totalRect,
+      overscanBefore: params.overscan.before,
+      overscanAfter: params.overscan.after,
+      scrollVelocity: this.scrollVelocity,
+      scrollDirection: this.scrollDirection,
+      adaptiveRangeActive: params.overscan.active,
+      items: params.items
+    };
+  }
+  locateCenter() {
+    return this.engine.locateCenter(
+      this.getViewportCenterPoint(),
+      this.lastCenterIndex,
+      this.lastViewportCenter,
+      this.getRecenterThreshold()
+    );
+  }
+  updateScrollVelocity(nextPoint, timestamp) {
+    if (!this.adaptiveRange.enabled) {
+      return;
+    }
+    if (this.lastScrollPoint === void 0 || this.lastScrollTime === void 0) {
+      this.lastScrollPoint = nextPoint;
+      this.lastScrollTime = timestamp;
+      return;
+    }
+    const previousOffset = this.projectScrollOffset(this.lastScrollPoint);
+    const nextOffset = this.projectScrollOffset(nextPoint);
+    const delta = nextOffset - previousOffset;
+    const elapsed = Math.max(1, timestamp - this.lastScrollTime);
+    this.lastScrollPoint = nextPoint;
+    this.lastScrollTime = timestamp;
+    if (delta === 0) {
+      if (this.lastMovementTime !== void 0 && timestamp - this.lastMovementTime > this.adaptiveRange.settleMs) {
+        this.scrollVelocity = 0;
+        this.scrollDirection = 0;
+      }
+      return;
+    }
+    const instantVelocity = Math.abs(delta) / elapsed;
+    const smoothing = this.adaptiveRange.velocitySmoothing;
+    this.scrollVelocity = this.scrollVelocity === 0 ? instantVelocity : this.scrollVelocity * smoothing + instantVelocity * (1 - smoothing);
+    this.scrollDirection = delta > 0 ? 1 : -1;
+    this.lastMovementTime = timestamp;
+  }
+  resetScrollVelocity() {
+    this.lastScrollPoint = this.scrollPoint;
+    this.lastScrollTime = void 0;
+    this.lastMovementTime = void 0;
+    this.scrollVelocity = 0;
+    this.scrollDirection = 0;
+  }
+  resolveCurrentOverscan() {
+    if (!this.adaptiveRange.enabled || this.scrollVelocity === 0 || this.scrollDirection === 0) {
+      return {
+        before: this.baseOverscan.before,
+        after: this.baseOverscan.after,
+        maxItems: this.baseOverscan.maxItems,
+        maxPx: this.baseOverscan.maxPx,
+        active: false
+      };
+    }
+    const lookahead = this.scrollVelocity * this.adaptiveRange.lookaheadMs;
+    const aheadExtra = lookahead * this.adaptiveRange.directionBias;
+    const behindExtra = lookahead * (1 - this.adaptiveRange.directionBias);
+    const before = this.scrollDirection < 0 ? this.baseOverscan.before + aheadExtra : this.baseOverscan.before + behindExtra;
+    const after = this.scrollDirection > 0 ? this.baseOverscan.after + aheadExtra : this.baseOverscan.after + behindExtra;
+    return {
+      before: clampNumber4(before, this.adaptiveRange.min, this.adaptiveRange.max),
+      after: clampNumber4(after, this.adaptiveRange.min, this.adaptiveRange.max),
+      maxItems: this.baseOverscan.maxItems,
+      maxPx: this.baseOverscan.maxPx,
+      active: true
+    };
+  }
+  getViewportCenterPoint() {
+    return createPoint(
+      this.scrollPoint.x + this.viewportRect.width / 2,
+      this.scrollPoint.y + this.viewportRect.height / 2
+    );
+  }
+  getRecenterThreshold() {
+    return this.recenterThreshold ?? Math.max(this.projectViewportSize() * 4, this.baseOverscan.before + this.baseOverscan.after, 1024);
+  }
+  clampScrollPoint(point) {
+    const total = this.engine.getTotalRect();
+    const maxX = Math.max(0, total.width - this.viewportRect.width);
+    const maxY = Math.max(0, total.height - this.viewportRect.height);
+    return createPoint(
+      this.scrollAxis === "vertical" ? 0 : clampNumber4(point.x, 0, maxX),
+      this.scrollAxis === "horizontal" ? 0 : clampNumber4(point.y, 0, maxY)
+    );
+  }
+  projectScrollOffset(point) {
+    return this.scrollAxis === "horizontal" ? point.x : point.y;
+  }
+  projectViewportSize() {
+    return this.scrollAxis === "horizontal" ? this.viewportRect.width : this.viewportRect.height;
+  }
+  projectTotalSize(rect) {
+    return this.scrollAxis === "horizontal" ? rect.width : rect.height;
+  }
+  projectPoint(point) {
+    if (point === void 0) {
+      return void 0;
+    }
+    return this.scrollAxis === "horizontal" ? point.x : point.y;
+  }
+  isHorizontalLayoutDirection() {
+    return this.layoutDirection === "horizontal";
+  }
+  resolveAnchorIndex(anchor) {
+    if (this.engine.keyOf(anchor.index) === anchor.key) {
+      return anchor.index;
+    }
+    return this.engine.indexOfKey(anchor.key);
+  }
+};
+function resolveAdaptiveRange(value, baseOverscan) {
+  const options = typeof value === "object" ? value : {};
+  const enabled = value === true || options.enabled === true;
+  const baseMax = Math.max(baseOverscan.before, baseOverscan.after, 1);
+  return {
+    enabled,
+    min: normalizeNonNegativeNumber(options.min ?? baseMax),
+    max: Math.max(normalizeNonNegativeNumber(options.max ?? baseMax * 6), baseMax),
+    lookaheadMs: normalizePositiveNumber(options.lookaheadMs ?? 140, 140),
+    velocitySmoothing: clampNumber4(options.velocitySmoothing ?? 0.65, 0, 0.95),
+    directionBias: clampNumber4(options.directionBias ?? 0.8, 0.5, 1),
+    settleMs: normalizePositiveNumber(options.settleMs ?? 180, 180)
+  };
+}
+function normalizeNonNegativeNumber(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, value);
+}
+function normalizeOptionalPositiveNumber2(value) {
+  if (value === void 0 || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return value;
+}
+function normalizePositiveNumber(value, fallback) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return fallback;
+  }
+  return value;
+}
+function clampNumber4(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+function resolveInitialScrollPoint(scroll) {
+  if (scroll.restore?.point !== void 0) {
+    return scroll.restore.point;
+  }
+  if (scroll.initialPoint !== void 0) {
+    return scroll.initialPoint;
+  }
+  const offset = scroll.restore?.offset ?? scroll.initialOffset;
+  if (offset === void 0) {
+    return createPoint();
+  }
+  return scroll.axis === "horizontal" ? createPoint(offset, 0) : createPoint(0, offset);
+}
+function nearestAxisTarget2(itemStart, itemEnd, viewportStart, viewportEnd) {
+  if (itemStart >= viewportStart && itemEnd <= viewportEnd) {
+    return viewportStart;
+  }
+  if (itemEnd > viewportEnd) {
+    return itemEnd - (viewportEnd - viewportStart);
+  }
+  return itemStart;
+}
+function now() {
+  return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+export {
+  FenwickTree,
+  LinearBandEngine,
+  SizeModel,
+  SpatialRectEngine,
+  Virtualizer,
+  createPoint,
+  createRect,
+  expandRect,
+  rectFromScrollPoint,
+  rectsIntersect,
+  resolveLayoutGap,
+  resolveLayoutPadding
+};