@elite-dangerous-almanac/core 0.1.0-beta.1

package/dist/astro/codex-region.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The 42 **galactic codex regions** of Elite Dangerous, as structured per-region
+ * objects.
+ *
+ * Every star system in the galaxy belongs to exactly one of 42 named regions (plus
+ * an implicit "outside the map"). This module exposes each region as a
+ * {@link CodexRegion} object carrying its id, name and pre-computed footprint —
+ * area, axis-aligned bounds and centroid on the galactic plane — so consumers can
+ * read per-region facts without touching the (much larger) lookup geometry.
+ * Resolving a *coordinate or `id64`* to a region lives in `./codex-region-lookup`,
+ * which loads the separate cell grid.
+ *
+ * The region ids and names come from klightspeed's EliteDangerousRegionMap; the
+ * footprint fields are derived from its grayscale region map. See the attribution
+ * in [`data/astro/galactic-regions.jsonc`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/astro/galactic-regions.jsonc).
+ *
+ * @remarks
+ * Region ids are 1–42; id `0` means "outside the mapped region grid" and has no
+ * {@link CodexRegion} object.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A 2-D point on the galactic plane (X east/west, Z toward/away from the core),
+ * in light-years.
+ *
+ * @example
+ * ```ts
+ * import type { GalacticPlanePosition } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * const point: GalacticPlanePosition = { x: 0, z: 0 };
+ * ```
+ */
+interface GalacticPlanePosition {
+    /** Galactic X coordinate, in light-years. */
+    readonly x: number;
+    /** Galactic Z coordinate, in light-years. */
+    readonly z: number;
+}
+/**
+ * Axis-aligned bounds of a region on the galactic plane, in light-years.
+ *
+ * @remarks
+ * The region map is two-dimensional (X/Z only); the vertical Y axis is not encoded,
+ * so regions have no Y extent here.
+ *
+ * @example
+ * ```ts
+ * import type { CodexRegionBounds } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * const bounds: CodexRegionBounds = {
+ *   minX: -100, maxX: 100, minZ: -200, maxZ: 200,
+ * };
+ * ```
+ */
+interface CodexRegionBounds {
+    /** Minimum galactic X, in light-years. */
+    readonly minX: number;
+    /** Maximum galactic X, in light-years. */
+    readonly maxX: number;
+    /** Minimum galactic Z, in light-years. */
+    readonly minZ: number;
+    /** Maximum galactic Z, in light-years. */
+    readonly maxZ: number;
+}
+/**
+ * A single Elite Dangerous galactic codex region.
+ *
+ * @remarks
+ * Footprint fields ({@link CodexRegion.areaLy2}, {@link CodexRegion.bounds},
+ * {@link CodexRegion.centroid}) are approximations derived from the ≈49.35 ly
+ * region grid, not survey-precise figures.
+ *
+ * @example
+ * ```ts
+ * import { getCodexRegionByName } from '@elite-dangerous-almanac/core/astro/codex-region';
+ * import type { CodexRegion } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * const innerOrionSpur: CodexRegion | null = getCodexRegionByName('Inner Orion Spur');
+ * ```
+ */
+interface CodexRegion {
+    /** Region id, 1–42. Stable across releases; matches the codex region ordering. */
+    readonly id: number;
+    /** Human-readable region name, e.g. `"Inner Orion Spur"`. */
+    readonly name: string;
+    /**
+     * Grayscale value this region has in the upstream `RegionMap.png`
+     * (`0xA8` for region 1, decreasing by 4 per id). Useful when cross-referencing
+     * the source image.
+     */
+    readonly grayscale: number;
+    /** Number of grid cells the region occupies (each cell ≈49.35 ly square). */
+    readonly cellCount: number;
+    /** Approximate footprint area on the galactic plane, in square light-years. */
+    readonly areaLy2: number;
+    /** Axis-aligned bounds on the galactic plane, in light-years. */
+    readonly bounds: CodexRegionBounds;
+    /** Cell-weighted centroid on the galactic plane, in light-years. */
+    readonly centroid: GalacticPlanePosition;
+}
+/**
+ * All 42 galactic regions, ordered by id (index `i` holds region id `i + 1`).
+ *
+ * @remarks
+ * This loads only `galactic-regions.jsonc` (region metadata); the lookup cell grid
+ * lives in a separate module, so importing this never bundles it.
+ *
+ * @example
+ * ```ts
+ * import { CODEX_REGIONS } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * CODEX_REGIONS.length; // -> 42
+ * CODEX_REGIONS[0]?.name; // -> 'Galactic Centre'
+ * ```
+ */
+declare const CODEX_REGIONS: readonly CodexRegion[];
+/**
+ * Look up a region by its id.
+ *
+ * @param id - Region id, 1–42.
+ * @returns The {@link CodexRegion}, or `null` if `id` is `0` (outside the map)
+ * or otherwise unknown.
+ * @example
+ * ```ts
+ * import { getCodexRegion } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * getCodexRegion(18)?.name; // -> 'Inner Orion Spur'
+ * ```
+ */
+declare function getCodexRegion(id: number): CodexRegion | null;
+/**
+ * Look up a region by name (case-insensitive).
+ *
+ * @param name - The region name, e.g. `"Inner Orion Spur"`. Matching ignores case
+ * and surrounding whitespace.
+ * @returns The {@link CodexRegion}, or `null` if no region has that name.
+ * @throws {TypeError} If `name` is present and not a string. A nullish
+ * `name` is a miss, answered the way an unrecognised one is.
+ * @example
+ * ```ts
+ * import { getCodexRegionByName } from '@elite-dangerous-almanac/core/astro/codex-region';
+ *
+ * getCodexRegionByName('the void')?.id; // -> 42
+ * ```
+ */
+declare function getCodexRegionByName(name: string): CodexRegion | null;
+
+export { CODEX_REGIONS, type CodexRegion, type CodexRegionBounds, type GalacticPlanePosition, getCodexRegion, getCodexRegionByName };

