@johnmorrisdotca/chikyu-earth 0.5.0 → 0.7.0

package/dist/space/ephemeris.d.ts

@@ -0,0 +1,151 @@
+/**
+ * A position or direction as `[x, y, z]`, in the scene's axes (x toward the vernal equinox, y north).
+ *
+ * @example
+ * ```ts
+ * import type { Vec3 } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const origin: Vec3 = [0, 0, 0];
+ * console.log(origin);
+ * ```
+ */
+export type Vec3 = [number, number, number];
+/**
+ * The planets drawn, nearest the Sun first.
+ *
+ * @example
+ * ```ts
+ * import { PLANETS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(PLANETS.join(", "));
+ * ```
+ */
+export declare const PLANETS: readonly ["Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"];
+/**
+ * One of the seven planets drawn, by name.
+ *
+ * @example
+ * ```ts
+ * import { orbitPath, type PlanetName } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const planet: PlanetName = "Mars";
+ * console.log(orbitPath(planet, Date.UTC(2026, 10, 2), 8).length);
+ * ```
+ */
+export type PlanetName = (typeof PLANETS)[number];
+/**
+ * Where everything is at one moment: positions in astronomical units from the Earth's centre, in scene axes (x to the vernal equinox, y north, z toward -y of the equator).
+ *
+ * @example
+ * ```ts
+ * import { frameAt, type Frame } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const frame: Frame = frameAt(Date.UTC(2026, 10, 2, 12));
+ * console.log(Object.keys(frame.planets).length, frame.spin.toFixed(0));
+ * ```
+ */
+export interface Frame {
+    ms: number;
+    sun: Vec3;
+    moon: Vec3;
+    planets: Record<PlanetName, Vec3>;
+    /** Greenwich sidereal time, in degrees: how far the Earth has turned against the stars. */
+    spin: number;
+}
+/**
+ * The Earth's radius in kilometres, the unit of the scene's distances.
+ *
+ * @example
+ * ```ts
+ * import { EARTH_RADIUS_KM } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(EARTH_RADIUS_KM);
+ * ```
+ */
+export declare const EARTH_RADIUS_KM = 6371;
+/**
+ * Earth radii in one astronomical unit.
+ *
+ * @example
+ * ```ts
+ * import { AU_IN_EARTH_RADII } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(Math.round(AU_IN_EARTH_RADII));
+ * ```
+ */
+export declare const AU_IN_EARTH_RADII: number;
+/**
+ * The state of the sky at `ms`: nine vectors and an angle, in a few tenths of a millisecond. It needs astronomy-engine (an optional peer dependency).
+ *
+ * @param ms - A moment, in milliseconds since the Unix epoch.
+ * @returns The Sun, the Moon and the planets as seen from the Earth's centre, and how far the Earth has turned.
+ *
+ * @example
+ * ```ts
+ * import { frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const frame = frameAt(Date.UTC(2026, 10, 2, 12));
+ * console.log(frame.moon.map((n) => n.toFixed(4)));
+ * ```
+ */
+export declare function frameAt(ms: number): Frame;
+/**
+ * A frame between two others, `t` from 0 to 1. The spin goes the short way round, so a step under half a turn is right.
+ *
+ * @param a - The earlier frame.
+ * @param b - The later frame.
+ * @param t - How far from `a` to `b`, from 0 to 1.
+ * @returns The frame at that fraction.
+ *
+ * @example
+ * ```ts
+ * import { blend, frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const start = Date.UTC(2026, 10, 2);
+ * const middle = blend(frameAt(start), frameAt(start + 1000), 0.5);
+ * console.log(middle.ms - start);
+ * ```
+ */
+export declare function blend(a: Frame, b: Frame, t: number): Frame;
+/**
+ * Answers for any moment from two real ones: `at(ms)` asks astronomy-engine only when `ms` leaves the span the last two answers cover, and then looks
+ * `stepMs` ahead, so playing time at a steady rate costs one pair of lookups every `stepMs` and every draw in between is arithmetic.
+ *
+ * @param initialStepMs - How far ahead the second answer looks, in milliseconds.
+ * @returns A track: `at(ms)` for a frame, `lookups` for how many times the ephemeris was asked, `reset()` and `setStep(ms)`.
+ *
+ * @example
+ * ```ts
+ * import { createTrack } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const track = createTrack(1000);
+ * const start = Date.UTC(2026, 10, 2);
+ * for (let step = 0; step < 10; step += 1) track.at(start + step * 50);
+ * console.log(track.lookups);
+ * ```
+ */
+export declare function createTrack(initialStepMs?: number): {
+    at(ms: number): Frame;
+    /** How many times astronomy-engine has been asked for a frame. */
+    readonly lookups: number;
+    reset(): void;
+    /** Look further ahead (a faster game clock): the next lookup uses it. */
+    setStep(ms: number): void;
+};
+/** The path a planet takes round the Sun, as `count` points around the orbit that starts where the planet is at `ms`, relative to the Sun (scene axes, AU).
+ *
+ * @param name - The planet.
+ * @param ms - The moment the orbit starts at, in milliseconds since the Unix epoch.
+ * @param count - How many segments to cut the orbit into.
+ * @returns `count + 1` points, the last on the first.
+ *
+ * @example
+ * ```ts
+ * import { orbitPath } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const points = orbitPath("Jupiter", Date.UTC(2026, 10, 2), 12);
+ * console.log(points.length);
+ * ```
+ */
+export declare function orbitPath(name: PlanetName, ms: number, count?: number): Vec3[];
+/** The Earth's own place relative to the Sun, for placing the orbits round the Sun's place in the Earth-centred scene. */

