@johnmorrisdotca/hoshi-stars 0.0.0-stage → 0.2.0

package/dist/deep-sky-core.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The kinds of deep-sky object, a small fixed list.
+ *
+ * @example
+ * ```ts
+ * import { DEEP_SKY_TYPES } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(DEEP_SKY_TYPES.length, DEEP_SKY_TYPES.includes("galaxy"));
+ * ```
+ */
+export declare const DEEP_SKY_TYPES: readonly ["other", "galaxy", "globular cluster", "open cluster", "nebula", "planetary nebula", "supernova remnant"];
+/**
+ * The kind of a deep-sky object: `galaxy`, `globular cluster`, `open cluster`, `nebula` (emission, reflection and dark nebulae and H II regions), `planetary nebula`, `supernova remnant`, or
+ * `other` (an asterism, a star cloud, a double star, a source that is not any of those).
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject, type DeepSkyType } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * const type: DeepSkyType = deepSkyObject("M1")!.type;
+ * console.log(type);
+ * ```
+ */
+export type DeepSkyType = (typeof DEEP_SKY_TYPES)[number];
+/**
+ * One deep-sky object. Positions are J2000 (equator and equinox of 2000), the same frame as `Star`.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject, type DeepSkyObject } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * const andromeda: DeepSkyObject = deepSkyObject("M31")!;
+ * console.log(andromeda.id, andromeda.ngc, andromeda.name, andromeda.magnitude);
+ * ```
+ */
+export interface DeepSkyObject {
+    /** The Messier designation (`M31`) if the object has one, else the NGC (`NGC 7000`), else the IC (`IC 434`). Unique, and a name `deepSkyObject` finds. */
+    id: string;
+    /** The Messier designation (`M31`), or `undefined`. */
+    messier: string | undefined;
+    /** The New General Catalogue designation (`NGC 224`), or `undefined`. Where an object has several (a duplicate entry, a component), the lowest plain number. */
+    ngc: string | undefined;
+    /** The Index Catalogue designation (`IC 434`), or `undefined`. */
+    ic: string | undefined;
+    /** The object's other NGC and IC designations (`NGC 978A`, `NGC 1051` for the object that is also `NGC 961`), each one found by `deepSkyObject` too. Usually empty. */
+    otherIds: string[];
+    /** The common name where Wikidata's English label is one (`Andromeda Galaxy`, `Crab Nebula`), else `undefined`. */
+    name: string | undefined;
+    /** The kind of object. */
+    type: DeepSkyType;
+    /** The IAU three-letter constellation abbreviation (`And`), or `undefined`. It is the same text as `Star.constellation`. */
+    constellation: string | undefined;
+    /** Right ascension in degrees at J2000, 0 up to 360. Given to 0.0001 degree (0.36 arc-second). */
+    rightAscension: number;
+    /** Declination in degrees at J2000, -90 to 90. Given to 0.0001 degree. */
+    declination: number;
+    /** Visual (V band) magnitude of the whole object, or `undefined` where there is none (for the Messier objects there always is one). Smaller is brighter: M31 is 3.4. */
+    magnitude: number | undefined;
+    /** The major axis in arc-minutes, or `undefined` where it is not known (most NGC and IC objects). */
+    sizeArcmin: number | undefined;
+}
+/**
+ * The catalogue names `deepSky` accepts for its `catalogue` option.
+ *
+ * @example
+ * ```ts
+ * import { DEEP_SKY_CATALOGUES, deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(DEEP_SKY_CATALOGUES.map((catalogue) => deepSky({ catalogue }).length));
+ * ```
+ */
+export declare const DEEP_SKY_CATALOGUES: readonly ["messier", "ngc", "ic"];
+/**
+ * The options of `deepSky`: all optional, and together they narrow the list.
+ *
+ * @example
+ * ```ts
+ * import { deepSky, type DeepSkyOptions } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * const options: DeepSkyOptions = { type: "globular cluster", magnitude: 6.5 };
+ * console.log(deepSky(options).map((o) => o.id));
+ * ```
+ */
+export interface DeepSkyOptions {
+    /** Only objects that have a number in that catalogue: `"messier"`, `"ngc"` or `"ic"`. */
+    catalogue?: (typeof DEEP_SKY_CATALOGUES)[number];
+    /** Only objects as bright as this magnitude (an object of exactly that magnitude is in). An object with no magnitude is never in. */
+    magnitude?: number;
+    /** Only objects of that kind. */
+    type?: DeepSkyType;
+}
+/**
+ * What a table of objects offers: the list, a filtered list and a lookup. Each entry point makes one from its data.
+ *
+ * @example
+ * ```ts
+ * import { deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(deepSky({ type: "planetary nebula" }).length);
+ * ```
+ */
+export interface DeepSkyTable {
+    /** All the objects in catalogue order, as a fresh array. */
+    all(): DeepSkyObject[];
+    /** The objects that meet the options, in catalogue order. */
+    select(options: DeepSkyOptions): DeepSkyObject[];
+    /** One object by any of its names, or `undefined`. */
+    find(text: string): DeepSkyObject | undefined;
+}
+/**
+ * Parse rows of the data into a table. A row is `Messier | NGC numbers | IC numbers | type | RA | Dec | magnitude | size | constellation | name | other names`, as `scripts/make-deep-sky-data.py` writes them.
+ *
+ * @param rowSets - One or more strings of rows, one object a line, in catalogue order.
+ * @returns The table.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyTable } from "../src/deep-sky-core.ts";
+ *
+ * console.log(deepSkyTable(["31|224||1|106847|412688|344||And|Andromeda Galaxy|"]).all()[0]?.id);
+ * ```
+ */
+export declare function deepSkyTable(rowSets: string[]): DeepSkyTable;

