@interstellar-tools/equations 1.1.0 → 1.2.0

package/dist/categories/anomalies/asymptote-true-anomaly.d.ts

@@ -0,0 +1,50 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **true anomaly of a hyperbola's asymptotes**: the limit a body on a hyperbola approaches but never reaches.
+ *
+ * $$
+ * \nu_\infty = \arccos\left(-\frac{1}{e}\right)
+ * $$
+ *
+ * **Units**
+ * - Input: `e` dimensionless.
+ * - Output: $ \nu_\infty $ in **radians**, in (π/2, π).
+ *
+ * ::: info Notes
+ *
+ * - The body comes in from $ -\nu_\infty $ and leaves towards $ +\nu_\infty $.
+ * - The trajectory turns through $ 2\nu_\infty - \pi = 2\arcsin(1/e) $, the turning angle of a flyby; see `gravityAssistTurningAngle`.
+ * - Just above $ e = 1 $ the asymptotes open to almost π (a near-parabola); for large $ e $ they close towards π/2 (a near-straight line).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **134.0°**
+ *
+ * _Asymptote of the approach hyperbola, e = 1.44_
+ *
+ * Without the lunar orbit insertion burn at closest approach, the Moon's gravity would have bent Apollo 11's path through 88° and sent it back out of the Moon's sphere of influence.
+ *
+ * ```ts
+ * asymptoteTrueAnomaly(1.44); // ≈ 2.338 rad, 134.0°
+ * ```
+ *
+ * :::
+ *
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Asymptote true anomaly $ \nu_\infty $ in **radians**.
+ * @throws {TypeError} If `e` is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * asymptoteTrueAnomaly(2); // 2π/3 (120°)
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export declare const asymptoteTrueAnomaly: (e: number) => Radians;
+//# sourceMappingURL=asymptote-true-anomaly.d.ts.map

package/dist/categories/anomalies/asymptote-true-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymptote-true-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/asymptote-true-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,oBAAoB,GAAI,GAAG,MAAM,KAAG,OAOhD,CAAC"}

package/dist/categories/anomalies/asymptote-true-anomaly.js

@@ -0,0 +1,55 @@
+/**
+ * Compute the **true anomaly of a hyperbola's asymptotes**: the limit a body on a hyperbola approaches but never reaches.
+ *
+ * $$
+ * \nu_\infty = \arccos\left(-\frac{1}{e}\right)
+ * $$
+ *
+ * **Units**
+ * - Input: `e` dimensionless.
+ * - Output: $ \nu_\infty $ in **radians**, in (π/2, π).
+ *
+ * ::: info Notes
+ *
+ * - The body comes in from $ -\nu_\infty $ and leaves towards $ +\nu_\infty $.
+ * - The trajectory turns through $ 2\nu_\infty - \pi = 2\arcsin(1/e) $, the turning angle of a flyby; see `gravityAssistTurningAngle`.
+ * - Just above $ e = 1 $ the asymptotes open to almost π (a near-parabola); for large $ e $ they close towards π/2 (a near-straight line).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **134.0°**
+ *
+ * _Asymptote of the approach hyperbola, e = 1.44_
+ *
+ * Without the lunar orbit insertion burn at closest approach, the Moon's gravity would have bent Apollo 11's path through 88° and sent it back out of the Moon's sphere of influence.
+ *
+ * ```ts
+ * asymptoteTrueAnomaly(1.44); // ≈ 2.338 rad, 134.0°
+ * ```
+ *
+ * :::
+ *
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Asymptote true anomaly $ \nu_\infty $ in **radians**.
+ * @throws {TypeError} If `e` is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * asymptoteTrueAnomaly(2); // 2π/3 (120°)
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export const asymptoteTrueAnomaly = (e) => {
+    if (!Number.isFinite(e))
+        throw new TypeError(`e must be a finite number. Received: ${e}`);
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    return Math.acos(-1 / e);
+};
+//# sourceMappingURL=asymptote-true-anomaly.js.map

package/dist/categories/anomalies/asymptote-true-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymptote-true-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/asymptote-true-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAS,EAAW,EAAE;IACzD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrB,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,EAAE,CAAC,CAAC;IAEnE,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAY,CAAC;AACtC,CAAC,CAAC"}

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.d.ts

@@ -0,0 +1,38 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Convert a **hyperbolic anomaly** $ F $ to the **true anomaly** on a hyperbola.
+ *
+ * $$
+ * \tan\frac{\nu}{2} = \sqrt{\frac{e + 1}{e - 1}}\,\tanh\frac{F}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `F` in **radians**, `e` dimensionless.
+ * - Output: $ \nu $ in **radians**, in $ (-\nu_\infty, \nu_\infty) $.
+ *
+ * ::: info Notes
+ *
+ * - The inverse of {@link trueToHyperbolicAnomaly}.
+ * - As $ F \to \pm\infty $, $ \nu $ approaches the asymptotes $ \pm\nu_\infty $ but never reaches them.
+ * - Returns a signed angle, negative before periapsis. Use `norm2pi` for [0, 2π).
+ *
+ * :::
+ *
+ * @param F - Hyperbolic anomaly $ F $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns True anomaly $ \nu $ in **radians**, in (-π, π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * const nu = hyperbolicToTrueAnomaly(Math.acosh(2), 2);
+ * // nu ≈ π/2
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see {@link solveKeplerHyperbolic}
+ */
+export declare const hyperbolicToTrueAnomaly: (F: number, e: number) => Radians;
+//# sourceMappingURL=hyperbolic-to-true-anomaly.d.ts.map

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-to-true-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/hyperbolic-to-true-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,uBAAuB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,OAa9D,CAAC"}

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.js

