WARNING: This program is using N-API and therefore might not work, since
N-API is subject to being changed. This API is also subject to being
changed. Therefore, the major version number is set to zero. Also, many
functions are currently missing but will be added on later.

Swiss Ephemeris is license by GNU GPL version 2 or later version. It is
currently not included with this package and you must compile it yourself.

Some functions take option arguments. These are objects, or undefined or
omitted if the default values are used. The list of possible options
which are keys for the object, are specified. If & is specified, this
means it is a "default option"; the option can be the value of this
option instead of an object, if only that option is to be set.

Also, most functions that require a date can use either a JavaScript Date
object or a Julian day number.


***** .ayanamsha(option,[date])

Computes and returns the ayanamsha (in degrees, normalized in range from 0
to 360) for the specified sidereal mode and date. "Ayanamsha" is the
Sanskrit word for the precession of equinoxes, and is the angle by which
the ecliptic longitude with the specified sidereal mode is less than the
ecliptic longitude with the equinox of date.

The valid options include:

 .ephemeris
   Specify which ephemeris to use.

 .ephemerisTime
   Set true to use ephemeris time instead of universal time.

 .sidereal &
   The sidereal mode to use. The return value will always be zero if this
   option is not specified, since the difference between the equinox of
   date and the equinox of date is always zero.


***** .calc(what,[option],[when])

Calculates the position (and optionally speed) of an object, specified as
a number (from .planet) or a string (a fixed star name; see .name() for
details about fixed star names).

The third argument is the date for which coordinates are wanted.

Valid options includes:

 .aberration
   Set true (the default) to use aberration. For astrometric positions,
   set this to false.

 .apparent
   Set true (default) to use apparent positions, or false for true
   positions instead.

 .barycentricNodes
   Only valid if .node is also set. Set true to use barycentric positions
   and speed for planets beyond Jupiter, for purpose of calculating the
   nodes and apsides.

 .ephemeris
   Specify which ephemeris to use.

 .ephemerisTime
   Set true to use ephemeris time instead of universal time.

 .equatorial
   Set true for equatorial coordinates, or false (default) for ecliptic.

 .geoalt
   Altitude above sea level (in metres); only used if .geolon and .geolat
   are also set. Default value is zero.

 .geolat
   Set to geographic latitude (in degrees) if you want topocentric
   coordinates (only valid if origin is set to Earth).

 .geolon
   Set to geographic longitude (in degrees) if you want topocentric
   coordinates (you must set .geolat option too). Positive numbers are
   used for east of prime meridian, and negative numbers for west.

 .gravitation
   Set true (the default) to use gravitational deflection. For astrometric
   positions, set this to false.

 .icrs
   Set true to use International Celestial Reference System.

 .jplHorizons
   Set true if you want JPL Horizons positions. You will need the data
   files to compute positions properly, otherwise it tries to approximate.

 .meanNodes
   Only valid if .node is also set. Set true to calculate mean nodes and
   apsides instead of osculating when possible.

 .node
   Set to calculate a node or apside instead of position. Not valid with
   fixed stars. This can be "A" for the ascending node, "D" for the
   descending node, "p" for perihelion, "a" for aphelion, or "f" for the
   second focal point of the orbital ellipse.

 .nutation
   Set true (the default) to use the true equinox of date; if false, the
   mean equinox of date is used instead.

 .origin
   Origin of measurement. Can be .planet.Earth (the default), .planet.Sun,
   or .planet.barycenter (not supported in some cases). (Future versions
   of this software may permit other origins.)

 .radians
   Set true if you want results in radians instead of degrees.

 .sidereal
   The sidereal mode to use, specifying where the zero point is. Can be
   false (the default) for equinox of date, true for J2000, or an object
   returned by the .sidereal() function.

 .speed
   Set true (the default) to calculate speed. Speed is not calculated for
   fixed stars; in this case it is false by default.

 .xyz
   Set true for rectangular instead of polar coordinates.

