@where-stars-drift/core 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2026 Volodymyr Lavrynovych
+
+All Rights Reserved.
+
+Proprietary and Confidential.
+
+This software is the proprietary property of Volodymyr Lavrynovych ("Owner") and is protected by copyright laws and international treaty provisions. You are hereby granted a non-exclusive, non-transferable, limited license to use this software for personal, non-commercial purposes only, subject to the terms and conditions of this license.
+
+You may not:
+a) copy, modify, distribute, sell, or lease any part of the software;
+b) reverse engineer or attempt to extract the source code of the software;
+c) remove any copyright or other proprietary notices from the software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# Where Stars Drift ✨
+
+> A TypeScript canvas library for creating interactive space simulations with realistic physics, celestial bodies, and dynamic fleet behaviors.
+
+[![License](https://img.shields.io/badge/license-Proprietary-red.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/@where-stars-drift/core.svg)](https://www.npmjs.com/package/@where-stars-drift/core)
+
+Born from a simple starfield background, **Where Stars Drift** evolved into a complete 2D space simulation engine inspired by classics like Homeworld and Freelancer.
+
+## ✨ Features
+
+- **Celestial Bodies**: Multiple star types, pulsars, ringed planets, black holes with gravitational effects
+- **Dynamic Entities**: Starships with AI behaviors, fleet formations, clans, and tactical movements
+- **Visual Effects**: Nebulas, comets, meteors, supernovas, and energy streams
+- **Physics Engine**: Real gravity simulation, collision detection, and spatial optimization via quadtree
+- **Interactive**: Mouse-driven interactions, hover effects, and responsive animations
+- **Framework Agnostic**: Pure canvas rendering with optional framework wrappers
+
+## 📦 Installation
+
+```bash
+npm install @where-stars-drift/core
+```
+
+## 🚀 Quick Start
+
+### Vanilla JavaScript / TypeScript
+
+```typescript
+import { WhereStarsDrift } from '@where-stars-drift/core';
+
+const canvas = document.getElementById('canvas') as HTMLCanvasElement;
+
+const simulation = new WhereStarsDrift(canvas, {
+  starsCount: 1000,
+  interactive: true,
+  debug: false,
+  showCatalog: false
+});
+
+simulation.start();
+```
+
+## 🏗️ Development
+
+This project is a monorepo structured with NPM workspaces:
+
+-   `/packages/where-stars-drift`: The core, framework-agnostic library source code.
+-   `/packages/demo-app`: A Next.js application to demonstrate the library's features.
+
+### Available Scripts
+
+-   `npm run dev`: Starts the Next.js development server for the demo app.
+-   `npm run build`: Compiles the TypeScript library (`@where-stars-drift/core`) into JavaScript and type definitions in `packages/where-stars-drift/dist`.
+-   `npm run build:app`: Builds the Next.js demo application for production.
+-   `npm run typecheck`: Runs a TypeScript check across the entire monorepo.
+
+## 📦 Publishing
+
+The NPM package published is `@where-stars-drift/core` from the `packages/where-stars-drift` directory.
+
+To publish the library to npm:
+
+1.  **Build the library**: Ensure the latest changes are compiled.
+    ```bash
+    npm run build
+    ```
+    The `prepublishOnly` script will automatically run this command before publishing.
+
+2.  **Publish to npm**:
+    ```bash
+    cd packages/where-stars-drift
+    npm publish
+    ```
+    
+    This process is automated via the `.github/workflows/npm-publish.yml` workflow when a new version tag is pushed.
+
+## 🌌 Features in Detail
+
+### Stars
+
+- **Regular Stars**: Twinkling stars with various colors
+- **Pulsars**: Rotating stars with pulsing effects
+- **Ringed Planets**: Planets with orbital rings
+
+### Black Holes
+
+- Multiple visual styles (spiral, singularity, accretion disk, etc.)
+- Gravitational pull affecting nearby stars
+- Star consumption with supernova effects
+- Energy streams between black holes
+
+### Starships
+
+- Multiple ship classes (Fighter, Corvette, Frigate, Capital)
+- AI behaviors (idle, traveling, docking, orbiting)
+- Fleet formations (V-formation, line, defensive sphere, etc.)
+- Clan system with different colors and behaviors
+- Mouse interaction (ships flee from cursor)
+
+### Physics
+
+- Gravity simulation
+- Collision detection via spatial quadtree
+- Orbital mechanics
+- Velocity and acceleration
+
+## 🎯 Roadmap
+
+- [ ] Performance optimizations
+- [ ] More formation patterns
+- [ ] Configurable color schemes
+- [ ] Sound effects
+- [ ] React/Vue/Angular wrappers
+- [ ] Save/load simulation state
+- [ ] WebGL rendering option
+
+## 📄 License
+
+Copyright © 2026 Volodymyr Lavrynovych. All Rights Reserved.
+
+This software is proprietary and confidential. See [LICENSE](LICENSE) for details.
+
+## 🤝 Contributing
+
+This is a private repository. Contributions are by invitation only.
+
+## 🌐 Links
+
+- Website: [starsdrift.space](https://starsdrift.space)
+- Organization: [@where-stars-drift](https://github.com/where-stars-drift)
+- Issues: [GitHub Issues](https://github.com/where-stars-drift/where-stars-drift-core/issues)
+
+## 🙏 Acknowledgments
+
+Inspired by:
+- Homeworld series
+- Freelancer
+- The beauty of the cosmos
+
+---
+
+*Dedicated to Victoria, the first black hole in this universe* 💫

package/dist/src/base/bounded-body.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies with physical boundaries.
+ */
+import { CelestialBody } from './celestial-body';
+export declare abstract class BoundedBody extends CelestialBody {
+    boundingRadius: number;
+    constructor(x: number, y: number, boundingRadius: number);
+}

package/dist/src/base/bounded-body.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies with physical boundaries.
+ */
+import { CelestialBody } from './celestial-body';
+export class BoundedBody extends CelestialBody {
+    constructor(x, y, boundingRadius) {
+        super(x, y);
+        this.boundingRadius = boundingRadius;
+    }
+}

package/dist/src/base/celestial-body.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies.
+ */
+export declare abstract class CelestialBody {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    constructor(x: number, y: number);
+    abstract update(context: CanvasRenderingContext2D, ...args: any[]): void;
+    abstract draw(context: CanvasRenderingContext2D, ...args: any[]): void;
+}

package/dist/src/base/celestial-body.js

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies.
+ */
+export class CelestialBody {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+        this.vx = 0;
+        this.vy = 0;
+    }
+}

package/dist/src/base/hoverable.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Defines the Hoverable interface for objects that can be hovered.
+ */
+export interface Hoverable {
+    x: number;
+    y: number;
+    isHovered: boolean;
+    hoverTimer: number;
+    hoverRadius: number;
+}

package/dist/src/base/hoverable.js

@@ -0,0 +1,4 @@
+/**
+ * @fileoverview Defines the Hoverable interface for objects that can be hovered.
+ */
+export {};

package/dist/src/base/massive-body.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies that have mass.
+ */
+import { BoundedBody } from './bounded-body';
+export declare abstract class MassiveBody extends BoundedBody {
+    mass: number;
+    constructor(x: number, y: number, boundingRadius: number, mass: number);
+}

package/dist/src/base/massive-body.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies that have mass.
+ */
+import { BoundedBody } from './bounded-body';
+export class MassiveBody extends BoundedBody {
+    constructor(x, y, boundingRadius, mass) {
+        super(x, y, boundingRadius);
+        this.mass = mass;
+    }
+}

package/dist/src/config/effects.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Centralized configuration for visual effects in the simulation.
+ */
+export declare const EFFECTS_CONFIG: {
+    /**
+     * If true, renders the energy streams flowing between two interacting black holes.
+     */
+    RENDER_INTER_HOLE_STREAMS: boolean;
+    /**
+     * If true, renders the energy streams from stars that are being consumed by a black hole.
+     * This is computationally expensive and can be disabled for performance.
+     */
+    RENDER_STAR_TO_HOLE_STREAMS: boolean;
+};

package/dist/src/config/effects.js

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Centralized configuration for visual effects in the simulation.
+ */
+export const EFFECTS_CONFIG = {
+    /**
+     * If true, renders the energy streams flowing between two interacting black holes.
+     */
+    RENDER_INTER_HOLE_STREAMS: true,
+    /**
+     * If true, renders the energy streams from stars that are being consumed by a black hole.
+     * This is computationally expensive and can be disabled for performance.
+     */
+    RENDER_STAR_TO_HOLE_STREAMS: true,
+};

package/dist/src/config/grid.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Centralized configuration for the sector grid.
+ */
+export declare const GRID_CONFIG: {
+    SECTOR_SIZE: number;
+    LINE_COLOR: string;
+    LINE_WIDTH: number;
+    FONT: string;
+    FONT_COLOR: string;
+};

package/dist/src/config/grid.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Centralized configuration for the sector grid.
+ */
+export const GRID_CONFIG = {
+    SECTOR_SIZE: 360,
+    LINE_COLOR: 'rgba(100, 120, 150, 0.2)',
+    LINE_WIDTH: 0.5,
+    FONT: '8px "Roboto Mono", monospace',
+    FONT_COLOR: 'rgba(100, 120, 150, 0.3)',
+};

package/dist/src/config/panel.d.ts

@@ -0,0 +1,26 @@
+export declare const PANEL_CONFIG: {
+    X: number;
+    WIDTH: number;
+    HEIGHT_PERCENT: number;
+    HEADER_HEIGHT: number;
+    TAB_HEIGHT: number;
+    ROW_HEIGHT: number;
+    GROUP_HEADER_HEIGHT: number;
+    PADDING: number;
+    BG_COLOR: string;
+    BORDER_COLOR: string;
+    TEXT_COLOR: string;
+    ACCENT_COLOR: string;
+    TITLE_FONT: string;
+    TAB_FONT: string;
+    ROW_FONT: string;
+    GROUP_FONT: string;
+    SHIP_RENDER_SCALE: number;
+    SCROLL_SPEED: number;
+    TOGGLE_BUTTON: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+};

package/dist/src/config/panel.js

@@ -0,0 +1,26 @@
+export const PANEL_CONFIG = {
+    X: 10,
+    WIDTH: 350,
+    HEIGHT_PERCENT: 0.5,
+    HEADER_HEIGHT: 40,
+    TAB_HEIGHT: 30,
+    ROW_HEIGHT: 25,
+    GROUP_HEADER_HEIGHT: 20,
+    PADDING: 10,
+    BG_COLOR: 'rgba(0, 0, 0, 0.75)',
+    BORDER_COLOR: '#555',
+    TEXT_COLOR: '#ddd',
+    ACCENT_COLOR: '#aaa',
+    TITLE_FONT: '14px "Roboto Mono", monospace',
+    TAB_FONT: '11px "Roboto Mono", monospace',
+    ROW_FONT: '12px "Roboto Mono", monospace',
+    GROUP_FONT: 'bold 12px "Roboto Mono", monospace',
+    SHIP_RENDER_SCALE: 1,
+    SCROLL_SPEED: 20,
+    TOGGLE_BUTTON: {
+        x: 15,
+        y: 5,
+        w: 120,
+        h: 22,
+    },
+};

package/dist/src/config/simulation.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @fileoverview Centralized configuration for the night sky simulation.
+ */
+export declare const SIMULATION_CONFIG: {
+    STARS_COUNT: number;
+};
+export declare const DEBUG_CONFIG: {
+    SHOW_DEBUG_INFO: boolean;
+    SHOW_ENTITY_HOVER_INFO: boolean;
+    SHOW_STARSHIP_TARGET_LINE: boolean;
+    SHOW_INTER_HOLE_DISTANCE: boolean;
+    SHOW_FORMATION_TARGET_DOTS: boolean;
+    SHOW_CATALOG_PANEL: boolean;
+    SHOW_STARSHIP_CATALOG: boolean;
+    SHOW_FORMATION_CATALOG: boolean;
+    SHOW_CLAN_CATALOG: boolean;
+    SHOW_FLEET_CATALOG: boolean;
+    SHOW_STAR_CATALOG: boolean;
+    SHOW_BLACK_HOLE_CATALOG: boolean;
+    SHOW_QUADTREE: boolean;
+};

package/dist/src/config/simulation.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Centralized configuration for the night sky simulation.
+ */
+// --- General Simulation ---
+export const SIMULATION_CONFIG = {
+    STARS_COUNT: 468,
+};
+// --- Debugging ---
+export const DEBUG_CONFIG = {
+    SHOW_DEBUG_INFO: true,
+    SHOW_ENTITY_HOVER_INFO: true, // Shows a detailed info panel on hover for individual entities
+    SHOW_STARSHIP_TARGET_LINE: true,
+    SHOW_INTER_HOLE_DISTANCE: true,
+    SHOW_FORMATION_TARGET_DOTS: false,
+    SHOW_CATALOG_PANEL: true,
+    SHOW_STARSHIP_CATALOG: true,
+    SHOW_FORMATION_CATALOG: true,
+    SHOW_CLAN_CATALOG: true,
+    SHOW_FLEET_CATALOG: true,
+    SHOW_STAR_CATALOG: true,
+    SHOW_BLACK_HOLE_CATALOG: true,
+    SHOW_QUADTREE: false,
+};

package/dist/src/controllers/clan-controller.d.ts

@@ -0,0 +1,7 @@
+import type { Clan } from '../entities/clans';
+export declare class ClanController {
+    private clanManager;
+    constructor();
+    getNextClan(): Clan;
+    getClans(): Clan[];
+}

package/dist/src/controllers/clan-controller.js

@@ -0,0 +1,12 @@
+import { ClanManager } from '../entities/clan-manager';
+export class ClanController {
+    constructor() {
+        this.clanManager = new ClanManager();
+    }
+    getNextClan() {
+        return this.clanManager.getClanForNewFleet();
+    }
+    getClans() {
+        return this.clanManager.getClans();
+    }
+}

package/dist/src/controllers/debug-controller.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Defines the DebugController for managing and drawing debug visualizations.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+interface BodyWithId extends Point {
+    id: number | string;
+}
+export declare class DebugController {
+    private linesToDraw;
+    constructor();
+    /**
+     * Resets the list of lines for the current frame.
+     */
+    clear(): void;
+    /**
+     * Registers a line to be drawn between two bodies, preventing duplicates.
+     * @param body1 The first body (source).
+     * @param body2 The second body (target).
+     * @param options Flags to control rendering.
+     */
+    registerLine(body1: BodyWithId, body2: BodyWithId, options?: {
+        drawLine: boolean;
+        showDistance: boolean;
+    }): void;
+    /**
+     * Registers a directional line from a source to a simple point target.
+     * Duplicates are not checked here as the source guarantees uniqueness for its own target line.
+     * @param source The source body.
+     * @param target The target point.
+     */
+    registerDirectionalLine(source: BodyWithId, target: Point, options?: {
+        drawLine: boolean;
+        showDistance: boolean;
+    }): void;
+    private drawDebugLineWithDistance;
+    /**
+     * Draws all registered lines for the current frame.
+     * @param ctx The canvas rendering context.
+     */
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+export {};

package/dist/src/controllers/debug-controller.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Defines the DebugController for managing and drawing debug visualizations.
+ */
+export class DebugController {
+    constructor() {
+        this.linesToDraw = new Map();
+    }
+    /**
+     * Resets the list of lines for the current frame.
+     */
+    clear() {
+        this.linesToDraw.clear();
+    }
+    /**
+     * Registers a line to be drawn between two bodies, preventing duplicates.
+     * @param body1 The first body (source).
+     * @param body2 The second body (target).
+     * @param options Flags to control rendering.
+     */
+    registerLine(body1, body2, options = { drawLine: true, showDistance: true }) {
+        // Create a unique, sorted key to prevent duplicate lines (A-B vs B-A)
+        const ids = [body1.id.toString(), body2.id.toString()].sort();
+        const lineKey = ids.join('-');
+        if (!this.linesToDraw.has(lineKey)) {
+            this.linesToDraw.set(lineKey, {
+                source: { x: body1.x, y: body1.y },
+                target: { x: body2.x, y: body2.y },
+                options,
+            });
+        }
+    }
+    /**
+     * Registers a directional line from a source to a simple point target.
+     * Duplicates are not checked here as the source guarantees uniqueness for its own target line.
+     * @param source The source body.
+     * @param target The target point.
+     */
+    registerDirectionalLine(source, target, options = { drawLine: true, showDistance: true }) {
+        const lineKey = `dir-${source.id}`;
+        this.linesToDraw.set(lineKey, { source, target, options });
+    }
+    drawDebugLineWithDistance(ctx, source, target, drawLine, showDistance) {
+        const dx = target.x - source.x;
+        const dy = target.y - source.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        // Draw the dashed line if requested
+        if (drawLine) {
+            ctx.beginPath();
+            ctx.setLineDash([2, 4]);
+            ctx.moveTo(source.x, source.y);
+            ctx.lineTo(target.x, target.y);
+            ctx.strokeStyle = 'rgba(255, 255, 255, 0.2)';
+            ctx.lineWidth = 0.5;
+            ctx.stroke();
+            ctx.setLineDash([]);
+        }
+        // Draw the distance text if requested
+        if (showDistance) {
+            const midX = source.x + dx / 2;
+            const midY = source.y + dy / 2;
+            ctx.fillStyle = 'rgba(255, 255, 255, 0.4)';
+            ctx.font = '10px "Roboto Mono", monospace';
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'bottom';
+            ctx.fillText(dist.toFixed(0), midX, midY - 2);
+        }
+    }
+    /**
+     * Draws all registered lines for the current frame.
+     * @param ctx The canvas rendering context.
+     */
+    draw(ctx) {
+        if (this.linesToDraw.size === 0) {
+            return;
+        }
+        ctx.save();
+        this.linesToDraw.forEach(({ source, target, options }) => {
+            this.drawDebugLineWithDistance(ctx, source, target, options.drawLine, options.showDistance);
+        });
+        ctx.restore();
+    }
+}

package/dist/src/controllers/effects-controller.d.ts

@@ -0,0 +1,17 @@
+import { Supernova } from '../entities/supernova';
+import { Star } from '../entities/star';
+import { BlackHle } from '../entities/black-hole';
+export declare class EffectsController {
+    private supernovas;
+    private meteors;
+    private meteorShowerCooldown;
+    private width;
+    private height;
+    constructor(width: number, height: number);
+    private getNewMeteorCooldown;
+    addSupernovas(newSupernovas: Supernova[]): void;
+    updateAndDrawSupernovas(ctx: CanvasRenderingContext2D): void;
+    private spawnMeteorShower;
+    updateAndDrawMeteors(ctx: CanvasRenderingContext2D): void;
+    drawStarToHoleStreams(ctx: CanvasRenderingContext2D, allStars: Star[], blackHoles: BlackHle[]): void;
+}

package/dist/src/controllers/effects-controller.js

@@ -0,0 +1,71 @@
+import { Meteor, METEOR_CONFIG } from '../entities/meteor';
+import { STAR_CONFIG } from '../entities/star';
+import { EFFECTS_CONFIG } from '../config/effects';
+import { drawSimpleStarStream } from '../lib/simplified-stream';
+export class EffectsController {
+    constructor(width, height) {
+        this.supernovas = [];
+        this.meteors = [];
+        this.width = width;
+        this.height = height;
+        this.meteorShowerCooldown = this.getNewMeteorCooldown();
+    }
+    getNewMeteorCooldown() {
+        return Math.random() * METEOR_CONFIG.SHOWER_COOLDOWN_VARIANCE + METEOR_CONFIG.SHOWER_COOLDOWN_MIN;
+    }
+    addSupernovas(newSupernovas) {
+        this.supernovas.push(...newSupernovas);
+    }
+    updateAndDrawSupernovas(ctx) {
+        this.supernovas = this.supernovas.filter(nova => {
+            nova.update();
+            if (nova.isAlive()) {
+                nova.draw(ctx);
+                return true;
+            }
+            return false;
+        });
+    }
+    spawnMeteorShower() {
+        const radiantX = Math.random() * this.width;
+        const radiantY = Math.random() * this.height * 0.5;
+        const baseAngle = Math.random() * Math.PI * 2;
+        const meteorCount = Math.random() * METEOR_CONFIG.COUNT_VARIANCE + METEOR_CONFIG.COUNT_MIN;
+        const showerColor = STAR_CONFIG.RARE_STAR_COLORS[Math.floor(Math.random() * STAR_CONFIG.RARE_STAR_COLORS.length)];
+        for (let i = 0; i < meteorCount; i++) {
+            const angle = baseAngle + (Math.random() - 0.5) * 0.3;
+            const speed = Math.random() * METEOR_CONFIG.SPEED_VARIANCE + METEOR_CONFIG.SPEED_MIN;
+            this.meteors.push(new Meteor(radiantX, radiantY, Math.cos(angle) * speed, Math.sin(angle) * speed, showerColor));
+        }
+    }
+    ;
+    updateAndDrawMeteors(ctx) {
+        this.meteorShowerCooldown--;
+        if (this.meteorShowerCooldown <= 0) {
+            this.spawnMeteorShower();
+            this.meteorShowerCooldown = this.getNewMeteorCooldown();
+        }
+        this.meteors = this.meteors.filter(meteor => {
+            meteor.update();
+            if (meteor.isAlive(this.width, this.height)) {
+                meteor.draw(ctx);
+                return true;
+            }
+            return false;
+        });
+    }
+    drawStarToHoleStreams(ctx, allStars, blackHoles) {
+        if (!EFFECTS_CONFIG.RENDER_STAR_TO_HOLE_STREAMS)
+            return;
+        for (const star of allStars) {
+            for (const hole of blackHoles) {
+                const dx = hole.x - star.x;
+                const dy = hole.y - star.y;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+                if (dist < hole.radius + 50) {
+                    drawSimpleStarStream(ctx, star, hole);
+                }
+            }
+        }
+    }
+}

package/dist/src/controllers/hover-controller.d.ts

@@ -0,0 +1,11 @@
+import { CelestialBody } from '../base/celestial-body';
+export declare class HoverController {
+    private bodies;
+    constructor(bodies: CelestialBody[]);
+    update(mouse: {
+        x: number;
+        y: number;
+    }, isMouseInside: boolean, debug: boolean): void;
+    private checkHoverState;
+    private updateHoverStates;
+}