### Install Astronomia Library using npm

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This command installs the astronomia library as a project dependency using npm. It ensures that the library is available for use in your Node.js project.

```bash
npm install --save astronomia
```

--------------------------------

### Run tests locally in a browser with npm

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This command starts a local server to run the astronomia library tests within a browser environment. It's helpful for debugging and testing browser compatibility.

```bash
npm run zuul -- --local 3000
```

--------------------------------

### Import specific VSOP87 dataset using CommonJS

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This example shows how to import a specific VSOP87 dataset, such as 'vsop87Bvenus', from the astronomia library using CommonJS. This allows for targeted use of planetary ephemeris data.

```javascript
const {vsop87Bvenus} = require('astronomia').data
```

--------------------------------

### Import specific VSOP87 dataset using ES6

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This example demonstrates importing a specific VSOP87 dataset, like 'vsop87Bvenus', from the astronomia library using ES6 import syntax. This is efficient for including only necessary ephemeris data.

```javascript
const vsop87Bvenus = require('astronomia/data/vsop87Bvenus')
```

--------------------------------

### Run tests using npm

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This command executes the test suite for the astronomia library using npm. It's a standard way to verify the library's functionality and ensure code integrity.

```bash
npm test
```

--------------------------------

### Import 'base' module using CommonJS

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This code snippet demonstrates how to import the 'base' module from the astronomia library using the CommonJS module system. This is useful for Node.js environments.

```javascript
const base = require('astronomia').base
```

--------------------------------

### Import 'base' module using ES6

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This code snippet shows how to import the 'base' module from the astronomia library using ES6 import syntax. This is suitable for modern Javascript environments and bundlers.

```javascript
import base from 'astronomia/base'
```

--------------------------------

### Run long-lasting tests with SLOWTESTS=1

Source: https://github.com/commenthol/astronomia/blob/master/README.md

This command runs the extended test suite for the astronomia library, including tests that may take a longer time to complete. It's useful for thorough testing.

```bash
SLOWTESTS=1 npm test
```

--------------------------------

### Sunrise, Sunset, and Twilight Calculations in JavaScript

Source: https://context7.com/commenthol/astronomia/llms.txt

Calculates solar transit times, sunrise, sunset, and various twilight phases (civil, nautical, astronomical) for any Earth location. It accounts for polar day and night conditions at extreme latitudes. Requires date, latitude, and longitude as inputs.

```javascript
import { sunrise, julian } from 'astronomia'

// Calculate sunrise/sunset for Brussels on September 24, 1935
const date = new julian.Calendar(new Date('1935-09-24T00:00:00Z'))
const lat = 50.79770  // latitude in degrees (positive north)
const lon = -4.35916  // longitude in degrees (positive westward)

const sr = new sunrise.Sunrise(date, lat, lon)

// Get various sun times
const riseTime = sr.rise().toDate()
console.log('Sunrise:', riseTime.toISOString())
// '1935-09-24T05:30:10.710Z'

const setTime = sr.set().toDate()
console.log('Sunset:', setTime.toISOString())
// '1935-09-24T17:38:37.766Z'

const noonTime = sr.noon().toDate()
console.log('Solar noon:', noonTime.toISOString())
// '1935-09-24T11:34:53.328Z'

// Twilight phases
console.log('Dawn (civil):', sr.dawn().toDate().toISOString())
console.log('Dusk (civil):', sr.dusk().toDate().toISOString())
console.log('Nautical dawn:', sr.nauticalDawn().toDate().toISOString())
console.log('Nautical dusk:', sr.nauticalDusk().toDate().toISOString())
console.log('Astronomical night end:', sr.nightEnd().toDate().toISOString())
console.log('Astronomical night start:', sr.nightStart().toDate().toISOString())

// Golden hour (photography)
console.log('Golden hour start:', sr.goldenHourStart().toDate().toISOString())
console.log('Golden hour end:', sr.goldenHourEnd().toDate().toISOString())
```

--------------------------------

### Astronomical Base Constants and Utilities in JavaScript