Return value is an object with the following properties:

 .ephemeris
   Specifies which ephemeris is in use. This may be different than the one
   passed in if it is unable to use the passed in one (such as if the
   files do not exist in the path); in this case you may call .warning()
   to retrieve an error message relating to it.

There are additional properties giving the coordinates, which depend on
whether it is ecliptic, equatorial, or rectangular.

For ecliptic coordinates, these are .lon (ecliptic longitude), .lat
(ecliptic latitude), and .dist (distance in AU).

For equatorial coordinates, these are .ra (right ascension), .dec
(declination), and .dist (distance in AU). Right ascension is returned in
degrees (or radians), and not in hours.

For rectangular coordinates, these are .x, .y, and .z, all in AU.

If speed is computed, there are additional properties with the same names
but with "d" at front; these are per day.

Distance for fixed stars is always 1 or close to 1, rather than the true
distance to the star (which is much farther away). (This may change in
future versions though.)


***** .cotrans(coordinate,obliquity)

Converts between ecliptic and equatorial coordinates. The second argument
is the obliquity of the ecliptic, in degrees. This should be negative to
convert ecliptic to equatorial, or positive for other way around.

The first argument is an object with two properties "lon" and "lat", with
the values in degrees. The return value is this same object, with the
values altered.


***** .deltaT([time],[ephemeris],[tidal])

The arguments are time (a Julian day number (in universal time) or a
JavaScript Date object), ephemeris selection, and tidal acceleration.
The tidal acceleration is given in arcseconds per square century, and
if not specified a default value will be used.

The result is a number given in days (not in seconds).


***** .ecliptic([date],[ephemerisTime])

Returns parameters for obliquity of the ecliptic and for nutation. The
output is an object with properties:
 .trueOb = True obliquity of the ecliptic (including nutation)
 .meanOb = Mean obliquity of the ecliptic
 .nutLon = Nutation in longitude
 .nutOb = Nutation in obliquity

Normally the calculation is using universal time. To use ephemeris time
instead, the second argument must be true.


***** .ephemeris

An object with constants to specify the ephemerides in use:
 .default = Use the default setting.
 .JPL = Use JPL ephemeris.
 .Moshier = Use Moshier ephemeris.
 .Swiss = Use Swiss ephemeris.

JPL ephemeris is the most accurate, but requires larger files. Moshier
does not require external files, but is the least precise.


***** .format(angle,option)

Format a number which is an angle, given in degrees. It is automatically
normalized to the proper range.

The valid options include:

 .d1
   First delimiter string, which is a space by default.

 .d2
   Second delimiter string. If omitted, the second delimiter and parts
   after it are omitted in the output (except for bearings).

 .d3
   Third delimiter string. If omitted, the third delimiter and parts after
   it are omitted in the output.

 .offset
   A number from 0 to 69 giving the degree offset, which is zero by
   default. You can change it to 1 to use the older one-based degree
   numbering that was sometimes used in astrology. Only the number
   displayed is affected by this, and not the calculation. Modes that
   treat the input as a signed number ignore this parameter.

 .padding
   Padding mode; a number from 0 to 3.

   0 = No padding (default)
   1 = Pad with spaces
   2 = Pad with spaces at beginning, zeroes in other places
   3 = Pad with zeroes

   Things other than numbers are padded only with spaces (if padding is
   enabled at all), and not with zeroes.

 .precision
   A number giving the number of decimal places for the last component; if
   zero, the dot is also omitted. The default setting is zero.

   In the case of type "c", this specifies how much the compass is
   divided, where 0 means four points, 1 means eight points, 2 means
   sixteen points, and 3 means thirty-two points. In the case of 32
   points, the d3 parameter sets the abbreviation for "by" (default "b").

 .type
   The type of formatting to use; a string with a single character (or the
   ASCII code of that character). The default is "s", although this may be
   changed in future so should not be relied on.

   "2" = Degrees and two-letter sign. [deg d1 sign d2 arcmin d3 arcsec]
   "3" = Degrees and three-letter sign. [deg d1 sign d2 arcmin d3 arcsec]
   "A" = Signed degrees (-999 to +999). [-/+ deg d2 arcmin d3 arcsec]
   "B" = Octant bearing. [dir d1 deg d2 dir]
   "D" = Degrees of latitude. [-/+ deg d2 arcmin d3 arcsec]
   "G" = Geographic latitude. [deg d1 dir d2 arcmin d3 arcsec]
   "S" = Sign only. [sign]
   "b" = Quadrant bearing. [dir d1 deg d2 dir]
   "c" = Compass direction. [dir]
   "d" = Degrees. [deg d2 arcmin d3 arcsec]
   "g" = Geographic longitude. [deg d1 dir d2 arcmin d3 arcsec]
   "h" = Sidereal hours. [hour d2 min d3 sec]
   "s" = Degrees and sign. [deg d1 sign d2 arcmin d3 arcsec]

