@kyralabs/m3e-motion 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,50 @@
+m3exp-web
+Copyright 2026 Kyra Labs
+
+This product is licensed under the Apache License, Version 2.0 (see LICENSE).
+
+This product includes software from the projects listed below, each licensed
+under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0).
+Portions have been modified and ported to TypeScript by Kyra Labs. Every ported
+file keeps its original copyright and license header and names its source path
+and commit.
+
+--------------------------------------------------------------------------------
+AndroidX Compose Material3 (design tokens, component logic, MaterialShapes)
+https://android.googlesource.com/platform/frameworks/support/+/19991f2c0858aadfcb442ce02b2c8e4743c96898/compose/material3/
+Copyright (C) The Android Open Source Project
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+AndroidX Compose Animation (animation-core: spring simulation and duration estimate)
+https://android.googlesource.com/platform/frameworks/support/+/19991f2c0858aadfcb442ce02b2c8e4743c96898/compose/animation/animation-core/
+Copyright (C) The Android Open Source Project
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+AndroidX Compose UI Graphics (Matrix: the subset MaterialShapes uses)
+https://android.googlesource.com/platform/frameworks/support/+/19991f2c0858aadfcb442ce02b2c8e4743c96898/compose/ui/ui-graphics/
+Copyright (C) The Android Open Source Project
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+AndroidX graphics-shapes (androidx.graphics:graphics-shapes 1.0.1, sources jar)
+https://dl.google.com/android/maven2/androidx/graphics/graphics-shapes/1.0.1/graphics-shapes-1.0.1-sources.jar
+Copyright (C) The Android Open Source Project
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+Material Web (@material/web 2.5.0: elevation shadow values in @kyralabs/m3e-tokens)
+https://github.com/material-components/material-web
+Copyright 2022 Google LLC
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+material-color-utilities (@material/material-color-utilities 0.4.0, bundled in @kyralabs/m3e-tokens)
+https://github.com/material-foundation/material-color-utilities
+Copyright 2021 Google LLC
+Licensed under the Apache License, Version 2.0
+
+--------------------------------------------------------------------------------
+Bundled fonts are distributed under their own licenses, included beside each
+font file in packages/m3e-tokens/fonts/.

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @kyralabs/m3e-motion
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Spring math for m3exp-web: TypeScript ports of Compose's `SpringSimulation` and spring duration
+estimate (float32-exact against the JVM), `FloatSpringSpec` helpers, a CSS `linear()` sampler and
+the top app bar scroll state. Mostly used by the other `@kyralabs` packages; no DOM access.
+
+```sh
+npm install @kyralabs/m3e-motion
+```
+
+## Usage
+
+```ts
+import { springDurationMillis, springToLinear, springValue } from '@kyralabs/m3e-motion';
+
+const spec = { dampingRatio: 0.9, stiffness: 700 };
+springValue(spec, 100, 0, 1); // position after 100 ms, animating 0 → 1
+springDurationMillis(spec, 0, 1); // settle time in ms
+springToLinear(spec); // CSS linear() easing plus its duration
+```
+
+Apache-2.0; see `LICENSE` and `NOTICE`.

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+/** A Material motion-scheme spring (`dampingRatio` ζ, `stiffness` k; mass 1). */
+interface SpringSpec {
+    readonly dampingRatio: number;
+    readonly stiffness: number;
+}
+/** `Spring.DefaultDisplacementThreshold` (VectorizedAnimationSpec.kt L842). */
+declare const DEFAULT_DISPLACEMENT_THRESHOLD = 0.01;
+/** Value at `playTimeMillis` (whole milliseconds, as in Compose). */
+declare function springValue(spec: SpringSpec, playTimeMillis: number, initialValue: number, targetValue: number, initialVelocity?: number): number;
+/** Velocity (units/s) at `playTimeMillis`. */
+declare function springVelocity(spec: SpringSpec, playTimeMillis: number, initialValue: number, targetValue: number, initialVelocity?: number): number;
+/**
+ * Duration until the spring stays within `visibilityThreshold` of the target, as Compose computes
+ * it (`FloatSpringSpec.getDurationNanos` / 1e6).
+ */
+declare function springDurationMillis(spec: SpringSpec, initialValue: number, targetValue: number, initialVelocity?: number, visibilityThreshold?: number): number;
+/**
+ * Damping coefficient c = 2ζ√(k·m), for physics engines parameterized by stiffness/damping/mass
+ * (e.g. Motion's `{ type: 'spring', stiffness, damping, mass }`).
+ */
+declare function dampingCoefficient(spec: SpringSpec, mass?: number): number;
+/** Inverse of {@link dampingCoefficient}: ζ = c / (2√(k·m)). */
+declare function dampingRatioFromCoefficient(damping: number, stiffness: number, mass?: number): number;
+
+interface LinearEasingOptions {
+    /** Fraction of the travel considered settled. Default 0.001. */
+    visibilityThreshold?: number;
+    /** Maximum stops in the `linear()` function (FOUNDATIONS §4: ≤ 40). Default 40. */
+    maxStops?: number;
+}
+interface LinearEasing {
+    /** e.g. `linear(0, 0.1234 5%, …, 1)` */
+    easing: string;
+    durationMillis: number;
+    /** `[progress 0–1, value]` pairs after rounding. */
+    stops: readonly (readonly [number, number])[];
+    /** Max |linear(t) − spring(t)| over every millisecond sample. */
+    maxError: number;
+}
+declare function springToLinear(spec: SpringSpec, options?: LinearEasingOptions): LinearEasing;
+
+interface LoadingIndicatorTiming {
+    /** `MorphIntervalMillis`: how often a morph starts. */
+    readonly morphIntervalMillis: number;
+    /** `GlobalRotationDurationMillis`: one linear turn. */
+    readonly rotationDurationMillis: number;
+    /** The morph spring (`morphAnimationSpec`). */
+    readonly spring: SpringSpec;
+    /** The morph spring's `visibilityThreshold`; it decides when the spring finishes. */
+    readonly visibilityThreshold: number;
+}
+/** What the indicator draws: a morph at a progress, rotated clockwise about the center. */
+interface IndeterminateFrame {
+    morphIndex: number;
+    /** The raw spring value: it overshoots past 1, as in Compose (the morph extrapolates). */
+    morphProgress: number;
+    /** Degrees, clockwise. */
+    rotation: number;
+}
+/**
+ * The first frame (and the one held under reduced motion): the first morph at 0, rotated by the
+ * initial `morphRotationTargetAngle` (a quarter turn).
+ */
+declare const initialIndeterminateFrame: Readonly<IndeterminateFrame>;
+/** How long one morph spring runs (Compose's `FloatSpringSpec.getDurationNanos`), in ms. */
+declare const morphSpringDurationMillis: (timing: LoadingIndicatorTiming) => number;
+/**
+ * The frame of an indeterminate loading indicator [elapsedMillis] after it started, cycling
+ * through [morphCount] morphs.
+ */
+declare function indeterminateFrame(elapsedMillis: number, morphCount: number, timing: LoadingIndicatorTiming): IndeterminateFrame;
+
+/**
+ * Returns the estimated time that the spring will last be at [delta]. Arguments are Kotlin
+ * `Float`s (rounded to float32).
+ */
+declare function estimateAnimationDurationMillis(stiffness: number, dampingRatio: number, initialVelocity: number, initialDisplacement: number, delta: number): number;
+/** Returns the estimated time that the spring will last be at [delta] (Double overload). */
+declare function estimateAnimationDurationMillisDouble(stiffness: number, dampingRatio: number, initialVelocity: number, initialDisplacement: number, delta: number): number;
+
+interface Motion {
+    value: number;
+    velocity: number;
+}
+/**
+ * Spring Simulation simulates spring physics, and allows you to query the motion (i.e. value and
+ * velocity) at certain time in the future based on the starting velocity and value.
+ *
+ * By configuring the stiffness and damping ratio, callers can create a spring with the look and
+ * feel suits their use case. Stiffness corresponds to the spring constant. The stiffer the spring
+ * is, the harder it is to stretch it, the faster it undergoes dampening.
+ *
+ * Spring damping ratio describes how oscillations in a system decay after a disturbance. When
+ * damping ratio > 1* (i.e. over-damped), the object will quickly return to the rest position
+ * without overshooting. If damping ratio equals to 1 (i.e. critically damped), the object will
+ * return to equilibrium within the shortest amount of time. When damping ratio is less than 1 (i.e.
+ * under-damped), the mass tends to overshoot, and return, and overshoot again. Without any damping
+ * (i.e. damping ratio = 0), the mass will oscillate forever.
+ */
+declare class SpringSimulation {
+    #private;
+    constructor(finalPosition: number);
+    get finalPosition(): number;
+    set finalPosition(value: number);
+    /** Stiffness of the spring. */
+    get stiffness(): number;
+    set stiffness(value: number);
+    /** Returns the damping ratio of the spring. */
+    get dampingRatio(): number;
+    set dampingRatio(value: number);
+    getAcceleration(lastDisplacement: number, lastVelocity: number): number;
+    /**
+     * Internal only call for Spring to calculate the spring position/velocity using an analytical
+     * approach.
+     */
+    updateValues(lastDisplacement: number, lastVelocity: number, timeElapsed: number): Motion;
+}
+
+/** How the bar reacts to its scroll container (TopAppBarDefaults.*ScrollBehavior). */
+type AppBarScrollBehavior = 'pinned' | 'enter-always';
+interface AppBarScrollState {
+    /** Most negative height offset: minus the bar's full height (adjustHeightOffsetLimit). */
+    readonly heightOffsetLimit: number;
+    /** Current height offset, between heightOffsetLimit and 0. */
+    readonly heightOffset: number;
+    /** Content scrolled under the bar (minus the scroll position). */
+    readonly contentOffset: number;
+    /** Whether the scrolling content is at its start (scroll position 0). */
+    readonly atStart: boolean;
+}
+/** A fully expanded bar of `height` px over unscrolled content. */
+declare function appBarScrollState(height: number): AppBarScrollState;
+/** TopAppBarState.heightOffset setter: coerced between heightOffsetLimit and 0. */
+declare function withHeightOffset(state: AppBarScrollState, offset: number): AppBarScrollState;
+/** A new bar height (onSizeChanged → adjustHeightOffsetLimit), keeping the offset in range. */
+declare function withHeight(state: AppBarScrollState, height: number): AppBarScrollState;
+/** 0 = fully expanded, 1 = fully collapsed (TopAppBarState.collapsedFraction). */
+declare function collapsedFraction(state: AppBarScrollState): number;
+/** Share of the visible bar overlapping scrolled content (TopAppBarState.overlappedFraction). */
+declare function overlappedFraction(state: AppBarScrollState): number;
+/**
+ * Whether the bar shows its scrolled container color: SingleRowTopAppBar targets the scrolled
+ * color once `overlappedFraction > 0.01f` (L2689-2693).
+ */
+declare function isScrolledUnder(state: AppBarScrollState): boolean;
+/**
+ * Applies a scroll position change. `delta` is the previous minus the new scroll position
+ * (positive when the content is pulled down, like Compose's `available.y`).
+ * - pinned: only the content offset moves (PinnedScrollBehavior.onPostScroll).
+ * - enter-always: the bar also collapses/expands by the same amount
+ *   (EnterAlwaysScrollBehavior.onPreScroll: `heightOffset += available.y`).
+ */
+declare function scrollAppBar(state: AppBarScrollState, behavior: AppBarScrollBehavior, scrollTop: number, delta: number): AppBarScrollState;
+/**
+ * Where a partially collapsed bar snaps when scrolling stops (settleAppBar): fully expanded below
+ * half, fully collapsed from half, or null when it is already (within 1%) settled.
+ */
+declare function settleTarget(state: AppBarScrollState): number | null;
+
+export { type AppBarScrollBehavior, type AppBarScrollState, DEFAULT_DISPLACEMENT_THRESHOLD, type IndeterminateFrame, type LinearEasing, type LinearEasingOptions, type LoadingIndicatorTiming, type Motion, SpringSimulation, type SpringSpec, appBarScrollState, collapsedFraction, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, indeterminateFrame, initialIndeterminateFrame, isScrolledUnder, morphSpringDurationMillis, overlappedFraction, scrollAppBar, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, withHeight, withHeightOffset };