Source: https://context7.com/commenthol/astronomia/llms.txt

Provides fundamental astronomical constants (e.g., AU, J2000 epoch) and utility functions for time conversions, illumination calculations, and mathematical operations. It depends on the 'astronomia' library and takes numerical inputs, returning constants or calculated values.

```javascript
import { base } from 'astronomia'

// Fundamental constants
console.log('Astronomical Unit:', base.AU, 'km')
console.log('J2000 epoch:', base.J2000) // Julian day of Jan 1.5, 2000
console.log('Julian year:', base.JulianYear, 'days')
console.log('Julian century:', base.JulianCentury, 'days')
console.log('Besselian year:', base.BesselianYear, 'days')

// Convert Julian year to Julian Ephemeris Day
const jde = base.JulianYearToJDE(2024.5) // mid-2024
console.log('Mid-2024 JDE:', jde)

// Convert JDE to Julian year
const jy = base.JDEToJulianYear(2451545) // J2000
console.log('J2000 as Julian year:', jy)

// Julian centuries since J2000
const T = base.J2000Century(2451545 + 36525) // one century after J2000
console.log('Centuries since J2000:', T)

// Illuminated fraction (for Moon or planets)
const phaseAngle = Math.PI / 3 // 60 degrees
const illumination = base.illuminated(phaseAngle)
console.log('Illuminated fraction:', (illumination * 100).toFixed(1), '%')

// Light travel time
const distanceAU = 1.0 // 1 AU
const lightTimeDays = base.lightTime(distanceAU)
console.log('Light time for 1 AU:', (lightTimeDays * 24 * 60).toFixed(2), 'minutes')

// Utility functions
console.log('Positive mod:', base.pmod(-30, 360)) // 330 (always positive)
console.log('Degrees to radians:', base.toRad(180)) // Math.PI
console.log('Radians to degrees:', base.toDeg(Math.PI)) // 180
console.log('sin and cos:', base.sincos(Math.PI / 4)) // [0.707..., 0.707...]

// Horner's method for polynomial evaluation
const coeffs = [1, 2, 3] // 1 + 2x + 3x²
const x = 2
console.log('Polynomial at x=2:', base.horner(x, ...coeffs)) // 1 + 4 + 12 = 17

// Separate integer and fractional parts
const [integer, fraction] = base.modf(3.75)
console.log('Integer:', integer, 'Fraction:', fraction) // 3, 0.75
```

--------------------------------

### Coordinate Transformations using 'astronomia'

Source: https://context7.com/commenthol/astronomia/llms.txt

Transforms celestial coordinates between ecliptic, equatorial, horizontal, and galactic systems using the 'coord', 'sexagesimal', 'globe', 'nutation', and 'base' modules. It demonstrates conversions involving Earth's axial tilt, observer location, sidereal time, and different equinoxes.

```javascript
import { coord, sexagesimal as sexa, globe, nutation, base } from 'astronomia'

// Define a position in ecliptic coordinates
const eclipticLon = 113.21563 * Math.PI / 180 // longitude in radians
const eclipticLat = 6.68417 * Math.PI / 180   // latitude in radians
const ecl = new coord.Ecliptic(eclipticLon, eclipticLat)

// Convert ecliptic to equatorial coordinates
const obliquity = 23.4393 * Math.PI / 180 // Earth's axial tilt
const equ = ecl.toEquatorial(obliquity)

// Display Right Ascension and Declination
const raHours = equ.ra * 12 / Math.PI // convert to hours
const decDeg = equ.dec * 180 / Math.PI // convert to degrees
console.log('Right Ascension:', raHours.toFixed(4), 'hours')
console.log('Declination:', decDeg.toFixed(4), 'degrees')

// Convert equatorial to horizontal coordinates
// (requires observer location and sidereal time)
const observer = new globe.Coord(
  51.5 * Math.PI / 180,  // latitude (London)
  0.1 * Math.PI / 180   // longitude (west positive)
)
const siderealTime = 12.5 // hours (example)
const horizontal = equ.toHorizontal(observer, siderealTime)

console.log('Azimuth:', (horizontal.az * 180 / Math.PI).toFixed(2), 'degrees')
console.log('Altitude:', (horizontal.alt * 180 / Math.PI).toFixed(2), 'degrees')

// Convert equatorial to galactic coordinates
// (must be in B1950 equinox for galactic conversion)
const equB1950 = new coord.Equatorial(
  new sexa.RA(10, 30, 0).rad(),   // RA = 10h 30m
  new sexa.Angle(false, 30, 0, 0).rad() // Dec = +30°
)
const galactic = equB1950.toGalactic()
console.log('Galactic lon:', (galactic.lon * 180 / Math.PI).toFixed(2), 'degrees')
console.log('Galactic lat:', (galactic.lat * 180 / Math.PI).toFixed(2), 'degrees')
```