@@ -0,0 +1,49 @@
+/**
+ * Convert a **hyperbolic anomaly** $ F $ to the **true anomaly** on a hyperbola.
+ *
+ * $$
+ * \tan\frac{\nu}{2} = \sqrt{\frac{e + 1}{e - 1}}\,\tanh\frac{F}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `F` in **radians**, `e` dimensionless.
+ * - Output: $ \nu $ in **radians**, in $ (-\nu_\infty, \nu_\infty) $.
+ *
+ * ::: info Notes
+ *
+ * - The inverse of {@link trueToHyperbolicAnomaly}.
+ * - As $ F \to \pm\infty $, $ \nu $ approaches the asymptotes $ \pm\nu_\infty $ but never reaches them.
+ * - Returns a signed angle, negative before periapsis. Use `norm2pi` for [0, 2π).
+ *
+ * :::
+ *
+ * @param F - Hyperbolic anomaly $ F $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns True anomaly $ \nu $ in **radians**, in (-π, π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * const nu = hyperbolicToTrueAnomaly(Math.acosh(2), 2);
+ * // nu ≈ π/2
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see {@link solveKeplerHyperbolic}
+ */
+export const hyperbolicToTrueAnomaly = (F, e) => {
+    for (const [name, x] of [
+        ['F', F],
+        ['e', e]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    return (2 *
+        Math.atan(Math.sqrt((e + 1) / (e - 1)) * Math.tanh(F / 2)));
+};
+//# sourceMappingURL=hyperbolic-to-true-anomaly.js.map

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-to-true-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/hyperbolic-to-true-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAS,EAAE,CAAS,EAAW,EAAE;IACvE,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,OAAO,CAAC,CAAC;QACP,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAY,CAAC;AAC3E,CAAC,CAAC"}

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.d.ts

@@ -0,0 +1,40 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Convert a **true anomaly** on a hyperbola to the **hyperbolic anomaly** $ F $.
+ *
+ * $$
+ * \tanh\frac{F}{2} = \sqrt{\frac{e - 1}{e + 1}}\,\tan\frac{\nu}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `nu` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The hyperbolic counterpart of the eccentric anomaly. Feed it to $ M_h = e \sinh F - F $ to get a time from periapsis.
+ * - `nu` is wrapped to (-π, π] first, so the incoming branch can be given either as a negative angle or just below 2π, as {@link stateToElements} returns it.
+ * - Only $ |\nu| < \nu_\infty $ exists on a hyperbola; see {@link asymptoteTrueAnomaly}.
+ *
+ * :::
+ *
+ * @param nu - True anomaly $ \nu $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Hyperbolic anomaly $ F $ in **radians**: negative before periapsis, positive after.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1` or `nu` is at or beyond the asymptotes.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = trueToHyperbolicAnomaly((Math.PI / 2) as Radians, 2);
+ * // F ≈ 1.317 (cosh F = e)
+ * ```
+ *
+ * @see {@link hyperbolicToTrueAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export declare const trueToHyperbolicAnomaly: (nu: Radians, e: number) => number;
+//# sourceMappingURL=true-to-hyperbolic-anomaly.d.ts.map

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-hyperbolic-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-hyperbolic-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,GAAI,IAAI,OAAO,EAAE,GAAG,MAAM,KAAG,MAmBhE,CAAC"}

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.js

@@ -0,0 +1,54 @@
+import { asymptoteTrueAnomaly } from './asymptote-true-anomaly.js';
+/**
+ * Convert a **true anomaly** on a hyperbola to the **hyperbolic anomaly** $ F $.
+ *
+ * $$
+ * \tanh\frac{F}{2} = \sqrt{\frac{e - 1}{e + 1}}\,\tan\frac{\nu}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `nu` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The hyperbolic counterpart of the eccentric anomaly. Feed it to $ M_h = e \sinh F - F $ to get a time from periapsis.
+ * - `nu` is wrapped to (-π, π] first, so the incoming branch can be given either as a negative angle or just below 2π, as {@link stateToElements} returns it.
+ * - Only $ |\nu| < \nu_\infty $ exists on a hyperbola; see {@link asymptoteTrueAnomaly}.
+ *
+ * :::
+ *
+ * @param nu - True anomaly $ \nu $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Hyperbolic anomaly $ F $ in **radians**: negative before periapsis, positive after.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1` or `nu` is at or beyond the asymptotes.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = trueToHyperbolicAnomaly((Math.PI / 2) as Radians, 2);
+ * // F ≈ 1.317 (cosh F = e)
+ * ```
+ *
+ * @see {@link hyperbolicToTrueAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export const trueToHyperbolicAnomaly = (nu, e) => {
+    for (const [name, x] of [
+        ['nu', nu],
+        ['e', e]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    const wrapped = Math.atan2(Math.sin(nu), Math.cos(nu));
+    if (Math.abs(wrapped) >= asymptoteTrueAnomaly(e))
+        throw new RangeError(`nu is at or beyond the asymptotes (|nu| >= acos(-1/e)). Received: nu=${nu}, e=${e}`);
+    return 2 * Math.atanh(Math.sqrt((e - 1) / (e + 1)) * Math.tan(wrapped / 2));
+};
+//# sourceMappingURL=true-to-hyperbolic-anomaly.js.map

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-hyperbolic-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-hyperbolic-anomaly.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,EAAW,EAAE,CAAS,EAAU,EAAE;IACxE,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,oBAAoB,CAAC,CAAC,CAAC;QAC9C,MAAM,IAAI,UAAU,CAClB,wEAAwE,EAAE,OAAO,CAAC,EAAE,CACrF,CAAC;IAEJ,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC"}

package/dist/categories/kepler/solve-kepler-hyperbolic.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Solve **Kepler's equation for a hyperbola**: find the hyperbolic anomaly $ F $ from the hyperbolic mean anomaly $ M_h $.
+ *
+ * $$
+ * M_h = e \sinh F - F
+ * $$
+ *
+ * solved with Newton's method:
+ *
+ * $$
+ * F_{n+1} = F_n - \frac{e \sinh F_n - F_n - M_h}{e \cosh F_n - 1}, \qquad F_0 = \min\left(\operatorname{asinh}\frac{|M_h|}{e - 1},\ \sqrt[3]{\frac{6|M_h|}{e}}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: `Mh` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The equation is odd in $ F $, so the solver works on $ |M_h| $ and restores the sign. Negative values are before periapsis.
+ * - $ F_0 $ is an upper bound on the root, since $ e\sinh F - F $ is at least $ (e-1)\sinh F $ and at least $ (e-1)F + eF^3/6 $. The function is increasing and convex for $ F > 0 $, so Newton's method converges monotonically from there, even close to $ e = 1 $ where the derivative $ e\cosh F - 1 $ is small near periapsis.
+ * - Unlike an ellipse, a hyperbola isn't periodic: $ M_h $ isn't reduced to one turn.
+ * - {@link solveKeplerHighEccentricity} also accepts $ e > 1 $, but this solver throws when it doesn't converge instead of returning its last estimate.
+ *
+ * :::
+ *
+ * @param Mh - Hyperbolic mean anomaly $ M_h $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param tolerance - Stop when a step is smaller than `tolerance * max(1, |F|)`. Defaults to `1e-14`.
+ * @param maxIter - Maximum number of Newton steps. Defaults to `50`.
+ * @returns The hyperbolic anomaly $ F $ in **radians**, with the sign of `Mh`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `tolerance <= 0` or `maxIter < 1`.
+ * @throws {Error} If the iteration doesn't converge within `maxIter` steps.
+ * @group Kepler Solvers
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = solveKeplerHyperbolic(12.66 as Radians, 1.44);
+ * // F ≈ 3.087, and 1.44 * sinh(F) - F ≈ 12.66
+ * ```
+ *
+ * @see {@link hyperbolicTimeOfFlight}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export declare const solveKeplerHyperbolic: (Mh: number, e: number, tolerance?: number, maxIter?: number) => number;
+//# sourceMappingURL=solve-kepler-hyperbolic.d.ts.map

package/dist/categories/kepler/solve-kepler-hyperbolic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve-kepler-hyperbolic.d.ts","sourceRoot":"","sources":["../../../src/categories/kepler/solve-kepler-hyperbolic.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,qBAAqB,GAChC,IAAI,MAAM,EACV,GAAG,MAAM,EACT,kBAAiB,EACjB,gBAAY,KACX,MAsCF,CAAC"}

package/dist/categories/kepler/solve-kepler-hyperbolic.js

@@ -0,0 +1,90 @@
+/** sinh x - x, from its Taylor series for small x to avoid cancellation. */
+const sinhMinusX = (x) => {
+    if (Math.abs(x) > 0.5)
+        return Math.sinh(x) - x;
+    const x2 = x * x;
+    let term = (x * x2) / 6;
+    let sum = term;
+    for (let k = 5; Math.abs(term) > 1e-17 * Math.abs(sum); k += 2) {
+        term *= x2 / ((k - 1) * k);
+        sum += term;
+    }
+    return sum;
+};
+/**
+ * Solve **Kepler's equation for a hyperbola**: find the hyperbolic anomaly $ F $ from the hyperbolic mean anomaly $ M_h $.
+ *
+ * $$
+ * M_h = e \sinh F - F
+ * $$
+ *
+ * solved with Newton's method:
+ *
+ * $$
+ * F_{n+1} = F_n - \frac{e \sinh F_n - F_n - M_h}{e \cosh F_n - 1}, \qquad F_0 = \min\left(\operatorname{asinh}\frac{|M_h|}{e - 1},\ \sqrt[3]{\frac{6|M_h|}{e}}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: `Mh` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The equation is odd in $ F $, so the solver works on $ |M_h| $ and restores the sign. Negative values are before periapsis.
+ * - $ F_0 $ is an upper bound on the root, since $ e\sinh F - F $ is at least $ (e-1)\sinh F $ and at least $ (e-1)F + eF^3/6 $. The function is increasing and convex for $ F > 0 $, so Newton's method converges monotonically from there, even close to $ e = 1 $ where the derivative $ e\cosh F - 1 $ is small near periapsis.
+ * - Unlike an ellipse, a hyperbola isn't periodic: $ M_h $ isn't reduced to one turn.
+ * - {@link solveKeplerHighEccentricity} also accepts $ e > 1 $, but this solver throws when it doesn't converge instead of returning its last estimate.
+ *
+ * :::
+ *
+ * @param Mh - Hyperbolic mean anomaly $ M_h $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param tolerance - Stop when a step is smaller than `tolerance * max(1, |F|)`. Defaults to `1e-14`.
+ * @param maxIter - Maximum number of Newton steps. Defaults to `50`.
+ * @returns The hyperbolic anomaly $ F $ in **radians**, with the sign of `Mh`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `tolerance <= 0` or `maxIter < 1`.
+ * @throws {Error} If the iteration doesn't converge within `maxIter` steps.
+ * @group Kepler Solvers
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = solveKeplerHyperbolic(12.66 as Radians, 1.44);
+ * // F ≈ 3.087, and 1.44 * sinh(F) - F ≈ 12.66
+ * ```
+ *
+ * @see {@link hyperbolicTimeOfFlight}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export const solveKeplerHyperbolic = (Mh, e, tolerance = 1e-14, maxIter = 50) => {
+    for (const [name, x] of [
+        ['Mh', Mh],
+        ['e', e],
+        ['tolerance', tolerance],
+        ['maxIter', maxIter]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    if (tolerance <= 0)
+        throw new RangeError(`tolerance must be > 0. Received: ${tolerance}`);
+    if (maxIter < 1)
+        throw new RangeError(`maxIter must be >= 1. Received: ${maxIter}`);
+    const M = Math.abs(Mh);
+    // Start above the root, where Newton's method can't overshoot
+    let F = Math.min(Math.asinh(M / (e - 1)), Math.cbrt((6 * M) / e));
+    for (let iter = 0; iter < maxIter; iter++) {
+        // e sinh F - F - M, written so nothing cancels when e ≈ 1 and F is small
+        const f = (e - 1) * F + e * sinhMinusX(F) - M;
+        const step = f / (e * Math.cosh(F) - 1);
+        F -= step;
+        if (Math.abs(step) <= tolerance * Math.max(1, Math.abs(F)))
+            return Math.sign(Mh) * F;
+    }
+    throw new Error(`solveKeplerHyperbolic did not converge in ${maxIter} steps. Received: Mh=${Mh}, e=${e}`);
+};
+//# sourceMappingURL=solve-kepler-hyperbolic.js.map

package/dist/categories/kepler/solve-kepler-hyperbolic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve-kepler-hyperbolic.js","sourceRoot":"","sources":["../../../src/categories/kepler/solve-kepler-hyperbolic.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,UAAU,GAAG,CAAC,CAAS,EAAU,EAAE;IACvC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG;QAAE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE/C,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAEjB,IAAI,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;IACxB,IAAI,GAAG,GAAG,IAAI,CAAC;IAEf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/D,IAAI,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3B,GAAG,IAAI,IAAI,CAAC;IACd,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,EAAU,EACV,CAAS,EACT,SAAS,GAAG,KAAK,EACjB,OAAO,GAAG,EAAE,EACJ,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,WAAW,EAAE,SAAS,CAAC;QACxB,CAAC,SAAS,EAAE,OAAO,CAAC;KACZ,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,IAAI,SAAS,IAAI,CAAC;QAChB,MAAM,IAAI,UAAU,CAAC,oCAAoC,SAAS,EAAE,CAAC,CAAC;IAExE,IAAI,OAAO,GAAG,CAAC;QACb,MAAM,IAAI,UAAU,CAAC,mCAAmC,OAAO,EAAE,CAAC,CAAC;IAErE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAEvB,8DAA8D;IAC9D,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAElE,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;QAC1C,yEAAyE;QACzE,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAExC,CAAC,IAAI,IAAI,CAAC;QAEV,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACxD,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED,MAAM,IAAI,KAAK,CACb,6CAA6C,OAAO,wBAAwB,EAAE,OAAO,CAAC,EAAE,CACzF,CAAC;AACJ,CAAC,CAAC"}

package/dist/categories/orbits/hyperbolic-eccentricity.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Compute the **eccentricity of a hyperbola** from the excess speed and the periapsis distance.
+ *
+ * $$
+ * e = 1 + \frac{r_p\, v_\infty^2}{\mu}
+ * $$
+ *
+ * Where:
+ * - $ r_p $ is the periapsis distance from the body's centre (m)
+ * - $ v_\infty $ is the hyperbolic excess speed (m/s)
+ * - $ \mu $ is the body's gravitational parameter (m³/s²)
+ *
+ * **Units**
+ * - Inputs: `vInfinity` in **m/s**, `rp` in **m**, `mu` in **m³/s²**.
+ * - Output: $ e $ dimensionless, > 1.
+ *
+ * ::: info Notes
+ *
+ * - From $ r_p = a(1 - e) $ with $ a = -\mu / v_\infty^2 $.
+ * - A slow, close pass gives $ e $ just above 1, a nearly parabolic swing; a fast, distant one gives a large $ e $ and a nearly straight path.
+ * - The trajectory turns through $ 2\arcsin(1/e) $; see `gravityAssistTurningAngle`.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **1.44**
+ *
+ * _Approach hyperbola: 1.08 km/s excess speed, closest approach 113.9 km above the surface_
+ *
+ * ```ts
+ * hyperbolicEccentricity(1080, 1_737_400 + 113_900, 4.902800118e12); // ≈ 1.440
+ * ```
+ *
+ * :::
+ *
+ * @param vInfinity - Hyperbolic excess speed $ v_\infty $ in **m/s** (finite, > 0).
+ * @param rp - Periapsis distance $ r_p $ in **m** (finite, > 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Eccentricity $ e $ (> 1).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `vInfinity <= 0`, `rp <= 0` or `mu <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // A Jupiter flyby: v∞ = 6 km/s, periapsis at 5 Jupiter radii
+ * const e = hyperbolicEccentricity(6000, 5 * 71_492e3, 1.26686534e17);
+ * // e ≈ 1.102
+ * ```
+ *
+ * @see {@link hyperbolicSemiMajorAxis}
+ * @see {@link asymptoteTrueAnomaly}
+ */
+export declare const hyperbolicEccentricity: (vInfinity: number, rp: number, mu: number) => number;
+//# sourceMappingURL=hyperbolic-eccentricity.d.ts.map

package/dist/categories/orbits/hyperbolic-eccentricity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-eccentricity.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-eccentricity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,MAAM,EACjB,IAAI,MAAM,EACV,IAAI,MAAM,KACT,MAkBF,CAAC"}

package/dist/categories/orbits/hyperbolic-eccentricity.js

@@ -0,0 +1,72 @@
+/**
+ * Compute the **eccentricity of a hyperbola** from the excess speed and the periapsis distance.
+ *
+ * $$
+ * e = 1 + \frac{r_p\, v_\infty^2}{\mu}
+ * $$
+ *
+ * Where:
+ * - $ r_p $ is the periapsis distance from the body's centre (m)
+ * - $ v_\infty $ is the hyperbolic excess speed (m/s)
+ * - $ \mu $ is the body's gravitational parameter (m³/s²)
+ *
+ * **Units**
+ * - Inputs: `vInfinity` in **m/s**, `rp` in **m**, `mu` in **m³/s²**.
+ * - Output: $ e $ dimensionless, > 1.
+ *
+ * ::: info Notes
+ *
+ * - From $ r_p = a(1 - e) $ with $ a = -\mu / v_\infty^2 $.
+ * - A slow, close pass gives $ e $ just above 1, a nearly parabolic swing; a fast, distant one gives a large $ e $ and a nearly straight path.
+ * - The trajectory turns through $ 2\arcsin(1/e) $; see `gravityAssistTurningAngle`.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **1.44**
+ *
+ * _Approach hyperbola: 1.08 km/s excess speed, closest approach 113.9 km above the surface_
+ *
+ * ```ts
+ * hyperbolicEccentricity(1080, 1_737_400 + 113_900, 4.902800118e12); // ≈ 1.440
+ * ```
+ *
+ * :::
+ *
+ * @param vInfinity - Hyperbolic excess speed $ v_\infty $ in **m/s** (finite, > 0).
+ * @param rp - Periapsis distance $ r_p $ in **m** (finite, > 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Eccentricity $ e $ (> 1).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `vInfinity <= 0`, `rp <= 0` or `mu <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // A Jupiter flyby: v∞ = 6 km/s, periapsis at 5 Jupiter radii
+ * const e = hyperbolicEccentricity(6000, 5 * 71_492e3, 1.26686534e17);
+ * // e ≈ 1.102
+ * ```
+ *
+ * @see {@link hyperbolicSemiMajorAxis}
+ * @see {@link asymptoteTrueAnomaly}
+ */
+export const hyperbolicEccentricity = (vInfinity, rp, mu) => {
+    for (const [name, x] of [
+        ['vInfinity', vInfinity],
+        ['rp', rp],
+        ['mu', mu]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (vInfinity <= 0)
+        throw new RangeError(`vInfinity must be > 0. Received: ${vInfinity}`);
+    if (rp <= 0)
+        throw new RangeError(`rp must be > 0. Received: ${rp}`);
+    if (mu <= 0)
+        throw new RangeError(`mu must be > 0. Received: ${mu}`);
+    return 1 + (rp * vInfinity * vInfinity) / mu;
+};
+//# sourceMappingURL=hyperbolic-eccentricity.js.map

package/dist/categories/orbits/hyperbolic-eccentricity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-eccentricity.js","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-eccentricity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,SAAiB,EACjB,EAAU,EACV,EAAU,EACF,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,WAAW,EAAE,SAAS,CAAC;QACxB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,SAAS,IAAI,CAAC;QAChB,MAAM,IAAI,UAAU,CAAC,oCAAoC,SAAS,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,SAAS,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC;AAC/C,CAAC,CAAC"}

package/dist/categories/orbits/hyperbolic-semi-major-axis.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Compute the **semi-major axis of a hyperbola** from the hyperbolic excess speed.
+ *
+ * $$
+ * a = -\frac{\mu}{v_\infty^2}
+ * $$
+ *
+ * Where:
+ * - $ v_\infty $ is the hyperbolic excess speed: the speed left over far from the body (m/s)
+ * - $ \mu $ is the body's gravitational parameter (m³/s²)
+ *
+ * **Units**
+ * - Inputs: `vInfinity` in **m/s**, `mu` in **m³/s²**.
+ * - Output: $ a $ in **m**, negative.
+ *
+ * ::: info Notes
+ *
+ * - Negative by convention, so that vis-viva $ v^2 = \mu(2/r - 1/a) $ holds for hyperbolas too.
+ * - $ v_\infty $ comes from a speed $ v $ at distance $ r $ by energy: $ v_\infty^2 = v^2 - 2\mu/r $, or from {@link characteristicEnergyC3} as $ \sqrt{C_3} $.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **−4 203 km**
+ *
+ * _Approach hyperbola, with 1.08 km/s left over far from the Moon_
+ *
+ * ```ts
+ * hyperbolicSemiMajorAxis(1080, 4.902800118e12); // ≈ -4 203 361 m
+ * ```
+ *
+ * :::
+ *
+ * @param vInfinity - Hyperbolic excess speed $ v_\infty $ in **m/s** (finite, > 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Semi-major axis $ a $ in **m** (negative).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `vInfinity <= 0` or `mu <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // Leaving Earth for Mars with v∞ ≈ 2.95 km/s
+ * const a = hyperbolicSemiMajorAxis(2950, 3.986004418e14);
+ * // a ≈ -45 803 km
+ * ```
+ *
+ * @see {@link hyperbolicEccentricity}
+ * @see {@link hyperbolicPeriapsisSpeed}
+ */
+export declare const hyperbolicSemiMajorAxis: (vInfinity: number, mu: number) => number;
+//# sourceMappingURL=hyperbolic-semi-major-axis.d.ts.map

package/dist/categories/orbits/hyperbolic-semi-major-axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-semi-major-axis.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-semi-major-axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,uBAAuB,GAClC,WAAW,MAAM,EACjB,IAAI,MAAM,KACT,MAeF,CAAC"}

package/dist/categories/orbits/hyperbolic-semi-major-axis.js

@@ -0,0 +1,66 @@
+/**
+ * Compute the **semi-major axis of a hyperbola** from the hyperbolic excess speed.
+ *
+ * $$
+ * a = -\frac{\mu}{v_\infty^2}
+ * $$
+ *
+ * Where:
+ * - $ v_\infty $ is the hyperbolic excess speed: the speed left over far from the body (m/s)
+ * - $ \mu $ is the body's gravitational parameter (m³/s²)
+ *
+ * **Units**
+ * - Inputs: `vInfinity` in **m/s**, `mu` in **m³/s²**.
+ * - Output: $ a $ in **m**, negative.
+ *
+ * ::: info Notes
+ *
+ * - Negative by convention, so that vis-viva $ v^2 = \mu(2/r - 1/a) $ holds for hyperbolas too.
+ * - $ v_\infty $ comes from a speed $ v $ at distance $ r $ by energy: $ v_\infty^2 = v^2 - 2\mu/r $, or from {@link characteristicEnergyC3} as $ \sqrt{C_3} $.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **−4 203 km**
+ *
+ * _Approach hyperbola, with 1.08 km/s left over far from the Moon_
+ *
+ * ```ts
+ * hyperbolicSemiMajorAxis(1080, 4.902800118e12); // ≈ -4 203 361 m
+ * ```
+ *
+ * :::
+ *
+ * @param vInfinity - Hyperbolic excess speed $ v_\infty $ in **m/s** (finite, > 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Semi-major axis $ a $ in **m** (negative).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `vInfinity <= 0` or `mu <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // Leaving Earth for Mars with v∞ ≈ 2.95 km/s
+ * const a = hyperbolicSemiMajorAxis(2950, 3.986004418e14);
+ * // a ≈ -45 803 km
+ * ```
+ *
+ * @see {@link hyperbolicEccentricity}
+ * @see {@link hyperbolicPeriapsisSpeed}
+ */
+export const hyperbolicSemiMajorAxis = (vInfinity, mu) => {
+    for (const [name, x] of [
+        ['vInfinity', vInfinity],
+        ['mu', mu]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (vInfinity <= 0)
+        throw new RangeError(`vInfinity must be > 0. Received: ${vInfinity}`);
+    if (mu <= 0)
+        throw new RangeError(`mu must be > 0. Received: ${mu}`);
+    return -mu / (vInfinity * vInfinity);
+};
+//# sourceMappingURL=hyperbolic-semi-major-axis.js.map

package/dist/categories/orbits/hyperbolic-semi-major-axis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-semi-major-axis.js","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-semi-major-axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACrC,SAAiB,EACjB,EAAU,EACF,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,WAAW,EAAE,SAAS,CAAC;QACxB,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,SAAS,IAAI,CAAC;QAChB,MAAM,IAAI,UAAU,CAAC,oCAAoC,SAAS,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,OAAO,CAAC,EAAE,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;AACvC,CAAC,CAAC"}

package/dist/categories/orbits/hyperbolic-time-of-flight.d.ts

@@ -0,0 +1,64 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **time of flight between two points on a hyperbola**, given by their true anomalies.
+ *
+ * $$
+ * t_2 - t_1 = \sqrt{\frac{-a^3}{\mu}}\,\Big[(e\sinh F_2 - F_2) - (e\sinh F_1 - F_1)\Big]
+ * $$
+ *
+ * with each hyperbolic anomaly $ F $ from {@link trueToHyperbolicAnomaly}.
+ *
+ * **Units**
+ * - Inputs: `nu1`, `nu2` in **radians**, `e` dimensionless, `a` in **m** (negative), `mu` in **m³/s²**.
+ * - Output: time in **s**, negative if `nu2` comes before `nu1`.
+ *
+ * ::: info Notes
+ *
+ * - Both points must lie inside the asymptotes. The incoming branch can be given as negative angles or just below 2π.
+ * - Crossing periapsis needs no special handling: $ F $ changes sign there.
+ * - To go from a time to a position, solve $ M_h = e\sinh F - F $ with {@link solveKeplerHyperbolic}, then use {@link hyperbolicToTrueAnomaly}.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, falling towards the Moon
+ *
+ * **13.8 h**
+ *
+ * _From the edge of the Moon's sphere of influence, 62 640 km out, to closest approach_
+ *
+ * The flight took 14 h 10 min from crossing into the sphere to lighting the engine for lunar orbit insertion. Patched conics leave out Earth's pull inside the sphere, one reason the two differ.
+ *
+ * ```ts
+ * const e = 1.44; // approach hyperbola
+ * const a = -4_203_000; // m
+ * const p = a * (1 - e * e);
+ * const nuSoi = -Math.acos((p / 62_640_000 - 1) / e) as Radians; // incoming
+ * hyperbolicTimeOfFlight(nuSoi, 0 as Radians, e, a, 4.902800118e12); // ≈ 49 600 s
+ * ```
+ *
+ * :::
+ *
+ * @param nu1 - True anomaly at the start $ \nu_1 $ in **radians** (finite, inside the asymptotes).
+ * @param nu2 - True anomaly at the end $ \nu_2 $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param a - Semi-major axis $ a $ in **m** (finite, < 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Time of flight in **s** from `nu1` to `nu2`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `a >= 0`, `mu <= 0`, or either true anomaly is at or beyond the asymptotes.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // From periapsis to 90° on a hyperbola with e = 2, a = -10 000 km, around Earth
+ * const t = hyperbolicTimeOfFlight(0 as Radians, (Math.PI / 2) as Radians, 2, -10_000e3, 3.986004418e14);
+ * // t ≈ 3 401 s
+ * ```
+ *
+ * @see {@link solveKeplerHyperbolic}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export declare const hyperbolicTimeOfFlight: (nu1: Radians, nu2: Radians, e: number, a: number, mu: number) => number;
+//# sourceMappingURL=hyperbolic-time-of-flight.d.ts.map

package/dist/categories/orbits/hyperbolic-time-of-flight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-time-of-flight.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-time-of-flight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,GAAG,MAAM,EACT,GAAG,MAAM,EACT,IAAI,MAAM,KACT,MA0BF,CAAC"}

package/dist/categories/orbits/hyperbolic-time-of-flight.js

@@ -0,0 +1,86 @@
+import { trueToHyperbolicAnomaly } from '../anomalies/true-to-hyperbolic-anomaly.js';
+/**
+ * Compute the **time of flight between two points on a hyperbola**, given by their true anomalies.
+ *
+ * $$
+ * t_2 - t_1 = \sqrt{\frac{-a^3}{\mu}}\,\Big[(e\sinh F_2 - F_2) - (e\sinh F_1 - F_1)\Big]
+ * $$
+ *
+ * with each hyperbolic anomaly $ F $ from {@link trueToHyperbolicAnomaly}.
+ *
+ * **Units**
+ * - Inputs: `nu1`, `nu2` in **radians**, `e` dimensionless, `a` in **m** (negative), `mu` in **m³/s²**.
+ * - Output: time in **s**, negative if `nu2` comes before `nu1`.
+ *
+ * ::: info Notes
+ *
+ * - Both points must lie inside the asymptotes. The incoming branch can be given as negative angles or just below 2π.
+ * - Crossing periapsis needs no special handling: $ F $ changes sign there.
+ * - To go from a time to a position, solve $ M_h = e\sinh F - F $ with {@link solveKeplerHyperbolic}, then use {@link hyperbolicToTrueAnomaly}.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, falling towards the Moon
+ *
+ * **13.8 h**
+ *
+ * _From the edge of the Moon's sphere of influence, 62 640 km out, to closest approach_
+ *
+ * The flight took 14 h 10 min from crossing into the sphere to lighting the engine for lunar orbit insertion. Patched conics leave out Earth's pull inside the sphere, one reason the two differ.
+ *
+ * ```ts
+ * const e = 1.44; // approach hyperbola
+ * const a = -4_203_000; // m
+ * const p = a * (1 - e * e);
+ * const nuSoi = -Math.acos((p / 62_640_000 - 1) / e) as Radians; // incoming
+ * hyperbolicTimeOfFlight(nuSoi, 0 as Radians, e, a, 4.902800118e12); // ≈ 49 600 s
+ * ```
+ *
+ * :::
+ *
+ * @param nu1 - True anomaly at the start $ \nu_1 $ in **radians** (finite, inside the asymptotes).
+ * @param nu2 - True anomaly at the end $ \nu_2 $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param a - Semi-major axis $ a $ in **m** (finite, < 0).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @returns Time of flight in **s** from `nu1` to `nu2`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `a >= 0`, `mu <= 0`, or either true anomaly is at or beyond the asymptotes.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // From periapsis to 90° on a hyperbola with e = 2, a = -10 000 km, around Earth
+ * const t = hyperbolicTimeOfFlight(0 as Radians, (Math.PI / 2) as Radians, 2, -10_000e3, 3.986004418e14);
+ * // t ≈ 3 401 s
+ * ```
+ *
+ * @see {@link solveKeplerHyperbolic}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export const hyperbolicTimeOfFlight = (nu1, nu2, e, a, mu) => {
+    for (const [name, x] of [
+        ['nu1', nu1],
+        ['nu2', nu2],
+        ['e', e],
+        ['a', a],
+        ['mu', mu]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    if (a >= 0)
+        throw new RangeError(`a must be < 0 for a hyperbola. Received: ${a}`);
+    if (mu <= 0)
+        throw new RangeError(`mu must be > 0. Received: ${mu}`);
+    const meanAnomaly = (nu) => {
+        const F = trueToHyperbolicAnomaly(nu, e);
+        return e * Math.sinh(F) - F;
+    };
+    return Math.sqrt((-a * a * a) / mu) * (meanAnomaly(nu2) - meanAnomaly(nu1));
+};
+//# sourceMappingURL=hyperbolic-time-of-flight.js.map

package/dist/categories/orbits/hyperbolic-time-of-flight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-time-of-flight.js","sourceRoot":"","sources":["../../../src/categories/orbits/hyperbolic-time-of-flight.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,GAAY,EACZ,GAAY,EACZ,CAAS,EACT,CAAS,EACT,EAAU,EACF,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,IAAI,CAAC,IAAI,CAAC;QACR,MAAM,IAAI,UAAU,CAAC,4CAA4C,CAAC,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,MAAM,WAAW,GAAG,CAAC,EAAW,EAAE,EAAE;QAClC,MAAM,CAAC,GAAG,uBAAuB,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAEzC,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC,CAAC;IAEF,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC"}

package/dist/index.d.ts

@@ -23,10 +23,14 @@ export * from './categories/helpers/rot-3.js';
 export * from './categories/helpers/transpose-3.js';
 export * from './categories/anomalies/advance-mean-anomaly.js';
 export * from './categories/anomalies/anomaly-at.js';
+export * from './categories/anomalies/asymptote-true-anomaly.js';
 export * from './categories/anomalies/eccentric-to-true-anomaly.js';
+export * from './categories/anomalies/hyperbolic-to-true-anomaly.js';
 export * from './categories/anomalies/true-to-mean-anomaly.js';
+export * from './categories/anomalies/true-to-hyperbolic-anomaly.js';
 export * from './categories/kepler/solve-kepler-bisection.js';
 export * from './categories/kepler/solve-kepler-high-eccentricity.js';
+export * from './categories/kepler/solve-kepler-hyperbolic.js';
 export * from './categories/kepler/solve-kepler-newton-raphson.js';
 export * from './categories/kepler/solve-kepler.js';
 export * from './categories/gravity/acceleration-on1-by2.js';
@@ -40,7 +44,10 @@ export * from './categories/orbits/cw-hill-derivatives.js';
 export * from './categories/orbits/elements-to-state.js';
 export * from './categories/orbits/escape-speed.js';
 export * from './categories/orbits/flight-path-angle-from-true-anomaly.js';
+export * from './categories/orbits/hyperbolic-eccentricity.js';
 export * from './categories/orbits/hyperbolic-periapsis-speed.js';
+export * from './categories/orbits/hyperbolic-semi-major-axis.js';
+export * from './categories/orbits/hyperbolic-time-of-flight.js';
 export * from './categories/orbits/inclination-from-launch-azimuth.js';
 export * from './categories/orbits/j2-argument-of-perigee-rate.js';
 export * from './categories/orbits/j2-nodal-precession-rate.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAIjD,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAI3E,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAIpD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gDAAgD,CAAC;AAI/D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAIpD,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAIhE,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,mDAAmD,CAAC;AAElE,cAAc,wDAAwD,CAAC;AAEvE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uCAAuC,CAAC;AAItD,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,yCAAyC,CAAC;AAExD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,qDAAqD,CAAC;AAEpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAIjD,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAI3E,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAIpD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,qDAAqD,CAAC;AAEpE,cAAc,sDAAsD,CAAC;AAErE,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sDAAsD,CAAC;AAIrE,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,gDAAgD,CAAC;AAE/D,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAIpD,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAIhE,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,gDAAgD,CAAC;AAE/D,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,wDAAwD,CAAC;AAEvE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uCAAuC,CAAC;AAItD,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,yCAAyC,CAAC;AAExD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,qDAAqD,CAAC;AAEpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,6CAA6C,CAAC"}

package/dist/index.js

@@ -27,11 +27,15 @@ export * from './categories/helpers/transpose-3.js';
 // categories/anomalies
 export * from './categories/anomalies/advance-mean-anomaly.js';
 export * from './categories/anomalies/anomaly-at.js';
+export * from './categories/anomalies/asymptote-true-anomaly.js';
 export * from './categories/anomalies/eccentric-to-true-anomaly.js';
+export * from './categories/anomalies/hyperbolic-to-true-anomaly.js';
 export * from './categories/anomalies/true-to-mean-anomaly.js';
+export * from './categories/anomalies/true-to-hyperbolic-anomaly.js';
 // categories/kepler (solvers)
 export * from './categories/kepler/solve-kepler-bisection.js';
 export * from './categories/kepler/solve-kepler-high-eccentricity.js';
+export * from './categories/kepler/solve-kepler-hyperbolic.js';
 export * from './categories/kepler/solve-kepler-newton-raphson.js';
 export * from './categories/kepler/solve-kepler.js';
 // categories/gravity
@@ -47,7 +51,10 @@ export * from './categories/orbits/cw-hill-derivatives.js';
 export * from './categories/orbits/elements-to-state.js';
 export * from './categories/orbits/escape-speed.js';
 export * from './categories/orbits/flight-path-angle-from-true-anomaly.js';
+export * from './categories/orbits/hyperbolic-eccentricity.js';
 export * from './categories/orbits/hyperbolic-periapsis-speed.js';
+export * from './categories/orbits/hyperbolic-semi-major-axis.js';
+export * from './categories/orbits/hyperbolic-time-of-flight.js';
 export * from './categories/orbits/inclination-from-launch-azimuth.js';
 export * from './categories/orbits/j2-argument-of-perigee-rate.js';
 export * from './categories/orbits/j2-nodal-precession-rate.js';

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mBAAmB;AACnB,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAEjD,yBAAyB;AAEzB,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAE3E,qBAAqB;AAErB,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAEpD,uBAAuB;AAEvB,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gDAAgD,CAAC;AAE/D,8BAA8B;AAE9B,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAEpD,qBAAqB;AAErB,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAEhE,oBAAoB;AAEpB,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,mDAAmD,CAAC;AAElE,cAAc,wDAAwD,CAAC;AAEvE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uCAAuC,CAAC;AAEtD,wBAAwB;AAExB,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,yCAAyC,CAAC;AAExD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,qDAAqD,CAAC;AAEpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mBAAmB;AACnB,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAEjD,yBAAyB;AAEzB,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAE3E,qBAAqB;AAErB,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAEpD,uBAAuB;AAEvB,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,qDAAqD,CAAC;AAEpE,cAAc,sDAAsD,CAAC;AAErE,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sDAAsD,CAAC;AAErE,8BAA8B;AAE9B,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,gDAAgD,CAAC;AAE/D,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAEpD,qBAAqB;AAErB,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAEhE,oBAAoB;AAEpB,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,gDAAgD,CAAC;AAE/D,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,wDAAwD,CAAC;AAEvE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uCAAuC,CAAC;AAEtD,wBAAwB;AAExB,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,yCAAyC,CAAC;AAExD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,qDAAqD,CAAC;AAEpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,6CAA6C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interstellar-tools/equations",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Curated, well-tested orbital mechanics and dynamics formulas (e.g., Newtonian gravity, vis-viva, Kepler's 3rd law, escape/circular speeds, specific energy, specific angular momentum, peri/apoapsis radii).",
   "keywords": [
     "interstellar",