Note: Astrological signs are not the same as constellations, even though
the names are similar. These signs are actually the unit of angular
measurement, used for measuring ecliptic longitude. (The abbreviations are
also different than those of the constellations.)

Note also that if you want a suffix (such as for arcseconds) you must add
that suffix on afterward by yourself.


***** .fromJulian(jd,[ephemerisTime])

Converts a Julian day number into a JavaScript Date object. The second
argument specifies whether to use ephemeris time (true) or universal time
(false or omitted).


***** .horizon(option)

Converts equatorial coordinates into horizontal coordinates.

Input:

 .dec
   The declination of the object, in degrees.

 .geolat
   The geographic latitude of the observer, in degrees.

 .hour
   The hour angle of the object, in degrees. This is equal to local
   sidereal time minus right ascension.

Output:

 .altitude
   The altitude in degrees, from -90 to +90.

 .azimuth
   Azimuth in degrees, from 0 to 360, where 0 is north and 90 is east.
   This value will be NaN if the object is directly overhead.

 .zenith
   The zenith angle in degrees.

Use .refract() to apply refraction to the returned altitude.


***** .house(option,[when])

Computes astrological houses. You must give either .geolon, or give .eps
and .time. If you do not give .geolon then the second argument isn't used.

Input:

 .eps
   Obliquity of the ecliptic.

 .geolat
   Geographic latitude to compute house positions for.

 .geolon
   Geographic longitude to compute house positions for.

 .method
   The house system to use. Can be one of:

   "A" = Equally spaced houses; house 1 is ascendant
   "B" = Alcabitus
   "C" = Campanus
   "D" = Equally spaced houses; house 10 is midheaven
   "E" = Same as "A"
   "F" = Carter / Poli-Equatorial
   "G" = Gauquelin sectors (has 36 houses, unlike other systems)
   "H" = Horizontal / Azimuthal
   "I" = Sunshine (Treindl)
   "i" = Sunshine (Makransky)
   "K" = Koch/GOH
   "L" = Pullen sinusoidal delta / Neo-Porphyry
   "M" = Morinus
   "N" = Null; houses are equally spaced beginning at zero
   "O" = Porphyrius
   "P" = Placidus
   "Q" = Pullen sinusoidal ratio
   "R" = Regiomontanus
   "S" = Sripati
   "T" = Polich/Page (sometimes called "topocentric")
   "U" = Krusinsky-Pisa-Goelzer
   "V" = Vehlow equal
   "W" = Whole; like "A" but rounded down to a multiple of 30 degrees
   "X" = Axial rotation / Meridian system / Zariel
   "Y" = APC

 .method2
   May be specified instead of .method for an alternative set of house
   systems (experimental). Can be one of:

   "L" = Latitude
   "N" = Hemisphere-Null; first house is vernal equinox
   "S" = Solar
   "V" = Vertical

   The following are not currently implemented:

   "A" = AM Sidereal Hours
   "C" = Clockwise
   "c" = Calendar
   "D" = Draconic (based on nodes)
   "G" = Great
   "g" = Natural graduation
   "h" = Natural hours
   "P" = Photographic
   "v" = Vehlow-RA

 .sidereal
   Specify sidereal mode to use.

 .time
   Local sidereal time (in degrees).

