@kyralabs/m3e-motion 1.4.0 → 1.6.0

package/dist/index.js

@@ -379,16 +379,17 @@ var SpringAnimatable = class {
   }
   /**
    * Animates to `target` from the value and velocity at `now` (ms); a null spec (e.g. a spatial
-   * spring under reduced motion) jumps there.
+   * spring under reduced motion) jumps there. `velocity` (units per second) overrides the current
+   * velocity, e.g. after the value was driven by something else (a drag, a tween).
    */
-  animateTo(target, spec, now) {
+  animateTo(target, spec, now, velocity) {
     this.sample(now);
     if (spec === null) {
       this.snapTo(target);
       return;
     }
     this.#from = this.#value;
-    this.#velocity0 = this.#velocity;
+    this.#velocity0 = velocity ?? this.#velocity;
     this.#target = target;
     this.#start = now;
     this.#spec = spec;
@@ -437,8 +438,21 @@ function menuNavigationTarget(key, count, current) {
   }
 }
 
+// src/type-select.ts
+var TYPEAHEAD_TIMEOUT_MS = 1e3;
+var collator;
+function typeSelectTarget(texts, from, search) {
+  collator ??= new Intl.Collator(void 0, { usage: "search", sensitivity: "base" });
+  const compare = collator;
+  const matches = (text) => text !== "" && compare.compare(text.slice(0, search.length), search) === 0;
+  const start = Math.max(from, 0);
+  for (let i = start; i < texts.length; i++) if (matches(texts[i] ?? "")) return i;
+  for (let i = 0; i < start; i++) if (matches(texts[i] ?? "")) return i;
+  return -1;
+}
+
 // src/toolbar-navigation.ts
-function toolbarNavigationTarget(key, count, current, orientation = "horizontal", rtl = false) {
+function toolbarNavigationTarget(key, count, current, orientation = "horizontal", rtl = false, wrap = false) {
   if (count === 0) return null;
   let step;
   switch (key) {
@@ -448,19 +462,21 @@ function toolbarNavigationTarget(key, count, current, orientation = "horizontal"
       return count - 1;
     case "ArrowRight":
     case "ArrowLeft":
-      if (orientation !== "horizontal") return null;
+      if (orientation === "vertical") return null;
       step = key === "ArrowRight" !== rtl ? 1 : -1;
       break;
     case "ArrowDown":
     case "ArrowUp":
-      if (orientation !== "vertical") return null;
+      if (orientation === "horizontal") return null;
       step = key === "ArrowDown" ? 1 : -1;
       break;
     default:
       return null;
   }
   if (current < 0) return step > 0 ? 0 : count - 1;
-  return Math.min(Math.max(current + step, 0), count - 1);
+  const next = current + step;
+  if (wrap) return (next + count) % count;
+  return Math.min(Math.max(next, 0), count - 1);
 }
 
 // src/cubic-bezier.ts
@@ -1031,6 +1047,1403 @@ function buttonGroupWidths(items, pressed, expandedRatio, visibleCount = items.l
   return widths.slice(0, last);
 }
 
-export { AmplitudeAnimation, DEFAULT_DISPLACEMENT_THRESHOLD, FAST_OUT_LINEAR_IN_EASING, SEARCH_BAR_EXPANDED_THRESHOLD, SEARCH_DROPDOWN_VISIBLE_PROGRESS, SearchBarAnimation, SpringAnimatable, SpringSimulation, TOP_TITLE_ALPHA_EASING, TweenAnimatable, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, circularIndeterminateFrame, collapsedFraction, cubicBezier, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, fabMenuItemVisible, floatingToolbarScrollState, indeterminateFrame, indicatorAmplitude, initialIndeterminateFrame, isScrolledUnder, linearIndeterminateFractions, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, overlappedFraction, parseCubicBezier, scrollAppBar, scrollFloatingToolbar, scrollToolbarExpansion, searchNavigationTarget, searchViewFrame, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, waveOffset, waveTravelMillis, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };
+// src/window-size-class.ts
+var WINDOW_WIDTH_BREAKPOINTS = /* @__PURE__ */ Object.freeze({
+  compact: 0,
+  medium: 600,
+  expanded: 840,
+  large: 1200,
+  "extra-large": 1600
+});
+var WINDOW_HEIGHT_BREAKPOINTS = /* @__PURE__ */ Object.freeze({ compact: 0, medium: 480, expanded: 900 });
+var WIDTH_CLASSES = [
+  "compact",
+  "medium",
+  "expanded",
+  "large",
+  "extra-large"
+];
+var HEIGHT_CLASSES = ["compact", "medium", "expanded"];
+function bucket(size, compact, classes, bounds) {
+  let match = compact;
+  for (const c of classes) if (size >= bounds[c]) match = c;
+  return match;
+}
+function windowWidthSizeClass(widthPx, options = {}) {
+  const classes = options.largeAndExtraLargeWidth === false ? WIDTH_CLASSES.slice(0, 3) : WIDTH_CLASSES;
+  return bucket(widthPx, "compact", classes, WINDOW_WIDTH_BREAKPOINTS);
+}
+function windowHeightSizeClass(heightPx) {
+  return bucket(heightPx, "compact", HEIGHT_CLASSES, WINDOW_HEIGHT_BREAKPOINTS);
+}
+function windowSizeClass(size, options = {}) {
+  const widthClass = windowWidthSizeClass(size.width, options);
+  const heightClass = windowHeightSizeClass(size.height);
+  return {
+    widthClass,
+    heightClass,
+    minWidth: WINDOW_WIDTH_BREAKPOINTS[widthClass],
+    minHeight: WINDOW_HEIGHT_BREAKPOINTS[heightClass]
+  };
+}
+function sameWindowSizeClass(a, b) {
+  return a.minWidth === b.minWidth && a.minHeight === b.minHeight;
+}
+var widthBound = (b) => typeof b === "number" ? b : WINDOW_WIDTH_BREAKPOINTS[b];
+var heightBound = (b) => typeof b === "number" ? b : WINDOW_HEIGHT_BREAKPOINTS[b];
+function isWidthAtLeastBreakpoint(sizeClass, breakpoint) {
+  return sizeClass.minWidth >= widthBound(breakpoint);
+}
+function isHeightAtLeastBreakpoint(sizeClass, breakpoint) {
+  return sizeClass.minHeight >= heightBound(breakpoint);
+}
+function isAtLeastBreakpoint(sizeClass, widthBreakpoint, heightBreakpoint) {
+  return isWidthAtLeastBreakpoint(sizeClass, widthBreakpoint) && isHeightAtLeastBreakpoint(sizeClass, heightBreakpoint);
+}
+var PARTITION_SPACER = 24;
+var DEFAULT_PREFERRED_WIDTH = 360;
+var DEFAULT_PREFERRED_WIDTH_XL = 412;
+var DEFAULT_PREFERRED_HEIGHT = 420;
+function paneScaffoldDirective(sizeClass, options = {}) {
+  let maxHorizontalPartitions;
+  let horizontalPartitionSpacerSize;
+  let defaultPanePreferredWidth;
+  switch (sizeClass.minWidth) {
+    case WINDOW_WIDTH_BREAKPOINTS.compact:
+    case WINDOW_WIDTH_BREAKPOINTS.medium:
+      maxHorizontalPartitions = 1;
+      horizontalPartitionSpacerSize = 0;
+      defaultPanePreferredWidth = DEFAULT_PREFERRED_WIDTH;
+      break;
+    case WINDOW_WIDTH_BREAKPOINTS.expanded:
+      maxHorizontalPartitions = 2;
+      horizontalPartitionSpacerSize = PARTITION_SPACER;
+      defaultPanePreferredWidth = DEFAULT_PREFERRED_WIDTH;
+      break;
+    default:
+      maxHorizontalPartitions = 3;
+      horizontalPartitionSpacerSize = PARTITION_SPACER;
+      defaultPanePreferredWidth = DEFAULT_PREFERRED_WIDTH_XL;
+  }
+  const stacked = options.isTabletop === true || maxHorizontalPartitions === 1 && sizeClass.minHeight === WINDOW_HEIGHT_BREAKPOINTS.expanded;
+  return {
+    maxHorizontalPartitions,
+    horizontalPartitionSpacerSize,
+    maxVerticalPartitions: stacked ? 2 : 1,
+    verticalPartitionSpacerSize: stacked ? PARTITION_SPACER : 0,
+    defaultPanePreferredWidth,
+    defaultPanePreferredHeight: DEFAULT_PREFERRED_HEIGHT
+  };
+}
+var NAVIGATION_SUITE_TYPES = [
+  "short-navigation-bar-compact",
+  "short-navigation-bar-medium",
+  "wide-navigation-rail-collapsed",
+  "wide-navigation-rail-expanded",
+  "navigation-drawer",
+  "none"
+];
+function isNavigationBarType(type) {
+  return type === "short-navigation-bar-compact" || type === "short-navigation-bar-medium";
+}
+var NAVIGATION_SUITE_EXPANDED_FROM = "large";
+function navigationSuiteType(sizeClass, options = {}) {
+  if (sizeClass.minWidth === WINDOW_WIDTH_BREAKPOINTS.compact)
+    return "short-navigation-bar-compact";
+  if (options.isTabletop === true || sizeClass.minHeight === WINDOW_HEIGHT_BREAKPOINTS.compact) {
+    return "short-navigation-bar-medium";
+  }
+  const { expandedFrom } = options;
+  if (expandedFrom !== void 0 && expandedFrom !== null && isWidthAtLeastBreakpoint(sizeClass, expandedFrom)) {
+    return options.expandedType ?? "wide-navigation-rail-expanded";
+  }
+  return "wide-navigation-rail-collapsed";
+}
+
+// src/navigation-suite.ts
+var HIDDEN = 0;
+var VISIBLE = 1;
+var NavigationSuiteScaffoldAnimation = class {
+  #state;
+  #progress;
+  #spec = null;
+  /** `hidden`: rememberNavigationSuiteScaffoldState(initialValue = Hidden); rendered at rest. */
+  constructor(hidden = false) {
+    const value = hidden ? HIDDEN : VISIBLE;
+    this.#state = new SpringAnimatable(value);
+    this.#progress = new SpringAnimatable(value);
+  }
+  /** NavigationSuiteScaffoldState.targetValue == Hidden. */
+  get targetHidden() {
+    return this.#state.target !== VISIBLE;
+  }
+  /** NavigationSuiteScaffoldState.currentValue == Hidden (anything but exactly Visible). */
+  get currentHidden() {
+    return this.#state.value !== VISIBLE;
+  }
+  /** NavigationSuiteScaffoldState.isAnimating (the state's spring, not the layout's). */
+  get isAnimating() {
+    return this.#state.isRunning;
+  }
+  /** NavigationSuiteScaffoldState.hide(). */
+  hide(spec, now) {
+    this.#animate(HIDDEN, spec, now);
+  }
+  /** NavigationSuiteScaffoldState.show(). */
+  show(spec, now) {
+    this.#animate(VISIBLE, spec, now);
+  }
+  /** NavigationSuiteScaffoldState.toggle(): towards the opposite of the target. */
+  toggle(spec, now) {
+    this.#animate(this.targetHidden ? VISIBLE : HIDDEN, spec, now);
+  }
+  /** NavigationSuiteScaffoldState.snapTo(): the state jumps; the layout animates from `now`. */
+  snapTo(hidden, spec, now) {
+    this.#spec = spec;
+    this.#state.snapTo(hidden ? HIDDEN : VISIBLE);
+    this.sample(now);
+  }
+  #animate(target, spec, now) {
+    this.#spec = spec;
+    this.#state.animateTo(target, spec, now);
+    this.sample(now);
+  }
+  /** Advances both springs to `now`; the layout retargets when currentValue changes. */
+  sample(now) {
+    this.#state.sample(now);
+    const target = this.currentHidden ? HIDDEN : VISIBLE;
+    if (this.#progress.target !== target) this.#progress.animateTo(target, this.#spec, now);
+    const progress = this.#progress.sample(now);
+    return { progress, running: this.#state.isRunning || this.#progress.isRunning };
+  }
+};
+function navigationSuiteOffset(size, progress) {
+  return size - Math.trunc(size * progress);
+}
+
+// src/wide-navigation-rail.ts
+var MODAL_RAIL_EXPANDED_PROGRESS = 0.3;
+var to = (expanded) => expanded ? 1 : 0;
+var WideNavigationRailAnimation = class {
+  modal;
+  hideOnCollapse;
+  #expanded;
+  #item;
+  #width;
+  #layout;
+  #position;
+  #scrim = new SpringAnimatable(0);
+  #slide;
+  #specs = null;
+  #open = false;
+  #modalExpanded = false;
+  /** hideOnCollapse: positionProgress waits for the slide out (animateToDismiss). */
+  #closeAfterSlide = false;
+  constructor(options) {
+    this.modal = Boolean(options.modal);
+    this.hideOnCollapse = this.modal && Boolean(options.hideOnCollapse);
+    this.#expanded = options.expanded;
+    const v = to(options.expanded);
+    const laidOut = this.hideOnCollapse ? 1 : this.modal ? options.expanded ? 1 : 0 : v;
+    this.#item = new SpringAnimatable(this.hideOnCollapse ? 1 : v);
+    this.#width = new SpringAnimatable(laidOut, options.widthThreshold ?? 0.01 / 264);
+    this.#layout = new SpringAnimatable(laidOut, options.layoutThreshold ?? 0.01 / 16);
+    this.#position = new SpringAnimatable(this.modal ? v : 0);
+    this.#slide = new SpringAnimatable(v, 0.01 / 360);
+    if (this.modal && options.expanded) {
+      this.#open = true;
+      this.#modalExpanded = true;
+      this.#scrim.snapTo(1);
+    }
+  }
+  /** WideNavigationRailState.targetValue. */
+  get expanded() {
+    return this.#expanded;
+  }
+  get isRunning() {
+    return this.#item.isRunning || this.#width.isRunning || this.#layout.isRunning || this.#position.isRunning || this.#scrim.isRunning || this.#slide.isRunning || this.#closeAfterSlide;
+  }
+  /** expand() / collapse() at `now` (ms). */
+  setExpanded(expanded, specs, now) {
+    this.sample(now);
+    this.#specs = specs;
+    if (expanded === this.#expanded) return;
+    this.#expanded = expanded;
+    const v = to(expanded);
+    if (!this.modal) {
+      this.#item.animateTo(v, specs.iconPosition, now);
+      this.#width.animateTo(v, specs.width, now);
+      this.#layout.animateTo(v, specs.width, now);
+      return;
+    }
+    if (this.hideOnCollapse) {
+      this.#slide.animateTo(v, specs.slide, now);
+      this.#scrim.animateTo(v, specs.scrim, now);
+      if (expanded) {
+        this.#closeAfterSlide = false;
+        this.#position.animateTo(1, specs.position, now);
+      } else {
+        this.#closeAfterSlide = true;
+      }
+      this.sample(now);
+      return;
+    }
+    this.#item.animateTo(v, specs.iconPosition, now);
+    this.#position.animateTo(v, specs.position, now);
+    this.sample(now);
+  }
+  /** WideNavigationRailState.snapTo. */
+  snapTo(expanded) {
+    this.#expanded = expanded;
+    const v = to(expanded);
+    this.#closeAfterSlide = false;
+    if (!this.modal) {
+      for (const a of [this.#item, this.#width, this.#layout]) a.snapTo(v);
+      return;
+    }
+    this.#position.snapTo(v);
+    this.#slide.snapTo(v);
+    this.#scrim.snapTo(v);
+    this.#open = expanded;
+    this.#modalExpanded = expanded;
+    if (!this.hideOnCollapse) {
+      for (const a of [this.#item, this.#width, this.#layout]) a.snapTo(v);
+    }
+  }
+  sample(now) {
+    const item = this.#item.sample(now);
+    if (this.modal) this.#sampleModal(now);
+    const width = this.#width.sample(now);
+    const layout = this.#layout.sample(now);
+    return {
+      item: Math.max(item, 0),
+      // iconPositionProgress.coerceAtLeast(0f) (NavigationItem.kt L544)
+      width,
+      layout,
+      open: this.#open,
+      railExpanded: !this.modal ? this.#expanded : this.#open && (this.hideOnCollapse || this.#modalExpanded),
+      scrim: Math.min(Math.max(this.#scrim.value, 0), 1),
+      slide: this.#slide.value,
+      running: this.isRunning
+    };
+  }
+  #sampleModal(now) {
+    const specs = this.#specs;
+    if (this.hideOnCollapse) {
+      this.#slide.sample(now);
+      this.#scrim.sample(now);
+      if (this.#closeAfterSlide && !this.#slide.isRunning) {
+        this.#closeAfterSlide = false;
+        this.#position.animateTo(0, specs?.position ?? null, now);
+      }
+      this.#open = this.#position.sample(now) > 0;
+      return;
+    }
+    const position = this.#position.sample(now);
+    const open = position > 0;
+    const modalExpanded = position >= MODAL_RAIL_EXPANDED_PROGRESS;
+    if (!open) {
+      this.#width.snapTo(0);
+      this.#layout.snapTo(0);
+      this.#scrim.snapTo(0);
+    } else if (!this.#open) {
+      const v = to(modalExpanded);
+      this.#width.snapTo(v);
+      this.#layout.snapTo(v);
+      this.#scrim.snapTo(v);
+    } else if (modalExpanded !== this.#modalExpanded) {
+      const v = to(modalExpanded);
+      this.#width.animateTo(v, specs?.modalWidth ?? null, now);
+      this.#layout.animateTo(v, specs?.width ?? null, now);
+      this.#scrim.animateTo(v, specs?.scrim ?? null, now);
+    }
+    this.#scrim.sample(now);
+    this.#open = open;
+    this.#modalExpanded = open && modalExpanded;
+  }
+};
+var lerp2 = (a, b, t) => a + (b - a) * t;
+function wideNavigationRailItemWidth(content, progress, m, maxWidth) {
+  const pad = m.itemHorizontalPadding;
+  const indicatorPadding = lerp2(m.collapsedIndicatorPadding, m.expandedIndicatorPadding, progress);
+  if (content === null)
+    return Math.min(m.iconSize + 2 * m.collapsedIndicatorPadding + 2 * pad, maxWidth);
+  const gapAndLabel = content - m.iconSize - 2 * m.expandedIndicatorPadding;
+  const label = gapAndLabel - m.iconLabelSpace;
+  const widthTop = Math.min(Math.max(label, m.iconSize + 2 * pad + 2 * indicatorPadding), maxWidth);
+  const ripple = lerp2(m.iconSize, m.iconSize + gapAndLabel, progress) + 2 * indicatorPadding;
+  const widthStart = Math.min(ripple + pad, maxWidth);
+  return widthTop + (widthStart - widthTop) * progress;
+}
+function wideNavigationRailWidth(input) {
+  const m = input.metrics;
+  const max = Math.min(input.maxWidth ?? m.expandedMaxWidth, m.expandedMaxWidth);
+  const minWidth = Math.min(lerp2(m.collapsedWidth, m.expandedMinWidth, input.widthProgress), max);
+  const fullRange = lerp2(m.collapsedWidth, m.expandedMaxWidth, input.widthProgress);
+  const expandedMin = Math.min(m.expandedMinWidth, max);
+  if (input.expanded) {
+    const itemMax = max - m.itemHorizontalPadding;
+    let widestItem = 0;
+    for (const content of input.items) {
+      const w = wideNavigationRailItemWidth(content, input.itemProgress, m, itemMax);
+      widestItem = Math.max(widestItem, w + m.itemHorizontalPadding);
+    }
+    const widest = Math.max(widestItem, input.header);
+    if (widest > minWidth && widest > expandedMin) {
+      const constrain = Math.min(Math.max(widest, expandedMin), max);
+      return { width: Math.min(fullRange, constrain), wide: true };
+    }
+    return { width: minWidth, wide: input.wide };
+  }
+  if (input.wide) {
+    const upper = Math.max(input.previousWidth, minWidth);
+    return { width: Math.min(Math.max(fullRange, minWidth), upper), wide: true };
+  }
+  return { width: minWidth, wide: false };
+}
+
+// src/navigation-drawer.ts
+var DRAWER_POSITIONAL_THRESHOLD = 0.5;
+var DRAWER_VELOCITY_THRESHOLD = 400;
+var DRAWER_SETTLE_MILLIS = 256;
+var DECAY_FRICTION = -4.2;
+var DECAY_VELOCITY_THRESHOLD = 0.1;
+function exponentialDecayTarget(value, velocity) {
+  if (Math.abs(velocity) <= DECAY_VELOCITY_THRESHOLD) return value;
+  const duration = Math.log(Math.abs(DECAY_VELOCITY_THRESHOLD / velocity)) / DECAY_FRICTION * 1e3;
+  return value - velocity / DECAY_FRICTION + velocity / DECAY_FRICTION * Math.exp(DECAY_FRICTION * duration / 1e3);
+}
+function drawerSettlesOpen(offset, velocity, width, velocityThreshold = DRAWER_VELOCITY_THRESHOLD) {
+  const closed = -width;
+  if (velocity === 0) return Math.abs(offset) <= Math.abs(offset - closed);
+  const forward = velocity > 0;
+  if (Math.abs(velocity) >= Math.abs(velocityThreshold)) return forward;
+  const threshold = Math.abs(width * DRAWER_POSITIONAL_THRESHOLD);
+  const fromStart = Math.abs((forward ? closed : 0) - offset);
+  return fromStart >= threshold ? forward : !forward;
+}
+var DrawerAnimation = class {
+  #width;
+  #open;
+  #settled;
+  #mode = "rest";
+  #spring;
+  #offset;
+  #velocity = 0;
+  // Tween / decay state.
+  #from = 0;
+  #to = 0;
+  #v0 = 0;
+  #start = 0;
+  #duration = 0;
+  #easing = (t) => t;
+  /** @param open initial value (at rest); @param width the sheet width in px. */
+  constructor(open, width) {
+    this.#width = Math.max(0, width);
+    this.#open = open;
+    this.#settled = open;
+    this.#offset = open ? 0 : -this.#width;
+    this.#spring = new SpringAnimatable(this.#offset);
+  }
+  /** DrawerState.targetValue === Open. */
+  get isOpen() {
+    return this.#open;
+  }
+  /** DrawerState.currentValue === Open: the last anchor it settled on. */
+  get isSettledOpen() {
+    return this.#settled;
+  }
+  get isDragging() {
+    return this.#mode === "drag";
+  }
+  get width() {
+    return this.#width;
+  }
+  /** Units: px per second, positive towards open (AnchoredDraggableState.lastVelocity). */
+  get velocity() {
+    return this.#velocity;
+  }
+  /** New anchors (the sheet was measured): at rest the offset follows its anchor. */
+  setWidth(width) {
+    const w = Math.max(0, width);
+    if (w === this.#width) return;
+    const previous = this.#width;
+    this.#width = w;
+    if (this.#mode === "rest") {
+      this.#offset = this.#open ? 0 : -w;
+      this.#spring.snapTo(this.#offset);
+    } else if (this.#mode !== "drag" && !this.#open && this.#to === -previous) {
+      this.#to = -w;
+    }
+  }
+  /** Jumps (DrawerState.snapTo). */
+  snapTo(open) {
+    this.#mode = "rest";
+    this.#open = open;
+    this.#settled = open;
+    this.#offset = open ? 0 : -this.#width;
+    this.#velocity = 0;
+    this.#spring.snapTo(this.#offset);
+  }
+  /** DrawerState.open() / close() at `now` (ms): springs from the current offset and velocity. */
+  animateTo(open, specs, now) {
+    this.sample(now);
+    if (this.#mode === "drag") this.#mode = "rest";
+    this.#open = open;
+    const target = open ? 0 : -this.#width;
+    const spec = open ? specs.open : specs.close;
+    if (spec === null || this.#offset === target && this.#velocity === 0) {
+      this.snapTo(open);
+      return;
+    }
+    const velocity = this.#velocity;
+    this.#spring.snapTo(this.#offset);
+    this.#spring.animateTo(target, spec, now, velocity);
+    if (this.#spring.isRunning) this.#mode = "spring";
+    else this.snapTo(open);
+  }
+  /** Grabs the sheet (pointer down past the slop): stops any animation where it is. */
+  startDrag(now) {
+    this.sample(now);
+    this.#mode = "drag";
+    this.#velocity = 0;
+  }
+  /** Moves the offset by `delta` px (positive towards open), coerced between the anchors. */
+  dragBy(delta) {
+    if (this.#mode !== "drag") return;
+    this.#offset = Math.min(0, Math.max(-this.#width, this.#offset + delta));
+  }
+  /**
+   * Ends a drag with the pointer `velocity` (px/s, positive towards open): picks the target
+   * (computeTarget) and settles on it (animateToWithDecay). Returns whether it settles open.
+   * `velocityThreshold`: DrawerVelocityThreshold in px/s.
+   */
+  release(velocity, specs, now, velocityThreshold = DRAWER_VELOCITY_THRESHOLD, confirm = () => true) {
+    if (this.#mode !== "drag") return this.#open;
+    const proposed = drawerSettlesOpen(this.#offset, velocity, this.#width, velocityThreshold);
+    const open = proposed === this.#settled || confirm(proposed) ? proposed : this.#settled;
+    this.#open = open;
+    const target = open ? 0 : -this.#width;
+    const prev = this.#offset;
+    this.#start = now;
+    this.#from = prev;
+    this.#to = target;
+    this.#v0 = velocity;
+    this.#velocity = velocity;
+    if (prev === target) {
+      this.snapTo(open);
+      return open;
+    }
+    const towards = velocity * (target - prev) > 0;
+    if (towards) {
+      const projected = exponentialDecayTarget(prev, velocity);
+      if (velocity > 0 ? projected >= target : projected <= target) {
+        this.#mode = "decay";
+        this.#duration = 1e3 * Math.log(DECAY_VELOCITY_THRESHOLD / Math.abs(velocity)) / DECAY_FRICTION;
+        return open;
+      }
+    }
+    if (specs.settle === null || specs.settle.duration <= 0) {
+      this.snapTo(open);
+      return open;
+    }
+    this.#mode = "tween";
+    this.#duration = specs.settle.duration;
+    this.#easing = specs.settle.easing;
+    return open;
+  }
+  /** Advances to `now` (ms). */
+  sample(now) {
+    switch (this.#mode) {
+      case "spring": {
+        this.#offset = this.#spring.sample(now);
+        this.#velocity = this.#spring.velocity;
+        if (!this.#spring.isRunning) this.#settle();
+        break;
+      }
+      case "tween": {
+        const elapsed = now - this.#start;
+        if (elapsed >= this.#duration) {
+          this.#settle();
+          break;
+        }
+        const f = (t) => {
+          const p = Math.min(1, Math.max(0, t / this.#duration));
+          return this.#from + (this.#to - this.#from) * this.#easing(p);
+        };
+        const value = f(elapsed);
+        this.#velocity = (f(elapsed + 1) - value) * 1e3;
+        this.#offset = value;
+        break;
+      }
+      case "decay": {
+        const t = (now - this.#start) / 1e3;
+        const value = this.#from - this.#v0 / DECAY_FRICTION + this.#v0 / DECAY_FRICTION * Math.exp(DECAY_FRICTION * t);
+        const crossed = this.#v0 > 0 ? value >= this.#to : value <= this.#to;
+        if (crossed || now - this.#start >= this.#duration) {
+          this.#settle();
+          break;
+        }
+        this.#offset = value;
+        this.#velocity = this.#v0 * Math.exp(DECAY_FRICTION * t);
+        break;
+      }
+    }
+    const w = this.#width;
+    const fraction = w <= 0 ? this.#open ? 1 : 0 : Math.min(1, Math.max(0, (this.#offset + w) / w));
+    return {
+      offset: this.#offset,
+      fraction,
+      running: this.#mode !== "rest",
+      visible: fraction !== 0
+    };
+  }
+  #settle() {
+    this.#mode = "rest";
+    this.#offset = this.#open ? 0 : -this.#width;
+    this.#velocity = 0;
+    this.#settled = this.#open;
+    this.#spring.snapTo(this.#offset);
+  }
+};
+
+// src/slider.ts
+var SLIDER_KEY_DIVISIONS = 100;
+var SLIDER_PAGE_DIVISOR = 10;
+var SLIDER_PAGE_MAX_STEPS = 10;
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+var lerp3 = (a, b, t) => a + (b - a) * t;
+function sliderSteps(min, max, step) {
+  if (step === void 0 || !(step > 0) || !(max > min)) return 0;
+  return Math.max(0, Math.round((max - min) / step) - 1);
+}
+function sliderTickFractions(steps) {
+  if (steps <= 0) return [];
+  return Array.from({ length: steps + 2 }, (_, i) => i / (steps + 1));
+}
+function sliderFraction(value, min, max) {
+  return clamp(max - min === 0 ? 0 : (value - min) / (max - min), 0, 1);
+}
+var sliderValueAt = (fraction, min, max) => lerp3(min, max, fraction);
+function sliderSnap(value, steps, min, max) {
+  const ticks = sliderTickFractions(steps);
+  if (ticks.length === 0) return value;
+  let best = value;
+  let distance = Infinity;
+  for (const t of ticks) {
+    const v = lerp3(min, max, t);
+    const d = Math.abs(v - value);
+    if (d < distance) {
+      distance = d;
+      best = v;
+    }
+  }
+  return best;
+}
+function sliderThumbValue(value, bounds, steps, min, max) {
+  return sliderSnap(clamp(value, bounds.min, bounds.max), steps, min, max);
+}
+function sliderThumbBounds(values, index, min, max) {
+  return {
+    min: index > 0 ? values[index - 1] ?? min : min,
+    max: index < values.length - 1 ? values[index + 1] ?? max : max
+  };
+}
+function sliderKeyDelta(steps, min, max) {
+  const actual = steps > 0 ? steps + 1 : SLIDER_KEY_DIVISIONS;
+  return Math.abs(max - min) / actual;
+}
+function sliderPageSteps(steps) {
+  const actual = steps > 0 ? steps + 1 : SLIDER_KEY_DIVISIONS;
+  return clamp(Math.floor(actual / SLIDER_PAGE_DIVISOR), 1, SLIDER_PAGE_MAX_STEPS);
+}
+function sliderKeyAction(key, options = {}) {
+  const { vertical = false, rtl = false, shiftKey = false } = options;
+  const page = (up) => shiftKey ? up ? "page-increment" : "page-decrement" : up ? "increment" : "decrement";
+  switch (key) {
+    case "ArrowUp":
+      return page(true);
+    case "ArrowDown":
+      return page(false);
+    case "ArrowRight":
+      return page(vertical || !rtl);
+    case "ArrowLeft":
+      return page(!(vertical || !rtl));
+    case "PageUp":
+      return "page-increment";
+    case "PageDown":
+      return "page-decrement";
+    case "Home":
+      return "min";
+    case "End":
+      return "max";
+    default:
+      return null;
+  }
+}
+function sliderKeyValue(action, values, index, steps, min, max) {
+  const value = values[index] ?? min;
+  const bounds = sliderThumbBounds(values, index, min, max);
+  const delta = sliderKeyDelta(steps, min, max);
+  const page = sliderPageSteps(steps) * delta;
+  const target = action === "increment" ? value + delta : action === "decrement" ? value - delta : action === "page-increment" ? value + page : action === "page-decrement" ? value - page : action === "min" ? bounds.min : bounds.max;
+  return sliderThumbValue(target, bounds, steps, min, max);
+}
+function sliderClosestThumb(values, value) {
+  const [start, end] = values;
+  if (start === void 0 || end === void 0) return 0;
+  const diffStart = Math.abs(start - value);
+  const diffEnd = Math.abs(end - value);
+  if (diffStart !== diffEnd) return diffStart < diffEnd ? 0 : 1;
+  return start > value ? 0 : 1;
+}
+function sliderTrackGeometry(input) {
+  const {
+    length,
+    cornerSize: c,
+    insideCornerSize: inside,
+    thumbWidth,
+    gapSize,
+    steps,
+    fraction,
+    centered = false,
+    cornerShrinking = false,
+    stopIndicator = true
+  } = input;
+  const range = input.startFraction !== void 0;
+  const ticks = sliderTickFractions(steps);
+  const onEdge = (f) => f === ticks[0] || f === ticks[ticks.length - 1];
+  const position = (f) => ticks.length > 0 && !onEdge(f) ? (length - c * 2) * f + c : length * f;
+  const end = position(fraction);
+  const start = range ? position(input.startFraction) : 0;
+  const centre = length / 2;
+  const before = fraction < 0.5;
+  const after = fraction > 0.5;
+  const startThumb = centered ? !after ? thumbWidth : 0 : range ? thumbWidth : 0;
+  const endThumb = centered ? !before ? thumbWidth : 0 : thumbWidth;
+  const startGapSize = centered || range ? gapSize : 0;
+  const startGap = startGapSize > 0 ? startThumb / 2 + startGapSize : 0;
+  const endGap = gapSize > 0 ? endThumb / 2 + gapSize : 0;
+  const thresholdCorner = !cornerShrinking || ticks.length > 0;
+  const parts = [];
+  const stops = [];
+  const adjustedEnd = centered ? Math.min(end, centre) : start;
+  const rangeThreshold = startGap + (thresholdCorner ? c : 0);
+  if ((centered || range) && adjustedEnd > rangeThreshold) {
+    parts.push({
+      kind: "inactive-start",
+      start: 0,
+      end: adjustedEnd - startGap,
+      startRadius: c,
+      endRadius: inside
+    });
+    if (stopIndicator) stops.push(c);
+  }
+  const adjustedStart = centered ? Math.max(end, centre) : end;
+  const inactiveThreshold = length - endGap - (thresholdCorner ? c : 0);
+  if (adjustedStart < inactiveThreshold) {
+    parts.push({
+      kind: "inactive-end",
+      start: adjustedStart + endGap,
+      end: length,
+      startRadius: inside,
+      endRadius: c
+    });
+    if (stopIndicator) stops.push(length - c);
+  }
+  const activeStart = centered ? adjustedEnd + (adjustedEnd < centre ? startGap : 0) : range ? start + startGap : 0;
+  const activeEnd = centered ? adjustedStart - (adjustedStart > centre ? endGap : 0) : end - endGap;
+  const activeStartRadius = centered || range ? inside : c;
+  const activeThreshold = thresholdCorner ? activeStartRadius : 0;
+  if (activeEnd - activeStart > activeThreshold) {
+    parts.push({
+      kind: "active",
+      start: activeStart,
+      end: activeEnd,
+      startRadius: activeStartRadius,
+      endRadius: inside
+    });
+  }
+  const tickList = [];
+  const centreGap = centered ? end > centre ? startGap : endGap : 0;
+  const thumbGap = centered ? end > centre ? endGap : startGap : endGap;
+  ticks.forEach((t, i) => {
+    if (stopIndicator && ((centered || range) && i === 0 || i === ticks.length - 1)) return;
+    const p = lerp3(c, length - c, t);
+    const within = (centreOf, gap) => p >= centreOf - gap && p <= centreOf + gap;
+    if (centered && within(centre, centreGap) || range && within(start, startGap) || within(end, thumbGap)) {
+      return;
+    }
+    tickList.push({ position: p, active: p >= activeStart && p <= activeEnd });
+  });
+  return { thumbs: range ? [start, end] : [end], parts, stops, ticks: tickList };
+}
+
+// src/tabs.ts
+var TAB_INDICATOR_MIN_WIDTH = 24;
+var THRESHOLD = 0.01;
+function tabPositions(tabs, start = 0, minIndicatorWidth = TAB_INDICATOR_MIN_WIDTH) {
+  let left = start;
+  return tabs.map(({ width, contentWidth }) => {
+    const position = { left, width, contentWidth: Math.max(contentWidth, minIndicatorWidth) };
+    left += width;
+    return position;
+  });
+}
+function tabIndicatorTarget(position, variant) {
+  return {
+    offset: position.left,
+    width: variant === "primary" ? position.contentWidth : position.width
+  };
+}
+var TabIndicatorAnimation = class {
+  #offset;
+  #width;
+  /** Starts at rest on the first layout's target (Compose: initialOffset / initialWidth). */
+  constructor(offset, width) {
+    this.#offset = new SpringAnimatable(offset, THRESHOLD);
+    this.#width = new SpringAnimatable(width, THRESHOLD);
+  }
+  get offset() {
+    return this.#offset;
+  }
+  get width() {
+    return this.#width;
+  }
+  get running() {
+    return this.#offset.isRunning || this.#width.isRunning;
+  }
+  /**
+   * Retargets each Animatable whose target changed, from its value and velocity at `now`; a null
+   * spec (reduced motion) jumps.
+   */
+  animateTo(offset, width, spec, now) {
+    if (width !== this.#width.target) this.#width.animateTo(width, spec, now);
+    if (offset !== this.#offset.target) this.#offset.animateTo(offset, spec, now);
+  }
+  snapTo(offset, width) {
+    this.#offset.snapTo(offset);
+    this.#width.snapTo(width);
+  }
+  sample(now) {
+    const offset = this.#offset.sample(now);
+    const width = this.#width.sample(now);
+    return { offset, width, running: this.running };
+  }
+};
+var tabIndicatorShift = (sample, selected) => sample.offset - selected.left;
+function scrollableTabOffset(tab, scrollWidth, visibleWidth) {
+  const centered = tab.left - (visibleWidth / 2 - tab.width / 2);
+  const available = Math.max(scrollWidth - visibleWidth, 0);
+  return Math.min(Math.max(centered, 0), available);
+}
+var TabScrollAnimation = class {
+  value;
+  constructor(position) {
+    this.value = new SpringAnimatable(position, THRESHOLD);
+  }
+  /** Starts a new scroll from `from` (the scroll state's value), velocity 0. */
+  animateTo(from, target, spec, now) {
+    this.value.snapTo(from);
+    this.value.animateTo(target, spec, now, 0);
+  }
+};
+
+// src/three-pane-scaffold.ts
+var THREE_PANE_SCAFFOLD_ROLES = [
+  "primary",
+  "secondary",
+  "tertiary"
+];
+var PRIORITY = {
+  primary: 10,
+  secondary: 5,
+  tertiary: 1
+};
+var LIST_DETAIL_ADAPT_STRATEGIES = {
+  primary: "hide",
+  secondary: "hide",
+  tertiary: "hide"
+};
+var SUPPORTING_PANE_ADAPT_STRATEGIES = {
+  primary: "hide",
+  secondary: { reflowUnder: "primary" },
+  tertiary: "hide"
+};
+var ListDetailPaneScaffoldRole = /* @__PURE__ */ Object.freeze({
+  List: "secondary",
+  Detail: "primary",
+  Extra: "tertiary"
+});
+var SupportingPaneScaffoldRole = /* @__PURE__ */ Object.freeze({
+  Main: "primary",
+  Supporting: "secondary",
+  Extra: "tertiary"
+});
+var LIST_DETAIL_PANE_ORDER = [
+  "secondary",
+  "primary",
+  "tertiary"
+];
+var SUPPORTING_PANE_ORDER = [
+  "primary",
+  "secondary",
+  "tertiary"
+];
+function sameThreePaneScaffoldValue(a, b) {
+  return a.primary === b.primary && a.secondary === b.secondary && a.tertiary === b.tertiary;
+}
+function calculateThreePaneScaffoldValue(maxHorizontalPartitions, adaptStrategies, destinationHistory, maxVerticalPartitions = 1) {
+  let expandedCount = 0;
+  const values = {};
+  let checkReflowedPane = maxHorizontalPartitions === 1 && maxVerticalPartitions > 1 && THREE_PANE_SCAFFOLD_ROLES.some((r) => adaptStrategies[r] !== "hide");
+  const order = [...destinationHistory.map((d) => d.pane).reverse(), ...THREE_PANE_SCAFFOLD_ROLES];
+  for (const pane of order) {
+    const hasAvailablePartition = expandedCount < maxHorizontalPartitions;
+    if (!hasAvailablePartition && !checkReflowedPane) break;
+    if (values[pane] !== void 0) continue;
+    let reflowedPane = null;
+    let anchorPane = pane;
+    let anchorValue;
+    const strategy = adaptStrategies[pane];
+    if (checkReflowedPane && strategy !== "hide") {
+      reflowedPane = pane;
+      anchorPane = strategy.reflowUnder;
+      anchorValue = values[anchorPane];
+    }
+    if (anchorValue === void 0) {
+      if (!hasAvailablePartition) continue;
+      values[anchorPane] = "expanded";
+      expandedCount++;
+    } else if (anchorValue !== "expanded") {
+      continue;
+    }
+    if (reflowedPane !== null) {
+      values[reflowedPane] = "reflowed";
+      checkReflowedPane = false;
+    }
+  }
+  return {
+    primary: values.primary ?? "hidden",
+    secondary: values.secondary ?? "hidden",
+    tertiary: values.tertiary ?? "hidden",
+    currentDestination: destinationHistory[destinationHistory.length - 1]?.pane ?? null
+  };
+}
+function expandedPanes(value, order) {
+  return order.filter((r) => value[r] === "expanded");
+}
+var RECOMMENDED_MAX_PANES = /* @__PURE__ */ Object.freeze({
+  compact: 1,
+  medium: 1,
+  expanded: 2,
+  large: 2,
+  "extra-large": 3
+});
+function threePaneScaffoldDirective(sizeClass, options = {}) {
+  const directive = paneScaffoldDirective(sizeClass, options);
+  if (options.paneRule === "compose") return directive;
+  return {
+    ...directive,
+    maxHorizontalPartitions: Math.min(
+      directive.maxHorizontalPartitions,
+      RECOMMENDED_MAX_PANES[sizeClass.widthClass]
+    )
+  };
+}
+var LIST_DETAIL_INITIAL_HISTORY = [
+  { pane: "secondary" }
+];
+var SUPPORTING_PANE_INITIAL_HISTORY = [
+  { pane: "primary" }
+];
+var ThreePaneScaffoldNavigator = class {
+  #history;
+  #directive;
+  #strategies;
+  #historyAware;
+  #value;
+  #listeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.#history = [...options.initialDestinationHistory];
+    this.#directive = options.scaffoldDirective;
+    this.#strategies = options.adaptStrategies;
+    this.#historyAware = options.isDestinationHistoryAware ?? true;
+    this.#value = this.#calculate(this.#history.length - 1);
+  }
+  get scaffoldDirective() {
+    return this.#directive;
+  }
+  set scaffoldDirective(directive) {
+    this.#directive = directive;
+    this.#recalculate();
+  }
+  get adaptStrategies() {
+    return this.#strategies;
+  }
+  set adaptStrategies(strategies) {
+    this.#strategies = strategies;
+    this.#recalculate();
+  }
+  get isDestinationHistoryAware() {
+    return this.#historyAware;
+  }
+  set isDestinationHistoryAware(aware) {
+    this.#historyAware = aware;
+    this.#recalculate();
+  }
+  /** The destination history, oldest first. */
+  get destinationHistory() {
+    return this.#history;
+  }
+  get currentDestination() {
+    return this.#history[this.#history.length - 1] ?? null;
+  }
+  get scaffoldValue() {
+    return this.#value;
+  }
+  /** Calls `listener` after every change of the history or the value; returns the unsubscriber. */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  peekPreviousScaffoldValue(behavior = "pop-until-scaffold-value-change") {
+    const index = this.#previousIndex(behavior);
+    return index === -1 ? this.#value : this.#calculate(index);
+  }
+  navigateTo(pane, contentKey) {
+    this.#history.push({ pane, contentKey });
+    this.#recalculate(true);
+  }
+  canNavigateBack(behavior = "pop-until-scaffold-value-change") {
+    return this.#previousIndex(behavior) >= 0;
+  }
+  /** Returns true when there was a destination to go back to (else the history is cleared). */
+  navigateBack(behavior = "pop-until-scaffold-value-change") {
+    const previous = this.#previousIndex(behavior);
+    if (previous < 0) {
+      this.#history = [];
+      this.#recalculate(true);
+      return false;
+    }
+    this.#history.length = previous + 1;
+    this.#recalculate(true);
+    return true;
+  }
+  #recalculate(force = false) {
+    const next = this.#calculate(this.#history.length - 1);
+    const changed = force || !sameThreePaneScaffoldValue(next, this.#value);
+    this.#value = next;
+    if (changed) for (const listener of [...this.#listeners]) listener();
+  }
+  /** getPreviousDestinationIndex (L430-466). */
+  #previousIndex(behavior) {
+    const history = this.#history;
+    if (history.length <= 1) return -1;
+    const last = history.length - 1;
+    const current = history[last];
+    for (let i = last - 1; i >= 0; i--) {
+      const item = history[i];
+      if (!item) continue;
+      switch (behavior) {
+        case "pop-latest":
+          return i;
+        case "pop-until-scaffold-value-change":
+          if (!sameThreePaneScaffoldValue(this.#calculate(i), this.#value)) return i;
+          break;
+        case "pop-until-current-destination-change":
+          if (item.pane !== current?.pane) return i;
+          break;
+        case "pop-until-content-change":
+          if (!Object.is(item.contentKey, current?.contentKey)) return i;
+          if (!sameThreePaneScaffoldValue(this.#calculate(i), this.#value)) return i;
+          break;
+      }
+    }
+    return -1;
+  }
+  /** calculateScaffoldValue (L468-490). */
+  #calculate(index) {
+    const { maxHorizontalPartitions, maxVerticalPartitions } = this.#directive;
+    const history = index === -1 ? [] : this.#historyAware ? this.#history.slice(0, index + 1) : this.#history.slice(index, index + 1);
+    return calculateThreePaneScaffoldValue(
+      maxHorizontalPartitions,
+      this.#strategies,
+      history,
+      maxVerticalPartitions
+    );
+  }
+};
+function threePaneScaffoldLayout(input) {
+  const { width: W, height: H, directive, value, order } = input;
+  const present = input.present ?? THREE_PANE_SCAFFOLD_ROLES;
+  const make = (role) => ({
+    role,
+    width: input.preferredWidths?.[role] ?? directive.defaultPanePreferredWidth,
+    height: input.preferredHeights?.[role] ?? directive.defaultPanePreferredHeight,
+    bounds: null
+  });
+  const select = (pick2) => order.filter((r) => present.includes(r) && pick2(value[r])).map(make);
+  const expanded = select((v) => v === "expanded");
+  const reflowed = select((v) => v === "reflowed");
+  const spacer = directive.horizontalPartitionSpacerSize;
+  const vSpacer = directive.verticalPartitionSpacerSize;
+  const outer = { x: 0, y: 0, width: W, height: H };
+  const right = (r) => r.x + r.width;
+  const between = (left, rightEdge) => ({
+    x: left,
+    y: 0,
+    width: rightEdge - left,
+    height: H
+  });
+  const inPartition = (partition, pane) => {
+    const flowed = reflowed[0];
+    const strategy = flowed ? input.adaptStrategies[flowed.role] : "hide";
+    if (flowed && strategy !== "hide" && strategy.reflowUnder === pane.role) {
+      const available = partition.height - vSpacer;
+      pane.height = Math.max(available - flowed.height, Math.trunc(available / 2));
+      flowed.height = available - pane.height;
+      flowed.bounds = {
+        x: partition.x,
+        y: partition.y + pane.height + vSpacer,
+        width: partition.width,
+        height: partition.height - pane.height - vSpacer
+      };
+    } else {
+      pane.height = partition.height;
+    }
+    pane.bounds = { ...partition, height: pane.height };
+  };
+  const partitions = (bounds, panes2) => {
+    if (panes2.length === 0) return;
+    const allocatable = bounds.width - (panes2.length - 1) * spacer;
+    const total = panes2.reduce((sum, p) => sum + p.width, 0);
+    if (allocatable > total) {
+      const top = panes2.reduce((a, b) => PRIORITY[b.role] > PRIORITY[a.role] ? b : a);
+      top.width += allocatable - total;
+    } else if (allocatable < total) {
+      const scale = Math.fround(allocatable / total);
+      for (const p of panes2) p.width = Math.trunc(Math.fround(p.width * scale));
+    }
+    let x = bounds.x;
+    for (const p of panes2) {
+      inPartition({ x, y: bounds.y, width: p.width, height: bounds.height }, p);
+      x += p.width + spacer;
+    }
+  };
+  const expansion = input.expansion;
+  const first = expanded[0];
+  const second = expanded[1];
+  const dragging = expansion?.draggingOffset;
+  const resting = expansion?.firstPaneWidth;
+  if (expanded.length === 2 && first && second && (dragging !== void 0 || resting !== void 0)) {
+    const half = Math.trunc(spacer / 2);
+    if (dragging !== void 0) {
+      if (dragging <= half)
+        inPartition({ ...outer, x: dragging * 2, width: W - dragging * 2 }, second);
+      else if (dragging >= W - half) inPartition({ ...outer, width: dragging * 2 - W }, first);
+      else {
+        inPartition(between(0, dragging - half), first);
+        inPartition(between(dragging + half, W), second);
+      }
+    } else if (resting !== void 0) {
+      const firstWidth = Math.max(0, Math.min(resting, W));
+      if (firstWidth === 0) inPartition(outer, second);
+      else if (firstWidth >= W - spacer) inPartition(outer, first);
+      else {
+        inPartition(between(0, firstWidth), first);
+        inPartition(between(firstWidth + spacer, W), second);
+      }
+    }
+  } else {
+    partitions(outer, expanded);
+  }
+  let handleOffset = null;
+  if (expanded.length === 2 && first && second) {
+    if (dragging !== void 0) handleOffset = dragging;
+    else if (first.bounds && second.bounds)
+      handleOffset = Math.trunc((right(first.bounds) + second.bounds.x) / 2);
+    else if (first.bounds) handleOffset = right(first.bounds);
+    else if (second.bounds) handleOffset = 0;
+  }
+  const panes = {};
+  for (const p of [...expanded, ...reflowed]) {
+    panes[p.role] = p.bounds ?? { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return { panes, handleOffset };
+}
+var motionType = (motion) => motion === "none" ? "hidden" : motion === "animate-bounds" ? "shown" : motion.startsWith("enter") ? "entering" : "exiting";
+function typeOf(previous, current) {
+  const was = previous !== "hidden";
+  const is = current !== "hidden";
+  return was && is ? "shown" : was ? "exiting" : is ? "entering" : "hidden";
+}
+function calculatePaneMotion(previous, current, order) {
+  const n = order.length;
+  const types = order.map((r) => typeOf(previous[r], current[r]));
+  const motions = order.map(() => "none");
+  let firstShown = n;
+  let firstEntering = n;
+  let lastShown = -1;
+  let lastEntering = -1;
+  types.forEach((t, i) => {
+    if (t === "shown") {
+      firstShown = Math.min(firstShown, i);
+      lastShown = Math.max(lastShown, i);
+      motions[i] = "animate-bounds";
+    } else if (t === "entering") {
+      firstEntering = Math.min(firstEntering, i);
+      lastEntering = Math.max(lastEntering, i);
+    }
+  });
+  let exitRight = false;
+  let exitLeft = false;
+  let firstExitRight = n;
+  let lastExitLeft = -1;
+  types.forEach((t, i) => {
+    if (t !== "exiting") return;
+    const shownLeft = firstShown < i;
+    const enteringLeft = firstEntering < i;
+    const shownRight = lastShown > i;
+    const enteringRight = lastEntering > i;
+    const toRight = () => {
+      exitRight = true;
+      firstExitRight = Math.min(firstExitRight, i);
+      motions[i] = "exit-to-right";
+    };
+    const toLeft = () => {
+      exitLeft = true;
+      lastExitLeft = Math.max(lastExitLeft, i);
+      motions[i] = "exit-to-left";
+    };
+    if (!shownRight && !enteringRight) toRight();
+    else if (!shownLeft && !enteringLeft) toLeft();
+    else if (!shownRight) toRight();
+    else if (!shownLeft) toLeft();
+    else motions[i] = "exit-with-shrink";
+  });
+  types.forEach((t, i) => {
+    if (t !== "entering") return;
+    const freeRight = !(lastShown > i) && !(lastExitLeft > i);
+    const freeLeft = !(firstShown < i) && !(firstExitRight < i);
+    motions[i] = freeRight && !exitRight ? "enter-from-right" : freeLeft && !exitLeft ? "enter-from-left" : freeRight ? "enter-from-right-delayed" : freeLeft ? "enter-from-left-delayed" : "enter-with-expand";
+  });
+  const out = { primary: "none", secondary: "none", tertiary: "none" };
+  order.forEach((r, i) => {
+    out[r] = motions[i] ?? "none";
+  });
+  return out;
+}
+var PANE_MOTION_DELAYED_RATIO = 0.1;
+function paneTransitions(motions, order, origin, target, scaffoldWidth) {
+  const zero = { x: 0, y: 0, width: 0, height: 0 };
+  const t = (r) => target[r] ?? origin[r] ?? zero;
+  const o = (r) => origin[r] ?? target[r] ?? zero;
+  const type = (r) => motionType(motions[r]);
+  const shown = (r, other) => type(r) === "shown" || type(r) === other;
+  const reversed = [...order].reverse();
+  const slideInFromLeft = () => {
+    let previous = null;
+    for (const r of reversed) {
+      const m = motions[r];
+      if (m === "enter-from-left" || m === "enter-from-left-delayed")
+        return -(previous ? t(previous).x : t(r).x + t(r).width);
+      if (shown(r, "entering")) previous = r;
+    }
+    return 0;
+  };
+  const slideInFromRight = () => {
+    let previous = null;
+    for (const r of order) {
+      const m = motions[r];
+      if (m === "enter-from-right" || m === "enter-from-right-delayed")
+        return scaffoldWidth - (previous ? t(previous).x + t(previous).width : t(r).x);
+      if (shown(r, "entering")) previous = r;
+    }
+    return 0;
+  };
+  const slideOutToLeft = () => {
+    let previous = null;
+    for (const r of reversed) {
+      if (motions[r] === "exit-to-left") return -(previous ? o(previous).x : o(r).x + o(r).width);
+      if (shown(r, "exiting")) previous = r;
+    }
+    return 0;
+  };
+  const slideOutToRight = () => {
+    let previous = null;
+    for (const r of order) {
+      if (motions[r] === "exit-to-right")
+        return scaffoldWidth - (previous ? o(previous).x + o(previous).width : o(r).x);
+      if (shown(r, "exiting")) previous = r;
+    }
+    return 0;
+  };
+  const leftEdge = (role, other, rect) => {
+    let edge = 0;
+    for (const r of order) {
+      if (r === role) return edge;
+      if (shown(r, other)) edge = rect(r).x + rect(r).width;
+    }
+    return edge;
+  };
+  const out = {};
+  for (const r of order) {
+    const motion = motions[r];
+    const to2 = t(r);
+    const from = o(r);
+    const shift = (rect, dx) => ({ ...rect, x: rect.x + dx });
+    let transition = null;
+    switch (motion) {
+      case "animate-bounds":
+        transition = { motion, from, to: to2, delayed: false };
+        break;
+      case "enter-from-left":
+      case "enter-from-left-delayed":
+        transition = {
+          motion,
+          from: shift(to2, slideInFromLeft()),
+          to: to2,
+          delayed: motion.endsWith("delayed")
+        };
+        break;
+      case "enter-from-right":
+      case "enter-from-right-delayed":
+        transition = {
+          motion,
+          from: shift(to2, slideInFromRight()),
+          to: to2,
+          delayed: motion.endsWith("delayed")
+        };
+        break;
+      case "enter-with-expand":
+        transition = {
+          motion,
+          from: { ...to2, x: leftEdge(r, "exiting", o), width: 0 },
+          to: to2,
+          delayed: false
+        };
+        break;
+      case "exit-to-left":
+        transition = { motion, from, to: shift(from, slideOutToLeft()), delayed: false };
+        break;
+      case "exit-to-right":
+        transition = { motion, from, to: shift(from, slideOutToRight()), delayed: false };
+        break;
+      case "exit-with-shrink":
+        transition = {
+          motion,
+          from,
+          to: { ...from, x: leftEdge(r, "entering", t), width: 0 },
+          delayed: false
+        };
+        break;
+    }
+    if (transition) out[r] = transition;
+  }
+  return out;
+}
+var PANE_EXPANSION_SAMPLE_ANCHORS = [
+  { proportion: 0 },
+  { offsetFromStart: 240 },
+  { proportion: 0.5 },
+  { offsetFromEnd: 240 },
+  { proportion: 1 }
+];
+var PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD = 200;
+function paneExpansionAnchorPosition(anchor, width, rtl = false) {
+  const offset = "proportion" in anchor ? Math.min(Math.max(Math.round(width * anchor.proportion), 0), width) : "offsetFromStart" in anchor ? Math.round(anchor.offsetFromStart) : width - Math.round(anchor.offsetFromEnd);
+  return rtl ? width - offset : offset;
+}
+function closestPaneExpansionAnchor(anchors, width, position, velocity, rtl = false) {
+  let best = -1;
+  let bestScore = Infinity;
+  const candidates2 = [];
+  anchors.forEach((anchor, index) => {
+    const at2 = paneExpansionAnchorPosition(anchor, width, rtl);
+    let score;
+    if (velocity >= PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD) {
+      const delta = at2 - position;
+      score = delta < 0 ? width - delta : delta;
+    } else if (velocity <= -PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD) {
+      const delta = position - at2;
+      score = delta < 0 ? width - delta : delta;
+    } else score = Math.abs(position - at2);
+    candidates2.push({ at: at2, index, score });
+  });
+  candidates2.sort((a, b) => a.at - b.at || a.index - b.index);
+  for (const c of candidates2) {
+    if (c.score < bestScore) {
+      best = c.index;
+      bestScore = c.score;
+    }
+  }
+  return best;
+}
+function nextPaneExpansionAnchor(anchors, width, position, rtl = false) {
+  const sorted = anchors.map((anchor, index) => ({ at: paneExpansionAnchorPosition(anchor, width, rtl), index })).sort((a, b) => a.at - b.at || a.index - b.index);
+  return (sorted.find((a) => position < a.at) ?? sorted[0])?.index ?? -1;
+}
+var PANE_MOTION_VISIBILITY_THRESHOLD = 1;
+var KEYS = ["x", "y", "width", "height"];
+var ThreePaneScaffoldAnimation = class {
+  #panes = /* @__PURE__ */ new Map();
+  start(transitions, spec, now) {
+    const next = /* @__PURE__ */ new Map();
+    for (const role of THREE_PANE_SCAFFOLD_ROLES) {
+      const transition = transitions[role];
+      if (!transition) continue;
+      const { from, to: to2 } = transition;
+      const previous = this.#panes.get(role);
+      if (previous) for (const k of KEYS) previous.springs[k].sample(now);
+      const springs = previous?.springs ?? Object.fromEntries(
+        KEYS.map((k) => [k, new SpringAnimatable(from[k], PANE_MOTION_VISIBILITY_THRESHOLD)])
+      );
+      const pane = { springs, to: to2, spec, delayUntil: null };
+      if (transition.delayed && spec !== null && !previous) {
+        const duration = Math.max(
+          ...KEYS.map(
+            (k) => springDurationMillis(spec, from[k], to2[k], 0, PANE_MOTION_VISIBILITY_THRESHOLD)
+          )
+        );
+        pane.delayUntil = now + Math.trunc(duration * PANE_MOTION_DELAYED_RATIO);
+      } else {
+        for (const k of KEYS) springs[k].animateTo(to2[k], spec, now);
+      }
+      next.set(role, pane);
+    }
+    this.#panes = next;
+  }
+  /** Jumps every pane to its target. */
+  finish() {
+    for (const pane of this.#panes.values()) {
+      pane.delayUntil = null;
+      for (const k of KEYS) pane.springs[k].snapTo(pane.to[k]);
+    }
+  }
+  sample(now) {
+    const panes = {};
+    let running = false;
+    for (const [role, pane] of this.#panes) {
+      const s = pane.springs;
+      if (pane.delayUntil !== null && now >= pane.delayUntil) {
+        for (const k of KEYS) s[k].animateTo(pane.to[k], pane.spec, pane.delayUntil);
+        pane.delayUntil = null;
+      }
+      panes[role] = {
+        x: s.x.sample(now),
+        y: s.y.sample(now),
+        width: Math.max(0, s.width.sample(now)),
+        height: Math.max(0, s.height.sample(now))
+      };
+      if (pane.delayUntil !== null || KEYS.some((k) => s[k].isRunning)) running = true;
+    }
+    return { panes, running };
+  }
+};
+
+export { AmplitudeAnimation, DEFAULT_DISPLACEMENT_THRESHOLD, DRAWER_POSITIONAL_THRESHOLD, DRAWER_SETTLE_MILLIS, DRAWER_VELOCITY_THRESHOLD, DrawerAnimation, FAST_OUT_LINEAR_IN_EASING, LIST_DETAIL_ADAPT_STRATEGIES, LIST_DETAIL_INITIAL_HISTORY, LIST_DETAIL_PANE_ORDER, ListDetailPaneScaffoldRole, MODAL_RAIL_EXPANDED_PROGRESS, NAVIGATION_SUITE_EXPANDED_FROM, NAVIGATION_SUITE_TYPES, NavigationSuiteScaffoldAnimation, PANE_EXPANSION_ANCHORING_VELOCITY_THRESHOLD, PANE_EXPANSION_SAMPLE_ANCHORS, PANE_MOTION_DELAYED_RATIO, PANE_MOTION_VISIBILITY_THRESHOLD, RECOMMENDED_MAX_PANES, SEARCH_BAR_EXPANDED_THRESHOLD, SEARCH_DROPDOWN_VISIBLE_PROGRESS, SLIDER_KEY_DIVISIONS, SLIDER_PAGE_DIVISOR, SLIDER_PAGE_MAX_STEPS, SUPPORTING_PANE_ADAPT_STRATEGIES, SUPPORTING_PANE_INITIAL_HISTORY, SUPPORTING_PANE_ORDER, SearchBarAnimation, SpringAnimatable, SpringSimulation, SupportingPaneScaffoldRole, TAB_INDICATOR_MIN_WIDTH, THREE_PANE_SCAFFOLD_ROLES, TOP_TITLE_ALPHA_EASING, TYPEAHEAD_TIMEOUT_MS, TabIndicatorAnimation, TabScrollAnimation, ThreePaneScaffoldAnimation, ThreePaneScaffoldNavigator, TweenAnimatable, WINDOW_HEIGHT_BREAKPOINTS, WINDOW_WIDTH_BREAKPOINTS, WideNavigationRailAnimation, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, calculatePaneMotion, calculateThreePaneScaffoldValue, circularIndeterminateFrame, closestPaneExpansionAnchor, collapsedFraction, cubicBezier, dampingCoefficient, dampingRatioFromCoefficient, drawerSettlesOpen, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, expandedPanes, exponentialDecayTarget, fabMenuItemVisible, floatingToolbarScrollState, indeterminateFrame, indicatorAmplitude, initialIndeterminateFrame, isAtLeastBreakpoint, isHeightAtLeastBreakpoint, isNavigationBarType, isScrolledUnder, isWidthAtLeastBreakpoint, linearIndeterminateFractions, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, navigationSuiteOffset, navigationSuiteType, nextPaneExpansionAnchor, overlappedFraction, paneExpansionAnchorPosition, paneScaffoldDirective, paneTransitions, parseCubicBezier, sameThreePaneScaffoldValue, sameWindowSizeClass, scrollAppBar, scrollFloatingToolbar, scrollToolbarExpansion, scrollableTabOffset, searchNavigationTarget, searchViewFrame, settleTarget, sliderClosestThumb, sliderFraction, sliderKeyAction, sliderKeyDelta, sliderKeyValue, sliderPageSteps, sliderSnap, sliderSteps, sliderThumbBounds, sliderThumbValue, sliderTickFractions, sliderTrackGeometry, sliderValueAt, springDurationMillis, springToLinear, springValue, springVelocity, tabIndicatorShift, tabIndicatorTarget, tabPositions, threePaneScaffoldDirective, threePaneScaffoldLayout, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, typeSelectTarget, waveOffset, waveTravelMillis, wideNavigationRailItemWidth, wideNavigationRailWidth, windowHeightSizeClass, windowSizeClass, windowWidthSizeClass, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map