package/dist/astro/codex-region.js

@@ -0,0 +1 @@
+export{CODEX_REGIONS,getCodexRegion,getCodexRegionByName}from"../chunk-NWPK6Q3S.js";                                                                                       //# sourceMappingURL=codex-region.js.map

package/dist/astro/codex-region.js.map

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

package/dist/astro/galaxy-grid.d.ts

@@ -0,0 +1,83 @@
+import { G as GalacticPosition } from '../galactic-position-shLkm4Qg.js';
+import { SectorGridPosition } from './sector-name.js';
+
+/**
+ * Turning a **galactic position** into a place on the procedural naming grid.
+ *
+ * `./sector-name` maps a *sector index* to a name, and `./system-address` works in
+ * *internal units* (32 per light-year, measured from the galaxy's corner). Neither
+ * speaks the units a consumer actually holds: light-years with Sol at the origin,
+ * as reported by the player journal, EDSM and Spansh. This module is the bridge —
+ * it converts {@link GalacticPosition} to the {@link SectorGridPosition} those functions
+ * want, so `sectorNameFromGridPosition` can be driven from real data.
+ *
+ * The three coordinate conventions on the public surface, in one place:
+ *
+ * | Convention | Unit | Origin | Where |
+ * | --- | --- | --- | --- |
+ * | {@link GalacticPosition} | light-years | Sol | journal, EDSM, Spansh, this module's input |
+ * | {@link SectorGridPosition} | 1280 ly sector cubes (0–127) | galaxy corner | `sectorNameFromGridPosition` |
+ * | internal units | 1/32 light-year | galaxy corner | `NamingRegionOrigin`, boxel maths |
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * The galaxy's origin corner in galactic light-years — the point sector index
+ * `0/0/0` starts at.
+ *
+ * @remarks
+ * Sector and boxel positions are measured from this corner, which is why an
+ * `id64`'s grid position has to be offset by it to become a position relative to
+ * Sol. The same triple is published as `CODEX_REGION_MAP_X0` / `_Y0` / `_Z0` by
+ * `./codex-region-lookup` (where it arrives with the region-cell data); it is
+ * repeated here as a plain constant so converting a coordinate never pulls in the
+ * region grid. A test asserts the two agree.
+ */
+declare const GALAXY_ORIGIN: Readonly<GalacticPosition>;
+/** Edge length of one procedural sector cube, in light-years. */
+declare const SECTOR_EDGE_LY = 1280;
+/**
+ * The sector cube a galactic position falls in.
+ *
+ * @param position - Galactic position in **light-years, Sol at the origin** (a journal
+ * `StarPos`, an EDSM/Spansh coordinate, a `ProceduralSystem.position`).
+ * @returns The integer {@link SectorGridPosition} of the 1280 ly sector cube containing
+ * that point, ready for {@link sectorNameFromGridPosition}.
+ * @throws {RangeError} If the position lies outside the 128×128×128 sector grid
+ * (i.e. outside the addressable galaxy). The message names the offending position.
+ * @example
+ * ```ts
+ * import { sectorGridPositionFromGalacticPosition } from '@elite-dangerous-almanac/core/astro/galaxy-grid';
+ *
+ * // Synuefe EN-H d11-96 sits at (751, -179, -91) per EDSM
+ * sectorGridPositionFromGalacticPosition({ x: 751, y: -179, z: -91 });
+ * // -> { sectorX: 39, sectorY: 31, sectorZ: 18 }
+ * ```
+ */
+declare function sectorGridPositionFromGalacticPosition(position: GalacticPosition): SectorGridPosition;
+/**
+ * The procedural sector name for a galactic position.
+ *
+ * The one-call form of {@link sectorGridPositionFromGalacticPosition} followed by
+ * {@link sectorNameFromGridPosition} — "which sector is this point in?".
+ *
+ * @param position - Galactic position in **light-years, Sol at the origin**.
+ * @returns The canonically-cased procedural sector name (e.g. `Synuefe`,
+ * `Blae Eock`).
+ * @throws {RangeError} If the position lies outside the sector grid, or the grid
+ * slot has no procedurally assigned name.
+ * @remarks
+ * This is always the *procedural* sector. A system inside a hand-authored region
+ * (Pleiades, Coalsack, …) is named after that region instead — resolve those with
+ * {@link findHandAuthoredRegionAt} from `./hand-authored-regions`.
+ * @example
+ * ```ts
+ * import { sectorNameFromGalacticPosition } from '@elite-dangerous-almanac/core/astro/galaxy-grid';
+ *
+ * sectorNameFromGalacticPosition({ x: 751, y: -179, z: -91 }); // -> 'Synuefe'
+ * ```
+ */
+declare function sectorNameFromGalacticPosition(position: GalacticPosition): string;
+
+export { GALAXY_ORIGIN, SECTOR_EDGE_LY, sectorGridPositionFromGalacticPosition, sectorNameFromGalacticPosition };