Output:

 [1]
   If a house system is specified, elements 1 to 12 (or 1 to 36 for method
   "G") contain the ecliptic longitude of that house, in degrees.

 .armc
   Right ascension of midheaven

 .asc
   Ascendant

 .coasc1
   Co-Ascendant (Koch)

 .coasc2
   Co-Ascendant (Munkasey)

 .equasc
   Equatorial Ascendant

 .mc
   Midheaven

 .polasc
   Polar Ascendant

 .vertex
   Vertex (the point of the ecliptic that is precisely to the west)


***** .jplFile(filename)

Set which JPL ephemeris file to use. The filename can be a string, buffer,
or a number; if a number it is just the DE number of the ephemeris to use.
It has no function unless the calculation functions specify that you are
using .ephemeris.JPL as the current ephemeris.


***** .julian([date],[ephemerisTime])

Converts a given JavaScript Date object into a Julian day number (if it is
already a number, just returns that number). Returns the current date/time
as a Julian day number if not specified.

Normally the result is using universal time. To use ephemeris time
instead, the second argument must be true.


***** .list(what)

Make a list of valid values for certain enumerations used in this API,
returning an object where the keys are ASCII strings describing them. Use
Object.keys() to retrieve the list (in an arbitrary order; you may wish to
sort the list afterward).

Choose from:
  "H" = House systems
  "h" = Alternate house systems
  "P" = Planets (including Sun, Moon, etc)
  "p" = Map projections


***** .listSidereal()

Returns an array of valid strings to pass to .sidereal().


***** .magnitude(star)

Returns the apparent magnitude of a (not necessarily fixed) star. The
input has the same format as with the .name() function.

Only stars can be used with this function; not planets.


***** .magnitudeSum(array)

Given an array of apparent magnitudes, returns the combined apparent
magnitude of them.


***** .model(model)

Set models to use and receive a report about it. This feature is meant
only for testing and there is no guarantee of its working.

The format of the argument given is deliberately undocumented.


***** .name(what)

Returns the name (as a string) of a celestial object, which can be
specified as a number or as a string.

If a number, it is something from the .planet list (which is not limited
to planets, however).

If a string, it is a fixed star, and the result will include a comma, with
the traditional name before the comma and the nomenclature name after the
comma. ("Fixed star" means stars other than our Sun. Use .planet.Sun if
you want to refer to our Sun. Also, "fixed stars" are not actually fixed.)

For a fixed star, the input can be one of five formats:

- A string representing a number. In this case, it is a line number in
sefstars.txt, not counting comment lines.

- A prefix of the traditional name. The first star listed in the file
that has that prefix (possibly as the entire name) is used.

- A comma followed by the nomenclature name.

- The full traditional name followed by a comma.

- The full traditional name followed by a comma and then the nomenclature
name. The return value has the same format as this.


***** .occult(what,[option],[start],[end])

Calculate when and where the moon blocks the view of another object. Give
the start and end dates for the search; if only one date is given, does a
search forever in the future (or past); if no dates are given, calculates
the next (or previous) occultation from now.

If the first argument is .planet.Sun then it can find solar eclipses.

Options:

 .ephemeris
   Specify what ephemeris to use.

 .geoalt
   Altitude above sea level, in metres. Default is sea level.

 .geolat
   Geographic latitude. If omitted, use a global calculation.

 .geolon
   Geographic longitude. If omitted, use a global calculation.

 .increment &
   Increment (in days) for searching within a given time frame. The
   default is 2 days (or -2 if the end date is earlier than the start
   date). Specify a negative number for a backward search.

