@johnmorrisdotca/uchusen-rockets 0.3.0 → 0.4.0

package/dist/flight.d.ts

@@ -1,21 +1,92 @@
 import { type Flight, type FlightPhase } from "./data/flights.ts";
 import type { Figure } from "./data/types.ts";
 export type { Flight, FlightBurn, FlightPhase, PartPose } from "./data/flights.ts";
-/** Seconds a phase takes on the screen when the timeline plays: one flight in under a minute, whatever its real length. */
+/**
+ * Seconds a phase takes on the screen when the timeline plays: one flight in under a minute, whatever its real length.
+ *
+ * @example
+ * ```ts
+ * import { SECONDS_PER_PHASE } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(SECONDS_PER_PHASE);
+ * ```
+ */
 export declare const SECONDS_PER_PHASE = 2.4;
-/** The flight for a rocket's variant, when a page gives one. */
+/**
+ * The flight for a rocket's variant, when a page gives one.
+ *
+ * @param rocket A rocket's id.
+ * @param variant A variant's id, or undefined.
+ * @returns The flight for that variant, or null when it has none.
+ * @example
+ * ```ts
+ * import { flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(flightOf("starship", "v3")?.name, flightOf("starship", "v4"));
+ * ```
+ */
 export declare const flightOf: (rocket: string, variant: string | undefined) => Flight | null;
-/** The last place on the timeline: the last phase. */
+/**
+ * The last place on the timeline: the last phase.
+ *
+ * @param flight A flight.
+ * @returns The index of its last phase.
+ * @example
+ * ```ts
+ * import { flightOf, lastPosition } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * console.log(flight ? lastPosition(flight) : null);
+ * ```
+ */
 export declare const lastPosition: (flight: Flight) => number;
-/** Which phase a place on the timeline is in, and how far along to the next. A value that is not a number is the start. */
+/**
+ * Which phase a place on the timeline is in, and how far along to the next. A value that is not a number is the start.
+ *
+ * @param flight A flight.
+ * @param position A place on the timeline: 0 is the first phase, 1 the second, 1.5 halfway to the third.
+ * @returns The phase index, how far along to the next (0 to 1) and the phase.
+ * @example
+ * ```ts
+ * import { flightOf, phaseAt } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(phaseAt(flight, 1.5).phase.name);
+ * ```
+ */
 export declare function phaseAt(flight: Flight, position: number): {
     index: number;
     along: number;
     phase: FlightPhase;
 };
-/** The place on the timeline of a phase by its id, or null for one the flight does not have. */
+/**
+ * The place on the timeline of a phase by its id, or null for one the flight does not have.
+ *
+ * @param flight A flight.
+ * @param id A phase's id, or null or undefined.
+ * @returns The place of that phase on the timeline, or null for an id the flight does not have.
+ * @example
+ * ```ts
+ * import { flightOf, phasePosition } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(phasePosition(flight, "nonsense"));
+ * ```
+ */
 export declare function phasePosition(flight: Flight, id: string | null | undefined): number | null;