package/dist/index.js

@@ -0,0 +1,403 @@
+// src/spring-estimation.ts
+var LONG_MAX = 2 ** 63;
+var LONG_MIN = -9223372036854776e3;
+var MAX_LONG_MILLIS = 9223372036854;
+var toLong = (x) => Number.isNaN(x) ? 0 : x >= LONG_MAX ? LONG_MAX : x <= LONG_MIN ? LONG_MIN : Math.trunc(x);
+function estimateAnimationDurationMillis(stiffness, dampingRatio, initialVelocity, initialDisplacement, delta) {
+  const f323 = Math.fround;
+  if (f323(dampingRatio) === 0) {
+    return MAX_LONG_MILLIS;
+  }
+  return estimateAnimationDurationMillisDouble(
+    f323(stiffness),
+    f323(dampingRatio),
+    f323(initialVelocity),
+    f323(initialDisplacement),
+    f323(delta)
+  );
+}
+function estimateAnimationDurationMillisDouble(stiffness, dampingRatio, initialVelocity, initialDisplacement, delta) {
+  const dampingCoefficient2 = 2 * dampingRatio * Math.sqrt(stiffness);
+  const partialRoot = dampingCoefficient2 * dampingCoefficient2 - 4 * stiffness;
+  const partialRootReal = partialRoot < 0 ? 0 : Math.sqrt(partialRoot);
+  const partialRootImaginary = partialRoot < 0 ? Math.sqrt(Math.abs(partialRoot)) : 0;
+  const firstRootReal = (-dampingCoefficient2 + partialRootReal) * 0.5;
+  const firstRootImaginary = partialRootImaginary * 0.5;
+  const secondRootReal = (-dampingCoefficient2 - partialRootReal) * 0.5;
+  return estimateDurationInternal(
+    firstRootReal,
+    firstRootImaginary,
+    secondRootReal,
+    dampingRatio,
+    initialVelocity,
+    initialDisplacement,
+    delta
+  );
+}
+function estimateUnderDamped(firstRootReal, firstRootImaginary, p0, v0, delta) {
+  const r = firstRootReal;
+  const c1 = p0;
+  const c2 = (v0 - r * c1) / firstRootImaginary;
+  const c = Math.sqrt(c1 * c1 + c2 * c2);
+  return Math.log(delta / c) / r;
+}
+var isNotFinite = (x) => !Number.isFinite(x);
+var iterateNewtonsMethod = (x, fn, fnPrime) => x - fn(x) / fnPrime(x);
+function estimateCriticallyDamped(firstRootReal, p0, v0, delta) {
+  const r = firstRootReal;
+  const c1 = p0;
+  const c2 = v0 - r * c1;
+  const t1 = Math.log(Math.abs(delta / c1)) / r;
+  const t2 = (() => {
+    const guess = Math.log(Math.abs(delta / c2));
+    let t = guess;
+    for (let i = 0; i <= 5; i++) {
+      t = guess - Math.log(Math.abs(t / r));
+    }
+    return t;
+  })() / r;
+  let tCurr = isNotFinite(t1) ? t2 : isNotFinite(t2) ? t1 : Math.max(t1, t2);
+  const tInflection = -(r * c1 + c2) / (r * c2);
+  const xInflection = c1 * Math.exp(r * tInflection) + c2 * tInflection * Math.exp(r * tInflection);
+  let signedDelta;
+  if (Number.isNaN(tInflection) || tInflection <= 0) {
+    signedDelta = -delta;
+  } else if (tInflection > 0 && -xInflection < delta) {
+    if (c2 < 0 && c1 > 0) {
+      tCurr = 0;
+    }
+    signedDelta = -delta;
+  } else {
+    tCurr = -(2 / r) - c1 / c2;
+    signedDelta = delta;
+  }
+  let tDelta = Number.MAX_VALUE;
+  let iterations = 0;
+  while (tDelta > 1e-3 && iterations < 100) {
+    iterations++;
+    const tLast = tCurr;
+    tCurr = iterateNewtonsMethod(
+      tCurr,
+      (t) => (c1 + c2 * t) * Math.exp(r * t) + signedDelta,
+      (t) => (c2 * (r * t + 1) + c1 * r) * Math.exp(r * t)
+    );
+    tDelta = Math.abs(tLast - tCurr);
+  }
+  return tCurr;
+}
+function estimateOverDamped(firstRootReal, secondRootReal, p0, v0, delta) {
+  const r1 = firstRootReal;
+  const r2 = secondRootReal;
+  const c2 = (r1 * p0 - v0) / (r1 - r2);
+  const c1 = p0 - c2;
+  const t1 = Math.log(Math.abs(delta / c1)) / r1;
+  const t2 = Math.log(Math.abs(delta / c2)) / r2;
+  let tCurr = isNotFinite(t1) ? t2 : isNotFinite(t2) ? t1 : Math.max(t1, t2);
+  const tInflection = Math.log(c1 * r1 / (-c2 * r2)) / (r2 - r1);
+  const xInflection = () => c1 * Math.exp(r1 * tInflection) + c2 * Math.exp(r2 * tInflection);
+  let signedDelta;
+  if (Number.isNaN(tInflection) || tInflection <= 0) {
+    signedDelta = -delta;
+  } else if (tInflection > 0 && -xInflection() < delta) {
+    if (c2 > 0 && c1 < 0) {
+      tCurr = 0;
+    }
+    signedDelta = -delta;
+  } else {
+    tCurr = Math.log(-(c2 * r2 * r2) / (c1 * r1 * r1)) / (r1 - r2);
+    signedDelta = delta;
+  }
+  if (Math.abs(c1 * r1 * Math.exp(r1 * tCurr) + c2 * r2 * Math.exp(r2 * tCurr)) < 1e-4) {
+    return tCurr;
+  }
+  let tDelta = Number.MAX_VALUE;
+  let iterations = 0;
+  while (tDelta > 1e-3 && iterations < 100) {
+    iterations++;
+    const tLast = tCurr;
+    tCurr = iterateNewtonsMethod(
+      tCurr,
+      (t) => c1 * Math.exp(r1 * t) + c2 * Math.exp(r2 * t) + signedDelta,
+      (t) => c1 * r1 * Math.exp(r1 * t) + c2 * r2 * Math.exp(r2 * t)
+    );
+    tDelta = Math.abs(tLast - tCurr);
+  }
+  return tCurr;
+}
+function estimateDurationInternal(firstRootReal, firstRootImaginary, secondRootReal, dampingRatio, initialVelocity, initialPosition, delta) {
+  if (initialPosition === 0 && initialVelocity === 0) {
+    return 0;
+  }
+  const v0 = initialPosition < 0 ? -initialVelocity : initialVelocity;
+  const p0 = Math.abs(initialPosition);
+  const seconds = dampingRatio > 1 ? estimateOverDamped(firstRootReal, secondRootReal, p0, v0, delta) : dampingRatio < 1 ? estimateUnderDamped(firstRootReal, firstRootImaginary, p0, v0, delta) : estimateCriticallyDamped(firstRootReal, p0, v0, delta);
+  return toLong(seconds * 1e3);
+}
+
+// src/spring-simulation.ts
+var f32 = Math.fround;
+var STIFFNESS_VERY_LOW = 50;
+var DAMPING_RATIO_NO_BOUNCY = 1;
+var SpringSimulation = class {
+  // Natural frequency
+  #naturalFreq = Math.sqrt(STIFFNESS_VERY_LOW);
+  #dampingRatio = DAMPING_RATIO_NO_BOUNCY;
+  #finalPosition;
+  constructor(finalPosition) {
+    this.#finalPosition = f32(finalPosition);
+  }
+  get finalPosition() {
+    return this.#finalPosition;
+  }
+  set finalPosition(value) {
+    this.#finalPosition = f32(value);
+  }
+  /** Stiffness of the spring. */
+  get stiffness() {
+    return f32(this.#naturalFreq * this.#naturalFreq);
+  }
+  set stiffness(value) {
+    if (this.stiffness <= 0) {
+      throw new RangeError("Spring stiffness constant must be positive.");
+    }
+    this.#naturalFreq = Math.sqrt(f32(value));
+  }
+  /** Returns the damping ratio of the spring. */
+  get dampingRatio() {
+    return this.#dampingRatio;
+  }
+  set dampingRatio(value) {
+    if (value < 0) {
+      throw new RangeError("Damping ratio must be non-negative");
+    }
+    this.#dampingRatio = f32(value);
+  }
+  getAcceleration(lastDisplacement, lastVelocity) {
+    const adjustedDisplacement = f32(f32(lastDisplacement) - this.#finalPosition);
+    const k = this.#naturalFreq * this.#naturalFreq;
+    const c = 2 * this.#naturalFreq * this.#dampingRatio;
+    return f32(-k * adjustedDisplacement - c * f32(lastVelocity));
+  }
+  /**
+   * Internal only call for Spring to calculate the spring position/velocity using an analytical
+   * approach.
+   */
+  updateValues(lastDisplacement, lastVelocity, timeElapsed) {
+    const dampingRatio = this.#dampingRatio;
+    const naturalFreq = this.#naturalFreq;
+    const velocity0 = f32(lastVelocity);
+    const adjustedDisplacement = f32(f32(lastDisplacement) - this.#finalPosition);
+    const deltaT = Math.trunc(timeElapsed) / 1e3;
+    const dampingRatioSquared = dampingRatio * dampingRatio;
+    const r = -dampingRatio * naturalFreq;
+    let displacement;
+    let currentVelocity;
+    if (dampingRatio > 1) {
+      const s = naturalFreq * Math.sqrt(dampingRatioSquared - 1);
+      const gammaPlus = r + s;
+      const gammaMinus = r - s;
+      const coeffB = (gammaMinus * adjustedDisplacement - velocity0) / (gammaMinus - gammaPlus);
+      const coeffA = adjustedDisplacement - coeffB;
+      displacement = coeffA * Math.exp(gammaMinus * deltaT) + coeffB * Math.exp(gammaPlus * deltaT);
+      currentVelocity = coeffA * gammaMinus * Math.exp(gammaMinus * deltaT) + coeffB * gammaPlus * Math.exp(gammaPlus * deltaT);
+    } else if (dampingRatio === 1) {
+      const coeffA = adjustedDisplacement;
+      const coeffB = velocity0 + naturalFreq * adjustedDisplacement;
+      const nFdT = -naturalFreq * deltaT;
+      displacement = (coeffA + coeffB * deltaT) * Math.exp(nFdT);
+      currentVelocity = (coeffA + coeffB * deltaT) * Math.exp(nFdT) * -naturalFreq + coeffB * Math.exp(nFdT);
+    } else {
+      const dampedFreq = naturalFreq * Math.sqrt(1 - dampingRatioSquared);
+      const cosCoeff = adjustedDisplacement;
+      const sinCoeff = 1 / dampedFreq * (-r * adjustedDisplacement + velocity0);
+      const dFdT = dampedFreq * deltaT;
+      displacement = Math.exp(r * deltaT) * (cosCoeff * Math.cos(dFdT) + sinCoeff * Math.sin(dFdT));
+      currentVelocity = displacement * r + Math.exp(r * deltaT) * (-dampedFreq * cosCoeff * Math.sin(dFdT) + dampedFreq * sinCoeff * Math.cos(dFdT));
+    }
+    return {
+      value: f32(displacement + this.#finalPosition),
+      velocity: f32(currentVelocity)
+    };
+  }
+};
+
+// src/spring.ts
+var DEFAULT_DISPLACEMENT_THRESHOLD = 0.01;
+var f322 = Math.fround;
+function simulation(spec, targetValue) {
+  const sim = new SpringSimulation(targetValue);
+  sim.dampingRatio = spec.dampingRatio;
+  sim.stiffness = spec.stiffness;
+  return sim;
+}
+function springValue(spec, playTimeMillis, initialValue, targetValue, initialVelocity = 0) {
+  return simulation(spec, targetValue).updateValues(initialValue, initialVelocity, playTimeMillis).value;
+}
+function springVelocity(spec, playTimeMillis, initialValue, targetValue, initialVelocity = 0) {
+  return simulation(spec, targetValue).updateValues(initialValue, initialVelocity, playTimeMillis).velocity;
+}
+function springDurationMillis(spec, initialValue, targetValue, initialVelocity = 0, visibilityThreshold = DEFAULT_DISPLACEMENT_THRESHOLD) {
+  const sim = simulation(spec, targetValue);
+  const threshold = f322(visibilityThreshold);
+  return estimateAnimationDurationMillis(
+    sim.stiffness,
+    sim.dampingRatio,
+    f322(f322(initialVelocity) / threshold),
+    f322(f322(f322(initialValue) - f322(targetValue)) / threshold),
+    1
+  );
+}
+function dampingCoefficient(spec, mass = 1) {
+  return 2 * spec.dampingRatio * Math.sqrt(spec.stiffness * mass);
+}
+function dampingRatioFromCoefficient(damping, stiffness, mass = 1) {
+  return damping / (2 * Math.sqrt(stiffness * mass));
+}
+
+// src/linear.ts
+var round = (n, digits) => {
+  const r = Number(n.toFixed(digits));
+  return Object.is(r, -0) ? 0 : r;
+};
+function at(list, i) {
+  const item = list[i];
+  if (item === void 0) throw new RangeError(`index ${String(i)} out of range`);
+  return item;
+}
+function simplify(points, tolerance) {
+  const keep = /* @__PURE__ */ new Set([0, points.length - 1]);
+  const stack = [[0, points.length - 1]];
+  for (let range = stack.pop(); range; range = stack.pop()) {
+    const [a, b] = range;
+    const [x0, y0] = at(points, a);
+    const [x1, y1] = at(points, b);
+    let worst = -1;
+    let worstDistance = tolerance;
+    for (let i = a + 1; i < b; i++) {
+      const [x, y] = at(points, i);
+      const expected = y0 + (y1 - y0) * (x - x0) / (x1 - x0);
+      const distance = Math.abs(y - expected);
+      if (distance > worstDistance) {
+        worst = i;
+        worstDistance = distance;
+      }
+    }
+    if (worst !== -1) {
+      keep.add(worst);
+      stack.push([a, worst], [worst, b]);
+    }
+  }
+  return [...keep].sort((x, y) => x - y);
+}
+function interpolate(stops, x) {
+  for (let i = 1; i < stops.length; i++) {
+    const [x1, y1] = at(stops, i);
+    const [x0, y0] = at(stops, i - 1);
+    if (x <= x1) return x1 === x0 ? y1 : y0 + (y1 - y0) * (x - x0) / (x1 - x0);
+  }
+  return at(stops, stops.length - 1)[1];
+}
+function springToLinear(spec, options = {}) {
+  const { visibilityThreshold = 1e-3, maxStops = 40 } = options;
+  if (maxStops < 2) throw new RangeError("maxStops must be at least 2");
+  const durationMillis = Math.max(1, springDurationMillis(spec, 0, 1, 0, visibilityThreshold));
+  const sim = new SpringSimulation(1);
+  sim.dampingRatio = spec.dampingRatio;
+  sim.stiffness = spec.stiffness;
+  const samples = [];
+  for (let t = 0; t <= durationMillis; t++) {
+    samples.push([t / durationMillis, sim.updateValues(0, 0, t).value]);
+  }
+  samples[samples.length - 1] = [1, 1];
+  let lo = 0;
+  let hi = 0.5;
+  let best = simplify(samples, hi);
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    const kept = simplify(samples, mid);
+    if (kept.length <= maxStops) {
+      best = kept;
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  const stops = best.map((i) => {
+    const [x, y] = at(samples, i);
+    return [round(x, 4), round(y, 4)];
+  });
+  const maxError = samples.reduce(
+    (m, [x, y]) => Math.max(m, Math.abs(interpolate(stops, x) - y)),
+    0
+  );
+  const body = stops.map(
+    ([x, y], i) => i === 0 || i === stops.length - 1 ? String(y) : `${String(y)} ${String(round(x * 100, 2))}%`
+  );
+  return { easing: `linear(${body.join(", ")})`, durationMillis, stops, maxError };
+}
+
+// src/loading-indicator.ts
+var FULL_ROTATION = 360;
+var QUARTER_ROTATION = FULL_ROTATION / 4;
+var initialIndeterminateFrame = {
+  morphIndex: 0,
+  morphProgress: 0,
+  rotation: QUARTER_ROTATION
+};
+var morphSpringDurationMillis = (timing) => springDurationMillis(timing.spring, 0, 1, 0, timing.visibilityThreshold);
+function indeterminateFrame(elapsedMillis, morphCount, timing) {
+  const t = Math.max(0, elapsedMillis);
+  const springMillis = morphSpringDurationMillis(timing);
+  const period = Math.max(timing.morphIntervalMillis, springMillis);
+  const completed = Math.floor(t / period);
+  const local = t - completed * period;
+  const running = local < springMillis;
+  const finished = running ? completed : completed + 1;
+  const morphIndex = finished % morphCount;
+  const targetAngle = QUARTER_ROTATION * (finished + 1) % FULL_ROTATION;
+  const morphProgress = running ? springValue(timing.spring, Math.floor(local), 0, 1) : 0;
+  const globalRotation = FULL_ROTATION * Math.floor(t % timing.rotationDurationMillis) / timing.rotationDurationMillis;
+  return {
+    morphIndex,
+    morphProgress,
+    rotation: morphProgress * QUARTER_ROTATION + targetAngle + globalRotation
+  };
+}
+
+// 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;
+}
+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;
+}
+
+export { DEFAULT_DISPLACEMENT_THRESHOLD, SpringSimulation, appBarScrollState, collapsedFraction, dampingCoefficient, dampingRatioFromCoefficient, estimateAnimationDurationMillis, estimateAnimationDurationMillisDouble, indeterminateFrame, initialIndeterminateFrame, isScrolledUnder, morphSpringDurationMillis, overlappedFraction, scrollAppBar, settleTarget, springDurationMillis, springToLinear, springValue, springVelocity, withHeight, withHeightOffset };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spring-estimation.ts","../src/spring-simulation.ts","../src/spring.ts","../src/linear.ts","../src/loading-indicator.ts","../src/app-bar-scroll.ts"],"names":["f32","dampingCoefficient"],"mappings":"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","file":"index.js","sourcesContent":["/*\n * Copyright 2020 The Android Open Source Project\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Ported to TypeScript by Kyra Labs from compose/animation/animation-core/src/commonMain/kotlin/androidx/compose/animation/core/SpringEstimation.kt@19991f2c0858aadfcb442ce02b2c8e4743c96898\n//\n// The Float overload's arguments are rounded to float32 (Math.fround) before widening to Double,\n// as in Kotlin. Durations are Long milliseconds: Kotlin's Double.toLong() (truncation, NaN → 0,\n// saturating) is reproduced by `toLong`.\n\n/** Maximum duration in Milliseconds. This takes into account that the duration will be converted to nanos. */\n// Long.MAX_VALUE / Long.MIN_VALUE as doubles (2^63 is what Kotlin's Long.toDouble() yields).\nconst LONG_MAX = 2 ** 63;\nconst LONG_MIN = -(2 ** 63);\nconst MAX_LONG_MILLIS = 9_223_372_036_854; // Long.MAX_VALUE / 1_000_000 (integer division)\n\nconst toLong = (x: number): number =>\n  Number.isNaN(x) ? 0 : x >= LONG_MAX ? LONG_MAX : x <= LONG_MIN ? LONG_MIN : Math.trunc(x);\n\n/**\n * Returns the estimated time that the spring will last be at [delta]. Arguments are Kotlin\n * `Float`s (rounded to float32).\n */\nexport function estimateAnimationDurationMillis(\n  stiffness: number,\n  dampingRatio: number,\n  initialVelocity: number,\n  initialDisplacement: number,\n  delta: number,\n): number {\n  const f32 = Math.fround;\n  if (f32(dampingRatio) === 0) {\n    // No damping, duration is infinite (max value).\n    return MAX_LONG_MILLIS;\n  }\n\n  return estimateAnimationDurationMillisDouble(\n    f32(stiffness),\n    f32(dampingRatio),\n    f32(initialVelocity),\n    f32(initialDisplacement),\n    f32(delta),\n  );\n}\n\n/** Returns the estimated time that the spring will last be at [delta] (Double overload). */\nexport function estimateAnimationDurationMillisDouble(\n  stiffness: number,\n  dampingRatio: number,\n  initialVelocity: number,\n  initialDisplacement: number,\n  delta: number,\n): number {\n  const dampingCoefficient = 2.0 * dampingRatio * Math.sqrt(stiffness);\n\n  // Compute the roots of the polynomial [a]x^2+[b]x+[c]=0 which may be complex.\n  // Here a is set to the constant 1.0, and folded into the other computations\n  const partialRoot = dampingCoefficient * dampingCoefficient - 4.0 * stiffness;\n  const partialRootReal = partialRoot < 0.0 ? 0.0 : Math.sqrt(partialRoot);\n  const partialRootImaginary = partialRoot < 0.0 ? Math.sqrt(Math.abs(partialRoot)) : 0.0;\n\n  const firstRootReal = (-dampingCoefficient + partialRootReal) * 0.5;\n  const firstRootImaginary = partialRootImaginary * 0.5;\n  const secondRootReal = (-dampingCoefficient - partialRootReal) * 0.5;\n\n  return estimateDurationInternal(\n    firstRootReal,\n    firstRootImaginary,\n    secondRootReal,\n    dampingRatio,\n    initialVelocity,\n    initialDisplacement,\n    delta,\n  );\n}\n\n/**\n * In the under-damped case we simply calculate the envelope of the function. The general solution\n * is of the form x(t) = c_1*e^(r*t)*cos(...) + c_2*e^(r*t)sin(...) which simplifies to x(t) =\n * c*e^(r*t)*cos(...) where c*e^(r*t) is the envelope of x(t)\n */\nfunction estimateUnderDamped(\n  firstRootReal: number,\n  firstRootImaginary: number,\n  p0: number,\n  v0: number,\n  delta: number,\n): number {\n  const r = firstRootReal;\n  const c1 = p0;\n  const c2 = (v0 - r * c1) / firstRootImaginary;\n  const c = Math.sqrt(c1 * c1 + c2 * c2);\n\n  return Math.log(delta / c) / r;\n}\n\nconst isNotFinite = (x: number) => !Number.isFinite(x);\n\nconst iterateNewtonsMethod = (\n  x: number,\n  fn: (t: number) => number,\n  fnPrime: (t: number) => number,\n): number => x - fn(x) / fnPrime(x);\n\n/**\n * In the critically-damped case we apply Newton-Raphson's iterative numerical method of solving the\n * equation x(t) = c_1*e^(r*t) + c_2*t*e^(r*t)\n */\nfunction estimateCriticallyDamped(\n  firstRootReal: number,\n  p0: number,\n  v0: number,\n  delta: number,\n): number {\n  const r = firstRootReal;\n  const c1 = p0;\n  const c2 = v0 - r * c1;\n\n  // For our initial guess, determine the max t of c_1*e^(r*t) = delta and\n  // c_2*t*e^(r*t) = delta\n  const t1 = Math.log(Math.abs(delta / c1)) / r;\n  const t2 =\n    (() => {\n      // Application of Lambert's W function to solve te^t\n      const guess = Math.log(Math.abs(delta / c2));\n      let t = guess;\n      for (let i = 0; i <= 5; i++) {\n        t = guess - Math.log(Math.abs(t / r));\n      }\n      return t;\n    })() / r;\n  let tCurr = isNotFinite(t1) ? t2 : isNotFinite(t2) ? t1 : Math.max(t1, t2);\n\n  // Calculate the inflection time. This is important if the inflection is in t > 0\n  const tInflection = -(r * c1 + c2) / (r * c2);\n  const xInflection = c1 * Math.exp(r * tInflection) + c2 * tInflection * Math.exp(r * tInflection);\n\n  // For inflection that does not exist in real time, we always solve for x(t)=delta. Note\n  // the system is manipulated such that p0 is always positive.\n  let signedDelta: number;\n  if (Number.isNaN(tInflection) || tInflection <= 0.0) {\n    signedDelta = -delta;\n  } else if (tInflection > 0.0 && -xInflection < delta) {\n    // In this scenario the first crossing with the threshold is to be found. Note that\n    // the inflection does not exceed delta. As such, we search from the left.\n    if (c2 < 0 && c1 > 0) {\n      tCurr = 0.0;\n    }\n    signedDelta = -delta;\n  } else {\n    // In this scenario there are three total crossings of the threshold, once from\n    // above, and then once when the inflection exceeds the threshold and then one last\n    // one when x(t) finally decays to zero. The point of determining concavity is to\n    // find the final crossing.\n    //\n    // By finding a point between when concavity changes, and when the inflection point is,\n    // Newton's method will always converge onto the rightmost point (in this case),\n    // the one that we are interested in.\n    tCurr = -(2.0 / r) - c1 / c2;\n    signedDelta = delta;\n  }\n\n  let tDelta = Number.MAX_VALUE;\n  let iterations = 0;\n  while (tDelta > 0.001 && iterations < 100) {\n    iterations++;\n    const tLast = tCurr;\n    tCurr = iterateNewtonsMethod(\n      tCurr,\n      (t) => (c1 + c2 * t) * Math.exp(r * t) + signedDelta,\n      (t) => (c2 * (r * t + 1) + c1 * r) * Math.exp(r * t),\n    );\n    tDelta = Math.abs(tLast - tCurr);\n  }\n\n  return tCurr;\n}\n\n/**\n * In the over-damped case we apply Newton-Raphson's iterative numerical method of solving the\n * equation x(t) = c_1*e^(r_1*t) + c_2*e^(r_2*t)\n */\nfunction estimateOverDamped(\n  firstRootReal: number,\n  secondRootReal: number,\n  p0: number,\n  v0: number,\n  delta: number,\n): number {\n  const r1 = firstRootReal;\n  const r2 = secondRootReal;\n  const c2 = (r1 * p0 - v0) / (r1 - r2);\n  const c1 = p0 - c2;\n\n  // For our initial guess, determine the max t of c_1*e^(r_1*t) = delta and\n  // c_2*e^(r_2*t) = delta\n  const t1 = Math.log(Math.abs(delta / c1)) / r1;\n  const t2 = Math.log(Math.abs(delta / c2)) / r2;\n\n  let tCurr = isNotFinite(t1) ? t2 : isNotFinite(t2) ? t1 : Math.max(t1, t2);\n\n  // Calculate the inflection time. This is important if the inflection is in t > 0\n  const tInflection = Math.log((c1 * r1) / (-c2 * r2)) / (r2 - r1);\n  const xInflection = () => c1 * Math.exp(r1 * tInflection) + c2 * Math.exp(r2 * tInflection);\n\n  // For inflection that does not exist in real time, we always solve for x(t)=delta. Note\n  // the system is manipulated such that p0 is always positive.\n  let signedDelta: number;\n  if (Number.isNaN(tInflection) || tInflection <= 0.0) {\n    signedDelta = -delta;\n  } else if (tInflection > 0.0 && -xInflection() < delta) {\n    // In this scenario the first crossing with the threshold is to be found. Note that\n    // the inflection does not exceed delta. As such, we search from the left.\n    if (c2 > 0.0 && c1 < 0.0) {\n      tCurr = 0.0;\n    }\n    signedDelta = -delta;\n  } else {\n    // In this scenario there are three total crossings of the threshold, once from\n    // above, and then once when the inflection exceeds the threshold and then one last\n    // one when x(t) finally decays to zero. The point of determining concavity is to\n    // find the final crossing.\n    //\n    // By finding a point between when concavity changes, and when the inflection point is,\n    // Newton's method will always converge onto the rightmost point (in this case),\n    // the one that we are interested in.\n    tCurr = Math.log(-(c2 * r2 * r2) / (c1 * r1 * r1)) / (r1 - r2);\n    signedDelta = delta;\n  }\n\n  // For a good initial guess, simply return\n  if (Math.abs(c1 * r1 * Math.exp(r1 * tCurr) + c2 * r2 * Math.exp(r2 * tCurr)) < 0.0001) {\n    return tCurr;\n  }\n  let tDelta = Number.MAX_VALUE;\n\n  // Cap iterations for safety - Experimentally this method takes <= 5 iterations\n  let iterations = 0;\n  while (tDelta > 0.001 && iterations < 100) {\n    iterations++;\n    const tLast = tCurr;\n    tCurr = iterateNewtonsMethod(\n      tCurr,\n      (t) => c1 * Math.exp(r1 * t) + c2 * Math.exp(r2 * t) + signedDelta,\n      (t) => c1 * r1 * Math.exp(r1 * t) + c2 * r2 * Math.exp(r2 * t),\n    );\n    tDelta = Math.abs(tLast - tCurr);\n  }\n\n  return tCurr;\n}\n\n// Applies Newton-Raphson's method to solve for the estimated time the spring mass system will\n// last be at [delta].\nfunction estimateDurationInternal(\n  firstRootReal: number,\n  firstRootImaginary: number,\n  secondRootReal: number,\n  dampingRatio: number,\n  initialVelocity: number,\n  initialPosition: number,\n  delta: number,\n): number {\n  if (initialPosition === 0.0 && initialVelocity === 0.0) {\n    return 0;\n  }\n\n  const v0 = initialPosition < 0 ? -initialVelocity : initialVelocity;\n  const p0 = Math.abs(initialPosition);\n\n  const seconds =\n    dampingRatio > 1.0\n      ? estimateOverDamped(firstRootReal, secondRootReal, p0, v0, delta)\n      : dampingRatio < 1.0\n        ? estimateUnderDamped(firstRootReal, firstRootImaginary, p0, v0, delta)\n        : estimateCriticallyDamped(firstRootReal, p0, v0, delta);\n  return toLong(seconds * 1000.0);\n}\n","/*\n * Copyright 2019 The Android Open Source Project\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Ported to TypeScript by Kyra Labs from compose/animation/animation-core/src/commonMain/kotlin/androidx/compose/animation/core/SpringSimulation.kt@19991f2c0858aadfcb442ce02b2c8e4743c96898\n//\n// Precision follows the Kotlin source: parameters and results are Float (Math.fround), the\n// solution is computed in Double, and time is whole milliseconds.\n\nconst f32 = Math.fround;\n\n/** `Spring.StiffnessVeryLow` / `Spring.DampingRatioNoBouncy` (VectorizedAnimationSpec.kt L813, L839). */\nconst STIFFNESS_VERY_LOW = 50;\nconst DAMPING_RATIO_NO_BOUNCY = 1;\n\nexport interface Motion {\n  value: number;\n  velocity: number;\n}\n\n/**\n * Spring Simulation simulates spring physics, and allows you to query the motion (i.e. value and\n * velocity) at certain time in the future based on the starting velocity and value.\n *\n * By configuring the stiffness and damping ratio, callers can create a spring with the look and\n * feel suits their use case. Stiffness corresponds to the spring constant. The stiffer the spring\n * is, the harder it is to stretch it, the faster it undergoes dampening.\n *\n * Spring damping ratio describes how oscillations in a system decay after a disturbance. When\n * damping ratio > 1* (i.e. over-damped), the object will quickly return to the rest position\n * without overshooting. If damping ratio equals to 1 (i.e. critically damped), the object will\n * return to equilibrium within the shortest amount of time. When damping ratio is less than 1 (i.e.\n * under-damped), the mass tends to overshoot, and return, and overshoot again. Without any damping\n * (i.e. damping ratio = 0), the mass will oscillate forever.\n */\nexport class SpringSimulation {\n  // Natural frequency\n  #naturalFreq = Math.sqrt(STIFFNESS_VERY_LOW);\n  #dampingRatio = DAMPING_RATIO_NO_BOUNCY;\n  #finalPosition: number;\n\n  constructor(finalPosition: number) {\n    this.#finalPosition = f32(finalPosition);\n  }\n\n  get finalPosition(): number {\n    return this.#finalPosition;\n  }\n\n  set finalPosition(value: number) {\n    this.#finalPosition = f32(value);\n  }\n\n  /** Stiffness of the spring. */\n  get stiffness(): number {\n    return f32(this.#naturalFreq * this.#naturalFreq);\n  }\n\n  set stiffness(value: number) {\n    // Upstream checks the *current* stiffness here (always positive), so the new value is not\n    // validated; kept as-is for parity.\n    if (this.stiffness <= 0) {\n      throw new RangeError('Spring stiffness constant must be positive.');\n    }\n    this.#naturalFreq = Math.sqrt(f32(value));\n  }\n\n  /** Returns the damping ratio of the spring. */\n  get dampingRatio(): number {\n    return this.#dampingRatio;\n  }\n\n  set dampingRatio(value: number) {\n    if (value < 0) {\n      throw new RangeError('Damping ratio must be non-negative');\n    }\n    this.#dampingRatio = f32(value);\n  }\n\n  getAcceleration(lastDisplacement: number, lastVelocity: number): number {\n    const adjustedDisplacement = f32(f32(lastDisplacement) - this.#finalPosition);\n\n    const k = this.#naturalFreq * this.#naturalFreq;\n    const c = 2.0 * this.#naturalFreq * this.#dampingRatio;\n\n    return f32(-k * adjustedDisplacement - c * f32(lastVelocity));\n  }\n\n  /**\n   * Internal only call for Spring to calculate the spring position/velocity using an analytical\n   * approach.\n   */\n  updateValues(lastDisplacement: number, lastVelocity: number, timeElapsed: number): Motion {\n    const dampingRatio = this.#dampingRatio;\n    const naturalFreq = this.#naturalFreq;\n    const velocity0 = f32(lastVelocity);\n    const adjustedDisplacement = f32(f32(lastDisplacement) - this.#finalPosition);\n    const deltaT = Math.trunc(timeElapsed) / 1000.0; // unit: seconds\n    const dampingRatioSquared = dampingRatio * dampingRatio;\n    const r = -dampingRatio * naturalFreq;\n\n    let displacement: number;\n    let currentVelocity: number;\n\n    if (dampingRatio > 1) {\n      // Over damping\n      const s = naturalFreq * Math.sqrt(dampingRatioSquared - 1);\n      const gammaPlus = r + s;\n      const gammaMinus = r - s;\n\n      // Overdamped\n      const coeffB = (gammaMinus * adjustedDisplacement - velocity0) / (gammaMinus - gammaPlus);\n      const coeffA = adjustedDisplacement - coeffB;\n      displacement = coeffA * Math.exp(gammaMinus * deltaT) + coeffB * Math.exp(gammaPlus * deltaT);\n      currentVelocity =\n        coeffA * gammaMinus * Math.exp(gammaMinus * deltaT) +\n        coeffB * gammaPlus * Math.exp(gammaPlus * deltaT);\n    } else if (dampingRatio === 1.0) {\n      // Critically damped\n      const coeffA = adjustedDisplacement;\n      const coeffB = velocity0 + naturalFreq * adjustedDisplacement;\n      const nFdT = -naturalFreq * deltaT;\n      displacement = (coeffA + coeffB * deltaT) * Math.exp(nFdT);\n      currentVelocity =\n        (coeffA + coeffB * deltaT) * Math.exp(nFdT) * -naturalFreq + coeffB * Math.exp(nFdT);\n    } else {\n      const dampedFreq = naturalFreq * Math.sqrt(1 - dampingRatioSquared);\n      // Underdamped\n      const cosCoeff = adjustedDisplacement;\n      const sinCoeff = (1 / dampedFreq) * (-r * adjustedDisplacement + velocity0);\n      const dFdT = dampedFreq * deltaT;\n      displacement = Math.exp(r * deltaT) * (cosCoeff * Math.cos(dFdT) + sinCoeff * Math.sin(dFdT));\n      currentVelocity =\n        displacement * r +\n        Math.exp(r * deltaT) *\n          (-dampedFreq * cosCoeff * Math.sin(dFdT) + dampedFreq * sinCoeff * Math.cos(dFdT));\n    }\n\n    return {\n      value: f32(displacement + this.#finalPosition),\n      velocity: f32(currentVelocity),\n    };\n  }\n}\n","// Spring helpers with Compose `FloatSpringSpec` semantics (animation-core FloatAnimationSpec.kt\n// L133–187 @19991f2c), built on the ported SpringSimulation / SpringEstimation.\nimport { estimateAnimationDurationMillis } from './spring-estimation.js';\nimport { SpringSimulation } from './spring-simulation.js';\n\n/** A Material motion-scheme spring (`dampingRatio` ζ, `stiffness` k; mass 1). */\nexport interface SpringSpec {\n  readonly dampingRatio: number;\n  readonly stiffness: number;\n}\n\n/** `Spring.DefaultDisplacementThreshold` (VectorizedAnimationSpec.kt L842). */\nexport const DEFAULT_DISPLACEMENT_THRESHOLD = 0.01;\n\nconst f32 = Math.fround;\n\nfunction simulation(spec: SpringSpec, targetValue: number): SpringSimulation {\n  const sim = new SpringSimulation(targetValue);\n  sim.dampingRatio = spec.dampingRatio;\n  sim.stiffness = spec.stiffness;\n  return sim;\n}\n\n/** Value at `playTimeMillis` (whole milliseconds, as in Compose). */\nexport function springValue(\n  spec: SpringSpec,\n  playTimeMillis: number,\n  initialValue: number,\n  targetValue: number,\n  initialVelocity = 0,\n): number {\n  return simulation(spec, targetValue).updateValues(initialValue, initialVelocity, playTimeMillis)\n    .value;\n}\n\n/** Velocity (units/s) at `playTimeMillis`. */\nexport function springVelocity(\n  spec: SpringSpec,\n  playTimeMillis: number,\n  initialValue: number,\n  targetValue: number,\n  initialVelocity = 0,\n): number {\n  return simulation(spec, targetValue).updateValues(initialValue, initialVelocity, playTimeMillis)\n    .velocity;\n}\n\n/**\n * Duration until the spring stays within `visibilityThreshold` of the target, as Compose computes\n * it (`FloatSpringSpec.getDurationNanos` / 1e6).\n */\nexport function springDurationMillis(\n  spec: SpringSpec,\n  initialValue: number,\n  targetValue: number,\n  initialVelocity = 0,\n  visibilityThreshold = DEFAULT_DISPLACEMENT_THRESHOLD,\n): number {\n  const sim = simulation(spec, targetValue);\n  const threshold = f32(visibilityThreshold);\n  return estimateAnimationDurationMillis(\n    sim.stiffness,\n    sim.dampingRatio,\n    f32(f32(initialVelocity) / threshold),\n    f32(f32(f32(initialValue) - f32(targetValue)) / threshold),\n    1,\n  );\n}\n\n/**\n * Damping coefficient c = 2ζ√(k·m), for physics engines parameterized by stiffness/damping/mass\n * (e.g. Motion's `{ type: 'spring', stiffness, damping, mass }`).\n */\nexport function dampingCoefficient(spec: SpringSpec, mass = 1): number {\n  return 2 * spec.dampingRatio * Math.sqrt(spec.stiffness * mass);\n}\n\n/** Inverse of {@link dampingCoefficient}: ζ = c / (2√(k·m)). */\nexport function dampingRatioFromCoefficient(damping: number, stiffness: number, mass = 1): number {\n  return damping / (2 * Math.sqrt(stiffness * mass));\n}\n","// CSS `linear()` approximation of a spring (FOUNDATIONS §4).\n//\n// - Duration: Compose's own settle estimate (`FloatSpringSpec.getDurationNanos`) for a 0 → 1\n//   animation at a visibility threshold of 0.001 (0.1% of the travel; e.g. Compose's 0.1 dp\n//   Dp threshold over a 100 dp move).\n// - Samples: the exact spring at every whole millisecond (Compose's time resolution), last stop\n//   forced to 1 so the animation lands on its target.\n// - Stops: Ramer–Douglas–Peucker in (progress, value) space with the smallest tolerance that fits\n//   `maxStops`.\n//\n// Limits (FOUNDATIONS §4): no velocity carry-over on interruption and a fixed duration; use the JS\n// spring for drags, rapid toggles and other interruptible motion.\nimport { type SpringSpec, springDurationMillis } from './spring.js';\nimport { SpringSimulation } from './spring-simulation.js';\n\nexport interface LinearEasingOptions {\n  /** Fraction of the travel considered settled. Default 0.001. */\n  visibilityThreshold?: number;\n  /** Maximum stops in the `linear()` function (FOUNDATIONS §4: ≤ 40). Default 40. */\n  maxStops?: number;\n}\n\nexport interface LinearEasing {\n  /** e.g. `linear(0, 0.1234 5%, …, 1)` */\n  easing: string;\n  durationMillis: number;\n  /** `[progress 0–1, value]` pairs after rounding. */\n  stops: readonly (readonly [number, number])[];\n  /** Max |linear(t) − spring(t)| over every millisecond sample. */\n  maxError: number;\n}\n\nconst round = (n: number, digits: number) => {\n  const r = Number(n.toFixed(digits));\n  return Object.is(r, -0) ? 0 : r;\n};\n\ntype Point = readonly [number, number];\n\nfunction at<T>(list: readonly T[], i: number): T {\n  const item = list[i];\n  if (item === undefined) throw new RangeError(`index ${String(i)} out of range`);\n  return item;\n}\n\n/** Ramer–Douglas–Peucker: indices of points to keep (vertical distance, monotone x). */\nfunction simplify(points: readonly Point[], tolerance: number): number[] {\n  const keep = new Set<number>([0, points.length - 1]);\n  const stack: [number, number][] = [[0, points.length - 1]];\n  for (let range = stack.pop(); range; range = stack.pop()) {\n    const [a, b] = range;\n    const [x0, y0] = at(points, a);\n    const [x1, y1] = at(points, b);\n    let worst = -1;\n    let worstDistance = tolerance;\n    for (let i = a + 1; i < b; i++) {\n      const [x, y] = at(points, i);\n      const expected = y0 + ((y1 - y0) * (x - x0)) / (x1 - x0);\n      const distance = Math.abs(y - expected);\n      if (distance > worstDistance) {\n        worst = i;\n        worstDistance = distance;\n      }\n    }\n    if (worst !== -1) {\n      keep.add(worst);\n      stack.push([a, worst], [worst, b]);\n    }\n  }\n  return [...keep].sort((x, y) => x - y);\n}\n\nfunction interpolate(stops: readonly Point[], x: number): number {\n  for (let i = 1; i < stops.length; i++) {\n    const [x1, y1] = at(stops, i);\n    const [x0, y0] = at(stops, i - 1);\n    if (x <= x1) return x1 === x0 ? y1 : y0 + ((y1 - y0) * (x - x0)) / (x1 - x0);\n  }\n  return at(stops, stops.length - 1)[1];\n}\n\nexport function springToLinear(spec: SpringSpec, options: LinearEasingOptions = {}): LinearEasing {\n  const { visibilityThreshold = 0.001, maxStops = 40 } = options;\n  if (maxStops < 2) throw new RangeError('maxStops must be at least 2');\n  const durationMillis = Math.max(1, springDurationMillis(spec, 0, 1, 0, visibilityThreshold));\n\n  const sim = new SpringSimulation(1);\n  sim.dampingRatio = spec.dampingRatio;\n  sim.stiffness = spec.stiffness;\n  const samples: Point[] = [];\n  for (let t = 0; t <= durationMillis; t++) {\n    samples.push([t / durationMillis, sim.updateValues(0, 0, t).value]);\n  }\n  samples[samples.length - 1] = [1, 1];\n\n  // Smallest tolerance (bisection) whose simplification fits maxStops.\n  let lo = 0;\n  let hi = 0.5;\n  let best = simplify(samples, hi);\n  for (let i = 0; i < 40; i++) {\n    const mid = (lo + hi) / 2;\n    const kept = simplify(samples, mid);\n    if (kept.length <= maxStops) {\n      best = kept;\n      hi = mid;\n    } else {\n      lo = mid;\n    }\n  }\n\n  const stops = best.map((i) => {\n    const [x, y] = at(samples, i);\n    return [round(x, 4), round(y, 4)] as const;\n  });\n  const maxError = samples.reduce(\n    (m, [x, y]) => Math.max(m, Math.abs(interpolate(stops, x) - y)),\n    0,\n  );\n  const body = stops.map(([x, y], i) =>\n    i === 0 || i === stops.length - 1 ? String(y) : `${String(y)} ${String(round(x * 100, 2))}%`,\n  );\n  return { easing: `linear(${body.join(', ')})`, durationMillis, stops, maxError };\n}\n","/*\n * Copyright 2024 The Android Open Source Project\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Ported to TypeScript by Kyra Labs from compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/LoadingIndicator.kt@19991f2c0858aadfcb442ce02b2c8e4743c96898\n//\n// The indeterminate LoadingIndicator's LaunchedEffect (L391–451) as a pure function of elapsed\n// time. Compose runs two coroutines:\n// - every MorphIntervalMillis a spring animates the morph progress 0 → 1; when it finishes, the\n//   indicator advances to the next morph, snaps the progress to 0 and adds a quarter turn to the\n//   morph rotation. The loop then waits for the rest of the interval (or for the spring, if it is\n//   slower than the interval);\n// - a linear global rotation turns 360° every GlobalRotationDurationMillis, restarting.\n// The drawn rotation is `progress × 90 + morphRotationTargetAngle + globalRotation` (L473).\n// The interval, rotation duration and spring are tokens (components/loading-indicator-motion.css).\n\nimport { type SpringSpec, springDurationMillis, springValue } from './spring.js';\n\nconst FULL_ROTATION = 360;\nconst QUARTER_ROTATION = FULL_ROTATION / 4;\n\nexport interface LoadingIndicatorTiming {\n  /** `MorphIntervalMillis`: how often a morph starts. */\n  readonly morphIntervalMillis: number;\n  /** `GlobalRotationDurationMillis`: one linear turn. */\n  readonly rotationDurationMillis: number;\n  /** The morph spring (`morphAnimationSpec`). */\n  readonly spring: SpringSpec;\n  /** The morph spring's `visibilityThreshold`; it decides when the spring finishes. */\n  readonly visibilityThreshold: number;\n}\n\n/** What the indicator draws: a morph at a progress, rotated clockwise about the center. */\nexport interface IndeterminateFrame {\n  morphIndex: number;\n  /** The raw spring value: it overshoots past 1, as in Compose (the morph extrapolates). */\n  morphProgress: number;\n  /** Degrees, clockwise. */\n  rotation: number;\n}\n\n/**\n * The first frame (and the one held under reduced motion): the first morph at 0, rotated by the\n * initial `morphRotationTargetAngle` (a quarter turn).\n */\nexport const initialIndeterminateFrame: Readonly<IndeterminateFrame> = {\n  morphIndex: 0,\n  morphProgress: 0,\n  rotation: QUARTER_ROTATION,\n};\n\n/** How long one morph spring runs (Compose's `FloatSpringSpec.getDurationNanos`), in ms. */\nexport const morphSpringDurationMillis = (timing: LoadingIndicatorTiming): number =>\n  springDurationMillis(timing.spring, 0, 1, 0, timing.visibilityThreshold);\n\n/**\n * The frame of an indeterminate loading indicator [elapsedMillis] after it started, cycling\n * through [morphCount] morphs.\n */\nexport function indeterminateFrame(\n  elapsedMillis: number,\n  morphCount: number,\n  timing: LoadingIndicatorTiming,\n): IndeterminateFrame {\n  const t = Math.max(0, elapsedMillis);\n  const springMillis = morphSpringDurationMillis(timing);\n  // `delay(MorphIntervalMillis)` then `deferred.await()`: the next morph starts after both.\n  const period = Math.max(timing.morphIntervalMillis, springMillis);\n  const completed = Math.floor(t / period);\n  const local = t - completed * period;\n  const running = local < springMillis;\n  // Each finished spring advances the index and adds a quarter turn (starting at a quarter turn).\n  const finished = running ? completed : completed + 1;\n  const morphIndex = finished % morphCount;\n  const targetAngle = (QUARTER_ROTATION * (finished + 1)) % FULL_ROTATION;\n  // Compose samples the spring at whole milliseconds of play time.\n  const morphProgress = running ? springValue(timing.spring, Math.floor(local), 0, 1) : 0;\n  const globalRotation =\n    (FULL_ROTATION * Math.floor(t % timing.rotationDurationMillis)) / timing.rotationDurationMillis;\n  return {\n    morphIndex,\n    morphProgress,\n    rotation: morphProgress * QUARTER_ROTATION + targetAngle + globalRotation,\n  };\n}\n","/*\n * Copyright 2021 The Android Open Source Project\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Ported to TypeScript by Kyra Labs from compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/AppBar.kt@19991f2c0858aadfcb442ce02b2c8e4743c96898\n//\n// TopAppBarState (L2050-2130), the pinned and enter-always scroll behaviors (L3267-3303,\n// L3400-3455) and the settle decision of settleAppBar (L3542-3589), adapted to DOM scrolling.\n// Compose receives nested\n// scroll deltas and can consume them; the web observes `scrollTop` after the browser scrolled, so\n// every delta goes to both the bar and the content, and momentum comes from the browser instead\n// of flingAnimationSpec. Offsets are in CSS px; y grows downward, so collapsing is negative.\n\n/** How the bar reacts to its scroll container (TopAppBarDefaults.*ScrollBehavior). */\nexport type AppBarScrollBehavior = 'pinned' | 'enter-always';\n\nexport interface AppBarScrollState {\n  /** Most negative height offset: minus the bar's full height (adjustHeightOffsetLimit). */\n  readonly heightOffsetLimit: number;\n  /** Current height offset, between heightOffsetLimit and 0. */\n  readonly heightOffset: number;\n  /** Content scrolled under the bar (minus the scroll position). */\n  readonly contentOffset: number;\n  /** Whether the scrolling content is at its start (scroll position 0). */\n  readonly atStart: boolean;\n}\n\n/** A fully expanded bar of `height` px over unscrolled content. */\nexport function appBarScrollState(height: number): AppBarScrollState {\n  return { heightOffsetLimit: -height, heightOffset: 0, contentOffset: 0, atStart: true };\n}\n\n/** TopAppBarState.heightOffset setter: coerced between heightOffsetLimit and 0. */\nexport function withHeightOffset(state: AppBarScrollState, offset: number): AppBarScrollState {\n  return { ...state, heightOffset: Math.min(Math.max(offset, state.heightOffsetLimit), 0) };\n}\n\n/** A new bar height (onSizeChanged → adjustHeightOffsetLimit), keeping the offset in range. */\nexport function withHeight(state: AppBarScrollState, height: number): AppBarScrollState {\n  return withHeightOffset({ ...state, heightOffsetLimit: -height }, state.heightOffset);\n}\n\n/** 0 = fully expanded, 1 = fully collapsed (TopAppBarState.collapsedFraction). */\nexport function collapsedFraction(state: AppBarScrollState): number {\n  // `+ 0` turns the -0 of 0 / -height into 0.\n  return state.heightOffsetLimit !== 0 ? state.heightOffset / state.heightOffsetLimit + 0 : 0;\n}\n\n/** Share of the visible bar overlapping scrolled content (TopAppBarState.overlappedFraction). */\nexport function overlappedFraction(state: AppBarScrollState): number {\n  if (!state.atStart && state.contentOffset === 0) return 1;\n  if (state.heightOffsetLimit === 0) return 0;\n  const limit = state.heightOffsetLimit;\n  const clamped = Math.min(Math.max(limit + Math.abs(state.contentOffset), limit), 0);\n  return 1 - clamped / limit;\n}\n\n/**\n * Whether the bar shows its scrolled container color: SingleRowTopAppBar targets the scrolled\n * color once `overlappedFraction > 0.01f` (L2689-2693).\n */\nexport function isScrolledUnder(state: AppBarScrollState): boolean {\n  return overlappedFraction(state) > 0.01;\n}\n\n/**\n * Applies a scroll position change. `delta` is the previous minus the new scroll position\n * (positive when the content is pulled down, like Compose's `available.y`).\n * - pinned: only the content offset moves (PinnedScrollBehavior.onPostScroll).\n * - enter-always: the bar also collapses/expands by the same amount\n *   (EnterAlwaysScrollBehavior.onPreScroll: `heightOffset += available.y`).\n */\nexport function scrollAppBar(\n  state: AppBarScrollState,\n  behavior: AppBarScrollBehavior,\n  scrollTop: number,\n  delta: number,\n): AppBarScrollState {\n  const next: AppBarScrollState = { ...state, contentOffset: -scrollTop, atStart: scrollTop <= 0 };\n  return behavior === 'enter-always' ? withHeightOffset(next, state.heightOffset + delta) : next;\n}\n\n/**\n * Where a partially collapsed bar snaps when scrolling stops (settleAppBar): fully expanded below\n * half, fully collapsed from half, or null when it is already (within 1%) settled.\n */\nexport function settleTarget(state: AppBarScrollState): number | null {\n  const fraction = collapsedFraction(state);\n  if (fraction < 0.01 || fraction === 1) return null;\n  if (!(state.heightOffset < 0 && state.heightOffset > state.heightOffsetLimit)) return null;\n  return fraction < 0.5 ? 0 : state.heightOffsetLimit;\n}\n"]}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@kyralabs/m3e-motion",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.1",
+  "description": "Spring and easing math for m3exp-web (internal-first).",
+  "keywords": [
+    "material-design",
+    "material-3",
+    "material-you",
+    "m3-expressive",
+    "design-system",
+    "spring",
+    "animation",
+    "motion"
+  ],
+  "license": "Apache-2.0",
+  "author": "Kyra Labs",
+  "homepage": "https://github.com/kyra-labs/m3exp-web/tree/main/packages/m3e-motion#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kyra-labs/m3exp-web",
+    "directory": "packages/m3e-motion"
+  },
+  "bugs": "https://github.com/kyra-labs/m3exp-web/issues",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "@kyralabs/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
 }