package/dist/astro/galaxy-grid.js

@@ -0,0 +1 @@
+export{GALAXY_ORIGIN,SECTOR_EDGE_LY,sectorGridPositionFromGalacticPosition,sectorNameFromGalacticPosition}from"../chunk-U6TMCYA6.js";                                                                                       //# sourceMappingURL=galaxy-grid.js.map

package/dist/astro/galaxy-grid.js.map

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

package/dist/astro/hand-authored-regions.d.ts

@@ -0,0 +1,121 @@
+import { G as GalacticPosition } from '../galactic-position-shLkm4Qg.js';
+
+/**
+ * Hand-authored named sectors, resolved by galactic position.
+ *
+ * The procedural generator only produces the boxel name for a position. Systems
+ * that physically fall inside a hand-authored nebula or cluster region (Pleiades,
+ * Coalsack, the NGC/IC/Col catalogues, …) are instead displayed by the game under
+ * that region's name. Each region is one or more spheres in galactic light-years
+ * (Sol at the origin); membership is first-match sphere containment.
+ *
+ * Sphere records are compiled and cross-checked against EDSM and Spansh; see
+ * [`data/astro/SOURCES.md`](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/data/astro/SOURCES.md) for provenance and source terms.
+ *
+ * The list is pre-sorted **smallest-radius-first**, which reproduces the game's
+ * overlap priority: when spheres overlap, the most specific (smallest) region
+ * wins. Data is loaded once from shared JSON ([`data/astro/`](https://github.com/DarkSession/Elite-Dangerous-Almanac/tree/main/data/astro)).
+ *
+ * @remarks
+ * "Region" is overloaded in this galaxy. A {@link HandAuthoredRegion} is a *hand-authored
+ * named sector* (Pleiades, Coalsack, …) — not to be confused with a **procedural
+ * sector** (`./sector-name`) or a **galactic codex region** (`./codex-region`,
+ * the 42 codex zones). Use {@link findHandAuthoredRegionAt} here for the first, and
+ * `findCodexRegionAt` from `./codex-region-lookup` for the third.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * One sphere of a hand-authored region (centre and radius in light-years).
+ *
+ * @example
+ * ```ts
+ * import type { HandAuthoredSphere } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ *
+ * const sphere: HandAuthoredSphere = { cx: -80.6, cy: -146.7, cz: -343.3, r: 100 };
+ * ```
+ */
+interface HandAuthoredSphere {
+    /** Sphere centre X in light-years (Sol at origin). */
+    readonly cx: number;
+    /** Sphere centre Y in light-years. */
+    readonly cy: number;
+    /** Sphere centre Z in light-years. */
+    readonly cz: number;
+    /** Sphere radius in light-years. */
+    readonly r: number;
+}
+/**
+ * A hand-authored named sector: its canonical name and the spheres it occupies.
+ *
+ * @remarks
+ * Whether the region needs a permit is not stored here — 28 of these regions are
+ * permit-locked, and `isPermitLockedRegionName` in `./permit-locks` is the single
+ * place that knows which. Pass {@link HandAuthoredRegion.name} to it.
+ *
+ * @example
+ * ```ts
+ * import { HAND_AUTHORED_REGIONS } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ *
+ * const pleiades = HAND_AUTHORED_REGIONS.find((region) => region.name === 'Pleiades Sector');
+ * ```
+ */
+interface HandAuthoredRegion {
+    /** Canonically-cased region name, e.g. `Pleiades Sector`. */
+    readonly name: string;
+    /** The spheres whose union defines the region's volume. */
+    readonly spheres: readonly HandAuthoredSphere[];
+}
+/**
+ * All hand-authored regions, sorted smallest-radius-first (overlap priority).
+ *
+ * @example
+ * ```ts
+ * import { HAND_AUTHORED_REGIONS } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ *
+ * HAND_AUTHORED_REGIONS[0]?.name;
+ * ```
+ */
+declare const HAND_AUTHORED_REGIONS: readonly HandAuthoredRegion[];
+/**
+ * The hand-authored region containing a galactic point, or `null` for procedural
+ * space.
+ *
+ * Because {@link HAND_AUTHORED_REGIONS} is sorted smallest-radius-first, the first region
+ * whose sphere set contains the point is the most specific one — matching the
+ * game's overlap priority.
+ *
+ * @remarks
+ * This resolves a *hand-authored named sector* only. For the codex region a point
+ * falls in, use `findCodexRegionAt` from `./codex-region-lookup` instead.
+ *
+ * @param position - Galactic position in light-years (Sol at origin). All three axes
+ * are used — hand-authored regions are 3-D spheres, so `y` matters here (unlike the
+ * flat `findCodexRegionAt`). A {@link ProceduralSystem.position} value can be passed directly.
+ * @returns The containing region, or `null` if the point is in procedural space.
+ * @example
+ * ```ts
+ * import { findHandAuthoredRegionAt } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ *
+ * findHandAuthoredRegionAt({ x: -80.6, y: -146.7, z: -343.3 })?.name;
+ * // -> 'Pleiades Sector'
+ * ```
+ * @example
+ * Resolving a permit lock from a position — the exact route, since it does not
+ * depend on how the system is named:
+ * ```ts
+ * import type { GalacticPosition } from '@elite-dangerous-almanac/core/astro';
+ * import { findHandAuthoredRegionAt } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ *
+ * declare const position: GalacticPosition;
+ *
+ * import { isPermitLockedRegionName } from '@elite-dangerous-almanac/core/astro/permit-locked-regions';
+ *
+ * const region = findHandAuthoredRegionAt(position);
+ * const needsPermit = region !== null && isPermitLockedRegionName(region.name);
+ * ```
+ */
+declare function findHandAuthoredRegionAt(position: GalacticPosition): HandAuthoredRegion | null;
+
+export { HAND_AUTHORED_REGIONS, type HandAuthoredRegion, type HandAuthoredSphere, findHandAuthoredRegionAt };