The result is the JavaScript "undefined" value if none was found,
otherwise it is an object with the following properties:

  .magnitude
    Fraction of solar diameter covered by moon (magnitude).

  .max
    Time of maximum eclipse.

  .obscuration
    Fraction of solar disc covered by moon (obscuration).

  .ratio
    Ratio of lunar diameter to solar one.

  .shadow
    Diameter of core shadow in km. (Seems to be negative for some reason.)

If a geographic location is specified, also has properties numbered 1 to 4
for the times of the first, second, third, and fourth contact.

If a geographic location is not specified, also has:

  .begin
    Begin time

  .beginCenter
    Center line begin time

  .beginTotal
    Begin time of totality

  .end
    End time

  .endCenter
    Center line end time

  .endTotal
    End time of totality

  .time
    Time, when eclipse takes place at local apparent noon.

Use .fromJulian() to convert time results into Date objects.


***** .path(path)

Set a pathname for the ephemeris files, and for some extra files such as
leap seconds, fictitious planets, fixed stars, etc. The format is the same
as the format of the PATH environment variable, and can be either a string
or a buffer. The path name is limited to 256 bytes.

If the environment variable called SE_EPHE_PATH is set, then this function
is ignored, and that environment variable is used instead. Your program
should not tamper with this environment variable without the user's
permission (the user may have a use to set their own ephemeris path).

The default setting is \SWEPH\EPHE (relative to the current drive) on
Windows (and presumably ReactOS), and is /users/ephe on UNIX.

Unlike with the C library, this JavaScript version does not need calling
this function for initialization; it will do so automatically.


***** .phase([option],[when])

Returns the phase angle of of the specified object (Moon by default), from
0 (fully illuminated) to 180 (dark), or from -180 to +180 in signed mode.