package/dist/space/ephemeris.js

@@ -0,0 +1,162 @@
+// Where the Sun, the Moon and the planets are, as seen from the centre of the Earth, for any date. astronomy-engine (MIT) does the sums; this file asks it
+// for a handful of vectors, keeps them in the scene's axes, and lets a draw interpolate between two answers a second apart instead of asking at every frame.
+import { Body, GeoVector, HelioVector, SiderealTime } from "astronomy-engine";
+/**
+ * The planets drawn, nearest the Sun first.
+ *
+ * @example
+ * ```ts
+ * import { PLANETS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(PLANETS.join(", "));
+ * ```
+ */
+export const PLANETS = ["Mercury", "Venus", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"];
+/** Equatorial J2000 axes (x to the vernal equinox, z to the north pole) to the scene's (y up). */
+const scene = (v) => [v.x, v.z, -v.y];
+const AU_KM = 149_597_870.7;
+/**
+ * The Earth's radius in kilometres, the unit of the scene's distances.
+ *
+ * @example
+ * ```ts
+ * import { EARTH_RADIUS_KM } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(EARTH_RADIUS_KM);
+ * ```
+ */
+export const EARTH_RADIUS_KM = 6371;
+/**
+ * Earth radii in one astronomical unit.
+ *
+ * @example
+ * ```ts
+ * import { AU_IN_EARTH_RADII } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(Math.round(AU_IN_EARTH_RADII));
+ * ```
+ */
+export const AU_IN_EARTH_RADII = AU_KM / EARTH_RADIUS_KM;
+/**
+ * The state of the sky at `ms`: nine vectors and an angle, in a few tenths of a millisecond. It needs astronomy-engine (an optional peer dependency).
+ *
+ * @param ms - A moment, in milliseconds since the Unix epoch.
+ * @returns The Sun, the Moon and the planets as seen from the Earth's centre, and how far the Earth has turned.
+ *
+ * @example
+ * ```ts
+ * import { frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const frame = frameAt(Date.UTC(2026, 10, 2, 12));
+ * console.log(frame.moon.map((n) => n.toFixed(4)));
+ * ```
+ */
+export function frameAt(ms) {
+    const date = new Date(ms);
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = scene(GeoVector(Body[name], date, true));
+    return {
+        ms,
+        sun: scene(GeoVector(Body.Sun, date, true)),
+        moon: scene(GeoVector(Body.Moon, date, true)),
+        planets,
+        spin: SiderealTime(date) * 15,
+    };
+}
+const lerp3 = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+/**
+ * A frame between two others, `t` from 0 to 1. The spin goes the short way round, so a step under half a turn is right.
+ *
+ * @param a - The earlier frame.
+ * @param b - The later frame.
+ * @param t - How far from `a` to `b`, from 0 to 1.
+ * @returns The frame at that fraction.
+ *
+ * @example
+ * ```ts
+ * import { blend, frameAt } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const start = Date.UTC(2026, 10, 2);
+ * const middle = blend(frameAt(start), frameAt(start + 1000), 0.5);
+ * console.log(middle.ms - start);
+ * ```
+ */
+export function blend(a, b, t) {
+    const planets = {};
+    for (const name of PLANETS)
+        planets[name] = lerp3(a.planets[name], b.planets[name], t);
+    let turn = b.spin - a.spin;
+    turn -= 360 * Math.round(turn / 360);
+    return { ms: a.ms + (b.ms - a.ms) * t, sun: lerp3(a.sun, b.sun, t), moon: lerp3(a.moon, b.moon, t), planets, spin: a.spin + turn * t };
+}
+/**
+ * Answers for any moment from two real ones: `at(ms)` asks astronomy-engine only when `ms` leaves the span the last two answers cover, and then looks
+ * `stepMs` ahead, so playing time at a steady rate costs one pair of lookups every `stepMs` and every draw in between is arithmetic.
+ *
+ * @param initialStepMs - How far ahead the second answer looks, in milliseconds.
+ * @returns A track: `at(ms)` for a frame, `lookups` for how many times the ephemeris was asked, `reset()` and `setStep(ms)`.
+ *
+ * @example
+ * ```ts
+ * import { createTrack } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const track = createTrack(1000);
+ * const start = Date.UTC(2026, 10, 2);
+ * for (let step = 0; step < 10; step += 1) track.at(start + step * 50);
+ * console.log(track.lookups);
+ * ```
+ */
+export function createTrack(initialStepMs = 1000) {
+    let stepMs = initialStepMs;
+    let a;
+    let b;
+    let lookups = 0;
+    return {
+        at(ms) {
+            if (!a || !b || ms < a.ms || ms > b.ms) {
+                a = frameAt(ms);
+                b = frameAt(ms + stepMs);
+                lookups += 2;
+            }
+            return blend(a, b, (ms - a.ms) / (b.ms - a.ms));
+        },
+        /** How many times astronomy-engine has been asked for a frame. */
+        get lookups() {
+            return lookups;
+        },
+        reset() {
+            a = undefined;
+            b = undefined;
+        },
+        /** Look further ahead (a faster game clock): the next lookup uses it. */
+        setStep(ms) {
+            stepMs = Math.max(1, ms);
+            a = undefined;
+            b = undefined;
+        },
+    };
+}
+/** The path a planet takes round the Sun, as `count` points around the orbit that starts where the planet is at `ms`, relative to the Sun (scene axes, AU).
+ *
+ * @param name - The planet.
+ * @param ms - The moment the orbit starts at, in milliseconds since the Unix epoch.
+ * @param count - How many segments to cut the orbit into.
+ * @returns `count + 1` points, the last on the first.
+ *
+ * @example
+ * ```ts
+ * import { orbitPath } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const points = orbitPath("Jupiter", Date.UTC(2026, 10, 2), 12);
+ * console.log(points.length);
+ * ```
+ */
+export function orbitPath(name, ms, count = 96) {
+    const periodDays = { Mercury: 87.97, Venus: 224.7, Mars: 686.98, Jupiter: 4332.6, Saturn: 10759, Uranus: 30688, Neptune: 60182 }[name];
+    const points = [];
+    for (let i = 0; i <= count; i += 1)
+        points.push(scene(HelioVector(Body[name], new Date(ms + (i / count) * periodDays * 86_400_000))));
+    return points;
+}
+/** The Earth's own place relative to the Sun, for placing the orbits round the Sun's place in the Earth-centred scene. */

package/dist/space/index.d.ts

@@ -0,0 +1,3 @@
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS, type Frame, type PlanetName, type Vec3 } from "./ephemeris.ts";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition, type ScaleMode } from "./scale.ts";
+export { plainPainter, type BodyDrawing, type BodyPainter } from "./scene.ts";