-/** How many engines of each part burn in a phase, as drawn: a blank figure draws its `drawn`. */
+/**
+ * How many engines of each part burn in a phase, as drawn: a blank figure draws its `drawn`.
+ *
+ * @param phase A phase of a flight.
+ * @returns The number of engines burning for each part, by slot.
+ * @example
+ * ```ts
+ * import { burnsOf, flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const phase = flightOf("falcon-9", "block-5")?.phases[0];
+ * console.log(phase ? burnsOf(phase) : {});
+ * ```
+ */
 export declare function burnsOf(phase: FlightPhase): Record<string, number>;
 export interface PoseNow {
     dx: number;
@@ -23,6 +94,18 @@ export interface PoseNow {
     pitch: number;
     gone: boolean;
 }
+/**
+ * Everything the picture needs at one place on the timeline: the phase, how each part stands, which engines burn, how far the ground has fallen, and how much smoke stands on the pad.
+ *
+ * @example
+ * ```ts
+ * import { flightOf, frameAt, type FlightFrame } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * const frame: FlightFrame | undefined = flight ? frameAt(flight, 0, [{ slot: "first-stage", baseY: 0 }], 70) : undefined;
+ * console.log(frame?.phase.name, frame?.separated);
+ * ```
+ */
 export interface FlightFrame {
     index: number;
     phase: FlightPhase;
@@ -40,7 +123,22 @@ export interface FlightPart {
     /** Where it stands in the stack: the base's height, metres. */
     baseY: number;
 }
-/** Everything the picture needs at a place on the timeline, for a vehicle `height` metres tall. */
+/**
+ * Everything the picture needs at a place on the timeline, for a vehicle `height` metres tall.
+ *
+ * @param flight A flight.
+ * @param position A place on the timeline.
+ * @param parts Each part's slot and the height of its base in the stack, in metres.
+ * @param height The vehicle's height in metres.
+ * @returns The frame to draw.
+ * @example
+ * ```ts
+ * import { flightOf, frameAt } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(frameAt(flight, 1, [{ slot: "first-stage", baseY: 0 }, { slot: "second-stage", baseY: 41 }], 70).burns);
+ * ```
+ */
 export declare function frameAt(flight: Flight, position: number, parts: readonly FlightPart[], height: number): FlightFrame;
 /** How far a flight's picture reaches, so the camera can hold all of it: the widest and highest every part stands, from the stack's own bounds. */
 export declare function flightBounds(flight: Flight, parts: readonly (FlightPart & {
@@ -50,7 +148,23 @@ export declare function flightBounds(flight: Flight, parts: readonly (FlightPart
     min: [number, number, number];
     max: [number, number, number];
 };
-/** The clock of one timeline: where it is and whether it runs. It only moves when told to, once a frame by whoever draws, so a timeline out of sight stands still. */
+/**
+ * The clock of one timeline: where it is and whether it runs. It only moves when told to, once a frame by whoever draws, so a timeline out of sight stands still.
+ *
+ * @param flight The flight whose clock this is.
+ * @example
+ * ```ts
+ * import { FlightClock, flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) {
+ *   const clock = new FlightClock(flight);
+ *   clock.play();
+ *   clock.advance(2.4);
+ *   console.log(clock.position, clock.ended);
+ * }
+ * ```
+ */
 export declare class FlightClock {
     readonly flight: Flight;
     position: number;
@@ -63,5 +177,16 @@ export declare class FlightClock {
     /** Moves on by `seconds` of the screen's time, and stops at the end. */
     advance(seconds: number): void;
 }
-/** A time as words: `T+2:35`, `T-0:03`, `T+1:05:20`. A blank says so. */
+/**
+ * A time as words: `T+2:35`, `T-0:03`, `T+1:05:20`. A blank says so.
+ *
+ * @param at A figure holding seconds from the flight's zero.
+ * @returns The time as text, such as `T+2:35`. A blank figure gives "Time: no source".
+ * @example
+ * ```ts
+ * import { clockWords } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(clockWords({ value: 155, source: "wikipedia-starship" }), clockWords({ value: -3, source: null }));
+ * ```
+ */
 export declare function clockWords(at: Figure): string;

package/dist/flight.js

@@ -1,24 +1,95 @@
 // A flight as a timeline: where the reader is along it, which engines burn there and how each part stands. The times and the counts are `src/data/flights.ts`, each with its page. Moving between the phases is a picture. Pure: no three.js and no DOM.
 import { FLIGHTS } from "./data/flights.js";
-/** Seconds a phase takes on the screen when the timeline plays: one flight in under a minute, whatever its real length. */
+/**
+ * Seconds a phase takes on the screen when the timeline plays: one flight in under a minute, whatever its real length.
+ *
+ * @example
+ * ```ts
+ * import { SECONDS_PER_PHASE } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(SECONDS_PER_PHASE);
+ * ```
+ */
 export const SECONDS_PER_PHASE = 2.4;
-/** The flight for a rocket's variant, when a page gives one. */
+/**
+ * The flight for a rocket's variant, when a page gives one.
+ *
+ * @param rocket A rocket's id.
+ * @param variant A variant's id, or undefined.
+ * @returns The flight for that variant, or null when it has none.
+ * @example
+ * ```ts
+ * import { flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(flightOf("starship", "v3")?.name, flightOf("starship", "v4"));
+ * ```
+ */
 export const flightOf = (rocket, variant) => FLIGHTS.find((flight) => flight.rocket === rocket && flight.variant === variant) ?? null;
-/** The last place on the timeline: the last phase. */
+/**
+ * The last place on the timeline: the last phase.
+ *
+ * @param flight A flight.
+ * @returns The index of its last phase.
+ * @example
+ * ```ts
+ * import { flightOf, lastPosition } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * console.log(flight ? lastPosition(flight) : null);
+ * ```
+ */
 export const lastPosition = (flight) => flight.phases.length - 1;
-/** Which phase a place on the timeline is in, and how far along to the next. A value that is not a number is the start. */
+/**
+ * Which phase a place on the timeline is in, and how far along to the next. A value that is not a number is the start.
+ *
+ * @param flight A flight.
+ * @param position A place on the timeline: 0 is the first phase, 1 the second, 1.5 halfway to the third.
+ * @returns The phase index, how far along to the next (0 to 1) and the phase.
+ * @example
+ * ```ts
+ * import { flightOf, phaseAt } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(phaseAt(flight, 1.5).phase.name);
+ * ```
+ */
 export function phaseAt(flight, position) {
     const last = lastPosition(flight);
     const place = Number.isFinite(position) ? Math.min(last, Math.max(0, position)) : 0;
     const index = Math.floor(place);
     return { index, along: place - index, phase: flight.phases[index] };
 }
-/** The place on the timeline of a phase by its id, or null for one the flight does not have. */
+/**
+ * The place on the timeline of a phase by its id, or null for one the flight does not have.
+ *
+ * @param flight A flight.
+ * @param id A phase's id, or null or undefined.
+ * @returns The place of that phase on the timeline, or null for an id the flight does not have.
+ * @example
+ * ```ts
+ * import { flightOf, phasePosition } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(phasePosition(flight, "nonsense"));
+ * ```
+ */
 export function phasePosition(flight, id) {
     const index = flight.phases.findIndex((phase) => phase.id === id);
     return index < 0 ? null : index;
 }
-/** How many engines of each part burn in a phase, as drawn: a blank figure draws its `drawn`. */
+/**
+ * How many engines of each part burn in a phase, as drawn: a blank figure draws its `drawn`.
+ *
+ * @param phase A phase of a flight.
+ * @returns The number of engines burning for each part, by slot.
+ * @example
+ * ```ts
+ * import { burnsOf, flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const phase = flightOf("falcon-9", "block-5")?.phases[0];
+ * console.log(phase ? burnsOf(phase) : {});
+ * ```
+ */
 export function burnsOf(phase) {
     const out = {};
     for (const [slot, burn] of Object.entries(phase.burns))
@@ -33,7 +104,22 @@ const poseIn = (pose, part, height) => ({
     pitch: pose?.pitch ?? 0,
     gone: pose?.gone ?? false,
 });
-/** Everything the picture needs at a place on the timeline, for a vehicle `height` metres tall. */
+/**
+ * Everything the picture needs at a place on the timeline, for a vehicle `height` metres tall.
+ *
+ * @param flight A flight.
+ * @param position A place on the timeline.
+ * @param parts Each part's slot and the height of its base in the stack, in metres.
+ * @param height The vehicle's height in metres.
+ * @returns The frame to draw.
+ * @example
+ * ```ts
+ * import { flightOf, frameAt } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) console.log(frameAt(flight, 1, [{ slot: "first-stage", baseY: 0 }, { slot: "second-stage", baseY: 41 }], 70).burns);
+ * ```
+ */
 export function frameAt(flight, position, parts, height) {
     const { index, along, phase } = phaseAt(flight, position);
     const next = flight.phases[Math.min(index + 1, lastPosition(flight))];
@@ -78,7 +164,23 @@ export function flightBounds(flight, parts, height) {
         }
     return { min, max };
 }
-/** The clock of one timeline: where it is and whether it runs. It only moves when told to, once a frame by whoever draws, so a timeline out of sight stands still. */
+/**
+ * The clock of one timeline: where it is and whether it runs. It only moves when told to, once a frame by whoever draws, so a timeline out of sight stands still.
+ *
+ * @param flight The flight whose clock this is.
+ * @example
+ * ```ts
+ * import { FlightClock, flightOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const flight = flightOf("falcon-9", "block-5");
+ * if (flight) {
+ *   const clock = new FlightClock(flight);
+ *   clock.play();
+ *   clock.advance(2.4);
+ *   console.log(clock.position, clock.ended);
+ * }
+ * ```
+ */
 export class FlightClock {
     flight;
     position = 0;
@@ -111,7 +213,18 @@ export class FlightClock {
             this.playing = false;
     }
 }
-/** A time as words: `T+2:35`, `T-0:03`, `T+1:05:20`. A blank says so. */
+/**
+ * A time as words: `T+2:35`, `T-0:03`, `T+1:05:20`. A blank says so.
+ *
+ * @param at A figure holding seconds from the flight's zero.
+ * @returns The time as text, such as `T+2:35`. A blank figure gives "Time: no source".
+ * @example
+ * ```ts
+ * import { clockWords } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(clockWords({ value: 155, source: "wikipedia-starship" }), clockWords({ value: -3, source: null }));
+ * ```
+ */
 export function clockWords(at) {
     if (at.value === null)
         return "Time: no source";

package/dist/flightbar.d.ts

@@ -1,4 +1,16 @@
 declare const HTMLBase: typeof HTMLElement;
+/**
+ * The `<uchusen-flight>` element: a play button, a slider and the phase's name for a rocket's flight. Its `for` attribute is the id of the `<uchusen-rocket>` it drives. A variant with no flight says so.
+ *
+ * @example
+ * ```ts no-run
+ * import { UchusenFlight } from "@johnmorrisdotca/uchusen-rockets/element";
+ *
+ * const flight: UchusenFlight = document.createElement("uchusen-flight") as UchusenFlight;
+ * flight.setAttribute("for", "rocket");
+ * document.body.append(flight);
+ * ```
+ */
 export declare class UchusenFlight extends HTMLBase {
     static readonly observedAttributes: string[];
     private rocket;

package/dist/flightbar.js

@@ -22,6 +22,18 @@ figcaption { font-size: 0.74rem; line-height: 1.25; margin-top: 0.2rem; }
 a { color: inherit; }
 `;
 const sheet = { made: null };
+/**
+ * The `<uchusen-flight>` element: a play button, a slider and the phase's name for a rocket's flight. Its `for` attribute is the id of the `<uchusen-rocket>` it drives. A variant with no flight says so.
+ *
+ * @example
+ * ```ts no-run
+ * import { UchusenFlight } from "@johnmorrisdotca/uchusen-rockets/element";
+ *
+ * const flight: UchusenFlight = document.createElement("uchusen-flight") as UchusenFlight;
+ * flight.setAttribute("for", "rocket");
+ * document.body.append(flight);
+ * ```
+ */
 export class UchusenFlight extends HTMLBase {
     static observedAttributes = ["for"];
     rocket = null;

package/dist/framing.d.ts

@@ -1,21 +1,133 @@
+/**
+ * Three numbers: x, y and z. Y is up and the windward side faces +Z, in metres.
+ *
+ * @example
+ * ```ts
+ * import type { Vec3 } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const origin: Vec3 = [0, 0, 0];
+ * console.log(origin);
+ * ```
+ */
 export type Vec3 = [number, number, number];
-/** The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long. */
+/**
+ * The camera's field of view, in degrees, top to bottom. Narrow, because a rocket is long.
+ *
+ * @example
+ * ```ts
+ * import { FOV_DEG } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(FOV_DEG);
+ * ```
+ */
 export declare const FOV_DEG = 24;
-/** The picture's shape. */
+/**
+ * The width of the picture a drawing is made in, in drawing units.
+ *
+ * @example
+ * ```ts
+ * import { PICTURE_W, PICTURE_H } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(PICTURE_W, PICTURE_H);
+ * ```
+ */
 export declare const PICTURE_W = 480;
+/**
+ * The height of the picture a drawing is made in, in drawing units.
+ *
+ * @example
+ * ```ts
+ * import { PICTURE_H } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(PICTURE_H);
+ * ```
+ */
 export declare const PICTURE_H = 640;
+/**
+ * The names of the views, in the order the demo lists them: `three-quarter`, `front`, `back`, `side` and `below`.
+ *
+ * @example
+ * ```ts
+ * import { VIEW_NAMES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(VIEW_NAMES.join(", "));
+ * ```
+ */
 export declare const VIEW_NAMES: readonly ["three-quarter", "front", "back", "side", "below"];
+/**
+ * The name of one view in `VIEW_NAMES`.
+ *
+ * @example
+ * ```ts
+ * import type { ViewName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const view: ViewName = "below";
+ * console.log(view);
+ * ```
+ */
 export type ViewName = (typeof VIEW_NAMES)[number];
+/**
+ * The view used when none is named or the name is not a view: `three-quarter`.
+ *
+ * @example
+ * ```ts
+ * import { DEFAULT_VIEW } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(DEFAULT_VIEW);
+ * ```
+ */
 export declare const DEFAULT_VIEW: ViewName;
-/** An angle to look from: `az` degrees round from the windward side towards +X, `el` degrees above the horizon. Front is the windward, tiled side; back is the steel side. */
+/**
+ * An angle to look from: `az` degrees round from the windward side towards +X, `el` degrees above the horizon. Front is the windward, tiled side; back is the steel side.
+ *
+ * @example
+ * ```ts
+ * import { VIEWS, type Angle } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const angle: Angle = VIEWS.back;
+ * console.log(angle);
+ * ```
+ */
 export interface Angle {
     az: number;
     el: number;
 }
+/**
+ * The angle of each named view.
+ *
+ * @example
+ * ```ts
+ * import { VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(VIEWS.front, VIEWS.below);
+ * ```
+ */
 export declare const VIEWS: Readonly<Record<ViewName, Angle>>;
+/**
+ * A value from outside as a view's name.
+ *
+ * @param value Anything.
+ * @returns The name if it is one of the views, and `three-quarter` for anything else.
+ * @example
+ * ```ts
+ * import { cleanView } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(cleanView("side"), cleanView("sideways"), cleanView(42));
+ * ```
+ */
 export declare const cleanView: (value: unknown) => ViewName;
 export declare const deg: (d: number) => number;
-/** What the family's view controls report: the turn and tip in degrees, the zoom (1 is the whole rocket in the picture) and the pan in pixels. */
+/**
+ * What the family's view controls report: the turn and tip in degrees, the zoom (1 is the whole rocket in the picture) and the pan in pixels.
+ *
+ * @example
+ * ```ts
+ * import type { ViewChoice } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const choice: ViewChoice = { yaw: 20, tilt: -5, zoom: 1, panX: 0, panY: 0 };
+ * console.log(choice);
+ * ```
+ */
 export interface ViewChoice {
     yaw: number;
     tilt: number;
@@ -23,20 +135,82 @@ export interface ViewChoice {
     panX: number;
     panY: number;
 }
-/** What the family's view controls choose: the turn and tip, in degrees, from a base angle. Dragging right makes `yaw` larger, which carries the camera the other way round; `tilt` larger tips the top away, which lowers the camera. */
+/**
+ * What the family's view controls choose: the turn and tip, in degrees, from a base angle. Dragging right makes `yaw` larger, which carries the camera the other way round; `tilt` larger tips the top away, which lowers the camera.
+ *
+ * @param base The angle to turn from.
+ * @param yaw Degrees turned round.
+ * @param tilt Degrees tipped up or down.
+ * @returns The new angle.
+ * @example
+ * ```ts
+ * import { turnedBy, VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(turnedBy(VIEWS.front, 30, 10));
+ * ```
+ */
 export declare function turnedBy(base: Angle, yaw: number, tilt: number): Angle;
-/** The unit vector from what is looked at towards the camera. */
+/**
+ * The unit vector from what is looked at towards the camera.
+ *
+ * @param angle The angle to look from.
+ * @returns A unit vector.
+ * @example
+ * ```ts
+ * import { directionOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(directionOf({ az: 0, el: 0 }));
+ * ```
+ */
 export declare function directionOf({ az, el }: Angle): Vec3;
+/**
+ * Where the camera stands: the point it looks at, its position and its distance from that point, in metres.
+ *
+ * @example
+ * ```ts
+ * import { frameFor, type Framing } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const framing: Framing = frameFor([-5, 0, -5], [5, 100, 5], { az: 30, el: 15 }, 480 / 640);
+ * console.log(framing.distance > 0);
+ * ```
+ */
 export interface Framing {
     target: Vec3;
     position: Vec3;
     distance: number;
 }
-/** The camera's own axes for looking along `direction`, with up as near to +Y as it can be. */
+/**
+ * The camera's own axes for looking along `direction`, with up as near to +Y as it can be.
+ *
+ * @param direction The direction from the target to the camera.
+ * @returns The camera's right, up and forward axes.
+ * @example
+ * ```ts
+ * import { axesOf } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(axesOf([0, 0, 1]));
+ * ```
+ */
 export declare function axesOf(direction: Vec3): {
     right: Vec3;
     up: Vec3;
     forward: Vec3;
 };
-/** The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`. */
+/**
+ * The nearest camera that holds the whole of `min` to `max` in a picture `aspect` wide for 1 tall, from `angle`.
+ *
+ * @param min The lowest corner of the box to hold.
+ * @param max The highest corner.
+ * @param angle The angle to look from.
+ * @param aspect The picture's width over its height.
+ * @param margin Room left round the box, as a multiple. Defaults to 1.08.
+ * @returns The camera that holds the whole box.
+ * @example
+ * ```ts
+ * import { frameFor, VIEWS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const framing = frameFor([-4.5, 0, -4.5], [4.5, 124, 4.5], VIEWS.front, 480 / 640);
+ * console.log(framing.target, framing.distance.toFixed(0));
+ * ```
+ */
 export declare function frameFor(min: Vec3, max: Vec3, angle: Angle, aspect: number, margin?: number): Framing;