--------------------------------

### Handle Sexagesimal Angles and Time (JavaScript)

Source: https://context7.com/commenthol/astronomia/llms.txt

Provides classes for representing and manipulating angles in degrees-minutes-seconds (DMS) and time in hours-minutes-seconds (HMS) format. It allows creating angle and time objects, converting them to radians or degrees/hours, and formatting them as strings. Utility functions for converting between degrees and DMS, and for unit conversions (degrees to radians, radians to degrees/arcseconds) are also included.

```javascript
import { sexagesimal as sexa } from 'astronomia'

// Create an angle from degrees, minutes, seconds
const angle = new sexa.Angle(false, 23, 26, 21.448) // +23° 26' 21.448"
console.log('Angle in radians:', angle.rad())
console.log('Angle in degrees:', angle.deg())
console.log('Angle string:', angle.toString(3)) // "23°26′21.448″"

// Negative angles (e.g., -0° 30' 0")
const negAngle = new sexa.Angle(true, 0, 30, 0) // negative flag = true
console.log('Negative angle:', negAngle.deg(), 'degrees')

// Right Ascension (RA)
const ra = new sexa.RA(14, 15, 39.67) // 14h 15m 39.67s
console.log('RA in radians:', ra.rad())
console.log('RA in hours:', ra.hour())
console.log('RA string:', ra.toString(2)) // "14ʰ15ᵐ39.67ˢ"

// Hour Angle
const ha = new sexa.HourAngle(false, 2, 30, 0) // 2h 30m 0s
console.log('Hour angle in radians:', ha.rad())

// Time
const time = new sexa.Time(false, 12, 30, 45.5) // 12h 30m 45.5s
console.log('Time in seconds:', time.sec())
console.log('Time in hours:', time.hour())
console.log('Time string:', time.toString(1)) // "12ʰ30ᵐ45.5ˢ"

// Convert degrees to DMS
const dms = sexa.degToDMS(45.5) // [neg, deg, min, sec]
console.log('45.5° =', dms) // [false, 45, 30, 0]

// Unit conversions
const radians = sexa.angleFromDeg(90)  // degrees to radians
const degrees = sexa.degFromAngle(Math.PI / 2) // radians to degrees
const arcsec = sexa.secFromAngle(Math.PI / 180 / 3600) // radians to arcseconds
console.log('90° =', radians, 'radians')
```

--------------------------------

### Calculate Equinoxes and Solstices (JavaScript)

Source: https://context7.com/commenthol/astronomia/llms.txt

Calculates the precise times of equinoxes and solstices for any given year. It offers both fast calculations (accurate to ~1 minute) and high-precision calculations (accurate to ~1 second) which require VSOP87 Earth data. The module also allows calculating the Julian Date when the Sun reaches a specific longitude.