package/dist/space/index.js

@@ -0,0 +1,5 @@
+// The space view's pure parts: where the bodies are (astronomy-engine, an optional peer) and the two scales. They import on a server. The element is
+// `@johnmorrisdotca/chikyu-earth/space/element`.
+export { AU_IN_EARTH_RADII, blend, createTrack, EARTH_RADIUS_KM, frameAt, orbitPath, PLANETS } from "./ephemeris.js";
+export { compress, MOON_COMPRESSED, placeAround, placeMoon, placeSun, RADIUS, SUN_COMPRESSED, truePosition } from "./scale.js";
+export { plainPainter } from "./scene.js";

package/dist/space/scale.d.ts

@@ -0,0 +1,124 @@
+import { type Vec3 } from "./ephemeris.ts";
+/**
+ * The scale the space view is drawn in: `compressed` squeezes the distances so the Moon, the Sun and Neptune fit one view, and `true` keeps the real ones.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon, type ScaleMode } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * const mode: ScaleMode = "compressed";
+ * console.log(placeMoon(mode, [0.00257, 0, 0]));
+ * ```
+ */
+export type ScaleMode = "compressed" | "true";
+/**
+ * The Moon's distance in a compressed view, in Earth radii (the true one is about 60).
+ *
+ * @example
+ * ```ts
+ * import { MOON_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(MOON_COMPRESSED);
+ * ```
+ */
+export declare const MOON_COMPRESSED = 10;
+/**
+ * The Sun's distance from the Earth in a compressed view, in Earth radii (the true one is about 23,500). One astronomical unit is this long there.
+ *
+ * @example
+ * ```ts
+ * import { SUN_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(SUN_COMPRESSED);
+ * ```
+ */
+export declare const SUN_COMPRESSED = 44;
+/**
+ * A place in astronomical units from the Earth's centre, at true distance, in Earth radii.
+ *
+ * @param v - The place, in astronomical units.
+ * @returns The same direction, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { truePosition } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(truePosition([0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const truePosition: (v: Vec3) => Vec3;
+/**
+ * The same direction at a compressed distance from the Earth: the Moon is 10 Earth radii away, and a body k times further than the Moon is k^0.25 times as far here.
+ *
+ * @param v - The place, in astronomical units from the Earth's centre.
+ * @returns The place in Earth radii, compressed; the centre stays at the centre.
+ *
+ * @example
+ * ```ts
+ * import { compress } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(compress([0.00257, 0, 0]), compress([0, 0, 0]));
+ * ```
+ */
+export declare function compress(v: Vec3): Vec3;
+/**
+ * The Moon, from the Earth's centre.
+ *
+ * @param mode - The scale.
+ * @param geo - The Moon's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeMoon("true", [0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export declare const placeMoon: (mode: ScaleMode, geo: Vec3) => Vec3;
+/**
+ * The Sun, from the Earth's centre: in a compressed view always 44 Earth radii away, in its real direction.
+ *
+ * @param mode - The scale.
+ * @param geo - The Sun's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeSun } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeSun("compressed", [1, 0, 0]));
+ * ```
+ */
+export declare function placeSun(mode: ScaleMode, geo: Vec3): Vec3;
+/**
+ * A place `helio` astronomical units from the Sun (a planet, or a point on its orbit), round the Sun at `sun`. True: as it is. Compressed: the same direction from
+ * the Sun, at 44 Earth radii times its distance in astronomical units to the power 0.45, so the Earth's own orbit is the 44 and Neptune's is about 200 (30 times as far, really).
+ *
+ * @param mode - The scale.
+ * @param sun - Where the Sun is drawn, in Earth radii.
+ * @param helio - The place in astronomical units from the Sun.
+ * @returns Where to draw the place, in Earth radii from the Earth's centre.
+ *
+ * @example
+ * ```ts
+ * import { placeAround } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeAround("compressed", [44, 0, 0], [1, 0, 0]));
+ * ```
+ */
+export declare function placeAround(mode: ScaleMode, sun: Vec3, helio: Vec3): Vec3;
+/**
+ * Radii in Earth radii: the real ones, and ones large enough to see in a compressed view.
+ *
+ * @example
+ * ```ts
+ * import { RADIUS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(RADIUS["Moon"]);
+ * ```
+ */
+export declare const RADIUS: Record<string, {
+    true: number;
+    compressed: number;
+}>;

