@n-uf/motion 26.11.2 → 26.11.4

package/dist/gestures.js

@@ -20,7 +20,7 @@ import {
   resolveDragModifier,
   toModifiers,
   wheelDeltaPx
-} from "./chunk-NFQ4LIIR.js";
+} from "./chunk-C4M62FUT.js";
 import "./chunk-OOKRBVMB.js";
 export {
   DWELL_DEFAULTS,

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { C as ClockPort, F as FrameSource, T as TimerSource } from './port-CmlUc
 export { FakeClock, FakeClockOptions, createFakeClock } from './clock.js';
 export { F as FrameInfo, a as FrameLoop, b as FrameLoopOptions, c as FrameStats, d as FrameTask, P as PHASES, e as Phase, R as RepeatingTask, S as ScheduleOptions, f as createFrameLoop } from './frame-loop-C88dc9xw.js';
 export { EffectCleanup, EffectOptions, Equals, ReadonlySignal, Signal, SignalOptions, batch, computed, effect, isSignal, signal, untracked } from './signals.js';
-export { Animator, AnimatorValue, Easing, MotionOptions, MotionValue, SPRING_DEFAULTS, SetOptions, Spring, SpringConfig, SpringParams, SpringState, Tween, TweenConfig, createSpring, createTween, cubicBezier, ease, easeIn, easeInOut, easeInOutCubic, easeOut, easeOutCubic, linear, motionValue, resolveSpring, springStep, springValue, tweenValue } from './values.js';
+export { Animator, AnimatorValue, Easing, MotionOptions, MotionValue, SETTLE_DEFAULTS, SETTLE_TEMPO, SPRING_DEFAULTS, SetOptions, Settle, SettleConfig, Spring, SpringConfig, SpringParams, SpringState, Tween, TweenConfig, createSettle, createSpring, createTween, cubicBezier, ease, easeIn, easeInOut, easeInOutCubic, easeOut, easeOutCubic, linear, motionValue, resolveSpring, settleValue, springStep, springValue, tweenValue } from './values.js';
+export { P as PopIn, R as RevealFrame, p as popIn, r as reveal } from './reveal-my7U6UyE.js';
 export { CancelReason, CoalescerOptions, DWELL_DEFAULTS, DWELL_IDLE, Deadline, DwellConfig, DwellInput, DwellMachineOptions, DwellState, FrameCoalescer, InputGesture, InputGestureType, Machine, MachineOptions, ModifierDrag, ModifierKey, Modifiers, NO_MODIFIERS, Platform, PointerKind, RECOGNIZER_DEFAULTS, RawInputEvent, RawPointerEvent, RawPointerType, RawSafariGestureEvent, RawWheelEvent, Recognizer, RecognizerOptions, RecognizerTimers, SurfacePointer, WHEEL_DEFAULTS, WHEEL_PAN_DEFAULTS, WheelIntent, WheelOptions, WheelPanOptions, classifyWheel, createDwellMachine, createFrameCoalescer, createMachine, createRecognizer, dampWheelPan, defaultDragModifier, dwellDeadline, dwellReducer, isHeld, modHeld, platformButton, resolveDragModifier, toModifiers, wheelDeltaPx } from './gestures.js';
 export { A as Animatable, P as Point, R as Rect, V as Vector, W as Widen, s as shapeEquals } from './shapes-EbQlwbCu.js';

package/dist/index.js

@@ -18,11 +18,11 @@ import {
   linear,
   motionValue,
   resolveSpring,
-  shapeEquals,
+  settleValue,
   springStep,
   springValue,
   tweenValue
-} from "./chunk-LCTGXGOI.js";
+} from "./chunk-CM6WVNDH.js";
 import {
   DWELL_DEFAULTS,
   DWELL_IDLE,
@@ -45,7 +45,7 @@ import {
   resolveDragModifier,
   toModifiers,
   wheelDeltaPx
-} from "./chunk-NFQ4LIIR.js";
+} from "./chunk-C4M62FUT.js";
 import {
   batch,
   computed,
@@ -54,12 +54,22 @@ import {
   signal,
   untracked
 } from "./chunk-OOKRBVMB.js";
+import {
+  SETTLE_DEFAULTS,
+  SETTLE_TEMPO,
+  createSettle,
+  popIn,
+  reveal,
+  shapeEquals
+} from "./chunk-WQQ2E25M.js";
 export {
   DWELL_DEFAULTS,
   DWELL_IDLE,
   NO_MODIFIERS,
   PHASES,
   RECOGNIZER_DEFAULTS,
+  SETTLE_DEFAULTS,
+  SETTLE_TEMPO,
   SPRING_DEFAULTS,
   WHEEL_DEFAULTS,
   WHEEL_PAN_DEFAULTS,
@@ -72,6 +82,7 @@ export {
   createFrameLoop,
   createMachine,
   createRecognizer,
+  createSettle,
   createSpring,
   createTween,
   cubicBezier,
@@ -92,8 +103,11 @@ export {
   modHeld,
   motionValue,
   platformButton,
+  popIn,
   resolveDragModifier,
   resolveSpring,
+  reveal,
+  settleValue,
   shapeEquals,
   signal,
   springStep,

package/dist/layout.d.ts

@@ -0,0 +1,258 @@
+import { F as FrameInfo, a as FrameLoop, e as Phase } from './frame-loop-C88dc9xw.js';
+import { R as Rect, P as Point } from './shapes-EbQlwbCu.js';
+import { R as RevealFrame, P as PopIn } from './reveal-my7U6UyE.js';
+import './port-CmlUctqx.js';
+
+/**
+ * What a {@link Drawable} draws on a frame: where the item is drawn, the box its content is laid out in, how to draw
+ * the one at the other without stretching ({@link reveal}), and its appearance ({@link popIn}).
+ */
+interface DrawFrame {
+    /** Where the item is drawn this frame (its frame: background, border, shadow). */
+    readonly drawn: Rect;
+    /** The box its content is laid out in: where it is heading, or (held) where it was laid out last. */
+    readonly box: Rect;
+    /** How to draw `box`'s content at `drawn`: a move, the frame at the drawn size, the content clipped. */
+    readonly reveal: RevealFrame;
+    /** Its uniform appearance: scale about its centre and opacity. */
+    readonly pop: PopIn;
+    /** How shown it is, 0 (gone) to 1. */
+    readonly shown: number;
+    /** All the way gone: hidden and at rest (out of sight and out of the way of the pointer). */
+    readonly gone: boolean;
+}
+/**
+ * How an item reaches the screen. The layout motion never measures or touches anything itself: it lays an item's
+ * content out once per new box and draws it once per frame through this. {@link domDrawable} writes an element's
+ * style; a canvas or a test can draw anything else.
+ */
+interface Drawable {
+    /** Lay the content out in `box` (its position and size): called once per new box, never per frame. */
+    layOut(box: Rect): void;
+    /** Draw the item for this frame. */
+    draw(frame: DrawFrame): void;
+}
+/**
+ * One item the layout motion moves: give it a new place and it settles there from wherever it is drawn.
+ *
+ * - {@link LayoutItem.moveTo}: a settle to the new place, retargeted from the drawn rect (no jump, no overshoot);
+ *   the content is laid out at the new box at once and the item redrawn at once, so no frame shows the old offset
+ *   from the new box.
+ * - A size change is revealed: the content is laid out at the target size and the frame clipped, never scaled.
+ * - {@link LayoutItem.show}: appear or disappear with a uniform-scale fade.
+ */
+interface LayoutItem {
+    readonly id: string;
+    /** Where it is drawn now. */
+    readonly drawn: Rect;
+    /** Where it is heading (its settle's target). */
+    readonly target: Rect;
+    /** The box its content is laid out in. */
+    readonly box: Rect;
+    /** At rest on its target. */
+    readonly settled: boolean;
+    /** How shown it is, 0 to 1, and whether it is heading for shown. */
+    readonly shown: number;
+    readonly showing: boolean;
+    /** Its appearance is at rest (fully shown, or gone). */
+    readonly shownSettled: boolean;
+    /** Settle to `to` from where it is drawn; lays the content out at `to` and redraws at once. */
+    moveTo(to: Rect): void;
+    /** Be at `to` now, at rest: no glide. */
+    jumpTo(to: Rect): void;
+    /** Drawn at `from` now, then settle to `to` (a FLIP's invert and play: `from` in the item's own coordinates). */
+    glideFrom(from: Rect, to: Rect): void;
+    /** Exactly at `r`, at rest (what a pointer holds); the content stays laid out in its box, moved with it. */
+    hold(r: Rect): void;
+    /** Appear (true) or disappear (false) with a uniform-scale fade; `now`: without the fade. */
+    show(on: boolean, options?: {
+        readonly now?: boolean;
+    }): void;
+    /** Draw it again now (after its drawable's element was laid out anew from outside). */
+    redraw(): void;
+}
+/** A task the layout motion runs on every frame before it steps the items; true keeps the frames coming. */
+type LayoutTask = (frame: FrameInfo) => boolean | void;
+interface LayoutMotionOptions {
+    /** The frame loop every item steps on (one loop for all of them). */
+    readonly loop: FrameLoop;
+    /** The settle tempo, per second ({@link SETTLE_TEMPO}); default `SETTLE_TEMPO.default`. */
+    readonly omega?: number;
+    /** The frame phase the items step and draw in; default `"layout"`. */
+    readonly phase?: Phase;
+    /** Where an appearing item grows from, as a share of its size ({@link popIn}'s `from`); default 0.87. */
+    readonly popFrom?: number;
+}
+/**
+ * Layout motion: items with an id and a target rect, each settled to its place on one shared frame loop.
+ *
+ * Give an item a new place ({@link LayoutItem.moveTo}) and it glides there from wherever it is drawn: the window
+ * motion rules of `values/` (settle, reveal, popIn) applied to every item at once. The loop runs only while
+ * something moves, or a task asks for frames, and stops by itself.
+ *
+ * It only animates the rects it is given: which items move where, and when, is the caller's layout.
+ */
+interface LayoutMotion {
+    /** Add an item drawn by `drawable`, at `at`, shown (or gone: `{ shown: false }`). Its content is laid out at once. */
+    add(id: string, drawable: Drawable, at: Rect, options?: {
+        readonly shown?: boolean;
+    }): LayoutItem;
+    get(id: string): LayoutItem | undefined;
+    /** Stop moving an item (its drawable is not touched again). */
+    remove(id: string): void;
+    readonly items: ReadonlyMap<string, LayoutItem>;
+    /** Run `task` on every frame, before the items step; returns how to stop it. */
+    task(task: LayoutTask): () => void;
+    /** Call `listener` on every frame, after the items have stepped and been drawn; returns how to stop it. */
+    onFrame(listener: (frame: FrameInfo) => void): () => void;
+    /** Call `listener` each time the frames stop (nothing moves); returns how to stop it. */
+    onIdle(listener: () => void): () => void;
+    /** Make sure at least one more frame runs (a task has something to do). */
+    wake(): void;
+    /** Frames are running. */
+    readonly running: boolean;
+    /** Set the tempo for every item (and the ones added later). */
+    configure(config: {
+        readonly omega?: number;
+    }): void;
+    /** Resolves once nothing moves (at once if nothing does). */
+    idle(): Promise<void>;
+    /** Stop the frames and forget every item. */
+    dispose(): void;
+}
+/** Create the {@link LayoutMotion} for one surface. */
+declare function createLayoutMotion(options: LayoutMotionOptions): LayoutMotion;
+
+/**
+ * An item held by a pointer: the real item (no copy) follows the pointer 1:1 from where it was grabbed, at the size
+ * it was lifted at; its place stays reserved (that is the caller's layout). Then:
+ *
+ * - {@link HeldDrag.snapTo}: glide into a slot (a snap preview); `null` leaves the slot and glides back to the
+ *   pointer, following it as it moves ({@link HeldDrag.follow} once a frame), until it is under it again.
+ * - {@link HeldDrag.land}: let go into a slot: the landing settles from where it was let go (the release rect), never
+ *   from its old home. Snapped into that slot already, it simply finishes that glide.
+ * - {@link HeldDrag.cancel}: let go with no drop: it glides home from where it was let go.
+ * - {@link HeldDrag.preview}: the three drop previews, per frame: indicator and gap keep the item under the pointer
+ *   (gap with the caller's room open), snap glides it into the slot; leaving glides it back to the pointer.
+ * - {@link HeldDrag.resize}: the item takes a new size mid-drag (its content laid out anew by the caller): it settles
+ *   to it from where it is drawn, the size revealed (never stretched), and is held 1:1 again once there.
+ */
+interface HeldDrag {
+    /** Where the pointer is (null before the first move). */
+    readonly pointer: Point | null;
+    /** Where the pointer holds the item: the pointer less the grab offset, at the held size (lifted, or resized). */
+    readonly held: Rect | null;
+    /** The slot it sits in (a snap), or null. */
+    readonly snapped: Rect | null;
+    /** It left a slot (or took a new size) and is gliding back to the pointer. */
+    readonly returning: boolean;
+    /** The pointer moved: held 1:1 (unless it sits in a slot or is on its way back). */
+    move(pointer: Point): void;
+    /**
+     * Into `slot` (a glide from where it is drawn; the same slot again does nothing), or out of the slot it sits in
+     * (`null`: back to the pointer). Returns what changed: `"snapped"`, `"left"`, or null.
+     */
+    snapTo(slot: Rect | null): "snapped" | "left" | null;
+    /** Once a frame: on its way back, retarget to the pointer; true on the frame it is under the pointer again. */
+    follow(): boolean;
+    /**
+     * Once a frame, a drop preview's part for the item (`plan`: `@n-uf/motion/drag`'s `previewPlan`, or any
+     * `{ snapItem }`): with `snapItem` it glides into `slot` (snap); else it stays under the pointer, or glides back to
+     * it from a slot it left (indicator, gap). The room, if the plan makes any, is the caller's layout. In place of
+     * {@link HeldDrag.snapTo} and {@link HeldDrag.follow}; returns what changed.
+     */
+    preview(plan: {
+        readonly snapItem: boolean;
+    }, slot: Rect | null): "snapped" | "left" | null;
+    /**
+     * Hold it at `size` from now on (the caller has laid its content out for that size). The grab point keeps its share
+     * of the item, so the pointer stays on the same spot of it; the item settles from where it is drawn to its new held
+     * rect (its size revealed, never stretched), then is held 1:1 again ({@link HeldDrag.follow} once a frame). In a
+     * slot it stays there, taking the new size when it leaves. The same size again does nothing; returns true on a
+     * change.
+     */
+    resize(size: {
+        readonly width: number;
+        readonly height: number;
+    }): boolean;
+    /** Let go into `slot`: returns the release rect, where the landing starts. */
+    land(slot: Rect): Rect;
+    /** Let go with no drop: glides `home` from the release rect, which it returns. */
+    cancel(home: Rect): Rect;
+}
+/** Hold `item` from the pointer at `grab` (the pointer's offset from its top-left corner), at its drawn size now. */
+declare function holdItem(item: LayoutItem, grab: Point): HeldDrag;
+
+/** A rect as a DOM rect reports it (`getBoundingClientRect()`): left, top, width, height. */
+interface RectLike {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** Anything that can say where it is drawn: a DOM node, or a test's stand-in. */
+interface Measurable {
+    getBoundingClientRect(): RectLike;
+}
+/** A {@link RectLike} as a {@link Rect}. */
+declare const rectOf: (r: RectLike) => Rect;
+/** One member of a {@link flip}: an item, the node it draws, and where it goes once the DOM has changed. */
+interface FlipEntry {
+    readonly item: LayoutItem;
+    readonly node: Measurable;
+    /**
+     * Once the DOM has changed: the old rect (as measured before, in page coordinates) in the item's own coordinates
+     * now, and its new place there.
+     */
+    readonly place: (before: Rect) => {
+        readonly from: Rect;
+        readonly to: Rect;
+    };
+}
+/**
+ * FLIP for DOM groups, on settle: record where each node is drawn (first), change the DOM (`change`: move nodes to
+ * other parents, reorder them), then each item is drawn at its old rect and settles to its new place (last, invert,
+ * play). No transform tween: a settle from the rect it was drawn at, so it never jumps or overshoots, and its size
+ * changes through reveal.
+ */
+declare function flip(entries: readonly FlipEntry[], change: () => void): void;
+
+/**
+ * The style properties the layout motion writes, as strings (a DOM node's `style` has them all). Structural: the
+ * library needs no DOM types.
+ */
+interface StyleLike {
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+    transform: string;
+    opacity: string;
+    clipPath: string;
+    visibility: string;
+}
+/** Something with a writable {@link StyleLike} `style`: a DOM node. */
+interface Styled {
+    readonly style: StyleLike;
+}
+/**
+ * The nodes of a drawn box: `node` is laid out at the box and moved to the drawn rect; `frame` (background, border,
+ * shadow) is drawn at the drawn size; `content` is clipped to it. With no `frame` and `content`, `node` itself is
+ * clipped (its content laid out at the box, never stretched).
+ */
+interface BoxNodes {
+    readonly node: Styled;
+    readonly frame?: Styled;
+    readonly content?: Styled;
+}
+/** Lay `node` out at `box`: its position and size, in its offset parent's coordinates. */
+declare function layOutBox(node: Styled, box: Rect): void;
+/**
+ * Draw one frame of a box laid out by {@link layOutBox}: one transform (the move to the drawn rect, and the uniform
+ * appearance about its centre), the frame at the drawn size, the content clipped (reveal); hidden when gone.
+ */
+declare function drawBox(nodes: BoxNodes, frame: DrawFrame): void;
+/** A {@link Drawable} for DOM nodes: {@link layOutBox} on a new box, {@link drawBox} on every frame. */
+declare function domDrawable(nodes: BoxNodes): Drawable;
+
+export { type BoxNodes, type DrawFrame, type Drawable, type FlipEntry, type HeldDrag, type LayoutItem, type LayoutMotion, type LayoutMotionOptions, type LayoutTask, type Measurable, type RectLike, type StyleLike, type Styled, createLayoutMotion, domDrawable, drawBox, flip, holdItem, layOutBox, rectOf };

package/dist/layout.js

@@ -0,0 +1,312 @@
+import {
+  SETTLE_TEMPO,
+  createSettle,
+  popIn,
+  reveal
+} from "./chunk-WQQ2E25M.js";
+
+// src/layout/motion.ts
+var same = (a, b) => Math.abs(a.x - b.x) < 0.01 && Math.abs(a.y - b.y) < 0.01 && Math.abs(a.width - b.width) < 0.01 && Math.abs(a.height - b.height) < 0.01;
+var copy = (r) => ({ x: r.x, y: r.y, width: r.width, height: r.height });
+function createLayoutMotion(options) {
+  const { loop } = options;
+  const phase = options.phase ?? "layout";
+  const popFrom = options.popFrom ?? 0.87;
+  let omega = options.omega ?? SETTLE_TEMPO.default;
+  const items = /* @__PURE__ */ new Map();
+  const steps = /* @__PURE__ */ new Map();
+  const tasks = /* @__PURE__ */ new Set();
+  const frames = /* @__PURE__ */ new Set();
+  const idles = /* @__PURE__ */ new Set();
+  const tempos = /* @__PURE__ */ new Set();
+  const removers = /* @__PURE__ */ new Map();
+  let waiters = [];
+  let stop = null;
+  let woken = false;
+  const wake = () => {
+    woken = true;
+    if (stop) return;
+    stop = loop.repeat(phase, tick);
+  };
+  function tick(frame) {
+    let moving = woken;
+    woken = false;
+    for (const task of [...tasks]) if (task(frame)) moving = true;
+    for (const step of [...steps.values()]) if (step(frame.delta)) moving = true;
+    for (const listener of [...frames]) listener(frame);
+    if (moving || woken) return true;
+    stop = null;
+    const resolve = waiters;
+    waiters = [];
+    for (const r of resolve) r();
+    for (const listener of [...idles]) listener();
+    return false;
+  }
+  function add(id, drawable, at, opts = {}) {
+    if (items.has(id)) throw new Error(`layout motion: item "${id}" is already added (remove it first)`);
+    const rect = createSettle(copy(at), { omega });
+    const pop = createSettle(opts.shown === false ? 0 : 1, { omega, restDelta: 1e-3 });
+    let box = copy(at);
+    const frameOf = () => {
+      const drawn = rect.value;
+      return { drawn, box, reveal: reveal(drawn, box), pop: popIn(pop.value, popFrom), shown: pop.value, gone: pop.settled && pop.value === 0 };
+    };
+    const draw = () => drawable.draw(frameOf());
+    const layOut = (to) => {
+      box = copy(to);
+      drawable.layOut(box);
+    };
+    const tempo = () => {
+      rect.configure({ omega });
+      pop.configure({ omega });
+    };
+    const item = {
+      id,
+      get drawn() {
+        return rect.value;
+      },
+      get target() {
+        return rect.target;
+      },
+      get box() {
+        return box;
+      },
+      get settled() {
+        return rect.settled;
+      },
+      get shown() {
+        return pop.value;
+      },
+      get showing() {
+        return pop.target === 1;
+      },
+      get shownSettled() {
+        return pop.settled;
+      },
+      moveTo(to) {
+        if (same(box, to) && same(rect.target, to)) return;
+        layOut(to);
+        draw();
+        if (same(rect.target, to)) return;
+        rect.setTarget(copy(to));
+        wake();
+      },
+      jumpTo(to) {
+        layOut(to);
+        rect.jumpTo(copy(to));
+        draw();
+      },
+      glideFrom(from, to) {
+        rect.jumpTo(copy(from));
+        layOut(to);
+        draw();
+        rect.setTarget(copy(to));
+        wake();
+      },
+      hold(r) {
+        rect.hold(copy(r));
+        draw();
+      },
+      show(on, o = {}) {
+        const want = on ? 1 : 0;
+        if (o.now) pop.jumpTo(want);
+        else if (pop.target !== want) {
+          pop.setTarget(want);
+          wake();
+        }
+        draw();
+      },
+      redraw: draw
+    };
+    drawable.layOut(box);
+    draw();
+    items.set(id, item);
+    tempos.add(tempo);
+    steps.set(id, (dt) => {
+      const a = rect.step(dt);
+      const b = pop.step(dt);
+      draw();
+      return a || b;
+    });
+    removers.set(id, () => tempos.delete(tempo));
+    return item;
+  }
+  return {
+    add,
+    get: (id) => items.get(id),
+    remove(id) {
+      items.delete(id);
+      steps.delete(id);
+      removers.get(id)?.();
+      removers.delete(id);
+    },
+    items,
+    task(task) {
+      tasks.add(task);
+      wake();
+      return () => tasks.delete(task);
+    },
+    onFrame(listener) {
+      frames.add(listener);
+      return () => frames.delete(listener);
+    },
+    onIdle(listener) {
+      idles.add(listener);
+      return () => idles.delete(listener);
+    },
+    wake,
+    get running() {
+      return stop !== null;
+    },
+    configure(config) {
+      if (config.omega !== void 0) omega = config.omega;
+      for (const t of tempos) t();
+    },
+    idle: () => stop ? new Promise((r) => waiters.push(r)) : Promise.resolve(),
+    dispose() {
+      stop?.();
+      stop = null;
+      items.clear();
+      steps.clear();
+      tasks.clear();
+      frames.clear();
+      idles.clear();
+      tempos.clear();
+      removers.clear();
+      const resolve = waiters;
+      waiters = [];
+      for (const r of resolve) r();
+    }
+  };
+}
+
+// src/layout/held.ts
+var CAUGHT = 0.5;
+function holdItem(item, grab) {
+  let size = { width: item.drawn.width, height: item.drawn.height };
+  let at = { x: grab.x, y: grab.y };
+  let pointer = null;
+  let snapped = null;
+  let returning = false;
+  const heldRect = () => pointer ? { x: pointer.x - at.x, y: pointer.y - at.y, width: size.width, height: size.height } : null;
+  const same2 = (a, b) => Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y), Math.abs(a.width - b.width), Math.abs(a.height - b.height)) < 0.01;
+  const snapTo = (slot) => {
+    if (slot) {
+      if (snapped && same2(snapped, slot)) return null;
+      snapped = { ...slot };
+      returning = false;
+      item.moveTo(slot);
+      return "snapped";
+    }
+    if (!snapped) return null;
+    snapped = null;
+    returning = true;
+    return "left";
+  };
+  const follow = () => {
+    const goal = heldRect();
+    if (!returning || !goal) return false;
+    item.moveTo(goal);
+    const d = item.drawn;
+    if (Math.max(Math.abs(d.x - goal.x), Math.abs(d.y - goal.y), Math.abs(d.width - goal.width), Math.abs(d.height - goal.height)) >= CAUGHT) return false;
+    returning = false;
+    item.hold(goal);
+    return true;
+  };
+  const letGo = (to) => {
+    const release = { ...item.drawn };
+    snapped = null;
+    returning = false;
+    item.moveTo(to);
+    return release;
+  };
+  return {
+    get pointer() {
+      return pointer;
+    },
+    get held() {
+      return heldRect();
+    },
+    get snapped() {
+      return snapped;
+    },
+    get returning() {
+      return returning;
+    },
+    move(p) {
+      pointer = { x: p.x, y: p.y };
+      if (snapped || returning) return;
+      item.hold(heldRect());
+    },
+    snapTo,
+    follow,
+    preview(plan, slot) {
+      const change = snapTo(plan.snapItem && slot ? slot : null);
+      follow();
+      return change;
+    },
+    resize(next) {
+      if (Math.abs(next.width - size.width) < 0.01 && Math.abs(next.height - size.height) < 0.01) return false;
+      at = { x: size.width ? at.x / size.width * next.width : 0, y: size.height ? at.y / size.height * next.height : 0 };
+      size = { width: next.width, height: next.height };
+      if (!snapped && pointer) {
+        returning = true;
+        follow();
+      }
+      return true;
+    },
+    land: letGo,
+    cancel: letGo
+  };
+}
+
+// src/layout/flip.ts
+var rectOf = (r) => ({ x: r.left, y: r.top, width: r.width, height: r.height });
+function flip(entries, change) {
+  const before = entries.map((e) => rectOf(e.node.getBoundingClientRect()));
+  change();
+  entries.forEach((e, i) => {
+    const { from, to } = e.place(before[i]);
+    e.item.glideFrom(from, to);
+  });
+}
+
+// src/layout/dom.ts
+function layOutBox(node, box) {
+  const s = node.style;
+  s.left = `${box.x}px`;
+  s.top = `${box.y}px`;
+  s.width = `${box.width}px`;
+  s.height = `${box.height}px`;
+}
+function drawBox(nodes, frame) {
+  const { reveal: r, pop } = frame;
+  const cx = frame.drawn.width / 2;
+  const cy = frame.drawn.height / 2;
+  const s = nodes.node.style;
+  s.transform = pop.scale === 1 ? `translate(${r.dx}px, ${r.dy}px)` : `translate(${r.dx}px, ${r.dy}px) translate(${cx}px, ${cy}px) scale(${pop.scale}) translate(${-cx}px, ${-cy}px)`;
+  s.opacity = pop.opacity === 1 ? "" : String(pop.opacity);
+  if (nodes.frame) {
+    nodes.frame.style.width = `${r.width}px`;
+    nodes.frame.style.height = `${r.height}px`;
+  }
+  const clipped = nodes.content ?? (nodes.frame ? null : nodes.node);
+  if (clipped) clipped.style.clipPath = r.clipRight || r.clipBottom ? `inset(0 ${r.clipRight}px ${r.clipBottom}px 0)` : "";
+  s.visibility = frame.gone ? "hidden" : "";
+}
+function domDrawable(nodes) {
+  return {
+    layOut: (box) => layOutBox(nodes.node, box),
+    draw: (frame) => drawBox(nodes, frame)
+  };
+}
+export {
+  createLayoutMotion,
+  domDrawable,
+  drawBox,
+  flip,
+  holdItem,
+  layOutBox,
+  rectOf
+};
+//# sourceMappingURL=layout.js.map