package/dist/astro/hand-authored-regions.js

@@ -0,0 +1 @@
+export{HAND_AUTHORED_REGIONS,findHandAuthoredRegionAt}from"../chunk-AVZI6VKA.js";                             //# sourceMappingURL=hand-authored-regions.js.map

package/dist/astro/hand-authored-regions.js.map

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

package/dist/astro/index.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Astrophysical data and calculations for the Elite Dangerous galaxy.
+ *
+ * This entry point re-exports the astro feature area's general API. Every symbol here
+ * is also reachable from its own module, so bundlers can drop anything you do not use.
+ * The 42-region coordinate lookup stays on `./codex-region-lookup`: its map geometry is
+ * large enough that native ESM and namespace consumers must opt into it explicitly.
+ *
+ * **Start with {@link ProceduralSystem}** — it composes the pieces below into one
+ * immutable handle (name ⇄ `id64`, sector, mass code, hand-authored regions). Drop
+ * to the individual functions when you need just one calculation.
+ *
+ * **A note on the word "region".** It means four different things here; the
+ * exports are grouped to keep them apart:
+ * - *procedural sector* — {@link sectorNameFromGridPosition} & co. (the boxel grid name).
+ * - *naming-region origin* — {@link resolveNamingRegionOrigin} (a sector's corner, for `id64`).
+ * - *hand-authored region* — {@link findHandAuthoredRegionAt} (Pleiades, Coalsack, …).
+ * - *galactic codex region* —
+ *   {@link astro/codex-region-lookup!findCodexRegionAt | findCodexRegionAt} (one of the 42 codex zones).
+ *
+ * None of those is the **nebula catalogue** — the nebulae themselves, and where
+ * they are: {@link nearestNebulae} & co. over {@link REAL_NEBULAE},
+ * {@link PROCGEN_NEBULAE}, and — on their own subpaths, so importing one never bundles
+ * the rest — {@link astro/nebulae-planetary!PLANETARY_NEBULAE | PLANETARY_NEBULAE} and
+ * {@link astro/nebulae-all!ALL_NEBULAE | ALL_NEBULAE}.
+ *
+ * **Coordinate spaces have different shapes.**
+ * {@link GalacticPosition} is `{x, y, z}` in light-years with Sol at the origin — what the journal,
+ * EDSM and Spansh report, and what {@link findHandAuthoredRegionAt} and
+ * {@link nearestNebulae} take.
+ * {@link SectorGridPosition} uses `{sectorX, sectorY, sectorZ}` integer indices on the
+ * 1280 ly naming grid, which is what {@link sectorNameFromGridPosition} takes. The
+ * distinct axis names prevent accidentally passing light-years as sector indices.
+ * Convert a real position with {@link sectorGridPositionFromGalacticPosition} (or go
+ * straight to {@link sectorNameFromGalacticPosition}).
+ *
+ * {@link astro/codex-region-lookup!findCodexRegionAt | findCodexRegionAt} reads only
+ * `{x, z}`, because the region map is an X/Z projection; it takes a `GalacticPosition`
+ * as it comes and ignores the `y`.
+ *
+ * **Permit locks** are six similarly-named lookups; {@link permitLockForSystemName}
+ * is the one to start from (it answers for both kinds of lock, from a name alone).
+ *
+ * @example
+ * Start here: a name in, an `id64` out, and back again.
+ *
+ * ```ts
+ * import { ProceduralSystem } from '@elite-dangerous-almanac/core/astro/procedural-system';
+ *
+ * const system = ProceduralSystem.fromName('Synuefe EN-H d11-96');
+ * system?.systemAddress; // -> 3309179996515n
+ * system?.namingRegionName; // -> 'Synuefe'
+ * system?.massCode; // -> 'd'
+ *
+ * ProceduralSystem.fromSystemAddress(3309179996515n).name; // -> 'Synuefe EN-H d11-96'
+ * ```
+ *
+ * `fromName` returns `null` for a string that is not a procedural name — Sol and the
+ * other hand-named systems are deliberately outside this type.
+ *
+ * @example
+ * The four meanings of "region", all answered for one position — the Pleiades. They
+ * disagree, which is the point: each names a different thing.
+ *
+ * ```ts
+ * import { sectorNameFromGalacticPosition } from '@elite-dangerous-almanac/core/astro/galaxy-grid';
+ * import { resolveNamingRegionOrigin } from '@elite-dangerous-almanac/core/astro/naming-region-origins';
+ * import { findHandAuthoredRegionAt } from '@elite-dangerous-almanac/core/astro/hand-authored-regions';
+ * import { findCodexRegionAt } from '@elite-dangerous-almanac/core/astro/codex-region-lookup';
+ *
+ * const position = { x: -81.625, y: -151.3125, z: -376.0625 };
+ *
+ * sectorNameFromGalacticPosition(position); // -> 'Synuefai'          procedural sector
+ * findHandAuthoredRegionAt(position)?.name; // -> 'Pleiades Sector'   hand-authored region
+ * findCodexRegionAt(position)?.name; // -> 'Inner Orion Spur'  codex region
+ * resolveNamingRegionOrigin('Synuefai')?.x0; // -> 1556480            naming-region origin
+ * ```
+ *
+ * And the nebula catalogue, which is none of those — it answers "what is *near* here":
+ *
+ * ```ts
+ * import { nearestNebulae } from '@elite-dangerous-almanac/core/astro/nebulae';
+ * import { REAL_NEBULAE } from '@elite-dangerous-almanac/core/astro/nebulae-real';
+ *
+ * const position = { x: -81.625, y: -151.3125, z: -376.0625 };
+ *
+ * nearestNebulae(position, REAL_NEBULAE, 2).map((n) => [n.name, n.distanceLy]);
+ * // -> [['Pleiades', 32.74…], ['Taurus Dark Region', 91.07…]]
+ * ```
+ *
+ * The catalogue argument is required here rather than defaulted: `ALL_NEBULAE` is
+ * 431.7 KiB, so importing it must be your decision.
+ *
+ * @example
+ * The two coordinate spaces, side by side. Light-years and sector indices are both
+ * three numbers, so the axis names are what stop you mixing them up.
+ *
+ * ```ts
+ * import { sectorGridPositionFromGalacticPosition } from '@elite-dangerous-almanac/core/astro/galaxy-grid';
+ * import { sectorNameFromGridPosition } from '@elite-dangerous-almanac/core/astro/sector-name';
+ *
+ * // GalacticPosition: light-years from Sol — what a journal or EDSM gives you.
+ * const position = { x: -81.625, y: -151.3125, z: -376.0625 };
+ *
+ * // SectorGridPosition: integer indices on the 1280 ly naming grid.
+ * const grid = sectorGridPositionFromGalacticPosition(position);
+ * grid; // -> { sectorX: 38, sectorY: 31, sectorZ: 18 }
+ *
+ * sectorNameFromGridPosition(grid); // -> 'Synuefai'
+ * ```
+ *
+ * @example
+ * Permit locks come in two kinds, and one lookup answers for both from a name alone.
+ *
+ * ```ts
+ * import { permitLockForSystemName } from '@elite-dangerous-almanac/core/astro/permit-locks';
+ *
+ * permitLockForSystemName('Sol')?.kind; // -> 'system'   individually locked
+ * permitLockForSystemName('Col 70 Sector AB-C d1-23')?.kind; // -> 'region'   the whole region is locked
+ * permitLockForSystemName('Synuefe EN-H d11-96'); // -> null       not locked at all
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { ProceduralSystem } from './procedural-system.js';
+export { G as GalacticPosition } from '../galactic-position-shLkm4Qg.js';
+export { BoxelLetters, IsProceduralSystemNameOptions, SystemNameParts, boxelCodeToLetters, canonicalizeSystemName, formatSystemName, isProceduralSystemName, lettersToBoxelCode, parseSystemName } from './system-name.js';
+export { A as AbsoluteBoxel, D as DecodedAddress, N as NamingRegionOrigin, S as SECTOR_INTERNAL_SIZE, a as absoluteBoxelToBoxelCode, b as boxelCodeToAbsoluteBoxel, c as boxelInternalSize, d as decodeModSystemAddress, e as decodeSystemAddress, f as encodeModSystemAddress, g as encodeSystemAddress, h as getHandAuthoredRegionOrigin, r as resolveNamingRegionOrigin } from '../system-address-DYsN1qOT.js';
+export { SystemAddressInput, toSystemAddress, tryToSystemAddress } from './system-address-input.js';
+export { SectorGridPosition, canonicalizeSectorName, sectorGridPositionFromName, sectorNameFromGridPosition } from './sector-name.js';
+export { GALAXY_ORIGIN, SECTOR_EDGE_LY, sectorGridPositionFromGalacticPosition, sectorNameFromGalacticPosition } from './galaxy-grid.js';
+export { BASE_BOXEL_LY, MASS_CODE_COUNT, boxelEdgeLy, massCodeToSizeClass, sizeClassToMassCode } from './mass-code.js';
+export { HAND_AUTHORED_REGIONS, HandAuthoredRegion, HandAuthoredSphere, findHandAuthoredRegionAt } from './hand-authored-regions.js';
+export { PermitLock, isPermitLockedSystemName, permitLockForSystemName } from './permit-locks.js';
+export { CODEX_REGIONS, CodexRegion, CodexRegionBounds, GalacticPlanePosition, getCodexRegion, getCodexRegionByName } from './codex-region.js';
+export { Nebula, NebulaType, NebulaWithDistance, getNebulaByName, nearestNebulae, nebulaeWithin } from './nebulae.js';
+export { REAL_NEBULAE } from './nebulae-real.js';
+export { PROCGEN_NEBULAE } from './nebulae-procgen.js';
+export { PERMIT_LOCKED_REGIONS, isPermitLockedRegionName, permitLockedRegionForSystemName } from './permit-locked-regions.js';
+export { PERMIT_LOCKED_SYSTEMS, PermitLockedSystem, permitLockedSystemForAddress, permitLockedSystemForName } from './permit-locked-systems.js';

package/dist/astro/index.js

@@ -0,0 +1 @@
+export{getNebulaByName,nearestNebulae,nebulaeWithin}from"../chunk-ZFT56QFR.js";export{isPermitLockedSystemName,permitLockForSystemName}from"../chunk-MFV4VZFP.js";export{PERMIT_LOCKED_SYSTEMS,permitLockedSystemForAddress,permitLockedSystemForName}from"../chunk-WV5YM7H5.js";export{ProceduralSystem}from"../chunk-VXVUEF5U.js";export{boxelCodeToLetters,canonicalizeSystemName,formatSystemName,isProceduralSystemName,lettersToBoxelCode,parseSystemName}from"../chunk-JWJ7RSZC.js";export{PERMIT_LOCKED_REGIONS,isPermitLockedRegionName,permitLockedRegionForSystemName}from"../chunk-VZXL5KBR.js";export{CODEX_REGIONS,getCodexRegion,getCodexRegionByName}from"../chunk-NWPK6Q3S.js";export{GALAXY_ORIGIN,SECTOR_EDGE_LY,sectorGridPositionFromGalacticPosition,sectorNameFromGalacticPosition}from"../chunk-U6TMCYA6.js";export{HAND_AUTHORED_REGIONS,findHandAuthoredRegionAt}from"../chunk-AVZI6VKA.js";export{BASE_BOXEL_LY,MASS_CODE_COUNT,boxelEdgeLy,massCodeToSizeClass,sizeClassToMassCode}from"../chunk-DACZE3HX.js";export{getHandAuthoredRegionOrigin,resolveNamingRegionOrigin}from"../chunk-Z4GTTB7I.js";export{SECTOR_INTERNAL_SIZE,absoluteBoxelToBoxelCode,boxelCodeToAbsoluteBoxel,boxelInternalSize,decodeModSystemAddress,decodeSystemAddress,encodeModSystemAddress,encodeSystemAddress}from"../chunk-BTPV5CIF.js";export{toSystemAddress,tryToSystemAddress}from"../chunk-IH4NXKVW.js";export{canonicalizeSectorName,sectorGridPositionFromName,sectorNameFromGridPosition}from"../chunk-J2PNZQY4.js";                                                          export{PROCGEN_NEBULAE}from"../chunk-K7F6WC4T.js";export{REAL_NEBULAE}from"../chunk-HI7FCS3G.js";                                                          //# sourceMappingURL=index.js.map

package/dist/astro/index.js.map

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

package/dist/astro/mass-code.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Mass-code helpers for Elite Dangerous procedural system names.
+ *
+ * The lower-case letter after the number-pair in a name (the `d` in
+ * `Synuefe EN-H d11-96`) is its **mass code** `a`–`h`. It selects the size of the
+ * boxel the system was generated in: an `a` boxel is 10 ly on a side and each
+ * subsequent code doubles it, up to `h` at 1280 ly (a whole sector). Internally
+ * the same value is the 0–7 **size class** used by the system-address bit layout.
+ *
+ * @packageDocumentation
+ */
+/** Number of mass codes (`a`–`h`) / distinct size classes. */
+declare const MASS_CODE_COUNT = 8;
+/** Edge length of an `a`-class boxel, in light-years. */
+declare const BASE_BOXEL_LY = 10;
+/**
+ * Convert a mass-code letter to its 0–7 size class.
+ *
+ * @param code - A single letter `a`–`h` (case-insensitive).
+ * @returns The size class 0–7.
+ * @throws {TypeError} If `code` is not a string. A mass code is a required argument
+ * rather than a key to search for, so a missing one is loud too.
+ * @throws {RangeError} If `code` is a string but not a single letter in `a`–`h`.
+ * @example
+ * ```ts
+ * import { massCodeToSizeClass } from '@elite-dangerous-almanac/core/astro/mass-code';
+ *
+ * massCodeToSizeClass('d'); // -> 3
+ * ```
+ */
+declare function massCodeToSizeClass(code: string): number;
+/**
+ * Convert a 0–7 size class to its mass-code letter.
+ *
+ * @param sizeClass - An integer 0–7.
+ * @returns The mass-code letter `a`–`h`.
+ * @throws {RangeError} If `sizeClass` is outside 0–7.
+ * @example
+ * ```ts
+ * import { sizeClassToMassCode } from '@elite-dangerous-almanac/core/astro/mass-code';
+ *
+ * sizeClassToMassCode(3); // -> 'd'
+ * ```
+ */
+declare function sizeClassToMassCode(sizeClass: number): string;
+/**
+ * Edge length, in light-years, of a boxel of the given size class.
+ *
+ * @param sizeClass - An integer 0–7 (mass codes `a`–`h`).
+ * @returns The boxel edge length in light-years (10, 20, … 1280).
+ * @throws {RangeError} If `sizeClass` is not an integer from 0 through 7.
+ */
+declare function boxelEdgeLy(sizeClass: number): number;
+
+export { BASE_BOXEL_LY, MASS_CODE_COUNT, boxelEdgeLy, massCodeToSizeClass, sizeClassToMassCode };

package/dist/astro/mass-code.js

@@ -0,0 +1 @@
+export{BASE_BOXEL_LY,MASS_CODE_COUNT,boxelEdgeLy,massCodeToSizeClass,sizeClassToMassCode}from"../chunk-DACZE3HX.js";                             //# sourceMappingURL=mass-code.js.map

package/dist/astro/mass-code.js.map

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

package/dist/astro/naming-region-origins.d.ts

@@ -0,0 +1,4 @@
+export { N as NamingRegionOrigin, S as SECTOR_INTERNAL_SIZE, h as getHandAuthoredRegionOrigin, r as resolveNamingRegionOrigin } from '../system-address-DYsN1qOT.js';
+import './system-name.js';
+import './sector-name.js';
+import './system-address-input.js';

package/dist/astro/naming-region-origins.js

@@ -0,0 +1 @@
+export{getHandAuthoredRegionOrigin,resolveNamingRegionOrigin}from"../chunk-Z4GTTB7I.js";export{SECTOR_INTERNAL_SIZE}from"../chunk-BTPV5CIF.js";                                                                                                                                                 //# sourceMappingURL=naming-region-origins.js.map

package/dist/astro/naming-region-origins.js.map

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

package/dist/astro/nebulae-all.d.ts

@@ -0,0 +1,40 @@
+import { Nebula } from './nebulae.js';
+import '../galactic-position-shLkm4Qg.js';
+
+/**
+ * The **complete** nebula catalogue: real, planetary and procedurally generated
+ * nebulae in one array.
+ *
+ * @remarks
+ * **This module pulls in every nebula catalogue (~432 KiB bundled)** — it exists for
+ * consumers that really do want to search all 5835 records (a "nearest nebula to my
+ * position" tool, say). If you only need one class, import that catalogue's module
+ * (`./nebulae-real`, `./nebulae-planetary`, `./nebulae-procgen`) and nothing else
+ * gets bundled.
+ *
+ * Data from EDAstro; see [ATTRIBUTIONS.md](https://github.com/DarkSession/Elite-Dangerous-Almanac/blob/main/ATTRIBUTIONS.md) for credit and licence terms.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Every catalogued nebula — the concatenation of `REAL_NEBULAE`,
+ * `PLANETARY_NEBULAE` and `PROCGEN_NEBULAE`, in that order (each class sorted by
+ * name).
+ *
+ * @remarks
+ * Filter on {@link Nebula.type} to narrow it down after the fact — though importing
+ * the single catalogue you need is cheaper, since it keeps the others out of your
+ * bundle entirely.
+ *
+ * @example
+ * ```ts
+ * import { ALL_NEBULAE } from '@elite-dangerous-almanac/core/astro/nebulae-all';
+ *
+ * ALL_NEBULAE.length;                                        // -> 5835
+ * ALL_NEBULAE.filter((n) => n.type === 'procgen').length;    // -> 166
+ * ```
+ */
+declare const ALL_NEBULAE: readonly Nebula[];
+
+export { ALL_NEBULAE };

package/dist/astro/nebulae-all.js

@@ -0,0 +1 @@
+import{PLANETARY_NEBULAE}from"../chunk-Z4OUB4SJ.js";import{PROCGEN_NEBULAE}from"../chunk-K7F6WC4T.js";import{REAL_NEBULAE}from"../chunk-HI7FCS3G.js";                                                          var ALL_NEBULAE=Object.freeze([...REAL_NEBULAE,...PLANETARY_NEBULAE,...PROCGEN_NEBULAE]);export{ALL_NEBULAE};//# sourceMappingURL=nebulae-all.js.map

package/dist/astro/nebulae-all.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/astro/nebulae-all.ts"],"names":["PLANETARY_NEBULAE","PROCGEN_NEBULAE","REAL_NEBULAE","ALL_NEBULAE","Object","freeze"],"mappings":"O,wMAuCO,IAAMG,YAAiCC,OAAOC,OAAO,IACrDH,gBACAF,qBACAC,yBACNE"}