@kyralabs/m3e-motion 1.3.0 → 1.5.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,6 +438,226 @@ function menuNavigationTarget(key, count, current) {
   }
 }
 
+// src/toolbar-navigation.ts
+function toolbarNavigationTarget(key, count, current, orientation = "horizontal", rtl = false) {
+  if (count === 0) return null;
+  let step;
+  switch (key) {
+    case "Home":
+      return 0;
+    case "End":
+      return count - 1;
+    case "ArrowRight":
+    case "ArrowLeft":
+      if (orientation !== "horizontal") return null;
+      step = key === "ArrowRight" !== rtl ? 1 : -1;
+      break;
+    case "ArrowDown":
+    case "ArrowUp":
+      if (orientation !== "vertical") 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);
+}
+
+// src/cubic-bezier.ts
+var bezier = (p1, p2, t) => 3 * (1 - t) * (1 - t) * t * p1 + 3 * (1 - t) * t * t * p2 + t * t * t;
+var cubicBezier = (a, b, c, d) => (fraction) => {
+  if (!(fraction > 0 && fraction < 1)) return fraction;
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0; i < 30; i++) {
+    const mid = (lo + hi) / 2;
+    if (bezier(a, c, mid) < fraction) lo = mid;
+    else hi = mid;
+  }
+  return bezier(b, d, (lo + hi) / 2);
+};
+function parseCubicBezier(css) {
+  const values = /cubic-bezier\(([^)]*)\)/.exec(css)?.[1]?.split(",").map(Number);
+  return values?.length === 4 && values.every(Number.isFinite) ? cubicBezier(...values) : null;
+}
+
+// src/app-bar-scroll.ts
+function appBarScrollState(height) {
+  return { heightOffsetLimit: -height, heightOffset: 0, contentOffset: 0, atStart: true };
+}
+function withHeightOffset(state, offset) {
+  return { ...state, heightOffset: Math.min(Math.max(offset, state.heightOffsetLimit), 0) };
+}
+function withHeight(state, height) {
+  return withHeightOffset({ ...state, heightOffsetLimit: -height }, state.heightOffset);
+}
+function collapsedFraction(state) {
+  return state.heightOffsetLimit !== 0 ? state.heightOffset / state.heightOffsetLimit + 0 : 0;
+}
+function overlappedFraction(state) {
+  if (!state.atStart && state.contentOffset === 0) return 1;
+  if (state.heightOffsetLimit === 0) return 0;
+  const limit = state.heightOffsetLimit;
+  const clamped = Math.min(Math.max(limit + Math.abs(state.contentOffset), limit), 0);
+  return 1 - clamped / limit;
+}
+function isScrolledUnder(state) {
+  return overlappedFraction(state) > 0.01;
+}
+function scrollAppBar(state, behavior, scrollTop, delta) {
+  const next = { ...state, contentOffset: -scrollTop, atStart: scrollTop <= 0 };
+  if (behavior === "pinned") return next;
+  if (behavior === "enter-always" || delta < 0) {
+    return withHeightOffset(next, state.heightOffset + delta);
+  }
+  const below = (top) => Math.max(0, -state.heightOffset - top);
+  return withHeightOffset(next, state.heightOffset + below(scrollTop) - below(scrollTop + delta));
+}
+function settleTarget(state) {
+  const fraction = collapsedFraction(state);
+  if (fraction < 0.01 || fraction === 1) return null;
+  if (!(state.heightOffset < 0 && state.heightOffset > state.heightOffsetLimit)) return null;
+  return fraction < 0.5 ? 0 : state.heightOffsetLimit;
+}
+var TOP_TITLE_ALPHA_EASING = [0.8, 0, 0.8, 0.15];
+var FAST_OUT_LINEAR_IN_EASING = [0.4, 0, 1, 1];
+var topTitleAlpha = /* @__PURE__ */ cubicBezier(...TOP_TITLE_ALPHA_EASING);
+var fastOutLinearIn = /* @__PURE__ */ cubicBezier(...FAST_OUT_LINEAR_IN_EASING);
+function twoRowsFrame(fraction) {
+  return {
+    collapsedTitleAlpha: topTitleAlpha(fraction),
+    expandedTitleAlpha: 1 - fraction,
+    containerColorFraction: fastOutLinearIn(fraction),
+    collapsedTitleHidden: fraction < 0.5
+  };
+}
+
+// src/floating-toolbar-scroll.ts
+function floatingToolbarScrollState(offsetLimit = -Number.MAX_VALUE, offset = 0, contentOffset = 0) {
+  return withToolbarOffset({ offsetLimit, offset: 0, contentOffset }, offset);
+}
+function withToolbarOffset(state, offset) {
+  return { ...state, offset: Math.min(Math.max(offset, state.offsetLimit), 0) };
+}
+function withToolbarOffsetLimit(state, distance) {
+  return withToolbarOffset({ ...state, offsetLimit: -Math.max(distance, 0) }, state.offset);
+}
+function scrollFloatingToolbar(state, delta) {
+  return withToolbarOffset(
+    { ...state, contentOffset: state.contentOffset + delta },
+    state.offset + delta
+  );
+}
+function toolbarCollapsedFraction(state) {
+  return state.offsetLimit !== 0 ? state.offset / state.offsetLimit + 0 : 0;
+}
+function toolbarSettleTarget(state) {
+  return settleTarget({
+    heightOffsetLimit: state.offsetLimit,
+    heightOffset: state.offset,
+    contentOffset: state.contentOffset});
+}
+function toolbarExpansionScroll(expanded, collapseThreshold, expandThreshold, contentOffset = 0) {
+  return {
+    contentOffset,
+    threshold: expanded ? contentOffset - collapseThreshold : contentOffset + expandThreshold
+  };
+}
+function scrollToolbarExpansion(state, delta, collapseThreshold, expandThreshold) {
+  const contentOffset = state.contentOffset + delta;
+  if (delta < 0 && contentOffset <= state.threshold) {
+    return {
+      state: { contentOffset, threshold: contentOffset + expandThreshold },
+      change: "collapse"
+    };
+  }
+  if (delta > 0 && contentOffset >= state.threshold) {
+    return {
+      state: { contentOffset, threshold: contentOffset - collapseThreshold },
+      change: "expand"
+    };
+  }
+  return { state: { contentOffset, threshold: state.threshold }, change: null };
+}
+
+// src/progress-indicator.ts
+var line = (t, [delay, duration], easing) => t <= delay ? 0 : t >= delay + duration ? 1 : easing((t - delay) / duration);
+function linearIndeterminateFractions(elapsedMillis, timing) {
+  const t = Math.max(0, elapsedMillis) % timing.durationMillis;
+  return [
+    line(t, timing.firstTail, timing.easing),
+    line(t, timing.firstHead, timing.easing),
+    line(t, timing.secondTail, timing.easing),
+    line(t, timing.secondHead, timing.easing)
+  ];
+}
+function circularIndeterminateFrame(elapsedMillis, timing) {
+  const d = timing.durationMillis;
+  const t = Math.max(0, elapsedMillis) % d;
+  const steps = Math.round(d / timing.additionalDelayMillis);
+  const step = timing.additionalRotation / steps;
+  const index = Math.floor(t / timing.additionalDelayMillis);
+  const within = t - index * timing.additionalDelayMillis;
+  const additional = step * index + step * Math.min(1, within / timing.additionalDurationMillis);
+  const half = d / 2;
+  const range = timing.maxProgress - timing.minProgress;
+  const sweep = t <= half ? timing.minProgress + range * (t / half) : timing.maxProgress - range * timing.easing((t - half) / half);
+  return { rotation: timing.rotation * t / d + additional, sweep };
+}
+function waveTravelMillis(wavelength, waveSpeed, minMillis, vertexCount = 1) {
+  if (!(waveSpeed > 0 && wavelength > 0)) return Number.POSITIVE_INFINITY;
+  return Math.max(minMillis, Math.round(wavelength / waveSpeed * 1e3 * vertexCount));
+}
+var waveOffset = (elapsedMillis, travelMillis) => Number.isFinite(travelMillis) ? Math.max(0, elapsedMillis) % travelMillis / travelMillis : 0;
+var indicatorAmplitude = (progress, minProgress, maxProgress) => progress <= minProgress || progress >= maxProgress ? 0 : 1;
+var AmplitudeAnimation = class {
+  #from;
+  #to;
+  #start = 0;
+  #tween = null;
+  #value;
+  constructor(initial) {
+    this.#from = initial;
+    this.#to = initial;
+    this.#value = initial;
+  }
+  get value() {
+    return this.#value;
+  }
+  get target() {
+    return this.#to;
+  }
+  get isRunning() {
+    return this.#tween !== null;
+  }
+  /** Advances to `now` (ms). */
+  sample(now) {
+    const tween = this.#tween;
+    if (tween === null) return this.#value;
+    const fraction = tween.durationMillis > 0 ? (now - this.#start) / tween.durationMillis : 1;
+    if (fraction >= 1) {
+      this.#tween = null;
+      this.#value = this.#to;
+    } else {
+      this.#value = this.#from + (this.#to - this.#from) * tween.easing(Math.max(0, fraction));
+    }
+    return this.#value;
+  }
+  /** Requests `target` at `now`; returns true when a tween started. */
+  update(target, now, increase, decrease) {
+    this.sample(now);
+    if (this.#tween !== null || target === this.#to) return false;
+    const tween = this.#value < target ? increase : decrease;
+    this.#from = this.#value;
+    this.#to = target;
+    this.#start = now;
+    this.#tween = tween;
+    if (tween.durationMillis <= 0) this.sample(now);
+    return true;
+  }
+};
+
 // src/loading-indicator.ts
 var FULL_ROTATION = 360;
 var QUARTER_ROTATION = FULL_ROTATION / 4;
@@ -572,38 +793,197 @@ function menuPosition(input) {
   };
 }
 
-// src/app-bar-scroll.ts
-function appBarScrollState(height) {
-  return { heightOffsetLimit: -height, heightOffset: 0, contentOffset: 0, atStart: true };
-}
-function withHeightOffset(state, offset) {
-  return { ...state, heightOffset: Math.min(Math.max(offset, state.heightOffsetLimit), 0) };
-}
-function withHeight(state, height) {
-  return withHeightOffset({ ...state, heightOffsetLimit: -height }, state.heightOffset);
-}
-function collapsedFraction(state) {
-  return state.heightOffsetLimit !== 0 ? state.heightOffset / state.heightOffsetLimit + 0 : 0;
-}
-function overlappedFraction(state) {
-  if (!state.atStart && state.contentOffset === 0) return 1;
-  if (state.heightOffsetLimit === 0) return 0;
-  const limit = state.heightOffsetLimit;
-  const clamped = Math.min(Math.max(limit + Math.abs(state.contentOffset), limit), 0);
-  return 1 - clamped / limit;
-}
-function isScrolledUnder(state) {
-  return overlappedFraction(state) > 0.01;
-}
-function scrollAppBar(state, behavior, scrollTop, delta) {
-  const next = { ...state, contentOffset: -scrollTop, atStart: scrollTop <= 0 };
-  return behavior === "enter-always" ? withHeightOffset(next, state.heightOffset + delta) : next;
+// src/search-bar.ts
+var SEARCH_BAR_EXPANDED_THRESHOLD = 0.02;
+var SEARCH_DROPDOWN_VISIBLE_PROGRESS = 0.1;
+var TweenAnimatable = class {
+  #value;
+  #from;
+  #target;
+  #start = 0;
+  #spec = null;
+  constructor(value) {
+    this.#value = value;
+    this.#from = value;
+    this.#target = value;
+  }
+  get value() {
+    return this.#value;
+  }
+  get target() {
+    return this.#target;
+  }
+  get isRunning() {
+    return this.#spec !== null;
+  }
+  snapTo(value) {
+    this.#spec = null;
+    this.#value = value;
+    this.#from = value;
+    this.#target = value;
+  }
+  animateTo(target, spec, now) {
+    this.sample(now);
+    if (spec === null || spec.delay + spec.duration <= 0) {
+      this.snapTo(target);
+      return;
+    }
+    this.#from = this.#value;
+    this.#target = target;
+    this.#start = now;
+    this.#spec = spec;
+  }
+  sample(now) {
+    const spec = this.#spec;
+    if (spec === null) return this.#value;
+    const elapsed = now - this.#start - spec.delay;
+    if (elapsed >= spec.duration) {
+      this.snapTo(this.#target);
+      return this.#value;
+    }
+    const fraction = elapsed <= 0 ? 0 : spec.easing(elapsed / spec.duration);
+    this.#value = this.#from + (this.#target - this.#from) * fraction;
+    return this.#value;
+  }
+};
+var SearchBarAnimation = class {
+  #progress;
+  #content;
+  #slide = new SpringAnimatable(0);
+  #specs = null;
+  #dropdownShown = false;
+  #dropdownVisible = false;
+  constructor(expanded = false) {
+    this.#progress = new SpringAnimatable(expanded ? 1 : 0);
+    this.#content = new TweenAnimatable(expanded ? 1 : 0);
+    this.#dropdownShown = expanded;
+    this.#dropdownVisible = expanded;
+  }
+  /** SearchBarState.targetValue. */
+  get isTargetExpanded() {
+    return this.#progress.target === 1;
+  }
+  /** SearchBarState.currentValue: expanded until the value drops to the 0.02 tolerance. */
+  get isExpanded() {
+    return this.#progress.value > SEARCH_BAR_EXPANDED_THRESHOLD;
+  }
+  get isRunning() {
+    return this.#progress.isRunning || this.#content.isRunning || this.#slide.isRunning;
+  }
+  /** animateToExpanded() at `now` (ms). */
+  expand(specs, now) {
+    this.#specs = specs;
+    this.#progress.animateTo(1, specs.expand, now);
+    this.#content.animateTo(1, specs.contentFadeIn, now);
+  }
+  /** animateToCollapsed() at `now` (ms). */
+  collapse(specs, now) {
+    this.#specs = specs;
+    this.#content.animateTo(0, specs.contentFadeOut, now);
+    this.#progress.animateTo(0, specs.collapse, now);
+  }
+  /** Jumps to collapsed (0) or expanded (1), stopping every animation. */
+  snapTo(expanded) {
+    this.#progress.snapTo(expanded ? 1 : 0);
+    this.#content.snapTo(expanded ? 1 : 0);
+    this.#slide.snapTo(0);
+    this.#dropdownShown = expanded;
+    this.#dropdownVisible = expanded;
+  }
+  /**
+   * Advances to `now`. `dropdownHeight` (px, the drop-down's full height) enables the with-gap
+   * slide: AnimatedVisibility(visible = progress > 0.1 && target == Expanded) slides in from minus
+   * half the height on the expand spring and out to it on the collapse spring.
+   */
+  sample(now, dropdownHeight) {
+    const value = this.#progress.sample(now);
+    const progress = Math.min(Math.max(value, 0), 1);
+    const contentProgress = Math.min(Math.max(this.#content.sample(now), 0), 1);
+    if (dropdownHeight !== void 0) {
+      const hidden = Math.round(-dropdownHeight / 2);
+      const visible = progress > SEARCH_DROPDOWN_VISIBLE_PROGRESS && this.isTargetExpanded;
+      if (visible !== this.#dropdownVisible) {
+        this.#dropdownVisible = visible;
+        if (visible) {
+          if (!this.#dropdownShown) this.#slide.snapTo(hidden);
+          this.#dropdownShown = true;
+          this.#slide.animateTo(0, this.#specs?.expand ?? null, now);
+        } else if (this.#dropdownShown) {
+          this.#slide.animateTo(hidden, this.#specs?.collapse ?? null, now);
+        }
+      }
+      this.#slide.sample(now);
+      if (!visible && this.#dropdownShown && !this.#slide.isRunning) this.#dropdownShown = false;
+    }
+    return {
+      value,
+      progress,
+      contentProgress,
+      slide: this.#slide.value,
+      dropdownShown: this.#dropdownShown
+    };
+  }
+};
+var lerp = (a, b, t) => a + (b - a) * t;
+function searchViewFrame(input) {
+  const { variant, collapsed: c, window: w, insetTop, metrics: m } = input;
+  const { value, progress: p } = input.sample;
+  const none = { radius: 0, alpha: 1, minHeight: 0, maxHeight: 0 };
+  if (variant === "docked" || variant === "docked-with-gap") {
+    const ratio = variant === "docked" ? m.dockedMaxHeightRatio : m.withGapMaxHeightRatio;
+    const tableMax = w.height * ratio;
+    const maxHeight = lerp(c.height, tableMax, Math.max(value, 0));
+    const minHeight = Math.min(Math.min(m.dockedMinHeight, tableMax), maxHeight);
+    if (variant === "docked") {
+      return {
+        surface: { ...c, radius: 0, alpha: 1, minHeight, maxHeight },
+        field: { x: c.x, y: c.y, width: c.width },
+        results: { x: c.x, y: c.y + c.height, width: c.width, maxHeight: maxHeight - c.height }
+      };
+    }
+    return {
+      surface: { x: 0, y: 0, width: w.width, height: w.height, ...none, alpha: p },
+      field: { x: c.x, y: c.y, width: c.width },
+      results: {
+        x: c.x,
+        y: c.y + c.height + m.dropdownGap,
+        width: c.width,
+        maxHeight: Math.max(0, maxHeight - c.height - m.dropdownGap)
+      }
+    };
+  }
+  const contained = variant === "full-screen-contained";
+  const width = contained ? w.width : lerp(c.width, w.width, p);
+  const height = contained ? w.height : lerp(c.height, w.height, p);
+  const offsetX = contained ? 0 : lerp(c.x, 0, p);
+  const padding = contained ? m.containedHorizontalPadding : 0;
+  const fieldWidth = lerp(c.width, width - 2 * padding, value);
+  const centerX2 = lerp(c.x + c.width / 2, offsetX + width / 2, value);
+  const topPadding = insetTop + (contained ? m.containedTopPadding : m.verticalPadding);
+  const animatedTopPadding = topPadding * Math.min(p, 1);
+  const bottomPadding = contained ? m.verticalPadding : m.verticalPadding * p;
+  const offsetY = lerp(c.y, 0, p);
+  const fieldY = offsetY + animatedTopPadding;
+  return {
+    surface: contained ? { x: 0, y: 0, width, height, ...none, alpha: p } : { x: offsetX, y: offsetY, width, height, ...none, radius: m.cornerRadius * (1 - p) },
+    field: { x: Math.round(centerX2 - fieldWidth / 2), y: fieldY, width: fieldWidth },
+    results: {
+      x: offsetX,
+      y: fieldY + c.height + bottomPadding,
+      width,
+      maxHeight: Math.max(0, height - (c.height + animatedTopPadding + bottomPadding))
+    }
+  };
 }
-function settleTarget(state) {
-  const fraction = collapsedFraction(state);
-  if (fraction < 0.01 || fraction === 1) return null;
-  if (!(state.heightOffset < 0 && state.heightOffset > state.heightOffsetLimit)) return null;
-  return fraction < 0.5 ? 0 : state.heightOffsetLimit;
+function searchNavigationTarget(key, enabled, active) {
+  const indices = enabled.flatMap((on, i) => on ? [i] : []);
+  const first = indices[0];
+  const last = indices.at(-1);
+  if (first === void 0 || last === void 0) return null;
+  const at2 = indices.indexOf(active);
+  if (key === "ArrowDown") return at2 === -1 ? first : indices[at2 + 1] ?? last;
+  if (key === "ArrowUp") return at2 === -1 ? last : at2 === 0 ? -1 : indices[at2 - 1] ?? first;
+  return null;
 }
 
 // src/button-group.ts
@@ -652,6 +1032,1231 @@ function buttonGroupWidths(items, pressed, expandedRatio, visibleCount = items.l
   return widths.slice(0, last);
 }
 
-export { DEFAULT_DISPLACEMENT_THRESHOLD, SpringAnimatable, SpringSimulation, animatedInt, appBarScrollState, buttonGroupVisibleCount, buttonGroupWidths, collapsedFraction, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, fabMenuItemVisible, indeterminateFrame, initialIndeterminateFrame, isScrolledUnder, menuNavigationTarget, menuPosition, menuTransformOrigin, morphSpringDurationMillis, overlappedFraction, scrollAppBar, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, withHeight, withHeightOffset };
+// 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/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, 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, 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, springDurationMillis, springToLinear, springValue, springVelocity, tabIndicatorShift, tabIndicatorTarget, tabPositions, threePaneScaffoldDirective, threePaneScaffoldLayout, toolbarCollapsedFraction, toolbarExpansionScroll, toolbarNavigationTarget, toolbarSettleTarget, twoRowsFrame, waveOffset, waveTravelMillis, wideNavigationRailItemWidth, wideNavigationRailWidth, windowHeightSizeClass, windowSizeClass, windowWidthSizeClass, withHeight, withHeightOffset, withToolbarOffset, withToolbarOffsetLimit };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map