@swisseph/node 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Swiss Ephemeris for Node.js - Modern TypeScript API
+ *
+ * This module provides a modern, type-safe API for Swiss Ephemeris astronomical calculations.
+ * It wraps the native C library with developer-friendly TypeScript interfaces.
+ */
+import { CalendarType, CelestialBody, HouseSystem, CalculationFlagInput, EclipseTypeFlagInput, PlanetaryPosition, HouseData, LunarEclipse, SolarEclipse, ExtendedDateTime } from '@swisseph/core';
+/**
+ * Set the directory path for ephemeris files
+ *
+ * By default, @swisseph/node uses bundled ephemeris files included with the package.
+ * Call this function only if you want to use custom ephemeris files.
+ *
+ * @param path - Directory path containing ephemeris files, or null/undefined for bundled files
+ *
+ * @example
+ * // Use custom ephemeris files
+ * setEphemerisPath('/path/to/custom/ephemeris');
+ *
+ * // Revert to bundled files
+ * setEphemerisPath(null);
+ */
+export declare function setEphemerisPath(path?: string | null): void;
+/**
+ * Calculate Julian day number from calendar date
+ *
+ * The Julian day number is a continuous count of days since the beginning
+ * of the Julian period (January 1, 4713 BCE, proleptic Julian calendar).
+ *
+ * @param year - Year (negative for BCE)
+ * @param month - Month (1-12)
+ * @param day - Day (1-31)
+ * @param hour - Hour as decimal (0.0-23.999...)
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns Julian day number
+ *
+ * @example
+ * const jd = julianDay(2007, 3, 3);
+ * console.log(jd); // 2454162.5
+ *
+ * const jdWithTime = julianDay(2007, 3, 3, 14.5);
+ * console.log(jdWithTime); // 2454163.104166667
+ */
+export declare function julianDay(year: number, month: number, day: number, hour?: number, calendarType?: CalendarType): number;
+/**
+ * Convert Julian day number to calendar date
+ *
+ * @param jd - Julian day number
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns DateTime object with year, month, day, and hour
+ *
+ * @example
+ * const date = julianDayToDate(2454162.5);
+ * console.log(date);
+ * // { year: 2007, month: 3, day: 3, hour: 0, calendarType: CalendarType.Gregorian }
+ *
+ * console.log(date.toString());
+ * // "2007-03-03 0.000000 hours (Gregorian)"
+ */
+export declare function julianDayToDate(jd: number, calendarType?: CalendarType): ExtendedDateTime;
+/**
+ * Calculate planetary positions
+ *
+ * This is the main function for calculating positions of planets, asteroids,
+ * and other celestial bodies.
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @param body - Celestial body to calculate (use Planet, Asteroid, etc. enums)
+ * @param flags - Calculation flags (default: SwissEphemeris with speed)
+ * @returns PlanetaryPosition object with longitude, latitude, distance, and speeds
+ *
+ * @example
+ * // Calculate Sun position
+ * const sun = calculatePosition(jd, Planet.Sun);
+ * console.log(`Sun longitude: ${sun.longitude}°`);
+ *
+ * // Calculate with specific flags
+ * const moon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.MoshierEphemeris | CalculationFlag.Speed
+ * );
+ *
+ * // Using flag builder
+ * import { CalculationFlags } from 'swisseph';
+ * const flags = CalculationFlags.from(
+ *   CalculationFlag.SwissEphemeris,
+ *   CalculationFlag.Speed,
+ *   CalculationFlag.Equatorial
+ * );
+ * const mars = calculatePosition(jd, Planet.Mars, flags);
+ */
+export declare function calculatePosition(julianDay: number, body: CelestialBody, flags?: CalculationFlagInput): PlanetaryPosition;
+/**
+ * Calculate house cusps and angles
+ *
+ * Houses divide the ecliptic into 12 sections based on the observer's
+ * location and the time of day.
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @param latitude - Geographic latitude (positive = north, negative = south)
+ * @param longitude - Geographic longitude (positive = east, negative = west)
+ * @param houseSystem - House system to use (default: Placidus)
+ * @returns HouseData object with cusps and angles
+ *
+ * @example
+ * // Calculate houses for New York
+ * const houses = calculateHouses(jd, 40.7128, -74.0060, HouseSystem.Placidus);
+ * console.log(`Ascendant: ${houses.ascendant}°`);
+ * console.log(`MC: ${houses.mc}°`);
+ *
+ * // Access house cusps
+ * for (let i = 1; i <= 12; i++) {
+ *   console.log(`House ${i}: ${houses.cusps[i]}°`);
+ * }
+ *
+ * // Try different house system
+ * const wholeSigns = calculateHouses(jd, 40.7128, -74.0060, HouseSystem.WholeSign);
+ */
+export declare function calculateHouses(julianDay: number, latitude: number, longitude: number, houseSystem?: HouseSystem): HouseData;
+/**
+ * Find the next lunar eclipse
+ *
+ * Searches for the next lunar eclipse after the given Julian day.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param eclipseType - Filter by eclipse type (0 = all types)
+ * @param backward - Search backward in time if true
+ * @returns LunarEclipse object with times and convenience methods
+ *
+ * @example
+ * // Find next lunar eclipse
+ * const jd = julianDay(2025, 1, 1);
+ * const eclipse = findNextLunarEclipse(jd);
+ *
+ * console.log(`Eclipse maximum: ${julianDayToDate(eclipse.maximum)}`);
+ * console.log(`Is total: ${eclipse.isTotal()}`);
+ * console.log(`Totality duration: ${eclipse.getTotalityDuration()} hours`);
+ *
+ * // Find previous lunar eclipse
+ * const previousEclipse = findNextLunarEclipse(jd, undefined, 0, true);
+ */
+export declare function findNextLunarEclipse(startJulianDay: number, flags?: CalculationFlagInput, eclipseType?: EclipseTypeFlagInput, backward?: boolean): LunarEclipse;
+/**
+ * Find the next solar eclipse globally
+ *
+ * Searches for the next solar eclipse visible anywhere on Earth.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param eclipseType - Filter by eclipse type (0 = all types)
+ * @param backward - Search backward in time if true
+ * @returns SolarEclipse object with times and convenience methods
+ *
+ * @example
+ * // Find next solar eclipse
+ * const jd = julianDay(2025, 1, 1);
+ * const eclipse = findNextSolarEclipse(jd);
+ *
+ * console.log(`Eclipse maximum: ${julianDayToDate(eclipse.maximum)}`);
+ * console.log(`Is total: ${eclipse.isTotal()}`);
+ * console.log(`Is annular: ${eclipse.isAnnular()}`);
+ * console.log(`Is central: ${eclipse.isCentral()}`);
+ */
+export declare function findNextSolarEclipse(startJulianDay: number, flags?: CalculationFlagInput, eclipseType?: EclipseTypeFlagInput, backward?: boolean): SolarEclipse;
+/**
+ * Get the name of a celestial body
+ *
+ * @param body - Celestial body identifier
+ * @returns Name of the body as a string
+ *
+ * @example
+ * const name = getCelestialBodyName(Planet.Mars);
+ * console.log(name); // "Mars"
+ *
+ * const sunName = getCelestialBodyName(Planet.Sun);
+ * console.log(sunName); // "Sun"
+ */
+export declare function getCelestialBodyName(body: CelestialBody): string;
+/**
+ * Close Swiss Ephemeris and free resources
+ *
+ * Call this function when you're done using Swiss Ephemeris to free
+ * allocated resources.
+ *
+ * @example
+ * // After all calculations are done
+ * close();
+ */
+export declare function close(): void;
+export * from '@swisseph/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAEZ,aAAa,EACb,WAAW,EAEX,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,YAAY,EAEZ,gBAAgB,EAQjB,MAAM,gBAAgB,CAAC;AAkCxB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAU3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,MAAU,EAChB,YAAY,GAAE,YAAqC,GAClD,MAAM,CAER;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,YAAY,GAAE,YAAqC,GAClD,gBAAgB,CAGlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,aAAa,EACnB,KAAK,GAAE,oBAAmE,GACzE,iBAAiB,CAenB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,WAAW,GAAE,WAAkC,GAC9C,SAAS,CAmBX;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,KAAK,GAAE,oBAAqD,EAC5D,WAAW,GAAE,oBAAwB,EACrC,QAAQ,GAAE,OAAe,GACxB,YAAY,CAwBd;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,IAAI,IAAI,CAE5B;AAGD,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,343 @@
+"use strict";
+/**
+ * Swiss Ephemeris for Node.js - Modern TypeScript API
+ *
+ * This module provides a modern, type-safe API for Swiss Ephemeris astronomical calculations.
+ * It wraps the native C library with developer-friendly TypeScript interfaces.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEphemerisPath = setEphemerisPath;
+exports.julianDay = julianDay;
+exports.julianDayToDate = julianDayToDate;
+exports.calculatePosition = calculatePosition;
+exports.calculateHouses = calculateHouses;
+exports.findNextLunarEclipse = findNextLunarEclipse;
+exports.findNextSolarEclipse = findNextSolarEclipse;
+exports.getCelestialBodyName = getCelestialBodyName;
+exports.close = close;
+const core_1 = require("@swisseph/core");
+const path = __importStar(require("path"));
+// Import the native addon
+const binding = require('../build/Release/swisseph.node');
+// Track if ephemeris path has been explicitly set
+let ephemerisPathSet = false;
+/**
+ * Get the path to bundled ephemeris files
+ * @internal
+ */
+function getBundledEphemerisPath() {
+    // The ephemeris files are bundled in the package at ../ephemeris
+    return path.join(__dirname, '..', 'ephemeris');
+}
+/**
+ * Initialize ephemeris with bundled files if not already set and using Swiss Ephemeris
+ * @internal
+ */
+function ensureEphemerisInitialized(flags) {
+    // Only auto-load if using Swiss Ephemeris (not Moshier) and path not explicitly set
+    const usingMoshier = (flags & core_1.CalculationFlag.MoshierEphemeris) !== 0;
+    if (!ephemerisPathSet && !usingMoshier) {
+        const bundledPath = getBundledEphemerisPath();
+        binding.set_ephe_path(bundledPath);
+        ephemerisPathSet = true;
+    }
+}
+/**
+ * Set the directory path for ephemeris files
+ *
+ * By default, @swisseph/node uses bundled ephemeris files included with the package.
+ * Call this function only if you want to use custom ephemeris files.
+ *
+ * @param path - Directory path containing ephemeris files, or null/undefined for bundled files
+ *
+ * @example
+ * // Use custom ephemeris files
+ * setEphemerisPath('/path/to/custom/ephemeris');
+ *
+ * // Revert to bundled files
+ * setEphemerisPath(null);
+ */
+function setEphemerisPath(path) {
+    if (path === null || path === undefined) {
+        // Use bundled ephemeris
+        const bundledPath = getBundledEphemerisPath();
+        binding.set_ephe_path(bundledPath);
+    }
+    else {
+        // Use custom path
+        binding.set_ephe_path(path);
+    }
+    ephemerisPathSet = true;
+}
+/**
+ * Calculate Julian day number from calendar date
+ *
+ * The Julian day number is a continuous count of days since the beginning
+ * of the Julian period (January 1, 4713 BCE, proleptic Julian calendar).
+ *
+ * @param year - Year (negative for BCE)
+ * @param month - Month (1-12)
+ * @param day - Day (1-31)
+ * @param hour - Hour as decimal (0.0-23.999...)
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns Julian day number
+ *
+ * @example
+ * const jd = julianDay(2007, 3, 3);
+ * console.log(jd); // 2454162.5
+ *
+ * const jdWithTime = julianDay(2007, 3, 3, 14.5);
+ * console.log(jdWithTime); // 2454163.104166667
+ */
+function julianDay(year, month, day, hour = 0, calendarType = core_1.CalendarType.Gregorian) {
+    return binding.julday(year, month, day, hour, calendarType);
+}
+/**
+ * Convert Julian day number to calendar date
+ *
+ * @param jd - Julian day number
+ * @param calendarType - Calendar system (default: Gregorian)
+ * @returns DateTime object with year, month, day, and hour
+ *
+ * @example
+ * const date = julianDayToDate(2454162.5);
+ * console.log(date);
+ * // { year: 2007, month: 3, day: 3, hour: 0, calendarType: CalendarType.Gregorian }
+ *
+ * console.log(date.toString());
+ * // "2007-03-03 0.000000 hours (Gregorian)"
+ */
+function julianDayToDate(jd, calendarType = core_1.CalendarType.Gregorian) {
+    const result = binding.revjul(jd, calendarType);
+    return new core_1.DateTimeImpl(result[0], result[1], result[2], result[3], calendarType);
+}
+/**
+ * Calculate planetary positions
+ *
+ * This is the main function for calculating positions of planets, asteroids,
+ * and other celestial bodies.
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @param body - Celestial body to calculate (use Planet, Asteroid, etc. enums)
+ * @param flags - Calculation flags (default: SwissEphemeris with speed)
+ * @returns PlanetaryPosition object with longitude, latitude, distance, and speeds
+ *
+ * @example
+ * // Calculate Sun position
+ * const sun = calculatePosition(jd, Planet.Sun);
+ * console.log(`Sun longitude: ${sun.longitude}°`);
+ *
+ * // Calculate with specific flags
+ * const moon = calculatePosition(
+ *   jd,
+ *   Planet.Moon,
+ *   CalculationFlag.MoshierEphemeris | CalculationFlag.Speed
+ * );
+ *
+ * // Using flag builder
+ * import { CalculationFlags } from 'swisseph';
+ * const flags = CalculationFlags.from(
+ *   CalculationFlag.SwissEphemeris,
+ *   CalculationFlag.Speed,
+ *   CalculationFlag.Equatorial
+ * );
+ * const mars = calculatePosition(jd, Planet.Mars, flags);
+ */
+function calculatePosition(julianDay, body, flags = core_1.CommonCalculationFlags.DefaultSwissEphemeris) {
+    const normalizedFlags = (0, core_1.normalizeFlags)(flags);
+    ensureEphemerisInitialized(normalizedFlags);
+    const result = binding.calc_ut(julianDay, body, normalizedFlags);
+    const [xx, retFlags] = result;
+    return {
+        longitude: xx[0],
+        latitude: xx[1],
+        distance: xx[2],
+        longitudeSpeed: xx[3],
+        latitudeSpeed: xx[4],
+        distanceSpeed: xx[5],
+        flags: retFlags,
+    };
+}
+/**
+ * Calculate house cusps and angles
+ *
+ * Houses divide the ecliptic into 12 sections based on the observer's
+ * location and the time of day.
+ *
+ * @param julianDay - Julian day number in Universal Time
+ * @param latitude - Geographic latitude (positive = north, negative = south)
+ * @param longitude - Geographic longitude (positive = east, negative = west)
+ * @param houseSystem - House system to use (default: Placidus)
+ * @returns HouseData object with cusps and angles
+ *
+ * @example
+ * // Calculate houses for New York
+ * const houses = calculateHouses(jd, 40.7128, -74.0060, HouseSystem.Placidus);
+ * console.log(`Ascendant: ${houses.ascendant}°`);
+ * console.log(`MC: ${houses.mc}°`);
+ *
+ * // Access house cusps
+ * for (let i = 1; i <= 12; i++) {
+ *   console.log(`House ${i}: ${houses.cusps[i]}°`);
+ * }
+ *
+ * // Try different house system
+ * const wholeSigns = calculateHouses(jd, 40.7128, -74.0060, HouseSystem.WholeSign);
+ */
+function calculateHouses(julianDay, latitude, longitude, houseSystem = core_1.HouseSystem.Placidus) {
+    const result = binding.houses(julianDay, latitude, longitude, houseSystem);
+    const [cusps, ascmc] = result;
+    return {
+        cusps,
+        ascendant: ascmc[core_1.HousePoint.Ascendant],
+        mc: ascmc[core_1.HousePoint.MC],
+        armc: ascmc[core_1.HousePoint.ARMC],
+        vertex: ascmc[core_1.HousePoint.Vertex],
+        equatorialAscendant: ascmc[core_1.HousePoint.EquatorialAscendant],
+        coAscendant1: ascmc[core_1.HousePoint.CoAscendant1],
+        coAscendant2: ascmc[core_1.HousePoint.CoAscendant2],
+        polarAscendant: ascmc[core_1.HousePoint.PolarAscendant],
+        houseSystem,
+    };
+}
+/**
+ * Find the next lunar eclipse
+ *
+ * Searches for the next lunar eclipse after the given Julian day.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param eclipseType - Filter by eclipse type (0 = all types)
+ * @param backward - Search backward in time if true
+ * @returns LunarEclipse object with times and convenience methods
+ *
+ * @example
+ * // Find next lunar eclipse
+ * const jd = julianDay(2025, 1, 1);
+ * const eclipse = findNextLunarEclipse(jd);
+ *
+ * console.log(`Eclipse maximum: ${julianDayToDate(eclipse.maximum)}`);
+ * console.log(`Is total: ${eclipse.isTotal()}`);
+ * console.log(`Totality duration: ${eclipse.getTotalityDuration()} hours`);
+ *
+ * // Find previous lunar eclipse
+ * const previousEclipse = findNextLunarEclipse(jd, undefined, 0, true);
+ */
+function findNextLunarEclipse(startJulianDay, flags = core_1.CalculationFlag.SwissEphemeris, eclipseType = 0, backward = false) {
+    const normalizedFlags = (0, core_1.normalizeFlags)(flags);
+    ensureEphemerisInitialized(normalizedFlags);
+    const normalizedEclipseType = (0, core_1.normalizeEclipseTypes)(eclipseType);
+    const result = binding.lun_eclipse_when(startJulianDay, normalizedFlags, normalizedEclipseType, backward ? 1 : 0);
+    const [retFlag, tret] = result;
+    return new core_1.LunarEclipseImpl(retFlag, tret[0], // maximum
+    tret[1], // partial begin
+    tret[2], // partial end
+    tret[3], // total begin
+    tret[4], // total end
+    tret[5], // penumbral begin
+    tret[6] // penumbral end
+    );
+}
+/**
+ * Find the next solar eclipse globally
+ *
+ * Searches for the next solar eclipse visible anywhere on Earth.
+ *
+ * @param startJulianDay - Julian day to start search from
+ * @param flags - Calculation flags (default: SwissEphemeris)
+ * @param eclipseType - Filter by eclipse type (0 = all types)
+ * @param backward - Search backward in time if true
+ * @returns SolarEclipse object with times and convenience methods
+ *
+ * @example
+ * // Find next solar eclipse
+ * const jd = julianDay(2025, 1, 1);
+ * const eclipse = findNextSolarEclipse(jd);
+ *
+ * console.log(`Eclipse maximum: ${julianDayToDate(eclipse.maximum)}`);
+ * console.log(`Is total: ${eclipse.isTotal()}`);
+ * console.log(`Is annular: ${eclipse.isAnnular()}`);
+ * console.log(`Is central: ${eclipse.isCentral()}`);
+ */
+function findNextSolarEclipse(startJulianDay, flags = core_1.CalculationFlag.SwissEphemeris, eclipseType = 0, backward = false) {
+    const normalizedFlags = (0, core_1.normalizeFlags)(flags);
+    ensureEphemerisInitialized(normalizedFlags);
+    const normalizedEclipseType = (0, core_1.normalizeEclipseTypes)(eclipseType);
+    const result = binding.sol_eclipse_when_glob(startJulianDay, normalizedFlags, normalizedEclipseType, backward ? 1 : 0);
+    const [retFlag, tret] = result;
+    return new core_1.SolarEclipseImpl(retFlag, tret[0], // maximum
+    tret[1], // partial begin
+    tret[2], // partial end
+    tret[3], // central begin
+    tret[4], // central end
+    tret[5], // center line begin
+    tret[6] // center line end
+    );
+}
+/**
+ * Get the name of a celestial body
+ *
+ * @param body - Celestial body identifier
+ * @returns Name of the body as a string
+ *
+ * @example
+ * const name = getCelestialBodyName(Planet.Mars);
+ * console.log(name); // "Mars"
+ *
+ * const sunName = getCelestialBodyName(Planet.Sun);
+ * console.log(sunName); // "Sun"
+ */
+function getCelestialBodyName(body) {
+    return binding.get_planet_name(body);
+}
+/**
+ * Close Swiss Ephemeris and free resources
+ *
+ * Call this function when you're done using Swiss Ephemeris to free
+ * allocated resources.
+ *
+ * @example
+ * // After all calculations are done
+ * close();
+ */
+function close() {
+    binding.close();
+}
+// Re-export all types for convenience
+__exportStar(require("@swisseph/core"), exports);