@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/reactivity/content-version.svelte.d.ts

@@ -1,14 +1,11 @@
 /**
- * A number that changes whenever a byte-writing door announces it, so a whole-document
- * derivation can memoize over a `$state` document that is mutated IN PLACE and never changes
- * identity. Reading it inside a `$derived` subscribes that reader to every edit. The doors are
- * censused (G4.52): the commit ceremony announces every structural write at its publish, and the
- * writers outside it announce their own.
+ * A number bumped whenever the document's bytes change, so a whole-document `$derived` can
+ * memoize over a `$state` document that is mutated in place and never changes identity.
+ * Every place that writes bytes must bump it; a commit does so for each structural write (G4.52).
  */
 export interface ContentVersion {
-    /** The current key, stable until a door bumps it. */
     read(): number;
-    /** Announce that this door moved the document's serialized bytes. */
+    /** Call after changing the document's serialized bytes. */
     bump(): void;
 }
 export declare function createContentVersion(): ContentVersion;

package/dist/reactivity/content-version.svelte.js

@@ -1,9 +1,7 @@
 /**
- * A number that changes whenever a byte-writing door announces it, so a whole-document
- * derivation can memoize over a `$state` document that is mutated IN PLACE and never changes
- * identity. Reading it inside a `$derived` subscribes that reader to every edit. The doors are
- * censused (G4.52): the commit ceremony announces every structural write at its publish, and the
- * writers outside it announce their own.
+ * A number bumped whenever the document's bytes change, so a whole-document `$derived` can
+ * memoize over a `$state` document that is mutated in place and never changes identity.
+ * Every place that writes bytes must bump it; a commit does so for each structural write (G4.52).
  */
 export function createContentVersion() {
     let version = $state(0);

package/dist/reactivity/hold-across.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Which block stays still across a measure round, picked level by level down the document's
+ * block lists before the round, and where it is once the round's changes have landed. See
+ * `docs/design/virtual-rendering.md` § Keeping the page still while heights change.
+ */
+import type { HeightModel } from '../cursor/height-model';
+/** A list's block heights, with the ids they were built from lined up by index. */
+export interface HeightTable {
+    readonly model: HeightModel;
+    /** A snapshot, so a round finds its held block by id in the order from before a change. */
+    readonly ids: readonly string[];
+}
+declare const picked: unique symbol;
+declare const measured: unique symbol;
+/** The block a list keeps still, with its index in the table it was picked from. Only
+ *  `heldBlock` makes one. */
+export type HeldBlock = {
+    readonly id: string;
+    readonly index: number;
+    /** Picked because the caret is in it, which a change that moves it cancels. */
+    readonly focused: boolean;
+    readonly [picked]: true;
+};
+/** How far the held block's top moved across a round. Only `heldDelta` makes one, so a
+ *  correction can't use a distance worked out some other way. */
+export type HeldDelta = number & {
+    readonly [measured]: true;
+};
+/** The focused block's index among the children of the list at `listPath`, or null when the
+ *  focus path doesn't run through that list. */
+export declare function focusedIndexIn(focusPath: readonly number[] | null, listPath: readonly number[]): number | null;
+/** The focused block when it sits at or below `localTop`, else the block at the top, else none. */
+export declare function heldBlock(table: HeightTable, localTop: number, focusedIndex: number | null): HeldBlock | null;
+/** Where `held` sits in `after`, or -1 when the change removed it, or moved the caret's block
+ *  (a reorder moves its block on a still page, so that block isn't held). */
+export declare function heldIndexIn(held: HeldBlock, before: HeightTable, after: HeightTable): number;
+/** The distance a round corrects by: the held block's offset after it minus before. */
+export declare function heldDelta(before: number, after: number): HeldDelta;
+export {};

package/dist/reactivity/hold-across.js

@@ -0,0 +1,57 @@
+import { recordNeighbourPass } from '../perf/instruments';
+/** The focused block's index among the children of the list at `listPath`, or null when the
+ *  focus path doesn't run through that list. */
+export function focusedIndexIn(focusPath, listPath) {
+    if (!focusPath || focusPath.length <= listPath.length)
+        return null;
+    for (let i = 0; i < listPath.length; i++)
+        if (focusPath[i] !== listPath[i])
+            return null;
+    return focusPath[listPath.length];
+}
+/** The focused block when it sits at or below `localTop`, else the block at the top, else none. */
+export function heldBlock(table, localTop, focusedIndex) {
+    // Past the end the viewport's top is below this list, so the pick stays with its container.
+    if (table.model.size === 0 || localTop >= table.model.total())
+        return null;
+    const topIndex = table.model.indexAtOffset(localTop);
+    const focused = focusedIndex ?? -1;
+    if (focused >= topIndex && focused < table.ids.length)
+        return pick(table, focused, true);
+    // At 0 the viewport's top is above this list, in its container's chrome or further up.
+    return localTop === 0 ? null : pick(table, topIndex, false);
+}
+/** Where `held` sits in `after`, or -1 when the change removed it, or moved the caret's block
+ *  (a reorder moves its block on a still page, so that block isn't held). */
+export function heldIndexIn(held, before, after) {
+    if (after === before)
+        return held.index;
+    const index = after.ids.indexOf(held.id);
+    if (index === -1 || !held.focused)
+        return index;
+    return movedAcross(before, after, held.index, index) ? -1 : index;
+}
+/** The distance a round corrects by: the held block's offset after it minus before. */
+export function heldDelta(before, after) {
+    return (after - before);
+}
+function pick(table, index, focused) {
+    return { id: table.ids[index], index, focused };
+}
+// A block whose surviving neighbours changed was moved by the edit.
+function movedAcross(before, after, index, afterIndex) {
+    recordNeighbourPass();
+    const inAfter = new Set(after.ids);
+    const inBefore = new Set(before.ids);
+    return (survivingNeighbour(before.ids, index, -1, inAfter) !==
+        survivingNeighbour(after.ids, afterIndex, -1, inBefore) ||
+        survivingNeighbour(before.ids, index, 1, inAfter) !==
+            survivingNeighbour(after.ids, afterIndex, 1, inBefore));
+}
+function survivingNeighbour(ids, index, step, survivors) {
+    for (let i = index + step; i >= 0 && i < ids.length; i += step) {
+        if (survivors.has(ids[i]))
+            return ids[i];
+    }
+    return undefined;
+}

package/dist/reactivity/layout-state.svelte.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What the editor's heights were measured for: the type scale, the width version the block lists
+ * rebuild their tables off, and the viewport-height version, which only changes how many blocks
+ * fit. Layout state builds the height estimator and hands out its reads alone, so it's the one
+ * place measured heights can be thrown away (G4.98): a route reports what changed.
+ */
+import { type MeasuredHeightOracle } from '../cursor/height-oracle';
+export interface LayoutState {
+    /** The editor's height estimator, without the drop. */
+    heightOracle: Omit<MeasuredHeightOracle, 'dropMeasured'>;
+    /** The host's font scale against `HEIGHT_ESTIMATES`. A plain read, since the height estimates
+     *  read it on the keystroke path and the width version already signals the rebuild. */
+    typeScale(): number;
+    widthVersion(): number;
+    viewportHeightVersion(): number;
+    /** A document swap or a mode switch: the measured heights belong to a view that's gone. The
+     *  width version stays, since a rebuild would lose the block held in place. */
+    forgetMeasuredHeights(): void;
+    /** A width change re-wraps every block: the measured heights go, and every list re-estimates
+     *  its table. */
+    rebuildForNewGeometry(): void;
+    /** A new font scale is a geometry change too. */
+    setTypeScale(next: number): void;
+    /** The scroll container's height changed; that re-wraps nothing, so every height stays. */
+    noteViewportHeight(): void;
+}
+export declare function createLayoutState(): LayoutState;

package/dist/reactivity/layout-state.svelte.js

@@ -0,0 +1,51 @@
+/**
+ * What the editor's heights were measured for: the type scale, the width version the block lists
+ * rebuild their tables off, and the viewport-height version, which only changes how many blocks
+ * fit. Layout state builds the height estimator and hands out its reads alone, so it's the one
+ * place measured heights can be thrown away (G4.98): a route reports what changed.
+ */
+import { createHeightOracle } from '../cursor/height-oracle';
+import { HEIGHT_ESTIMATES } from '../cursor/typography-estimates';
+export function createLayoutState() {
+    let typeScale = 1;
+    let widthVersion = $state(0);
+    let viewportHeightVersion = $state(0);
+    // Only font-relative terms scale; getters, so a scale change needs no new height estimator.
+    const oracle = createHeightOracle({
+        get lineHeight() {
+            return HEIGHT_ESTIMATES.proseLineHeight * typeScale;
+        },
+        get codeLineHeight() {
+            return HEIGHT_ESTIMATES.codeLineHeight * typeScale;
+        },
+        get avgCharWidth() {
+            return HEIGHT_ESTIMATES.avgCharWidth * typeScale;
+        },
+        blockChrome: HEIGHT_ESTIMATES.blockChrome,
+        imageBlockMinHeight: HEIGHT_ESTIMATES.imageBlockMinHeight
+    });
+    function rebuildForNewGeometry() {
+        oracle.dropMeasured();
+        widthVersion++;
+    }
+    return {
+        heightOracle: {
+            estimate: oracle.estimate,
+            measured: oracle.measured,
+            recordMeasured: oracle.recordMeasured,
+            measuredIds: oracle.measuredIds
+        },
+        typeScale: () => typeScale,
+        widthVersion: () => widthVersion,
+        viewportHeightVersion: () => viewportHeightVersion,
+        forgetMeasuredHeights: () => oracle.dropMeasured(),
+        rebuildForNewGeometry,
+        setTypeScale(next) {
+            typeScale = next;
+            rebuildForNewGeometry();
+        },
+        noteViewportHeight: () => {
+            viewportHeightVersion++;
+        }
+    };
+}

package/dist/reactivity/list-tree.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Every mounted block list of one editor, so the scroll owner can read the document through their
+ * height tables: where a block sits, and which one block to keep still across a measure round.
+ * See `docs/design/virtual-rendering.md` § Keeping the page still while heights change.
+ */
+import type { TargetTop } from '../cursor/scroll-owner';
+import { type HeightTable, type HeldDelta } from './hold-across';
+/** One block list as the tree reads it. */
+export interface ListLevel {
+    path(): readonly number[];
+    /** The table as last built, read without building one: what a round opening in the middle of
+     *  a change counts from. */
+    built(): HeightTable;
+    /** The table as it reads now, rebuilt first if the list's blocks changed. */
+    current(): HeightTable;
+    /** The root list's top in the scroll content, a nested list's top below the top of the box its
+     *  parent measures; null before it mounts. */
+    top(): number | null;
+    /** This list's top in the scroll content, off its element; null before it mounts. */
+    contentTop(): number | null;
+    isInWindow(index: number): boolean;
+}
+export interface ListTreeDeps {
+    getScrollTop: () => number | null;
+    getFocusPath: () => readonly number[] | null;
+}
+export interface ListTree {
+    add(level: ListLevel): () => void;
+    /** Where the block at `path` sits in the scroll content, from the tables along its path; null
+     *  when a mounted container has windowed it out. */
+    resolve(path: readonly number[]): TargetTop | null;
+    /** Where to scroll so the list holding `path` mounts that block: the list's top plus its table's
+     *  offset of the block. */
+    mountTop(path: readonly number[]): number | null;
+    /** Picks the block to keep still from the tables and the scroll as they stand; the returned
+     *  read says how far that block has moved since. Null with nothing to hold. */
+    holdForRound(): (() => HeldDelta) | null;
+}
+export declare function createListTree(deps: ListTreeDeps): ListTree;

package/dist/reactivity/list-tree.js

@@ -0,0 +1,132 @@
+import { focusedIndexIn, heldBlock, heldDelta, heldIndexIn } from './hold-across';
+export function createListTree(deps) {
+    const levels = new Set();
+    function levelAt(path) {
+        for (const level of levels) {
+            const at = level.path();
+            if (at.length === path.length && at.every((index, i) => index === path[i]))
+                return level;
+        }
+        return undefined;
+    }
+    /** The one walk down a path: the offset below the root list's top at each level it reaches,
+     *  mounted containers' chrome included; null past a table's end, or a windowed-out block. */
+    function walk(path, read, inWindowOnly) {
+        let level = levelAt([]);
+        if (!level)
+            return null;
+        const offsets = [];
+        let offset = 0;
+        let height = 0;
+        for (let depth = 0; depth < path.length; depth++) {
+            const { model } = read(level);
+            const index = path[depth];
+            if (index >= model.size)
+                return null;
+            offset += model.offsetOf(index);
+            height = model.heightOf(index);
+            offsets.push(offset);
+            if (depth === path.length - 1)
+                break;
+            const inner = levelAt(path.slice(0, depth + 1));
+            const chrome = inner?.top() ?? null;
+            // An unmounted container stands in with its own top.
+            if (!inner || chrome === null)
+                break;
+            // The user scrolled past the target inside a mounted container: decline, not jump.
+            if (inWindowOnly && !inner.isInWindow(path[depth + 1]))
+                return null;
+            offset += chrome;
+            level = inner;
+        }
+        return { offsets, height };
+    }
+    /** The held block at each level, from the viewport's top down, preferring the caret's block. */
+    function descend(localTop, focus) {
+        const steps = [];
+        let level = levelAt([]);
+        let top = localTop;
+        while (level) {
+            const table = level.built();
+            const held = heldBlock(table, top, focusedIndexIn(focus, level.path()));
+            if (!held)
+                break;
+            steps.push({ level, held, table });
+            const inner = levelAt([...level.path(), held.index]);
+            const chrome = inner?.top() ?? null;
+            if (!inner || chrome === null)
+                break;
+            top = Math.max(0, top - table.model.offsetOf(held.index) - chrome);
+            level = inner;
+        }
+        return steps;
+    }
+    /** The held path as indices now, cut at the first level whose block the change removed; empty
+     *  when the caret's block was moved, so the round falls back to the block at the top. */
+    function pathNow(steps) {
+        const path = [];
+        for (const { level, held, table } of steps) {
+            // A list the round's change unmounted stands in with its container, as in `walk`.
+            if (!levels.has(level))
+                return path;
+            const index = heldIndexIn(held, table, level.current());
+            if (index === -1)
+                return held.focused ? [] : path;
+            path.push(index);
+        }
+        return path;
+    }
+    function holdForRound() {
+        const scrollTop = deps.getScrollTop();
+        const rootTop = levelAt([])?.top() ?? null;
+        if (scrollTop === null || rootTop === null)
+            return null;
+        const localTop = Math.max(0, scrollTop - rootTop);
+        const focus = deps.getFocusPath();
+        const candidates = [descend(localTop, focus)];
+        if (candidates[0].some((step) => step.held.focused))
+            candidates.push(descend(localTop, null));
+        const before = candidates.map((steps) => walk(steps.map((step) => step.held.index), (level) => level.built(), false)?.offsets ?? []);
+        if (before.every((offsets) => offsets.length === 0))
+            return null;
+        function movedSince() {
+            let from = 0;
+            let to = 0;
+            for (let i = 0; i < candidates.length; i++) {
+                const path = pathNow(candidates[i]);
+                const after = path.length > 0 ? walk(path, (level) => level.current(), false) : null;
+                if (!after)
+                    continue;
+                from = before[i][path.length - 1];
+                to = after.offsets[path.length - 1];
+                break;
+            }
+            return heldDelta(from, to);
+        }
+        return movedSince;
+    }
+    return {
+        add(level) {
+            levels.add(level);
+            return () => levels.delete(level);
+        },
+        resolve(path) {
+            const rootTop = levelAt([])?.top() ?? null;
+            if (rootTop === null || path.length === 0)
+                return null;
+            const at = walk(path, (level) => level.current(), true);
+            if (!at)
+                return null;
+            return { top: rootTop + at.offsets[at.offsets.length - 1], height: at.height };
+        },
+        mountTop(path) {
+            const level = levelAt(path.slice(0, -1));
+            const top = level?.contentTop() ?? null;
+            const index = path[path.length - 1];
+            if (!level || top === null || index === undefined)
+                return null;
+            return top + level.current().model.offsetOf(index);
+        },
+        holdForRound
+    };
+}

package/dist/reactivity/list-windowing.svelte.d.ts

@@ -1,100 +1,79 @@
 import type { HeightOracle } from '../cursor/height-oracle';
-import type { Scrollport } from '../cursor/scrollport';
+import type { ScrollportReader } from '../cursor/scrollport';
+import type { TargetTop } from '../cursor/scroll-owner';
 import { type WindowResult } from './block-window.svelte';
-import { type MeasureEntry } from './measure-batch';
+import type { ListLevel } from './list-tree';
 import type { NodeView } from '../core/node-views';
-import type { RevealBlock } from '../cursor/reveal-anchor';
-/**
- * An active reveal target in one scope's coordinates. The model addresses only this
- * scope's own children, so a nested target arrives as its top-level ancestor's `index`
- * plus the measured drop down to the target — pinning the block the reveal aimed at
- * rather than its container.
- */
-export interface RevealAnchorPlacement {
-    index: number;
-    block: RevealBlock;
-    /** Drop from the ancestor's top to the target's top; 0 when the target IS the ancestor. */
-    innerOffset: number;
-    /** The target's own height, for `'center'`; null when it can't be measured. */
-    height: number | null;
+/** How a list reaches the editor's scroll owner. A list writes heights, never a scroll: the owner
+ *  keeps one block still across each flush of them. */
+export interface ListScrollWrites {
+    /** Called before this list's table changes, so the round counts from the table as it was. */
+    beginRound(): void;
+    /** True from a round's first height write until its scroll correction lands. */
+    roundOpen(): boolean;
+    measureSoon(run: () => void): void;
+    /** Scroll so the block at `path` mounts; the owner works out where. */
+    scrollToMount(path: readonly number[]): void;
 }
 export interface ListWindowingDeps {
     oracle: HeightOracle;
     getChildren: () => readonly NodeView[];
     getChildIds: () => string[];
-    /** This scope's own list element — its top within the scroll content maps port scrollTop to local. */
+    /** This list's own element; its top within the scroll content converts the scroll
+     *  container's `scrollTop` into this list's coordinates. */
     getListEl: () => HTMLElement | null;
-    /** The single scrollport every scope of this editor windows against: the root under
-     *  `scrollMode="self"`, the host's scroller or the page viewport under `"host"`. */
-    getPort: () => Scrollport | null;
-    /** The focused block's full path, for the per-level pin. */
+    /** The one scroll container every list in this editor windows against: the editor root
+     *  under `scrollMode="self"`, the host's scroller or the page viewport under `"host"`. */
+    getPort: () => ScrollportReader | null;
+    scroll: ListScrollWrites;
+    /** The focused block's full path, so each level knows which block to hold in place. */
     getFocusPath: () => number[] | null;
-    /** Where an active reveal target sits in this scope's coordinates, else null. While set,
-     *  `correctAnchor` holds THAT position instead of the top-of-viewport block. Wired on
-     *  the ROOT scope only — nested scopes would fight over one scrollTop. */
-    getRevealAnchorTarget?: () => RevealAnchorPlacement | null;
-    /** Monotonic counter bumped on an editor WIDTH change (after the oracle's measured
-     *  cache is cleared). Rebuilds the model at the new width and re-measures mounted blocks. */
+    /** Counter bumped on an editor width change, after the height estimator's measured cache
+     *  is cleared. Rebuilds the height table at the new width and re-measures mounted blocks. */
     getWidthVersion: () => number;
-    /** Monotonic counter bumped when the PORT's height changes. The slice's extent comes
-     *  from a plain DOM height read, which no reactive edge reaches; this is that edge. */
+    /** Bumped when the scroll container's height changes, since the viewport height comes from
+     *  a plain DOM read that nothing reactive sees. */
     getViewportHeightVersion: () => number;
-    /** This scope's path (the parentPath its children render under). [] at top level. */
+    /** This list's path (the `parentPath` its children render under). `[]` at top level. */
     getParentPath: () => number[];
-    /** This scope's own measurable box; re-measured on inner reflow to report a fresh subtotal upward. Absent at top level. */
-    getOwnEl?: () => HTMLElement | null;
-    /** Report this scope's own box height to the parent scope's setChildSubtotal (undefined at top level). */
-    reportSelfHeight?: (height: number) => void;
-    /** False while the HOST's native scroll anchoring holds the reader instead (host mode below
-     *  the windowing budget): two writers on one scroll position double-correct. */
-    correctsScroll: () => boolean;
-    /** Collapse clamp: while true this scope mounts ONLY its chrome row, a fixed [0,1) with
-     *  zero spacers. The window math is bypassed, not fed — collapse is height removal, and
-     *  a clamped slice through `computeWindow` would emit the body as a giant spacer. */
+    /** While true the list mounts only its title row and skips the window math: collapsing
+     *  removes height, and a clamped slice would emit the body as one giant spacer. */
     isCollapsed?: () => boolean;
     overscan: number;
     pinExtensionCap: number;
     activateAbovePx: number;
     deactivateBelowPx: number;
 }
+/** A child of this list, measured under its own id at its index. */
+export interface MeasuredChild {
+    index: number;
+    readHeight: () => number;
+}
 export interface ListWindowing {
     readonly window: WindowResult;
-    /** A DIRECTLY-MEASURED leaf: oracle (by id) + model slot. Passive — no scrollTop write. */
-    recordMeasuredChild(index: number, id: string, height: number): void;
-    /** A PROPAGATED child-container subtotal: oracle + model slot, addressed by index. No anchor correction. */
-    setChildSubtotal(index: number, total: number): void;
-    /** Enroll a child in this scope's batched measure pass, read after the flush that registered
-     *  it; returns an unregister fn to call on the child's unmount. The scope reads ALL pending
-     *  children before applying ANY write, so a fling that mounts many costs one reflow. */
-    registerChild(id: string, child: MeasureEntry): () => void;
-    /** Re-measure ONE registered child immediately (its content height changed on edit). */
+    /** This list as the editor's list tree reads it. */
+    readonly level: ListLevel;
+    /** Queues a child for the batched measure pass after the flush that registered it, so a fast
+     *  scroll that mounts many costs one reflow. Returns the unregister function. */
+    registerChild(id: string, child: MeasuredChild): () => void;
+    /** Re-measure one registered child immediately, after an edit changed its height. */
     measureChildNow(id: string): void;
-    /** ResizeObserver path: O(1)-gate `observedHeight` against the height this scope last
-     *  applied and re-measure only on a genuine post-mount change, so the no-op mount resize
-     *  on a fling costs no DOM read. */
+    /** Compares `observedHeight` against the height last applied, with no DOM read, so the
+     *  no-op resize every mount fires costs nothing during a fast scroll. */
     measureChildOnResize(id: string, observedHeight: number): void;
-    /**
-     * True when the scroll position IS the reveal target's requested placement. Asked by
-     * any writer that would otherwise add a relative delta to the same scrollTop: the
-     * anchor derives its position from live geometry, so a delta on top double-counts.
-     * A question, never a write — re-placing here would drag the reader to the top pin on
-     * a resize they only wanted compensated. Root scope only; nested scopes answer false.
-     */
-    revealHoldsScroll(): boolean;
-    /** Scroll this scope so child `index` enters its window; resolves after a tick. */
+    /** Where child `index`'s top sits in the scroll container's content, by the height table,
+     *  and its height; null past the end or before the list mounts. */
+    targetTopOf(index: number): TargetTop | null;
+    /** A scripted `scrollTop` write fires no `scroll` event in time, so the window re-reads it. */
+    syncScrollTop(): void;
+    /** Scroll this list so child `index` is inside the mounted range; resolves after a tick. */
     revealChild(index: number): Promise<void>;
-    /** True iff `index` is in the CURRENT mounted window (inactive ⇒ always true; collapsed
-     *  ⇒ only the chrome row). Read after `revealChild` to prove a reveal landed before
-     *  waiting on a mount that can otherwise never come (VR-5 termination). */
+    /** Whether `index` is in the mounted range; read after `revealChild` so a wait for the mount
+     *  gives up instead of hanging when the scroll didn't bring it in (VR-5). */
     isInWindow(index: number): boolean;
     dispose(): void;
 }
-/**
- * Resize-gate decision (pure, unit-tested). Keyed on the height DIFFERING from what is
- * recorded, never on which callback delivered it: a cached remount can report the grown
- * size in the very first callback, so a callback-order heuristic would drop it.
- * `recorded === undefined` means the scope has applied no height for this block yet —
- * defer to the batched pass rather than racing a lone read in on a fling-dirtied layout.
- */
+/** Whether a resize is worth re-measuring: only when the height differs from the one this list
+ *  applied. With none applied yet, the batched pass owns the first measure. */
 export declare function shouldRemeasureOnResize(recorded: number | undefined, observed: number): boolean;
 export declare function createListWindowing(deps: ListWindowingDeps): ListWindowing;