```javascript
import { solstice, julian, planetposition, data } from 'astronomia'

// Fast calculation (accurate to ~1 minute for 1951-2050)
const year = 2024
const marchEquinox = solstice.march(year)
const juneSolstice = solstice.june(year)
const septemberEquinox = solstice.september(year)
const decemberSolstice = solstice.december(year)

console.log('2024 Equinoxes and Solstices:')
console.log('March equinox:', julian.JDEToDate(marchEquinox).toISOString())
console.log('June solstice:', julian.JDEToDate(juneSolstice).toISOString())
console.log('September equinox:', julian.JDEToDate(septemberEquinox).toISOString())
console.log('December solstice:', julian.JDEToDate(decemberSolstice).toISOString())

// High-precision calculation (accurate to ~1 second)
// Requires VSOP87 Earth data
const earth = new planetposition.Planet(data.vsop87Bearth)

const marchEquinox2 = solstice.march2(year, earth)
const juneSolstice2 = solstice.june2(year, earth)
const septemberEquinox2 = solstice.september2(year, earth)
const decemberSolstice2 = solstice.december2(year, earth)

console.log('\nHigh-precision calculation:')
console.log('March equinox:', julian.JDEToDate(marchEquinox2).toISOString())
console.log('June solstice:', julian.JDEToDate(juneSolstice2).toISOString())

// Calculate when Sun reaches a specific longitude
const lon90 = Math.PI / 2 // 90 degrees = June solstice
const jdeLon90 = solstice.longitude(year, earth, lon90)
console.log('Sun at 90° longitude:', julian.JDEToDate(jdeLon90).toISOString())
```

--------------------------------

### Julian Day and Calendar Conversions in JavaScript

Source: https://context7.com/commenthol/astronomia/llms.txt

Converts between calendar dates (Gregorian and Julian) and Julian Days (JD). It handles historical calendar transitions and provides utility functions for leap years and day of the week. This module is fundamental for all date/time calculations within the library.

```javascript
import { julian, base } from 'astronomia'

// Convert a Gregorian calendar date to Julian Day
const jd = julian.CalendarGregorianToJD(2000, 1, 1.5)
console.log(jd) // 2451545 (J2000 epoch)

// Convert Julian Day back to calendar date
const date = julian.JDToCalendarGregorian(2451545)
console.log(date) // { year: 2000, month: 1, day: 1.5 }

// Using the Calendar class for more convenience
const cal = new julian.CalendarGregorian(1957, 10, 4.81)
console.log(cal.toJD()) // 2436116.31 (Sputnik launch)
console.log(cal.toDate().toISOString()) // JavaScript Date object

// Convert between calendars
const gregorian = new julian.CalendarGregorian(1582, 10, 15)
const julianCal = gregorian.toJulian()
console.log(julianCal.getDate()) // { year: 1582, month: 10, day: 5 }

// Convert JavaScript Date to Julian Day and back
const jsDate = new Date('2000-01-01T12:00:00Z')
const jdFromDate = julian.DateToJD(jsDate)
console.log(jdFromDate) // 2451545 (base.J2000)

// Check for leap years
console.log(julian.LeapYearGregorian(2000)) // true
console.log(julian.LeapYearGregorian(1900)) // false (divisible by 100 but not 400)

// Day of week (0 = Sunday)
const dayOfWeek = julian.DayOfWeek(2434923.5)
console.log(dayOfWeek) // 3 (Wednesday)

// Convert decimal year to calendar date
const calFromYear = new julian.CalendarGregorian().fromYear(1977.12055)
console.log(calFromYear.getDate()) // { year: 1977, month: 2, day: 14 }
```

--------------------------------

### Calculate Moon Phases using 'astronomia'

Source: https://context7.com/commenthol/astronomia/llms.txt

Calculates Julian Ephemeris Day (JDE) for new moons, full moons, and quarter phases nearest to a specified date using the 'moonphase' and 'julian' modules. It also provides the mean synodic lunar month and demonstrates both accurate and mean calculations for moon phases.

