@elite-dangerous-almanac/core 0.2.1 → 0.2.2

package/README.md

@@ -45,7 +45,8 @@ coordinate lookup are only exported from their leaf subpaths, not the feature ba
 
 The package has six feature areas:
 
-- `astro`: procedural names, id64 addresses, regions, nebulae and permit locks;
+- `astro`: procedural names, id64 addresses, regions, nebulae, permit locks, and scanned
+  bodies with their physics;
 - `ships`: ships, modules, SLEF loadouts, engineering and build metrics;
 - `equipment`: Odyssey suits, handheld weapons, grade upgrades and modifications;
 - `i18n`: sparse localized catalogue names, descriptions, slot labels and structured
@@ -120,7 +121,7 @@ const build = ShipLoadout.fromSlef(slefJsonString);
 const metrics = BuildMetrics.of(build);
 metrics.maxJumpRange();
 metrics.powerBudget();
-metrics.shieldMetrics();
+metrics.shieldMetricsResult().value;
 metrics.armourMetrics();
 metrics.weaponMetrics();
 metrics.weaponsCapacitorMetrics({ weaponsPips: 2 });

package/THIRD_PARTY_NOTICES.md

@@ -61,6 +61,28 @@ a verbatim copy produced at build time — edit this file, never the copy.
 - **SLEF parsing and writing** — both follow the
   [Inara Ship Loadout Export Format specification](https://inara.cz/elite/inara-impexp-slef/)
   published by **Inara** (Artie).
+- **Body calculations** — bulk density, the rigid and fluid Roche limits, the Hill radius,
+  a primary's angular diameter, orbit extents and their eccentricity bands, spin-orbit
+  resonance, equatorial velocity, ring dynamics and surface density, the invisible-ring
+  heuristic, ring-particle densities, main-sequence lifetime, absolute bolometric
+  magnitude, the Schwarzschild radius, the degeneracy-pressure mass limits and the
+  neutron-star classes are ported as fact (our own implementation, re-expressed in the
+  journal's units) from **canonn-signals**' `body-physics.service.ts`,
+  `stellar-physics.service.ts` and `stellar-reference.ts` — credited under Data below.
+  Most of it is textbook astrophysics; three parts are the **Canonn Research Group's own
+  observational research** into how the game behaves, and are theirs rather than
+  astronomy's: the `3/8` nominal-radius factor that recovers a ring's single rigid-body
+  rotation period, the invisible-ring width and surface-density thresholds, and the
+  neutron-star classification bands with the observed in-game mass past which neutron
+  stars become rare.
+  Each carries that provenance in its own TSDoc.
+- **The journal `Scan` event shape** — the body-scan import interface describes the format
+  **Frontier Developments plc** writes its Player Journal in, and its field set, types and
+  conditional presence are cross-checked against
+  [jixxed/ed-journal-schemas](https://github.com/jixxed/ed-journal-schemas), the
+  community-maintained JSON Schemas for post-Odyssey journal events, **Apache-2.0**.
+  Field names and types are facts about Frontier's format; no schema text is redistributed
+  and no code from that project is used.
 
 ## Data
 
@@ -101,8 +123,8 @@ a verbatim copy produced at build time — edit this file, never the copy.
   [Frontier forums](https://forums.frontier.co.uk/threads/determining-the-region-of-a-system.537845/).
 - **[canonn-science/canonn-signals](https://github.com/canonn-science/canonn-signals)** by
   the **Canonn Research Group**, **MIT**, © 2023 — the route by which two of the sources
-  below were obtained, and the TypeScript port the procedural-naming algorithm passed
-  through.
+  below were obtained, the TypeScript port the procedural-naming algorithm passed through,
+  and the source of the body calculations credited under Algorithms above.
 - **EDAstro nebulae coordinates** published by **CMDR Orvidius**
   ([EDAstro](https://edastro.com/mapcharts/)) — nebula names, catalogued systems,
   coordinates, classes and region ids, obtained via canonn-signals. EDAstro states no

package/dist/astro/body-orbit.d.ts

@@ -0,0 +1,174 @@
+import { b as BodyProperties } from '../body-scan-CEUYjCfH.js';
+import './system-address-input.js';
+
+/**
+ * What a scanned body's orbit and spin work out to: where the orbit actually reaches, how
+ * eccentric it is, whether the spin is locked to the orbit, and how fast the surface moves.
+ *
+ * Every function takes {@link BodyProperties} — a journal `Scan` line as it comes, or any
+ * record carrying the same fields — and works in the journal's own units: metres for
+ * distance, seconds for a period, degrees for an angle. Nothing here holds data. The type
+ * itself is exported from `../astro`, alongside `BodyScanEvent`.
+ *
+ * These read the body's own fields only, so none of them needs the primary.
+ *
+ * The maths is ported from the Canonn Research Group's
+ * [canonn-signals](https://github.com/canonn-science/canonn-signals); see
+ * [ATTRIBUTIONS.md](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/ATTRIBUTIONS.md).
+ *
+ * @example
+ * ```ts
+ * import { orbitExtents } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * // A semi-major axis is a mean: this orbit is 10% closer at one end and 10% further at the other.
+ * const extents = orbitExtents({ SemiMajorAxis: 1e9, Eccentricity: 0.1 });
+ * extents?.periapsis; // -> 900000000
+ * extents?.apoapsis; // -> 1100000000
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/** How far an orbit actually reaches at each end, in metres from the primary's centre. */
+interface OrbitExtents {
+    /** The orbit's semi-major axis, in metres — its mean distance, as the scan wrote it. */
+    readonly semiMajorAxis: number;
+    /** Closest approach, in metres — `a(1 − e)`. */
+    readonly periapsis: number;
+    /** Furthest recession, in metres — `a(1 + e)`. */
+    readonly apoapsis: number;
+    /** The eccentricity used, which is `0` when the scan wrote none. */
+    readonly eccentricity: number;
+}
+/**
+ * How round an orbit is, in the four bands the Canonn tooling reports.
+ *
+ * - `circular` — eccentricity exactly `0`.
+ * - `nearly-circular` — below `0.4`.
+ * - `eccentric` — below `0.8`.
+ * - `highly-eccentric` — `0.8` and above.
+ *
+ * @remarks
+ * The bands are descriptive rather than physical: nothing changes at `0.4`. They exist so
+ * that "how unusual is this orbit" has one answer everywhere instead of a different
+ * threshold per caller.
+ */
+type EccentricityClass = 'circular' | 'nearly-circular' | 'eccentric' | 'highly-eccentric';
+/** A spin-orbit resonance as the small whole-number ratio it is. */
+interface SpinOrbitResonance {
+    /** Rotations the body makes — the `3` of a 3:2 resonance. */
+    readonly rotations: number;
+    /** Orbits it makes in the same time — the `2` of a 3:2 resonance. */
+    readonly orbits: number;
+}
+/**
+ * Where a body's orbit actually reaches, from the mean distance and eccentricity the scan
+ * wrote.
+ *
+ * @remarks
+ * {@link BodyProperties.SemiMajorAxis | SemiMajorAxis} is an average, and an eccentric
+ * orbit spends none of its time there. Periapsis is the figure a Roche breach, a tidal
+ * heating argument or a close-approach question turns on.
+ *
+ * @param body - The body. Needs {@link BodyProperties.SemiMajorAxis | SemiMajorAxis};
+ * {@link BodyProperties.Eccentricity | Eccentricity} is taken as `0` when absent, which is
+ * what a circular orbit means.
+ * @returns The extents in metres, or `null` when the body has no usable semi-major axis —
+ * a single-star system's primary star, which orbits nothing, among them.
+ * @throws {TypeError} If `body` is not an object.
+ * @example
+ * ```ts
+ * import { orbitExtents } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * orbitExtents({ SemiMajorAxis: 1e9, Eccentricity: 0.25 })?.periapsis; // -> 750000000
+ *
+ * // No eccentricity written means a circle: both ends sit on the axis.
+ * orbitExtents({ SemiMajorAxis: 1e9 })?.apoapsis; // -> 1000000000
+ *
+ * orbitExtents({ MassEM: 1 }); // -> null
+ * ```
+ */
+declare function orbitExtents(body: BodyProperties): OrbitExtents | null;
+/**
+ * Which of the four descriptive bands an eccentricity falls in.
+ *
+ * @param eccentricity - An orbital eccentricity, as
+ * {@link BodyProperties.Eccentricity | Eccentricity} carries it: `0` for a circle, rising
+ * towards `1` for a long ellipse.
+ * @returns The band. See {@link EccentricityClass} for the thresholds.
+ * @throws {RangeError} If `eccentricity` is not a finite non-negative number. This takes a
+ * bare number rather than a body, so there is no absent field for a bad one to be.
+ * @example
+ * ```ts
+ * import { classifyEccentricity } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * classifyEccentricity(0); // -> 'circular'
+ * classifyEccentricity(0.0549); // -> 'nearly-circular'
+ * classifyEccentricity(0.9); // -> 'highly-eccentric'
+ * ```
+ */
+declare function classifyEccentricity(eccentricity: number): EccentricityClass;
+/**
+ * The simple whole-number resonance between a body's spin and its orbit, when there is one.
+ *
+ * @remarks
+ * A body in a spin-orbit resonance turns a whole number of times for a whole number of
+ * orbits. `1:1` is tidal locking — one face kept to the primary, which the scan also
+ * reports as {@link BodyProperties.TidalLock | TidalLock} — and `3:2` is the next most
+ * common, the resonance Mercury sits in.
+ *
+ * Both terms are searched up to 5, and a ratio counts as a resonance when it lands within
+ * 1% of it. A retrograde rotation is written as a negative period; the resonance is a
+ * ratio of magnitudes, so a retrograde tidally-locked body still reads `1:1`.
+ *
+ * @param body - The body. Needs {@link BodyProperties.RotationPeriod | RotationPeriod} and
+ * {@link BodyProperties.OrbitalPeriod | OrbitalPeriod}. Both are seconds, and only their
+ * ratio matters.
+ * @returns The resonance, or `null` when either period is missing or the ratio is not
+ * close to any simple one — most bodies are in no resonance at all.
+ * @throws {TypeError} If `body` is not an object.
+ * @example
+ * ```ts
+ * import { spinOrbitResonance } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * // One rotation per orbit: tidally locked.
+ * spinOrbitResonance({ RotationPeriod: 86400, OrbitalPeriod: 86400 }); // -> { rotations: 1, orbits: 1 }
+ *
+ * // Mercury: three rotations every two orbits.
+ * spinOrbitResonance({ RotationPeriod: 5067360, OrbitalPeriod: 7600544 }); // -> { rotations: 3, orbits: 2 }
+ *
+ * spinOrbitResonance({ RotationPeriod: 86400, OrbitalPeriod: 271828 }); // -> null
+ * ```
+ */
+declare function spinOrbitResonance(body: BodyProperties): SpinOrbitResonance | null;
+/**
+ * How fast a body's equator moves as it turns, in metres per second.
+ *
+ * @remarks
+ * `2πR / T`. This is the ground speed a point on the equator carries, which is why a fast
+ * rotator is worth knowing about before landing on one: the surface of a neutron star
+ * spinning in milliseconds is moving at a sizeable fraction of light speed.
+ *
+ * Speed is a magnitude, so a retrograde body — written with a negative
+ * {@link BodyProperties.RotationPeriod | RotationPeriod} — reads the same as a prograde
+ * one turning as fast.
+ *
+ * @param body - The body. Needs {@link BodyProperties.Radius | Radius} and
+ * {@link BodyProperties.RotationPeriod | RotationPeriod}.
+ * @returns The equatorial speed in m/s, or `null` when either is missing. A body the scan
+ * reports as not rotating carries no period, and answers `null` rather than `0`.
+ * @throws {TypeError} If `body` is not an object.
+ * @example
+ * ```ts
+ * import { equatorialVelocity } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * // Earth: about 465 m/s at the equator.
+ * equatorialVelocity({ Radius: 6_378_137, RotationPeriod: 86164.1 }); // -> 465.1…
+ *
+ * // Retrograde is the same speed, the other way round.
+ * equatorialVelocity({ Radius: 6_378_137, RotationPeriod: -86164.1 }); // -> 465.1…
+ * ```
+ */
+declare function equatorialVelocity(body: BodyProperties): number | null;
+
+export { type EccentricityClass, type OrbitExtents, type SpinOrbitResonance, classifyEccentricity, equatorialVelocity, orbitExtents, spinOrbitResonance };

package/dist/astro/body-orbit.js

@@ -0,0 +1 @@
+export{classifyEccentricity,equatorialVelocity,orbitExtents,spinOrbitResonance}from"../chunk-ZZ376WHL.js";                                                          //# sourceMappingURL=body-orbit.js.map

package/dist/astro/body-orbit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}

package/dist/astro/body-physics.d.ts

@@ -0,0 +1,228 @@
+import { b as BodyProperties } from '../body-scan-CEUYjCfH.js';
+import './system-address-input.js';
+
+/**
+ * Bulk properties of a scanned body, and the geometry between a body and the one it
+ * orbits: mass, density, Roche limits, Hill radius, apparent size.
+ *
+ * Every function takes {@link BodyProperties} — a journal `Scan` line as it comes, or any
+ * record carrying the same fields — and works in the journal's own units: metres,
+ * kilograms, seconds. Nothing here holds data or reads a catalogue. The type itself is
+ * exported from `../astro`, alongside `BodyScanEvent`.
+ *
+ * **A calculation that compares two bodies takes both.** A journal line names a body's
+ * parent only by `BodyID` ({@link BodyProperties} carries no parent), so
+ * {@link rocheLimits}, {@link hillRadius} and {@link primaryAngularDiameter} take the
+ * primary as a second argument. Resolve it from your own record of the system — the
+ * `Parents` chain on the scan says which `BodyID` to look for.
+ *
+ * **Everything answers `null` rather than guessing.** A field the scan did not write, a
+ * zero radius, a `NaN` mass: all are "cannot be computed", never a substituted zero.
+ *
+ * The maths is ported from the Canonn Research Group's
+ * [canonn-signals](https://github.com/canonn-science/canonn-signals); see
+ * [ATTRIBUTIONS.md](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/ATTRIBUTIONS.md).
+ *
+ * @example
+ * ```ts
+ * import { bulkDensity } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * bulkDensity({ MassEM: 1, Radius: 6_371_000 }); // -> 5513.2…
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Newton's gravitational constant, in m³ kg⁻¹ s⁻² (CODATA).
+ *
+ * @remarks
+ * Exported because every orbital figure this library reports is proportional to it, so a
+ * consumer reproducing one gets the same answer rather than a near miss.
+ */
+declare const GRAVITATIONAL_CONSTANT = 6.6743e-11;
+/**
+ * Kilograms in one Earth mass — the unit {@link BodyProperties.MassEM | MassEM} is written
+ * in.
+ */
+declare const KG_PER_EARTH_MASS = 5.972e+24;
+/**
+ * Kilograms in one solar mass — the unit {@link BodyProperties.StellarMass | StellarMass}
+ * is written in.
+ */
+declare const KG_PER_SOLAR_MASS = 1.989e+30;
+/**
+ * The two Roche limits for one pair of bodies, in metres from the primary's centre.
+ *
+ * @remarks
+ * Inside the Roche limit a satellite is pulled apart by the tide the primary raises on it.
+ * Which limit applies depends on what holds the satellite together: a rigid body resists
+ * with its own strength, a fluid one only with self-gravity, so the fluid limit is the
+ * larger and the truth for a real body sits between them.
+ */
+interface RocheLimits {
+    /**
+     * Rigid-body limit, in metres — `1.26 · R · (ρ_primary / ρ_satellite)^(1/3)`. The
+     * conservative figure: a solid body can survive closer than this only on its own
+     * material strength.
+     */
+    readonly rigid: number;
+    /**
+     * Fluid-body limit, in metres — `2.456 · R · (ρ_primary / ρ_satellite)^(1/3)`. The
+     * generous figure, for a satellite held together by gravity alone.
+     */
+    readonly fluid: number;
+}
+/**
+ * A body's mass in kilograms, whichever unit the scan wrote it in.
+ *
+ * @param body - The body. A planet or moon carries
+ * {@link BodyProperties.MassEM | MassEM} (Earth masses), a star
+ * {@link BodyProperties.StellarMass | StellarMass} (solar masses).
+ * @returns The mass in kilograms, or `null` when the scan wrote neither field usably. When
+ * a record carries both — which no journal line does — `MassEM` is the one read.
+ * @throws {TypeError} If `body` is not an object.
+ * @example
+ * ```ts
+ * import { bodyMass } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * bodyMass({ MassEM: 1 }); // -> 5.972e24
+ * bodyMass({ StellarMass: 1 }); // -> 1.989e30
+ * bodyMass({ Radius: 6_371_000 }); // -> null
+ * ```
+ */
+declare function bodyMass(body: BodyProperties): number | null;
+/**
+ * A body's mean density, in kg/m³ — its mass spread evenly through a sphere of its radius.
+ *
+ * @param body - The body. Needs a mass ({@link bodyMass}) and
+ * {@link BodyProperties.Radius | Radius}.
+ * @returns Density in kg/m³, or `null` when either is missing. The scale is wide: an icy
+ * moon reads near 1000, rock and metal a few thousand, a neutron star around 10¹⁷.
+ * @throws {TypeError} If `body` is not an object.
+ * @example
+ * ```ts
+ * import { bulkDensity } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * // Earth: one Earth mass in a 6371 km sphere.
+ * bulkDensity({ MassEM: 1, Radius: 6_371_000 }); // -> 5513.2…
+ * ```
+ */
+declare function bulkDensity(body: BodyProperties): number | null;
+/**
+ * Roche limits around a primary for a satellite of a stated density.
+ *
+ * @remarks
+ * Use this when the satellite's density is assumed rather than measured — ring material,
+ * for instance, whose density comes from its class rather than from a mass and a radius
+ * (`ringRocheLimits` in `./body-rings` is this function with that density filled in).
+ * When the satellite is a scanned body with a mass and a radius of its own, prefer
+ * {@link rocheLimits}, which reads the density off it.
+ *
+ * @param primary - The body being orbited. Needs a mass and a
+ * {@link BodyProperties.Radius | Radius}.
+ * @param satelliteDensityKgM3 - The orbiting material's density in kg/m³.
+ * @returns Both limits in metres from the primary's centre, or `null` when the primary's
+ * own density cannot be computed.
+ * @throws {TypeError} If `primary` is not an object.
+ * @throws {RangeError} If `satelliteDensityKgM3` is not a finite positive number — an
+ * assumed density is the caller's own figure, so a bad one is a mistake rather than a
+ * missing scan field.
+ * @example
+ * ```ts
+ * import { rocheLimitsForDensity } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * // Icy particles (1000 kg/m³) around an Earth-density primary.
+ * const limits = rocheLimitsForDensity({ MassEM: 1, Radius: 6_371_000 }, 1000);
+ * limits?.rigid; // -> 14181242.2…
+ * limits?.fluid; // -> 27642167.3…
+ * ```
+ */
+declare function rocheLimitsForDensity(primary: BodyProperties, satelliteDensityKgM3: number): RocheLimits | null;
+/**
+ * Roche limits around a primary for one scanned satellite.
+ *
+ * @remarks
+ * Compare them against the satellite's **periapsis**, not its semi-major axis: a breach is
+ * set by closest approach, so an eccentric moon can dip inside the rigid limit while its
+ * mean distance looks safe. `orbitExtents` in `./body-orbit` gives that periapsis.
+ *
+ * @param satellite - The orbiting body. Needs a mass and a
+ * {@link BodyProperties.Radius | Radius}, from which its density is taken.
+ * @param primary - The body being orbited. Needs the same.
+ * @returns Both limits in metres from the primary's centre, or `null` when either body's
+ * density cannot be computed.
+ * @throws {TypeError} If either argument is not an object.
+ * @example
+ * ```ts
+ * import { rocheLimits } from '@elite-dangerous-almanac/core/astro/body-physics';
+ * import { orbitExtents } from '@elite-dangerous-almanac/core/astro/body-orbit';
+ *
+ * const moon = { MassEM: 0.0123, Radius: 1_737_400, SemiMajorAxis: 3.844e8, Eccentricity: 0.0549 };
+ * const earth = { MassEM: 1, Radius: 6_371_000 };
+ *
+ * const limits = rocheLimits(moon, earth);
+ * const closest = orbitExtents(moon)?.periapsis ?? 0;
+ *
+ * closest < (limits?.rigid ?? 0); // -> false
+ * ```
+ */
+declare function rocheLimits(satellite: BodyProperties, primary: BodyProperties): RocheLimits | null;
+/**
+ * The radius of a body's Hill sphere, in metres — how far its own gravity wins against the
+ * body it orbits.
+ *
+ * @remarks
+ * `r_H = a · (m / 3M)^(1/3)`. Anything orbiting the body must stay inside this radius to
+ * remain bound to it, so it is the reach a moon has over nearby material — which is what
+ * makes a small moon a shepherd of a ring it does not sit in.
+ *
+ * The semi-major axis is used as written, so the figure is the mean-distance Hill radius.
+ * On an eccentric orbit the sphere shrinks at periapsis; recompute with
+ * `orbitExtents(body)?.periapsis` in place of the axis when that matters.
+ *
+ * @param body - The body whose sphere is wanted. Needs
+ * {@link BodyProperties.SemiMajorAxis | SemiMajorAxis} and a mass.
+ * @param primary - The body it orbits. Needs a mass.
+ * @returns The Hill radius in metres, or `null` when a mass or the orbit is missing.
+ * @throws {TypeError} If either argument is not an object.
+ * @example
+ * ```ts
+ * import { hillRadius } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * // Earth about the Sun: about 1.5 million km.
+ * hillRadius({ MassEM: 1, SemiMajorAxis: 1.496e11 }, { StellarMass: 1 }); // -> 1496417737.0…
+ * ```
+ */
+declare function hillRadius(body: BodyProperties, primary: BodyProperties): number | null;
+/**
+ * How large the body it orbits appears in a body's sky, as an angular diameter in degrees.
+ *
+ * @remarks
+ * `2 · atan(R_primary / a)`, taken exactly rather than through the small-angle
+ * approximation `2R/a`: the two diverge by percent at the tens of degrees a parent
+ * actually subtends from a close moon, which is the range worth asking about. A landable
+ * moon whose primary fills 45° of sky is a view; one at 0.5° is a dot.
+ *
+ * Distance is the body's own semi-major axis, centre to centre, so the figure is the mean.
+ *
+ * @param body - The body being stood on. Needs
+ * {@link BodyProperties.SemiMajorAxis | SemiMajorAxis}.
+ * @param primary - The body it orbits. Needs {@link BodyProperties.Radius | Radius}.
+ * @returns The angular diameter in degrees, or `null` when the orbit or the primary's
+ * radius is missing.
+ * @throws {TypeError} If either argument is not an object.
+ * @example
+ * ```ts
+ * import { primaryAngularDiameter } from '@elite-dangerous-almanac/core/astro/body-physics';
+ *
+ * // A primary as far away as it is wide fills a right angle of sky.
+ * primaryAngularDiameter({ SemiMajorAxis: 1e9 }, { Radius: 1e9 }); // -> 90
+ *
+ * // Earth's Moon, looking back: Earth subtends about 2°.
+ * primaryAngularDiameter({ SemiMajorAxis: 3.844e8 }, { Radius: 6_371_000 }); // -> 1.899…
+ * ```
+ */
+declare function primaryAngularDiameter(body: BodyProperties, primary: BodyProperties): number | null;
+
+export { GRAVITATIONAL_CONSTANT, KG_PER_EARTH_MASS, KG_PER_SOLAR_MASS, type RocheLimits, bodyMass, bulkDensity, hillRadius, primaryAngularDiameter, rocheLimits, rocheLimitsForDensity };

package/dist/astro/body-physics.js

@@ -0,0 +1 @@
+export{GRAVITATIONAL_CONSTANT,KG_PER_EARTH_MASS,KG_PER_SOLAR_MASS,bodyMass,bulkDensity,hillRadius,primaryAngularDiameter,rocheLimits,rocheLimitsForDensity}from"../chunk-TMXKC6JL.js";                                                          //# sourceMappingURL=body-physics.js.map

package/dist/astro/body-physics.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"O"}