package/dist/deep-sky-core.js

@@ -0,0 +1,139 @@
+// The part the two deep-sky entry points share: what an object is, how a row of the data becomes one, and the lookups. Not an entry point itself.
+// Pure: no DOM, no clock, no state beyond the parsed table.
+/**
+ * The kinds of deep-sky object, a small fixed list.
+ *
+ * @example
+ * ```ts
+ * import { DEEP_SKY_TYPES } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(DEEP_SKY_TYPES.length, DEEP_SKY_TYPES.includes("galaxy"));
+ * ```
+ */
+export const DEEP_SKY_TYPES = ["other", "galaxy", "globular cluster", "open cluster", "nebula", "planetary nebula", "supernova remnant"];
+/**
+ * The catalogue names `deepSky` accepts for its `catalogue` option.
+ *
+ * @example
+ * ```ts
+ * import { DEEP_SKY_CATALOGUES, deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(DEEP_SKY_CATALOGUES.map((catalogue) => deepSky({ catalogue }).length));
+ * ```
+ */
+export const DEEP_SKY_CATALOGUES = ["messier", "ngc", "ic"];
+function fold(text) {
+    return text.normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+/** The lookup key of a text: `M 31`, `m31` and `Messier 31` all give `m31`; `ngc 0224` gives `ngc224`; any other text is its folded self. */
+function key(text) {
+    const folded = fold(text);
+    const designation = /^(m|messier|ngc|ic) ?0*(\d+) ?([a-z]?)$/.exec(folded);
+    return designation === null ? folded : `${designation[1] === "messier" ? "m" : designation[1]}${designation[2]}${designation[3]}`;
+}
+function designations(prefix, list) {
+    return list === "" ? [] : list.split(",").map((number) => `${prefix}${number}`);
+}
+const parsedRows = new Map();
+const aliasesOf = new WeakMap();
+/** The objects of a string of rows, parsed once however many tables use it (the large table's Messier objects are the small table's). */
+function parsed(rows) {
+    const found = parsedRows.get(rows);
+    if (found !== undefined)
+        return found;
+    const list = [];
+    for (const row of rows.split("\n")) {
+        const p = row.split("|");
+        const messier = p[0] === "" ? undefined : `M${p[0]}`;
+        const ngc = designations("NGC ", p[1]);
+        const ic = designations("IC ", p[2]);
+        const object = Object.freeze({
+            id: messier ?? ngc[0] ?? ic[0],
+            messier,
+            ngc: ngc[0],
+            ic: ic[0],
+            otherIds: Object.freeze([...ngc.slice(1), ...ic.slice(1)]),
+            name: p[9] === "" ? undefined : p[9],
+            type: DEEP_SKY_TYPES[Number(p[3])],
+            constellation: p[8] === "" ? undefined : p[8],
+            rightAscension: Number(p[4]) / 10000,
+            declination: Number(p[5]) / 10000,
+            magnitude: p[6] === "" ? undefined : Number(p[6]) / 100,
+            sizeArcmin: p[7] === "" ? undefined : Number(p[7]) / 10,
+        });
+        if (p[10] !== "")
+            aliasesOf.set(object, p[10].split(";"));
+        list.push(object);
+    }
+    parsedRows.set(rows, list);
+    return list;
+}
+/**
+ * Parse rows of the data into a table. A row is `Messier | NGC numbers | IC numbers | type | RA | Dec | magnitude | size | constellation | name | other names`, as `scripts/make-deep-sky-data.py` writes them.
+ *
+ * @param rowSets - One or more strings of rows, one object a line, in catalogue order.
+ * @returns The table.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyTable } from "../src/deep-sky-core.ts";
+ *
+ * console.log(deepSkyTable(["31|224||1|106847|412688|344||And|Andromeda Galaxy|"]).all()[0]?.id);
+ * ```
+ */
+export function deepSkyTable(rowSets) {
+    const stored = [];
+    const byKey = new Map();
+    const ambiguous = new Set();
+    let loaded = false;
+    function add(text, object) {
+        if (text === undefined || text === "")
+            return;
+        const k = key(text);
+        const other = byKey.get(k);
+        if (other !== undefined && other !== object) {
+            // A Messier object keeps a name that a fainter object also carries (Wikidata calls a part of Barnard's Galaxy "Ring Nebula" too).
+            if (other.messier !== undefined && object.messier === undefined)
+                return;
+            ambiguous.add(k);
+        }
+        byKey.set(k, object);
+    }
+    function load() {
+        if (loaded)
+            return;
+        loaded = true;
+        for (const rows of rowSets) {
+            for (const object of parsed(rows)) {
+                stored.push(object);
+                for (const text of [object.messier, object.ngc, object.ic, ...object.otherIds, object.name, ...(aliasesOf.get(object) ?? [])])
+                    add(text, object);
+            }
+        }
+        for (const k of ambiguous)
+            byKey.delete(k);
+    }
+    return {
+        all: () => {
+            load();
+            return [...stored];
+        },
+        select: (options) => {
+            load();
+            const { catalogue, magnitude, type } = options;
+            if (catalogue !== undefined && !DEEP_SKY_CATALOGUES.includes(catalogue))
+                throw new RangeError(`catalogue must be "messier", "ngc" or "ic", got ${JSON.stringify(catalogue)}`);
+            if (magnitude !== undefined && (typeof magnitude !== "number" || Number.isNaN(magnitude)))
+                throw new TypeError(`magnitude must be a number, got ${String(magnitude)}`);
+            if (type !== undefined && !DEEP_SKY_TYPES.includes(type))
+                throw new RangeError(`type must be one of ${DEEP_SKY_TYPES.join(", ")}, got ${JSON.stringify(type)}`);
+            return stored.filter((o) => (catalogue === undefined || o[catalogue] !== undefined) && (type === undefined || o.type === type) && (magnitude === undefined || (o.magnitude !== undefined && o.magnitude <= magnitude)));
+        },
+        find: (text) => {
+            if (typeof text !== "string")
+                throw new TypeError(`text must be a string, got ${typeof text}`);
+            load();
+            return byKey.get(key(text));
+        },
+    };
+}

package/dist/deep-sky-ngc-ic.d.ts

@@ -0,0 +1,34 @@
+import { type DeepSkyObject, type DeepSkyOptions } from "./deep-sky-core.ts";
+export { DEEP_SKY_CATALOGUES, DEEP_SKY_TYPES, type DeepSkyObject, type DeepSkyOptions, type DeepSkyType } from "./deep-sky-core.ts";
+/**
+ * The Messier, NGC and IC objects that meet the options: the Messier objects first in Messier order, then the others by NGC number and then IC number. The NGC and IC objects are those Wikidata gives a
+ * position (11,788 besides the 110 Messier objects, about nine in ten of the two catalogues), and their magnitudes and types are Wikidata's as well. Magnitude is missing for about four in ten.
+ *
+ * @param options - `catalogue`: only objects with a number in `"messier"`, `"ngc"` or `"ic"`. `magnitude`: only objects as bright as that (an object with no magnitude is never in). `type`: only that kind.
+ * @returns A fresh array of the shared, frozen objects.
+ * @throws RangeError if `catalogue` or `type` is not one of the listed values. TypeError if `magnitude` is not a number.
+ *
+ * @example
+ * ```ts
+ * import { deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic";
+ *
+ * console.log(deepSky({ catalogue: "ngc", type: "planetary nebula", magnitude: 10 }).length);
+ * ```
+ */
+export declare function deepSky(options?: DeepSkyOptions): DeepSkyObject[];
+/**
+ * An object by any of its names, ignoring case, spacing and the accent on a letter: `M31`, `Messier 31`, `NGC 224`, `IC 434`, an object's other NGC or IC number (`NGC 1051` for `NGC 961`) or its common
+ * name in English (`North America Nebula`). A name that two objects share finds neither, except that a Messier object keeps its name.
+ *
+ * @param text - The designation or name.
+ * @returns The object, or `undefined` if the text names none.
+ * @throws TypeError if `text` is not a string.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject } from "@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic";
+ *
+ * console.log(deepSkyObject("IC 434")?.type, deepSkyObject("NGC 7000")?.name, deepSkyObject("Andromeda Galaxy")?.id);
+ * ```
+ */
+export declare function deepSkyObject(text: string): DeepSkyObject | undefined;

package/dist/deep-sky-ngc-ic.js

@@ -0,0 +1,43 @@
+// The Messier, NGC and IC objects that Wikidata gives a position: 11,898 in all. The large deep-sky tier (`@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic`): the table is about 150 kB gzipped, so it is its own
+// import and the Messier-only `@johnmorrisdotca/hoshi-stars/deep-sky` stays small. Pure: no DOM, no clock, no state beyond the parsed table.
+import { MESSIER_ROWS } from "./data/messier.js";
+import { NGC_IC_ROWS } from "./data/ngc-ic.js";
+import { deepSkyTable } from "./deep-sky-core.js";
+export { DEEP_SKY_CATALOGUES, DEEP_SKY_TYPES } from "./deep-sky-core.js";
+const table = deepSkyTable([MESSIER_ROWS, NGC_IC_ROWS]);
+/**
+ * The Messier, NGC and IC objects that meet the options: the Messier objects first in Messier order, then the others by NGC number and then IC number. The NGC and IC objects are those Wikidata gives a
+ * position (11,788 besides the 110 Messier objects, about nine in ten of the two catalogues), and their magnitudes and types are Wikidata's as well. Magnitude is missing for about four in ten.
+ *
+ * @param options - `catalogue`: only objects with a number in `"messier"`, `"ngc"` or `"ic"`. `magnitude`: only objects as bright as that (an object with no magnitude is never in). `type`: only that kind.
+ * @returns A fresh array of the shared, frozen objects.
+ * @throws RangeError if `catalogue` or `type` is not one of the listed values. TypeError if `magnitude` is not a number.
+ *
+ * @example
+ * ```ts
+ * import { deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic";
+ *
+ * console.log(deepSky({ catalogue: "ngc", type: "planetary nebula", magnitude: 10 }).length);
+ * ```
+ */
+export function deepSky(options = {}) {
+    return table.select(options);
+}
+/**
+ * An object by any of its names, ignoring case, spacing and the accent on a letter: `M31`, `Messier 31`, `NGC 224`, `IC 434`, an object's other NGC or IC number (`NGC 1051` for `NGC 961`) or its common
+ * name in English (`North America Nebula`). A name that two objects share finds neither, except that a Messier object keeps its name.
+ *
+ * @param text - The designation or name.
+ * @returns The object, or `undefined` if the text names none.
+ * @throws TypeError if `text` is not a string.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject } from "@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic";
+ *
+ * console.log(deepSkyObject("IC 434")?.type, deepSkyObject("NGC 7000")?.name, deepSkyObject("Andromeda Galaxy")?.id);
+ * ```
+ */
+export function deepSkyObject(text) {
+    return table.find(text);
+}

package/dist/deep-sky.d.ts

@@ -0,0 +1,49 @@
+import { type DeepSkyObject, type DeepSkyOptions } from "./deep-sky-core.ts";
+export { DEEP_SKY_CATALOGUES, DEEP_SKY_TYPES, type DeepSkyObject, type DeepSkyOptions, type DeepSkyType } from "./deep-sky-core.ts";
+/**
+ * The 110 Messier objects, M1 first and M110 last. M102 is the one the literature disagrees about: Messier's own description matches M101 (a repeat of it), and the modern lists take it for the
+ * lenticular galaxy NGC 5866, which is what this table does (a note on M102 is in `NOTICE.md`). M40 (Winnecke 4, a double star) and M73 (four stars) are in the list as `other`, since Messier
+ * listed them.
+ *
+ * @returns A fresh array of the shared, frozen objects.
+ *
+ * @example
+ * ```ts
+ * import { messier } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(messier().length, messier()[30]?.name);
+ * ```
+ */
+export declare function messier(): DeepSkyObject[];
+/**
+ * The Messier objects that meet the options, in Messier order. For the NGC and IC objects too, use `deepSky` from `@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic`.
+ *
+ * @param options - `catalogue`: only objects with a number in `"messier"`, `"ngc"` or `"ic"` (here 110, 106 and 3: M24 and M25 have only an IC number, and M40 and M45 have none). `magnitude`: only objects as
+ * bright as that. `type`: only that kind (`"galaxy"`, `"globular cluster"`, `"open cluster"`, `"nebula"`, `"planetary nebula"`, `"supernova remnant"` or `"other"`).
+ * @returns A fresh array of the shared, frozen objects.
+ * @throws RangeError if `catalogue` or `type` is not one of those. TypeError if `magnitude` is not a number.
+ *
+ * @example
+ * ```ts
+ * import { deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(deepSky({ type: "globular cluster", magnitude: 6.5 }).map((o) => o.id));
+ * ```
+ */
+export declare function deepSky(options?: DeepSkyOptions): DeepSkyObject[];
+/**
+ * A Messier object by any of its names, ignoring case, spacing and the accent on a letter: the Messier designation (`M31`, `m 31`, `Messier 31`), its NGC or IC designation (`NGC 224`, `ngc224`) or its
+ * common name in English (`Andromeda Galaxy`, `Andromeda Nebula`). A name that two objects share finds neither, except that a Messier object keeps its name.
+ *
+ * @param text - The designation or name.
+ * @returns The object, or `undefined` if the text names none of the Messier objects.
+ * @throws TypeError if `text` is not a string.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(deepSkyObject("M31")?.ngc, deepSkyObject("Crab Nebula")?.id, deepSkyObject("NGC 1976")?.name);
+ * ```
+ */
+export declare function deepSkyObject(text: string): DeepSkyObject | undefined;

package/dist/deep-sky.js

@@ -0,0 +1,59 @@
+// The 110 Messier objects, and the lookups for them. The deep-sky tier (`@johnmorrisdotca/hoshi-stars/deep-sky`): a table of about 3 kB gzipped. The NGC and IC objects, about 150 kB more, are the
+// separate `@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic`, so a page that wants the Messier objects pays for them only. Pure: no DOM, no clock, no state beyond the parsed table.
+import { MESSIER_ROWS } from "./data/messier.js";
+import { deepSkyTable } from "./deep-sky-core.js";
+export { DEEP_SKY_CATALOGUES, DEEP_SKY_TYPES } from "./deep-sky-core.js";
+const table = deepSkyTable([MESSIER_ROWS]);
+/**
+ * The 110 Messier objects, M1 first and M110 last. M102 is the one the literature disagrees about: Messier's own description matches M101 (a repeat of it), and the modern lists take it for the
+ * lenticular galaxy NGC 5866, which is what this table does (a note on M102 is in `NOTICE.md`). M40 (Winnecke 4, a double star) and M73 (four stars) are in the list as `other`, since Messier
+ * listed them.
+ *
+ * @returns A fresh array of the shared, frozen objects.
+ *
+ * @example
+ * ```ts
+ * import { messier } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(messier().length, messier()[30]?.name);
+ * ```
+ */
+export function messier() {
+    return table.all();
+}
+/**
+ * The Messier objects that meet the options, in Messier order. For the NGC and IC objects too, use `deepSky` from `@johnmorrisdotca/hoshi-stars/deep-sky/ngc-ic`.
+ *
+ * @param options - `catalogue`: only objects with a number in `"messier"`, `"ngc"` or `"ic"` (here 110, 106 and 3: M24 and M25 have only an IC number, and M40 and M45 have none). `magnitude`: only objects as
+ * bright as that. `type`: only that kind (`"galaxy"`, `"globular cluster"`, `"open cluster"`, `"nebula"`, `"planetary nebula"`, `"supernova remnant"` or `"other"`).
+ * @returns A fresh array of the shared, frozen objects.
+ * @throws RangeError if `catalogue` or `type` is not one of those. TypeError if `magnitude` is not a number.
+ *
+ * @example
+ * ```ts
+ * import { deepSky } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(deepSky({ type: "globular cluster", magnitude: 6.5 }).map((o) => o.id));
+ * ```
+ */
+export function deepSky(options = {}) {
+    return table.select(options);
+}
+/**
+ * A Messier object by any of its names, ignoring case, spacing and the accent on a letter: the Messier designation (`M31`, `m 31`, `Messier 31`), its NGC or IC designation (`NGC 224`, `ngc224`) or its
+ * common name in English (`Andromeda Galaxy`, `Andromeda Nebula`). A name that two objects share finds neither, except that a Messier object keeps its name.
+ *
+ * @param text - The designation or name.
+ * @returns The object, or `undefined` if the text names none of the Messier objects.
+ * @throws TypeError if `text` is not a string.
+ *
+ * @example
+ * ```ts
+ * import { deepSkyObject } from "@johnmorrisdotca/hoshi-stars/deep-sky";
+ *
+ * console.log(deepSkyObject("M31")?.ngc, deepSkyObject("Crab Nebula")?.id, deepSkyObject("NGC 1976")?.name);
+ * ```
+ */
+export function deepSkyObject(text) {
+    return table.find(text);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { blackBodyColour, starByHr, starByName, starColour, starDistanceLightYears, starPosition, starTemperatureK, stars, type Star } from "./stars.ts";
+export type { When } from "./when.ts";

package/dist/index.js

@@ -0,0 +1,2 @@
+// The entry point: the bright stars. Constellations, deep-sky objects and charts will be their own entry points, so a page pays only for what it imports.
+export { blackBodyColour, starByHr, starByName, starColour, starDistanceLightYears, starPosition, starTemperatureK, stars } from "./stars.js";

package/dist/lines.d.ts

@@ -0,0 +1,49 @@
+import { type Constellation } from "./constellations.ts";
+import { type Star } from "./stars.ts";
+/**
+ * The stick figure of one constellation.
+ *
+ * @example
+ * ```ts
+ * import { figureOf, type Figure } from "@johnmorrisdotca/hoshi-stars/lines";
+ *
+ * const orion: Figure = figureOf("Ori");
+ * console.log(orion.constellation.name, orion.stars.length, orion.segments.length);
+ * ```
+ */
+export interface Figure {
+    /** The constellation the figure is drawn in. */
+    constellation: Constellation;
+    /** The stars the figure uses, each once, in the order the figure first reaches them. */
+    stars: Star[];
+    /** The lines to draw, each a pair of stars of the constellation, no pair twice. Empty where the figure is one star. */
+    segments: Array<[Star, Star]>;
+}
+/**
+ * The stick figures of all 88 constellations, in the order of `constellations()` (alphabetical by Latin name).
+ *
+ * @returns A fresh array of the shared, frozen figures.
+ *
+ * @example
+ * ```ts
+ * import { figures } from "@johnmorrisdotca/hoshi-stars/lines";
+ *
+ * console.log(figures().length, figures().reduce((sum, f) => sum + f.segments.length, 0));
+ * ```
+ */
+export declare function figures(): Figure[];
+/**
+ * The stick figure of one constellation: the bright stars to join, as pairs. Every star of a pair lies inside the constellation, so a chart can draw one figure without crossing into another.
+ *
+ * @param text - The constellation, as the IAU abbreviation (`Ori`) or any other name `constellation` accepts.
+ * @returns The shared, frozen figure.
+ * @throws TypeError if `text` is not a string. RangeError if it is not one of the 88 constellations.
+ *
+ * @example
+ * ```ts
+ * import { figureOf } from "@johnmorrisdotca/hoshi-stars/lines";
+ *
+ * for (const [a, b] of figureOf("Great Bear").segments) console.log(a.name ?? a.designation, "to", b.name ?? b.designation);
+ * ```
+ */
+export declare function figureOf(text: string): Figure;

package/dist/lines.js

@@ -0,0 +1,64 @@
+// The stick figures of the 88 constellations, as pairs of bright stars to join with a line.
+// The lines tier (`@johnmorrisdotca/hoshi-stars/lines`): about 2 kB of data gzipped, on top of the constellations table and the bright-star table it points into. Pure: no DOM, no state beyond the parsed table.
+// The figures are our own, decided from the stars' positions and brightness; none is copied from a book, an atlas or another program's files.
+import { LINE_ROWS } from "./data/lines.js";
+import { constellation, constellations } from "./constellations.js";
+import { starByHr } from "./stars.js";
+const stored = new Map();
+function load() {
+    if (stored.size > 0)
+        return;
+    const byAbbreviation = new Map(constellations().map((c) => [c.abbreviation, c]));
+    for (const row of LINE_ROWS.split("\n")) {
+        const [abbreviation, chains] = row.split("|");
+        const used = new Map();
+        const segments = [];
+        for (const chain of chains.split(";")) {
+            const members = chain.split("-").map((hr) => {
+                const star = starByHr(Number(hr));
+                used.set(star.hr, star);
+                return star;
+            });
+            for (let i = 1; i < members.length; i++)
+                segments.push(Object.freeze([members[i - 1], members[i]]));
+        }
+        stored.set(abbreviation, Object.freeze({ constellation: byAbbreviation.get(abbreviation), stars: Object.freeze([...used.values()]), segments: Object.freeze(segments) }));
+    }
+}
+/**
+ * The stick figures of all 88 constellations, in the order of `constellations()` (alphabetical by Latin name).
+ *
+ * @returns A fresh array of the shared, frozen figures.
+ *
+ * @example
+ * ```ts
+ * import { figures } from "@johnmorrisdotca/hoshi-stars/lines";
+ *
+ * console.log(figures().length, figures().reduce((sum, f) => sum + f.segments.length, 0));
+ * ```
+ */
+export function figures() {
+    load();
+    return constellations().map((c) => stored.get(c.abbreviation));
+}
+/**
+ * The stick figure of one constellation: the bright stars to join, as pairs. Every star of a pair lies inside the constellation, so a chart can draw one figure without crossing into another.
+ *
+ * @param text - The constellation, as the IAU abbreviation (`Ori`) or any other name `constellation` accepts.
+ * @returns The shared, frozen figure.
+ * @throws TypeError if `text` is not a string. RangeError if it is not one of the 88 constellations.
+ *
+ * @example
+ * ```ts
+ * import { figureOf } from "@johnmorrisdotca/hoshi-stars/lines";
+ *
+ * for (const [a, b] of figureOf("Great Bear").segments) console.log(a.name ?? a.designation, "to", b.name ?? b.designation);
+ * ```
+ */
+export function figureOf(text) {
+    const found = constellation(text);
+    if (found === undefined)
+        throw new RangeError(`"${text}" is not one of the 88 constellations (use the IAU abbreviation such as "Ori")`);
+    load();
+    return stored.get(found.abbreviation);
+}