@johnmorrisdotca/wakusei-planets 0.6.0 → 0.11.0

package/dist/ephemeris.d.ts

@@ -1,10 +1,10 @@
-import { type BodyId, type MoonId, type PlanetId } from "./facts.ts";
+import { type BodyId, type HostId, type MoonId } from "./facts.ts";
 import { type Vec3 } from "./vec.ts";
 /** Solve Kepler's equation for the eccentric anomaly, all in radians. */
 export declare function kepler(meanAnomaly: number, e: number): number;
 /**
- * A planet's position in the Sun's frame (J2000 ecliptic, astronomical units) at a time, from JPL's approximate elements.
- * @param planet - The planet's name.
+ * A planet's or dwarf planet's position in the Sun's frame (J2000 ecliptic, astronomical units) at a time: a planet from JPL's approximate elements, a dwarf planet from the osculating elements of one epoch (JPL's Small-Body Database).
+ * @param planet - The planet's or dwarf planet's name.
  * @param ms - The instant, in milliseconds since 1970.
  * @returns The position as x, y, z in au.
  *
@@ -16,7 +16,7 @@ export declare function kepler(meanAnomaly: number, e: number): number;
  * console.log(Math.hypot(x, y, z).toFixed(3));
  * ```
  */
-export declare function heliocentric(planet: PlanetId, ms: number): Vec3;
+export declare function heliocentric(planet: HostId, ms: number): Vec3;
 /**
  * The Moon's position from the Earth's centre (J2000 ecliptic, kilometres), from the largest terms of Meeus's lunar series.
  * @param ms - The instant, in milliseconds since 1970.
@@ -164,7 +164,7 @@ export interface System {
  * console.log(moons.map((moon) => `${moon.id} ${moon.x.toFixed(1)}`).join(", "));
  * ```
  */
-export declare function system(planet: PlanetId, time: number): System;
+export declare function system(planet: HostId, time: number): System;
 /**
  * The path one moon follows round its planet over one trip, as the Earth sees it at `time`: x, y, z in planet radii, in the viewer's frame at that moment.
  *
@@ -183,7 +183,7 @@ export declare function system(planet: PlanetId, time: number): System;
  */
 export declare function orbitPath(id: MoonId, time: number, points?: number): Float32Array;
 /** The planets' moons that are near enough to draw in a system view, nearest first, with how far each goes in planet radii. */