package/dist/space/scale.js

@@ -0,0 +1,141 @@
+// The two scales the space view can show. The true one is the Earth's radius for a unit and the real distances in it; the compressed one keeps every
+// direction but squeezes the distances so that the Moon, the Sun and Neptune fit one view. Pure.
+import { AU_IN_EARTH_RADII } from "./ephemeris.js";
+const MOON_AU = 0.00257;
+/**
+ * The Moon's distance in a compressed view, in Earth radii (the true one is about 60).
+ *
+ * @example
+ * ```ts
+ * import { MOON_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(MOON_COMPRESSED);
+ * ```
+ */
+export const MOON_COMPRESSED = 10;
+/**
+ * The Sun's distance from the Earth in a compressed view, in Earth radii (the true one is about 23,500). One astronomical unit is this long there.
+ *
+ * @example
+ * ```ts
+ * import { SUN_COMPRESSED } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(SUN_COMPRESSED);
+ * ```
+ */
+export const SUN_COMPRESSED = 44;
+const length = (v) => Math.hypot(v[0], v[1], v[2]);
+const scaled = (v, k) => [v[0] * k, v[1] * k, v[2] * k];
+/**
+ * A place in astronomical units from the Earth's centre, at true distance, in Earth radii.
+ *
+ * @param v - The place, in astronomical units.
+ * @returns The same direction, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { truePosition } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(truePosition([0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export const truePosition = (v) => scaled(v, AU_IN_EARTH_RADII);
+/**
+ * The same direction at a compressed distance from the Earth: the Moon is 10 Earth radii away, and a body k times further than the Moon is k^0.25 times as far here.
+ *
+ * @param v - The place, in astronomical units from the Earth's centre.
+ * @returns The place in Earth radii, compressed; the centre stays at the centre.
+ *
+ * @example
+ * ```ts
+ * import { compress } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(compress([0.00257, 0, 0]), compress([0, 0, 0]));
+ * ```
+ */
+export function compress(v) {
+    const l = length(v);
+    return l === 0 ? [0, 0, 0] : scaled(v, (MOON_COMPRESSED * (l / MOON_AU) ** 0.25) / l);
+}
+/**
+ * The Moon, from the Earth's centre.
+ *
+ * @param mode - The scale.
+ * @param geo - The Moon's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeMoon } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeMoon("true", [0.00257, 0, 0]).map(Math.round));
+ * ```
+ */
+export const placeMoon = (mode, geo) => (mode === "true" ? truePosition(geo) : compress(geo));
+/**
+ * The Sun, from the Earth's centre: in a compressed view always 44 Earth radii away, in its real direction.
+ *
+ * @param mode - The scale.
+ * @param geo - The Sun's place in astronomical units from the Earth's centre.
+ * @returns Where to draw it, in Earth radii.
+ *
+ * @example
+ * ```ts
+ * import { placeSun } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeSun("compressed", [1, 0, 0]));
+ * ```
+ */
+export function placeSun(mode, geo) {
+    if (mode === "true")
+        return truePosition(geo);
+    const l = length(geo);
+    return l === 0 ? [0, 0, 0] : scaled(geo, SUN_COMPRESSED / l);
+}
+/**
+ * A place `helio` astronomical units from the Sun (a planet, or a point on its orbit), round the Sun at `sun`. True: as it is. Compressed: the same direction from
+ * the Sun, at 44 Earth radii times its distance in astronomical units to the power 0.45, so the Earth's own orbit is the 44 and Neptune's is about 200 (30 times as far, really).
+ *
+ * @param mode - The scale.
+ * @param sun - Where the Sun is drawn, in Earth radii.
+ * @param helio - The place in astronomical units from the Sun.
+ * @returns Where to draw the place, in Earth radii from the Earth's centre.
+ *
+ * @example
+ * ```ts
+ * import { placeAround } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(placeAround("compressed", [44, 0, 0], [1, 0, 0]));
+ * ```
+ */
+export function placeAround(mode, sun, helio) {
+    if (mode === "true")
+        return [sun[0] + helio[0] * AU_IN_EARTH_RADII, sun[1] + helio[1] * AU_IN_EARTH_RADII, sun[2] + helio[2] * AU_IN_EARTH_RADII];
+    const l = length(helio);
+    if (l === 0)
+        return sun;
+    const d = (SUN_COMPRESSED * l ** 0.45) / l;
+    return [sun[0] + helio[0] * d, sun[1] + helio[1] * d, sun[2] + helio[2] * d];
+}
+/**
+ * Radii in Earth radii: the real ones, and ones large enough to see in a compressed view.
+ *
+ * @example
+ * ```ts
+ * import { RADIUS } from "@johnmorrisdotca/chikyu-earth/space";
+ *
+ * console.log(RADIUS["Moon"]);
+ * ```
+ */
+export const RADIUS = {
+    Sun: { true: 109.1, compressed: 5 },
+    Earth: { true: 1, compressed: 1 },
+    Moon: { true: 0.2727, compressed: 0.9 },
+    Mercury: { true: 0.383, compressed: 0.5 },
+    Venus: { true: 0.949, compressed: 0.8 },
+    Mars: { true: 0.532, compressed: 0.6 },
+    Jupiter: { true: 10.97, compressed: 1.8 },
+    Saturn: { true: 9.14, compressed: 1.6 },
+    Uranus: { true: 3.98, compressed: 1.0 },
+    Neptune: { true: 3.86, compressed: 1.0 },
+};