```javascript
import { moonphase, julian } from 'astronomia'

// Find the new moon nearest to February 14, 1977
const decimalYear = new julian.CalendarGregorian(1977, 2, 14).toYear()
const newMoonJDE = moonphase.newMoon(decimalYear)

console.log('New Moon JDE:', newMoonJDE) // 2443192.65118
console.log('New Moon Date:', julian.JDEToDate(newMoonJDE).toISOString())
// '1977-02-18T03:36:54.534Z'

// Mean synodic lunar month (average time between new moons)
console.log('Mean lunar month:', moonphase.meanLunarMonth, 'days')
// 29.530588861 days

// Calculate all four phases
const year = 2024.5 // mid-2024
const newMoon = julian.JDEToDate(moonphase.newMoon(year))
const firstQuarter = julian.JDEToDate(moonphase.first(year))
const fullMoon = julian.JDEToDate(moonphase.full(year))
const lastQuarter = julian.JDEToDate(moonphase.last(year))

console.log('New Moon:', newMoon.toISOString())
console.log('First Quarter:', firstQuarter.toISOString())
console.log('Full Moon:', fullMoon.toISOString())
console.log('Last Quarter:', lastQuarter.toISOString())

// Mean calculations (less accurate but faster)
const meanNewJDE = moonphase.meanNew(2044.04) // near January 16, 2044
const meanLastJDE = moonphase.meanLast(2044.04)
console.log('Mean new moon:', julian.JDToDate(meanNewJDE).toISOString())
console.log('Mean last quarter:', julian.JDToDate(meanLastJDE).toISOString())
```

--------------------------------

### Calculate Planet Positions with VSOP87 Theory (JavaScript)

Source: https://context7.com/commenthol/astronomia/llms.txt

Computes precise heliocentric positions of planets using the VSOP87 theory. It requires importing modules for planet position, base calculations, Julian dates, and VSOP87 data. The output includes heliocentric longitude, latitude, and distance from the Sun, with options for J2000 or ecliptic of date, and conversion to the FK5 reference frame.

```javascript
import { planetposition, base, julian, data } from 'astronomia'

// Create planet objects using VSOP87 data
const earth = new planetposition.Planet(data.vsop87Bearth)
const mars = new planetposition.Planet(data.vsop87Bmars)
const venus = new planetposition.Planet(data.vsop87Bvenus)

// Calculate Earth's position at J2000
const jde = base.J2000
const earthPos = earth.position2000(jde)

console.log('Earth heliocentric longitude:', (earthPos.lon * 180 / Math.PI).toFixed(6), 'degrees')
console.log('Earth heliocentric latitude:', (earthPos.lat * 180 / Math.PI).toFixed(6), 'degrees')
console.log('Earth distance from Sun:', earthPos.range.toFixed(6), 'AU')

// Position at equinox and ecliptic of date (for Meeus's tables)
const marsPos = mars.position(jde)
console.log('Mars heliocentric longitude:', (marsPos.lon * 180 / Math.PI).toFixed(4), 'degrees')
console.log('Mars distance from Sun:', marsPos.range.toFixed(6), 'AU')

// Calculate position for a specific date
const date = new julian.CalendarGregorian(2024, 6, 21) // Summer solstice
const jdeDate = date.toJDE()
const venusPos = venus.position2000(jdeDate)
console.log('Venus position on summer solstice 2024:')
console.log('  Longitude:', (venusPos.lon * 180 / Math.PI).toFixed(4), 'degrees')
console.log('  Distance:', venusPos.range.toFixed(6), 'AU')

// Convert to FK5 reference frame
const fk5Pos = planetposition.toFK5(venusPos.lon, venusPos.lat, jdeDate)
console.log('Venus FK5 longitude:', (fk5Pos.lon * 180 / Math.PI).toFixed(4), 'degrees')
```

--------------------------------

### Calculate Moon Position using 'astronomia'

Source: https://context7.com/commenthol/astronomia/llms.txt

Calculates the geocentric position of the Moon, including longitude, latitude, and distance from Earth, using the 'moonposition', 'julian', and 'base' modules. It also demonstrates how to calculate horizontal parallax and lunar nodes (ascending and true) and perigee.