The options can be:

 .ephemeris
   Specify which ephemeris to use.

 .ephemerisTime
   Set true to use ephemeris time instead of universal time.

 .geoalt
   Altitude above sea level, in metres. If specified, .geolat and .geolon
   must also be specified. Default is zero (sea level).

 .geolat
   Geographic latitude in degrees. If omitted, use geocentric calculation.

 .geolon
   Geographic longitude in degrees. If omitted, it is geocentric.

 .object
   The object to calculate the phase angle of (relative to the Earth and
   Sun). The default is the Moon. Any number from .planet is allowed
   (although some aren't useful, such as lunar nodes).

 .radians
   If true, return radians instead of degrees.

 .signed
   If true, use signed mode; false (default) is unsigned mode. (I am
   unsure that the signed mode is actually work properly, currently.)


***** .phenomena(which,[option],[when])

Calculates planetary phenomena (phase angle, phase of illumination,
elongation, apparent diameter of disc, and apparent magnitude) of the
specified object; fixed stars are not allowed.

Options can be:

 .apparent
    Set true (default) for apparent positions (taking light time into
    account); set false for true positions (disregarding light time).

 .ephemeris &
    Specify which ephemeris to use.

 .ephemerisTime
    Set true for ephemeris time instead of universal time.

Return value is an object with properties:

 .diameter
    Apparent diameter of disc.

 .elongation
    Elongation.

 .magnitude
    Apparent magnitude.

 .phase
    Phase (fraction of illumination).

 .phaseAngle
    Phase angle.


***** .planet

An object with constants to specify which planet or other object you want.

This includes the solar system planets, including Pluto (now considered a
dwarf planet), as well as Sun and Moon even though they are not planets.
There is also TrueNode and MeanNode for the ascending lunar node (angular
points where the orbit of the Moon crosses the ecliptic; there are two
such points, and the descending node is 180 degrees away; TrueNode is the
osculating node element), even though that is not a physical object.

The planet name should be capitalized.

You can use .planet.fiction and add a zero-based index number from the
seorbel.txt file to calculate positions for a planet that does not
actually exist (you will not find them with a telescope). (See the
comments in seorbel.txt for the documentation of its format.)

You can use .planet.asteroid plus a minor planet catalogue number to
represent a "minor planet" (not necessarily an asteroid; dwarf planets
are also included). You can use .planet.asteroid+134340 for Pluto,
although this is a different number than .planet.Pluto, the same
positions will be calculated.

There is also .planet.barycenter which represents the solar system
barycenter, and is allowed only as a center of measurement (not as an
object), for barycentric calculations, which won't always work.


***** .projection(option)

Compute a map projection. Input options are:

 .accuracy
   Number of iterations of Newton's method, if applicable. Default is 5.

 .geoalt
   Altitude above sea level in metres (currently unused). Default is zero.

 .geolat
   Latitude in degrees, from -90 (south) to 90 (north).

 .geolon
   Longitude in degrees, from -180 (west) to 180 (east). You can subtract
   the number of the wanted prime meridian if you do not want the official
   prime meridian to be in use.

 .method
   The type of projection to use. Can be one of:

   "0" = Horoscope (maps longitude to a circle and ignores latitude)
   "2" = Eckert II
   "3" = Winkel tripel
   "4" = Eckert IV
   "6" = Eckert VI
   "7" = Kavrayskiy VII
   "A" = Aitoff
   "C" = Cassini
   "E" = Equirectangular (default)
   "G" = Gall-Peters
   "H" = Hammer
   "L" = Lambert cylindrical equal area
   "M" = Mercator (y output may be out of range -1 to +1)
   "P" = Polyconic
   "S" = Sinusoidal
   "V" = Van der Grinten
   "W" = Werner
   "Z" = Polar azimuthal equidistant
   "m" = Mollweide
   "z" = Equatorial azimuthal equidistant

   The following are not currently implemented (some require extra
   parameters, which is part of the reason why it isn't implemented; if
   they will be implemented, such parameter must be added; also, some
   are only for a part of the world):

   "1" = Gnomonic
   "8" = Cahill-Keyes octahedral
   "9" = Front face of globe
   "F" = Flat-polar quartic
   "N" = Natural Earth
   "O" = Ortelius oval
   "Q" = Craig retroazimuthal
   "R" = Robinson
   "T" = Tobler hyperelliptical
   "a" = Armadillo
   "b" = Waterman butterfly
   "c" = Lambert conformal conic
   "d" = Dymaxion
   "g" = Goode homolosine (interrupted)
   "h" = HEALPix
   "j" = Authagraph
   "k" = Gauss-Kruger
   "l" = Albers
   "o" = Hobo-Dyer
   "q" = Peirce quincunxial
   "u" = Guyou hemisphere-in-a-square

Output is an object with properties named x and y; y is positive upward,
and the result should be treated with a 1:1 aspect ratio (if the map has a
different aspect ratio, then y will have a shorter range than -1 to +1).
The x coordinate is normalized to be in range from -1 to +1. The z
coordinate is currently unused and is always zero.


***** .refract(altitude,[option])

Convert true to apparent altitude (both in degrees), by refraction.

Valid options are:

 .geoalt
    Geographic altitude (metres above sea level). The default setting is
    to compute refraction at sea level.

 .lapseRate
    Lapse rate in kelvins per metre. The default is 0.0065.

 .pressure
    Atmospheric pressure in millibars (or hectopascals).

 .temperature
    Atmospheric temperature in Celsius.


***** .release()

Try to release any memory and open file handles used by Swiss Ephemeris.
The effect is not visible; it will continue to work regardless. The path
settings will still be set and will not be reset.


***** .rise([option],[when])

Tell you when is sunrise/sunset; result is a Julian day number (you can
then use .fromJulian() to convert into a Date object). Searches after the
time specified by the second argument (by default, the current time).

Valid options are:

 .apparent
   Set true (default) for apparent positions; false for true positions.

 .disc
   Tell which part of the disc to use. Set 0 (default) for centre of disc,
   -1 for bottom of disc, and +1 for top of disc. Other numbers should not
   be used because their meaning may change in future versions.

 .ephemeris
   Specify which ephemeris to use.

 .fixed
   Set true to use a fixed disc size (for Sun and Moon); otherwise will
   try to calculate disc size.

 .geoalt
   Altitude above sea level in metres (default is sea level).

 .geolat
   Geographic latitude, in degrees. The default is the Royal Observatory.

 .geolon
   Geographic longitude, in degrees. The default is zero.

 .horizon
   The degrees of the horizon. Specify -6 for civil twilight (used for
   aviation, automobile headlights, and various other laws), -12 for
   nautical twilight (for sailors navigation and military), and -18 for
   astronomical twilight (for observing the stars).

 .nutation
   Set true (the default) to consider nutation.

 .object
   What object to compute rising/setting times for; by default, the Sun.

 .pressure
   Specify atmospheric pressure in millibars; only used if the temperature
   is also set. If omitted but the temperature is included, attempt to
   estimate it.

 .set
   False (the default) to compute rising times, or true for setting.

 .temperature
   Specify atmospheric temperature in Celsius. If omitted, don't include
   refraction in the calculation.


***** .sidereal([date_or_string],[option])

Define a sidereal mode. Sidereal modes are used to determine where the
zero point of ecliptic longitude is used; when doing calculations without
sidereal modes, the equinox of date is used.

There are two possibilities:

One is to give a date and (optionally) option. The date is the date when
the ecliptic longitude of the vernal equinox is zero, if no option is
specified; you can also omit the date to define a sidereal mode for the
ecliptic longitude of the vernal equinox to be zero at the time of
definition.

Second possibility is to use a string value, such as "Fagan/Bradley" or
"J2000" or "B1950". (See Swiss Ephemeris for a list of valid strings.) In
this case, no options are allowed.

Valid options (for the first case only) include:

 .ayanamsha &
   The ecliptic longitude (in degrees) of the vernal equinox at the
   specified date. By default, it is zero.

 .ecliptic
   Set true to use projection onto the ecliptic of the specified date.

 .ephemerisTime
   Set true to use ephemeris time instead of universal time.

 .solarSystemRotationPlane
   Set true to use projection onto the solar system rotation plane.

Returns an object. This object should not be tampered with, and later
versions may change the structure of this object. Nevertheless, if any
function requires a sidereal mode as an option, and the sidereal mode is
the default option, you can still specify it instead of the object with
the set of options if it is the only option to set.

Wherever a sidereal mode is expected, instead of an object returned by
this function, you may also specify true to use J2000, false or undefined
or omitted to use the equinox of date, or a number to use that Julian day
number (in universal time).


***** .time([when])

Computes sidereal time for longitude zero in degrees. Date must be given
in universal time.

Use this together with right ascension to compute hour angle. Local
sidereal time is Greenwich sidereal time plus the geographic longitude.
Hour angle is local sidereal time minus right ascension (using equinox
of date).


***** .unrefract(altitude,[option])

Convert apparent to true altitude (both in degrees), by refraction.

Valid options are same as .refract() function.


***** .version

The version number of Swiss Ephemeris, for example "2.06".

(This is not the same as the version of this program.)


***** (Other features not yet implemented)

Stuff that probably should be implemented in future:

- Terminator lines

- Origins of measurement other than Earth and Sun

- Moons for other planets

- Topocentric position of Earth

- Conversion between geocentric and geographic coordinates

- Search for configurations (including positions, aspects, station, solar
returns, and various others)

- Lunar eclipses

- Artificial satellites

- Galactic and supergalactic coordinates

- Constellations

- House positions in "3D" (using two coordinates, so actually 2D)

Stuff that will not be implemented in this API but in the author's opinion
may be implemented in a program using this:

- Arabic parts

- Calendar generation

- Esoteric rays

- Planetary rulerships

- Various graphics

- Macros

- World map/globe

Stuff that will not be implemented, and that in the author's opinion will
not be put into a program using this (that this author writes, anyways):

- Biorhythms

- Interpretations (which is pretty much junk anyways)