-export declare function nearMoons(planet: PlanetId, within?: number): {
+export declare function nearMoons(planet: HostId, within?: number): {
     id: MoonId;
     reach: number;
 }[];

package/dist/ephemeris.js

@@ -3,6 +3,7 @@
 // good to about an arc minute. The Moon: the largest terms of Meeus, "Astronomical Algorithms", chapter 47. Other moons: JPL's mean elements (data/orbits.ts).
 // Light travel time is allowed for, so a turning planet shows the face it really showed when the light left. Pure: no DOM, no three.js.
 import { ORBITS } from "./data/orbits.js";
+import { DWARF_ELEMENTS } from "./data/dwarf.js";
 import { BODIES, MOONS_OF } from "./facts.js";
 import { add, cross, DEG, dot, fromRaDec, length, OBLIQUITY, RAD, scale, sub, toEcliptic, unit, wrap360 } from "./vec.js";
 /** Milliseconds since 1970 at J2000.0 (2000-01-01 12:00 TT, taken as UTC). */
@@ -42,8 +43,8 @@ export function kepler(meanAnomaly, e) {
     return E;
 }
 /**
- * A planet's position in the Sun's frame (J2000 ecliptic, astronomical units) at a time, from JPL's approximate elements.
- * @param planet - The planet's name.
+ * A planet's or dwarf planet's position in the Sun's frame (J2000 ecliptic, astronomical units) at a time: a planet from JPL's approximate elements, a dwarf planet from the osculating elements of one epoch (JPL's Small-Body Database).
+ * @param planet - The planet's or dwarf planet's name.
  * @param ms - The instant, in milliseconds since 1970.
  * @returns The position as x, y, z in au.
  *
@@ -56,16 +57,34 @@ export function kepler(meanAnomaly, e) {
  * ```
  */
 export function heliocentric(planet, ms) {
-    const el = ELEMENTS[planet];
-    const T = centuries(ms);
-    const a = el[0] + el[6] * T;
-    const e = el[1] + el[7] * T;
-    const I = (el[2] + el[8] * T) * RAD;
-    const L = el[3] + el[9] * T;
-    const peri = el[4] + el[10] * T;
-    const node = (el[5] + el[11] * T) * RAD;
-    const w = peri * RAD - node;
-    const E = kepler((L - peri) * RAD, e);
+    let a;
+    let e;
+    let I;
+    let node;
+    let w;
+    let E;
+    const dwarf = DWARF_ELEMENTS[planet];
+    if (dwarf !== undefined) {
+        // a dwarf planet: the osculating elements of one epoch, run as a plain ellipse (good for years either side of it)
+        a = dwarf.a;
+        e = dwarf.e;
+        I = dwarf.i * RAD;
+        node = dwarf.node * RAD;
+        w = dwarf.w * RAD;
+        E = kepler((dwarf.m + (dwarf.n * (ms - dwarf.epoch)) / DAY) * RAD, e);
+    }
+    else {
+        const el = ELEMENTS[planet];
+        const T = centuries(ms);
+        a = el[0] + el[6] * T;
+        e = el[1] + el[7] * T;
+        I = (el[2] + el[8] * T) * RAD;
+        const L = el[3] + el[9] * T;
+        const peri = el[4] + el[10] * T;
+        node = (el[5] + el[11] * T) * RAD;
+        w = peri * RAD - node;
+        E = kepler((L - peri) * RAD, e);
+    }
     const x = a * (Math.cos(E) - e);
     const y = a * Math.sqrt(1 - e * e) * Math.sin(E);
     const cw = Math.cos(w);
@@ -231,6 +250,8 @@ export function moonVector(id, ms) {
 function referenceBasis(orbit) {
     if (orbit.frame === "ecliptic")
         return { x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] };
+    if (orbit.frame === "j2000")
+        return { x: toEcliptic([1, 0, 0]), y: toEcliptic([0, 1, 0]), z: toEcliptic([0, 0, 1]) };
     const pole = orbit.frame === "laplace" && orbit.pole !== undefined ? orbit.pole : [BODIES[orbit.parent].pole.ra, BODIES[orbit.parent].pole.dec];
     const z = fromRaDec(pole[0], pole[1]);
     const x = fromRaDec(pole[0] + 90, 0);

package/dist/facts.d.ts

@@ -10,7 +10,18 @@
  */
 export declare const PLANET_IDS: readonly ["mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"];
 /**
- * The moons the package draws, by planet.
+ * The dwarf planets besides Pluto, nearest the Sun first (by the size of their orbits).
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * console.log(DWARF_IDS.join(", "));
+ * ```
+ */
+export declare const DWARF_IDS: readonly ["ceres", "orcus", "haumea", "quaoar", "makemake", "gonggong", "eris", "sedna"];
+/**
+ * The moons the package draws, by planet or dwarf planet.
  *
  * @example
  * ```ts
@@ -27,6 +38,9 @@ export declare const MOONS_OF: {
     readonly uranus: readonly ["miranda", "ariel", "umbriel", "titania", "oberon"];
     readonly neptune: readonly ["proteus", "triton", "nereid"];
     readonly pluto: readonly ["charon", "nix", "hydra"];
+    readonly orcus: readonly ["vanth"];
+    readonly haumea: readonly ["hiiaka", "namaka"];
+    readonly eris: readonly ["dysnomia"];
 };
 /**
  * The name of a planet or of Pluto: `mercury` to `pluto`.
@@ -40,6 +54,30 @@ export declare const MOONS_OF: {
  * ```
  */
 export type PlanetId = (typeof PLANET_IDS)[number];
+/**
+ * The name of a dwarf planet besides Pluto: `ceres`, `eris`, `haumea`...
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS, type DwarfId } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * const id: DwarfId = DWARF_IDS[0];
+ * console.log(id);
+ * ```
+ */
+export type DwarfId = (typeof DWARF_IDS)[number];
+/**
+ * A body a moon can go round: a planet, Pluto or another dwarf planet.
+ *
+ * @example
+ * ```ts
+ * import { MOONS_OF, type HostId } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * const host: HostId = "eris";
+ * console.log(MOONS_OF[host]);
+ * ```
+ */
+export type HostId = PlanetId | DwarfId;
 /**
  * The name of a moon the package draws, such as `moon`, `io` or `titan`.
  *
@@ -53,7 +91,7 @@ export type PlanetId = (typeof PLANET_IDS)[number];
  */
 export type MoonId = (typeof MOONS_OF)[keyof typeof MOONS_OF][number];
 /**
- * The name of a body: `sun`, a planet or a moon.
+ * The name of a body: `sun`, a planet, a dwarf planet or a moon.
  *
  * @example
  * ```ts
@@ -63,7 +101,7 @@ export type MoonId = (typeof MOONS_OF)[keyof typeof MOONS_OF][number];
  * console.log(lineSvg(id, { size: 64 }).length > 100);
  * ```
  */
-export type BodyId = "sun" | PlanetId | MoonId;
+export type BodyId = "sun" | PlanetId | DwarfId | MoonId;
 /**
  * How a body is drawn: `line` (an outline drawing), `realistic` (shaded, from the numbers) or `painted` (a real surface map).
  *
@@ -139,8 +177,8 @@ export type Feature = {
 export interface BodyFacts {
     id: BodyId;
     kind: "star" | "planet" | "dwarf-planet" | "moon";
-    /** The planet a moon goes round. */
-    parent?: PlanetId;
+    /** The planet or dwarf planet a moon goes round. */
+    parent?: HostId;
     name: {
         en: string;
         ja: string;
@@ -186,7 +224,7 @@ export interface BodyFacts {
  */
 export declare const BODIES: Readonly<Record<BodyId, BodyFacts>>;
 /**
- * Every body's name: the Sun, the planets outward, then the moons of each planet.
+ * Every body's name: the Sun, the planets outward, the dwarf planets, then the moons of each.
  *
  * @example
  * ```ts

package/dist/facts.js

@@ -12,7 +12,18 @@
  */
 export const PLANET_IDS = ["mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune", "pluto"];
 /**
- * The moons the package draws, by planet.
+ * The dwarf planets besides Pluto, nearest the Sun first (by the size of their orbits).
+ *
+ * @example
+ * ```ts
+ * import { DWARF_IDS } from "@johnmorrisdotca/wakusei-planets";
+ *
+ * console.log(DWARF_IDS.join(", "));
+ * ```
+ */
+export const DWARF_IDS = ["ceres", "orcus", "haumea", "quaoar", "makemake", "gonggong", "eris", "sedna"];
+/**
+ * The moons the package draws, by planet or dwarf planet.
  *
  * @example
  * ```ts
@@ -29,6 +40,9 @@ export const MOONS_OF = {
     uranus: ["miranda", "ariel", "umbriel", "titania", "oberon"],
     neptune: ["proteus", "triton", "nereid"],
     pluto: ["charon", "nix", "hydra"],
+    orcus: ["vanth"],
+    haumea: ["hiiaka", "namaka"],
+    eris: ["dysnomia"],
 };
 const f = (id, kind, en, ja, radiusKm, flattening, tiltDeg, ra, dec, w0, rate, rotationHours, colour, more = {}) => ({
     id,
@@ -131,6 +145,17 @@ export const BODIES = {
             ...dots([[-60, 20, 6], [-100, -20, 7], [60, 40, 5]]),
         ],
     }),
+    ceres: f("ceres", "dwarf-planet", "Ceres", "ケレス", 481.05, 0.0731, 4.04, 291.42744, 66.76033, 170.65, 952.1532, 9.07417, "#7b7873", {
+        showLon: 239,
+        features: [{ kind: "circle", lon: 239, lat: 20, radius: 6 }, { kind: "circle", lon: 239, lat: 20, radius: 1.5, fill: true }, { kind: "circle", lon: 10, lat: -42, radius: 10 }, ...dots([[-60, 30, 8], [100, 15, 9], [160, -20, 7], [-120, -35, 8], [40, 45, 6], [-20, 0, 5]])],
+    }),
+    orcus: f("orcus", "dwarf-planet", "Orcus", "オルクス", 455, 0, 73.83, 142.474, 15.004, 0, 655.15, 13.188, "#9a9a9c", { features: dots([[-60, 20, 9], [40, -15, 7], [130, 30, 8], [-130, -30, 6]]) }),
+    haumea: f("haumea", "dwarf-planet", "Haumea", "ハウメア", 798, 0, 90.15, 282.6, -13, 0, 2206.6, 3.915341, "#dfe0e3", { showLon: 90, axesKm: [1161, 852, 513], features: [{ kind: "oval", lon: 40, lat: 5, rx: 22, ry: 12, fill: true }, { kind: "band", lat: 0 }, ...dots([[-80, 25, 7]])] }),
+    quaoar: f("quaoar", "dwarf-planet", "Quaoar", "クワオアー", 557.8, 0, 0, 265.4, 74.409, 0, 488.72, 17.6788, "#a3735a", { showLon: 90, axesKm: [620.7, 546.5, 511.5], features: dots([[-40, 20, 8], [70, -15, 9], [150, 35, 7], [-110, -30, 6]]) }),
+    makemake: f("makemake", "dwarf-planet", "Makemake", "マケマケ", 715, 0.01, 0, 317.92, 50.03, 0, 378.5, 22.8266, "#b87f5d", { features: [{ kind: "oval", lon: 30, lat: 10, rx: 30, ry: 18, fill: true }, ...dots([[-70, -20, 8], [120, 25, 7]])] }),
+    gonggong: f("gonggong", "dwarf-planet", "Gonggong", "ゴンゴン", 615, 0, 0, 255.383, 36.831, 0, 385.7, 22.4, "#9c4f3b", { features: dots([[-50, 10, 9], [60, -25, 8], [140, 30, 7]]) }),
+    eris: f("eris", "dwarf-planet", "Eris", "エリス", 1163, 0, 78.22, 36.17, 44.51, 0, 22.805163, 378.8616, "#e8e4dc", { features: [{ kind: "band", lat: 0 }, ...dots([[-30, 30, 8], [80, -20, 9]])] }),
+    sedna: f("sedna", "dwarf-planet", "Sedna", "セドナ", 453, 0, 0, 297.062, 74.71, 0, 840.95, 10.273, "#9a3f2b", { features: dots([[-40, 20, 9], [70, -30, 8], [150, 10, 7]]) }),
     moon: f("moon", "moon", "Moon", "月", 1737.4, 0.0012, 6.68, 269.9949, 66.5392, 38.3213, 13.17635815, 655.728, "#b8b5ae", {
         parent: "earth",
         synchronous: true,
@@ -169,9 +194,13 @@ export const BODIES = {
     charon: f("charon", "moon", "Charon", "カロン", 606, 0, 0, 132.993, -6.163, 122.695, 56.3625225, 153.2935, "#9c9189", { parent: "pluto", synchronous: true, features: [{ kind: "oval", lon: 0, lat: 76, rx: 90, ry: 14, fill: true }, { kind: "circle", lon: 40, lat: -15, radius: 12 }, ...dots([[-60, 10, 8], [120, 30, 7]])] }),
     nix: f("nix", "moon", "Nix", "ニクス", 19.3, 0.3, 0, 132.993, -6.163, 0, 14.48, 0, "#b3ada7", { parent: "pluto", axesKm: [24.9, 16.6, 15.6], features: [{ kind: "circle", lon: 0, lat: 0, radius: 18 }] }),
     hydra: f("hydra", "moon", "Hydra", "ヒドラ", 19.5, 0.4, 0, 132.993, -6.163, 0, 9.42, 0, "#c4beb6", { parent: "pluto", axesKm: [32.5, 22.5, 12.5], features: [{ kind: "circle", lon: 30, lat: 10, radius: 20 }] }),
+    vanth: f("vanth", "moon", "Vanth", "ヴァント", 221, 0, 0, 142.474, 15.004, 0, 37.738618, 228.9488, "#6e6a66", { parent: "orcus", synchronous: true, features: dots([[-50, 15, 10], [80, -20, 9], [150, 30, 8]]) }),
+    hiiaka: f("hiiaka", "moon", "Hiʻiaka", "ヒイアカ", 185, 0, 0, 282.6, -13, 0, 0, 0, "#e0e0e0", { parent: "haumea", features: dots([[-30, 20, 12], [70, -25, 10]]) }),
+    namaka: f("namaka", "moon", "Namaka", "ナマカ", 75, 0, 0, 282.6, -13, 0, 0, 0, "#d0d0d0", { parent: "haumea", features: dots([[0, 0, 14]]) }),
+    dysnomia: f("dysnomia", "moon", "Dysnomia", "ディスノミア", 308, 0, 0, 36.17, 44.51, 0, 22.805163, 378.8616, "#5a5856", { parent: "eris", synchronous: true, features: dots([[-60, 20, 10], [50, -25, 9], [140, 30, 8]]) }),
 };
 /**
- * Every body's name: the Sun, the planets outward, then the moons of each planet.
+ * Every body's name: the Sun, the planets outward, the dwarf planets, then the moons of each.
  *
  * @example
  * ```ts
@@ -180,7 +209,7 @@ export const BODIES = {
  * console.log(BODY_IDS.length, BODY_IDS[0]);
  * ```
  */
-export const BODY_IDS = ["sun", ...PLANET_IDS, ...Object.values(MOONS_OF).flat()];
+export const BODY_IDS = ["sun", ...PLANET_IDS, ...DWARF_IDS, ...Object.values(MOONS_OF).flat()];
 /** A body's polar radius as a fraction of its equatorial radius. */
 export const polarRatio = (facts) => 1 - facts.flattening;
 /**

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-export { BODIES, BODY_IDS, MOONS_OF, PLANET_IDS, ringReach, type BodyFacts, type BodyId, type Feature, type Look, type MoonId, type PlanetId, type RingBand } from "./facts.ts";
+export { BODIES, BODY_IDS, DWARF_IDS, MOONS_OF, PLANET_IDS, ringReach, type BodyFacts, type BodyId, type DwarfId, type Feature, type HostId, type Look, type MoonId, type PlanetId, type RingBand } from "./facts.ts";
 export { apparent, moonGeocentric, heliocentric, orbitPath, system, type Apparent, type MoonPlace, type Pose, type System } from "./ephemeris.ts";
 export { drawnTilt, portrait, type PortraitOptions } from "./pose.ts";
 export { lineSvg, mix, type LineOptions } from "./line.ts";
 export { ringStrip, type RingStrip } from "./scene/rings.ts";
-export { embedCode, embedCredit, EMBED_KINDS, type EmbedKind, type EmbedOptions, type EmbedSettings } from "./embed.ts";
+export { embedCode, embedCredit, EMBED_KINDS, portraitCode, type EmbedKind, type EmbedOptions, type EmbedSettings, type PortraitEmbed } from "./embed.ts";
+export { addBody, decodeScene, defaultPortrait, encodeScene, PRESETS as PORTRAIT_PRESETS, resolve as layoutPortrait, type Item as PortraitItem, type Placed as PlacedItem, type Portrait, type Preset as PortraitPreset, type Resolved as PortraitLayout } from "./portrait/model.ts";

package/dist/index.js

@@ -1,6 +1,7 @@
-export { BODIES, BODY_IDS, MOONS_OF, PLANET_IDS, ringReach } from "./facts.js";
+export { BODIES, BODY_IDS, DWARF_IDS, MOONS_OF, PLANET_IDS, ringReach } from "./facts.js";
 export { apparent, moonGeocentric, heliocentric, orbitPath, system } from "./ephemeris.js";
 export { drawnTilt, portrait } from "./pose.js";
 export { lineSvg, mix } from "./line.js";
 export { ringStrip } from "./scene/rings.js";
-export { embedCode, embedCredit, EMBED_KINDS } from "./embed.js";
+export { embedCode, embedCredit, EMBED_KINDS, portraitCode } from "./embed.js";
+export { addBody, decodeScene, defaultPortrait, encodeScene, PRESETS as PORTRAIT_PRESETS, resolve as layoutPortrait } from "./portrait/model.js";

package/dist/line.js

@@ -54,12 +54,15 @@ function around(lon, lat, rx, ry, steps = 28) {
     }
     return out;
 }
+/** The semi-axes of a body that is far from round, as fractions of its radius. */
+const axesOf = (facts) => (facts.axesKm === undefined ? undefined : [facts.axesKm[0] / facts.radiusKm, facts.axesKm[1] / facts.radiusKm, facts.axesKm[2] / facts.radiusKm]);
 function featurePaths(facts, pose, frame, stroke, hair) {
     const f = facts.flattening;
-    const visible = (lon, lat) => facing(pose, lon, lat, f) > 0.02;
+    const axes = axesOf(facts);
+    const visible = (lon, lat) => facing(pose, lon, lat, f, axes) > 0.02;
     const out = [];
     const draw = (pts, close, fill) => {
-        const parts = runs(pts.map((p) => surfacePoint(pose, p.lon, p.lat, f)), (_, i) => visible(pts[i].lon, pts[i].lat));
+        const parts = runs(pts.map((p) => surfacePoint(pose, p.lon, p.lat, f, axes)), (_, i) => visible(pts[i].lon, pts[i].lat));
         for (const part of parts) {
             const whole = close && part.length === pts.length;
             if (part.length < 2)
@@ -176,7 +179,7 @@ function cachedOrbit(id, time) {
 }
 function bodyGroup(id, pose, frame, o, hair, ringScale) {
     const facts = BODIES[id];
-    const sil = silhouette(pose, facts.flattening);
+    const sil = silhouette(pose, facts.flattening, axesOf(facts));
     const disc = `<ellipse cx="${n(frame.cx)}" cy="${n(frame.cy)}" rx="${n(frame.r * sil.a)}" ry="${n(frame.r * sil.b)}" transform="rotate(${n(sil.angle)} ${n(frame.cx)} ${n(frame.cy)})"`;
     const rings = ringPaths(facts, pose, frame, o.stroke, hair, ringScale);
     const dark = id === "sun" || facts.kind === "star" ? "" : nightPath(pose, frame);
@@ -227,7 +230,7 @@ export function lineSvg(id, options = {}) {
     if (options.moons === true && facts.parent === undefined && id !== "sun")
         return systemSvg(id, options, size, stroke, paper, hair, head);
     const pose = poseFor(id, options);
-    const reach = Math.max(ringReach(facts), id === "sun" ? 1.08 : 1);
+    const reach = Math.max(ringReach(facts), id === "sun" ? 1.08 : 1, ...(axesOf(facts) ?? []));
     const fit = options.fill === undefined ? 0.94 / reach : options.fill;
     const zoom = options.zoom ?? 1;
     const frame = { cx: (size / 2) * (1 - (options.panX ?? 0)), cy: (size / 2) * (1 + (options.panY ?? 0)), r: (size / 2) * fit * zoom };

package/dist/portrait/element.d.ts

@@ -0,0 +1,77 @@
+import type { SharedRenderer } from "@johnmorrisdotca/kazoku-ui/renderer";
+import type { ThreeParts } from "../scene/body.ts";
+import { setThreeLoader } from "../scene/shared.ts";
+import { type Guide, type Placed, type Portrait, type Resolved } from "./model.ts";
+export { setThreeLoader };
+/**
+ * What the element is doing: `line` (an SVG), `loading`, `still`, `live`, `lost` or `unavailable` (no WebGL: the line drawing is shown).
+ *
+ * @example
+ * ```ts no-run
+ * import type { PortraitState } from "@johnmorrisdotca/wakusei-planets/portrait";
+ *
+ * const done = (state: PortraitState): boolean => state === "live" || state === "line";
+ * console.log(done("still"));
+ * ```
+ */
+export type PortraitState = "line" | "loading" | "still" | "live" | "lost" | "unavailable";
+/**
+ * The `<wakusei-portrait>` custom element: a scene of bodies arranged on one picture.
+ *
+ * Attributes: `scene` (the scene as the portrait builder writes it in its address), `look` (`line`, `realistic` or `painted`: replaces the scene's), `size` (pixels across), `lang` (`en` or `ja`: the names),
+ * `live` (`always`, `hover` or `off`: when it takes the page's one WebGL context), `texture-base` and `texture-far-base` (where the surface pictures are).
+ *
+ * @example
+ * ```ts no-run
+ * import { WakuseiPortrait } from "@johnmorrisdotca/wakusei-planets/portrait";
+ *
+ * const view = document.createElement("wakusei-portrait") as WakuseiPortrait;
+ * view.setAttribute("scene", "arrange:arc~look:painted~sun_0_0_0.3_0~earth_0_0_0.3_0~moon_0_0_0.3_0");
+ * document.body.append(view);
+ * ```
+ */
+export declare class WakuseiPortrait extends HTMLElement {
+    #private;
+    static observedAttributes: string[];
+    /** The scene now. Setting it hands the element a scene of your own, as the builder does; it is drawn at once and at most thirty times a second after. */
+    get portrait(): Portrait;
+    set portrait(value: Portrait);
+    /** The chosen body's index and the guides to draw over the picture (the builder's editing). */
+    set editing(value: {
+        selected?: number;
+        guides?: readonly Guide[];
+    });
+    get state(): PortraitState;
+    /** Numbers for a test or a status line. */
+    get stats(): {
+        state: PortraitState;
+        bodies: number;
+        renderer: SharedRenderer<ThreeParts>["stats"] | undefined;
+    };
+    /** Where everything is on the page now: the picture's size in pixels, pixels to a scene unit, and the bodies (back to front). */
+    get metrics(): {
+        width: number;
+        height: number;
+        scale: number;
+        camera: Resolved["camera"];
+        placed: readonly Placed[];
+    };
+    /** The body under a point of the page (client coordinates): its index in the list, or -1. `slop` is the smallest radius, in pixels, a body is hit within. */
+    pick(clientX: number, clientY: number, slop?: number): number;
+    /** A point of the page (client coordinates) in the scene's units. */
+    worldAt(clientX: number, clientY: number): {
+        x: number;
+        y: number;
+    };
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /** Take the page's one WebGL context and draw the scene on it. Resolves true when it is live; a line scene has nothing to take and resolves false. */
+    goLive(): Promise<boolean>;
+    /** Give the WebGL context back: the picture stays as a still. */
+    rest(): void;
+    /** The picture as a PNG: the background, the bodies and the names, at the size it is on the page times `scale` (the canvas of the bodies is at most the page's pixel ratio, 2). */
+    toPng(scale?: number): Promise<Blob>;
+    /** The picture as SVG. The line look is all vector. The shaded looks hold the bodies as a picture inside the SVG, with the background, the orbits and the names as vector. */
+    toSvg(): Promise<string>;
+}