```javascript
import { moonposition, julian, base } from 'astronomia'

// Calculate Moon position for a given Julian Ephemeris Day
const jde = base.J2000 // January 1, 2000 at noon
const moonPos = moonposition.position(jde)

// Convert radians to degrees for display
const lonDeg = moonPos.lon * 180 / Math.PI
const latDeg = moonPos.lat * 180 / Math.PI
const distKm = moonPos.range

console.log('Moon longitude:', lonDeg.toFixed(4), 'degrees')
console.log('Moon latitude:', latDeg.toFixed(4), 'degrees')
console.log('Moon distance:', distKm.toFixed(0), 'km')

// Calculate parallax (apparent size from Earth's surface)
const parallaxRad = moonposition.parallax(distKm)
const parallaxArcMin = parallaxRad * 180 / Math.PI * 60
console.log('Horizontal parallax:', parallaxArcMin.toFixed(2), 'arc-minutes')

// Lunar nodes (where Moon's orbit crosses the ecliptic)
const ascendingNode = moonposition.node(jde) * 180 / Math.PI
console.log('Ascending node longitude:', ascendingNode.toFixed(4), 'degrees')

// True ascending node (instantaneous orbit)
const trueNodeLon = moonposition.trueNode(jde) * 180 / Math.PI
console.log('True ascending node:', trueNodeLon.toFixed(4), 'degrees')

// Lunar perigee (closest point to Earth)
const perigeeLon = moonposition.perigee(jde) * 180 / Math.PI
console.log('Perigee longitude:', perigeeLon.toFixed(4), 'degrees')
```

--------------------------------

### Earth and Globe Calculations in JavaScript

Source: https://context7.com/commenthol/astronomia/llms.txt

Calculates geodetic distances, angular distances, and parallax corrections using Earth's ellipsoid model. It requires the 'astronomia' library and takes coordinate objects (latitude and longitude in radians) as input, returning distances in kilometers and angles in radians or degrees.

```javascript
import { globe, sexagesimal as sexa } from 'astronomia'

// Define observer coordinates (latitude and longitude in radians)
// Note: longitude is positive westward
const london = new globe.Coord(
  51.5074 * Math.PI / 180,  // latitude
  0.1278 * Math.PI / 180   // longitude (west of Greenwich)
)

const newYork = new globe.Coord(
  40.7128 * Math.PI / 180,  // latitude
  74.006 * Math.PI / 180   // longitude (west of Greenwich)
)

// Calculate distance using Earth ellipsoid (IAU 1976)
const distance = globe.Earth76.distance(london, newYork)
console.log('Distance London-New York:', distance.toFixed(1), 'km')

// Approximate angular distance (returns cosine of angle)
const cosAngle = globe.approxAngularDistance(london, newYork)
const angularDist = Math.acos(cosAngle) // in radians
console.log('Angular distance:', (angularDist * 180 / Math.PI).toFixed(2), 'degrees')

// Approximate linear distance (treats Earth as sphere)
const linearDist = globe.approxLinearDistance(angularDist)
console.log('Approximate distance:', linearDist.toFixed(1), 'km')

// Radius of parallel at latitude
const radiusAtLat = globe.Earth76.radiusAtLatitude(london.lat)
console.log('Radius at London latitude:', radiusAtLat.toFixed(1), 'km')

// Length of 1 degree of longitude at latitude
const oneDegLon = globe.oneDegreeOfLongitude(radiusAtLat)
console.log('1° longitude at London:', oneDegLon.toFixed(2), 'km')

// Radius of curvature along meridian
const radiusCurv = globe.Earth76.radiusOfCurvature(london.lat)
const oneDegLat = globe.oneDegreeOfLatitude(radiusCurv)
console.log('1° latitude at London:', oneDegLat.toFixed(2), 'km')

// Parallax constants for topocentric calculations
const [rhoSinPhi, rhoCosPhi] = globe.Earth76.parallaxConstants(
  london.lat,
  100 // height in meters above ellipsoid
)
console.log('Parallax constants:', rhoSinPhi.toFixed(6), rhoCosPhi.toFixed(6))
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.