panchang-ts 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3465 @@
+'use strict';
+
+// src/types/errors.ts
+var PanchangError = class _PanchangError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "PanchangError";
+    this.code = code;
+    Object.setPrototypeOf(this, _PanchangError.prototype);
+  }
+};
+
+// src/utils/validation.ts
+function validateLocation(location) {
+  if (typeof location.latitude !== "number" || location.latitude < -90 || location.latitude > 90) {
+    throw new PanchangError(
+      `Latitude must be a number between -90 and 90, got ${location.latitude}`,
+      "INVALID_LATITUDE"
+    );
+  }
+  if (typeof location.longitude !== "number" || location.longitude < -180 || location.longitude > 180) {
+    throw new PanchangError(
+      `Longitude must be a number between -180 and 180, got ${location.longitude}`,
+      "INVALID_LONGITUDE"
+    );
+  }
+  if (location.elevation !== void 0 && (typeof location.elevation !== "number" || location.elevation < -500)) {
+    throw new PanchangError(
+      `Elevation must be >= -500 meters, got ${location.elevation}`,
+      "INVALID_ELEVATION"
+    );
+  }
+}
+function validateDate(date) {
+  if (!(date instanceof Date) || isNaN(date.getTime())) {
+    throw new PanchangError(`Invalid Date: ${String(date)}`, "INVALID_DATE");
+  }
+  const year = date.getFullYear();
+  if (year < 1900 || year > 2100) {
+    throw new PanchangError(
+      `Date must be between 1900 and 2100 for astronomical accuracy, got year ${year}`,
+      "INVALID_DATE"
+    );
+  }
+}
+
+// node_modules/astronomy-engine/esm/astronomy.js
+var C_AUDAY = 173.1446326846693;
+var KM_PER_AU = 14959787069098932e-8;
+var DEG2RAD = 0.017453292519943295;
+var HOUR2RAD = 0.26179938779914946;
+var RAD2DEG = 57.29577951308232;
+var RAD2HOUR = 3.819718634205488;
+var DAYS_PER_TROPICAL_YEAR = 365.24217;
+var J2000 = /* @__PURE__ */ new Date("2000-01-01T12:00:00Z");
+var PI2 = 2 * Math.PI;
+var ARC = 3600 * (180 / Math.PI);
+var ASEC2RAD = 484813681109536e-20;
+var ASEC180 = 180 * 60 * 60;
+var ASEC360 = 2 * ASEC180;
+var ANGVEL = 7292115e-11;
+var SECONDS_PER_DAY = 24 * 3600;
+var SOLAR_DAYS_PER_SIDEREAL_DAY = 0.9972695717592592;
+var SUN_RADIUS_KM = 695700;
+var SUN_RADIUS_AU = SUN_RADIUS_KM / KM_PER_AU;
+var EARTH_FLATTENING = 0.996647180302104;
+var EARTH_FLATTENING_SQUARED = EARTH_FLATTENING * EARTH_FLATTENING;
+var EARTH_EQUATORIAL_RADIUS_KM = 6378.1366;
+var EARTH_EQUATORIAL_RADIUS_AU = EARTH_EQUATORIAL_RADIUS_KM / KM_PER_AU;
+var MOON_EQUATORIAL_RADIUS_KM = 1738.1;
+var MOON_EQUATORIAL_RADIUS_AU = MOON_EQUATORIAL_RADIUS_KM / KM_PER_AU;
+var REFRACTION_NEAR_HORIZON = 34 / 60;
+var EARTH_MOON_MASS_RATIO = 81.30056;
+var SUN_GM = 2959122082855911e-19;
+var JUPITER_GM = 2825345909524226e-22;
+var SATURN_GM = 8459715185680659e-23;
+var URANUS_GM = 1292024916781969e-23;
+var NEPTUNE_GM = 1524358900784276e-23;
+function VerifyNumber(x) {
+  if (!Number.isFinite(x)) {
+    console.trace();
+    throw `Value is not a finite number: ${x}`;
+  }
+  return x;
+}
+function Frac(x) {
+  return x - Math.floor(x);
+}
+var Body;
+(function(Body2) {
+  Body2["Sun"] = "Sun";
+  Body2["Moon"] = "Moon";
+  Body2["Mercury"] = "Mercury";
+  Body2["Venus"] = "Venus";
+  Body2["Earth"] = "Earth";
+  Body2["Mars"] = "Mars";
+  Body2["Jupiter"] = "Jupiter";
+  Body2["Saturn"] = "Saturn";
+  Body2["Uranus"] = "Uranus";
+  Body2["Neptune"] = "Neptune";
+  Body2["Pluto"] = "Pluto";
+  Body2["SSB"] = "SSB";
+  Body2["EMB"] = "EMB";
+  Body2["Star1"] = "Star1";
+  Body2["Star2"] = "Star2";
+  Body2["Star3"] = "Star3";
+  Body2["Star4"] = "Star4";
+  Body2["Star5"] = "Star5";
+  Body2["Star6"] = "Star6";
+  Body2["Star7"] = "Star7";
+  Body2["Star8"] = "Star8";
+})(Body || (Body = {}));
+var StarList = [
+  Body.Star1,
+  Body.Star2,
+  Body.Star3,
+  Body.Star4,
+  Body.Star5,
+  Body.Star6,
+  Body.Star7,
+  Body.Star8
+];
+var StarTable = [
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 },
+  { ra: 0, dec: 0, dist: 0 }
+];
+function GetStar(body) {
+  const index = StarList.indexOf(body);
+  return index >= 0 ? StarTable[index] : null;
+}
+function UserDefinedStar(body) {
+  const star = GetStar(body);
+  return star && star.dist > 0 ? star : null;
+}
+var PrecessDirection;
+(function(PrecessDirection2) {
+  PrecessDirection2[PrecessDirection2["From2000"] = 0] = "From2000";
+  PrecessDirection2[PrecessDirection2["Into2000"] = 1] = "Into2000";
+})(PrecessDirection || (PrecessDirection = {}));
+var vsop = {
+  Mercury: [
+    [
+      [
+        [4.40250710144, 0, 0],
+        [0.40989414977, 1.48302034195, 26087.9031415742],
+        [0.050462942, 4.47785489551, 52175.8062831484],
+        [0.00855346844, 1.16520322459, 78263.70942472259],
+        [0.00165590362, 4.11969163423, 104351.61256629678],
+        [34561897e-11, 0.77930768443, 130439.51570787099],
+        [7583476e-11, 3.71348404924, 156527.41884944518]
+      ],
+      [
+        [26087.90313685529, 0, 0],
+        [0.01131199811, 6.21874197797, 26087.9031415742],
+        [0.00292242298, 3.04449355541, 52175.8062831484],
+        [75775081e-11, 6.08568821653, 78263.70942472259],
+        [19676525e-11, 2.80965111777, 104351.61256629678]
+      ]
+    ],
+    [
+      [
+        [0.11737528961, 1.98357498767, 26087.9031415742],
+        [0.02388076996, 5.03738959686, 52175.8062831484],
+        [0.01222839532, 3.14159265359, 0],
+        [0.0054325181, 1.79644363964, 78263.70942472259],
+        [0.0012977877, 4.83232503958, 104351.61256629678],
+        [31866927e-11, 1.58088495658, 130439.51570787099],
+        [7963301e-11, 4.60972126127, 156527.41884944518]
+      ],
+      [
+        [0.00274646065, 3.95008450011, 26087.9031415742],
+        [99737713e-11, 3.14159265359, 0]
+      ]
+    ],
+    [
+      [
+        [0.39528271651, 0, 0],
+        [0.07834131818, 6.19233722598, 26087.9031415742],
+        [0.00795525558, 2.95989690104, 52175.8062831484],
+        [0.00121281764, 6.01064153797, 78263.70942472259],
+        [21921969e-11, 2.77820093972, 104351.61256629678],
+        [4354065e-11, 5.82894543774, 130439.51570787099]
+      ],
+      [
+        [0.0021734774, 4.65617158665, 26087.9031415742],
+        [44141826e-11, 1.42385544001, 52175.8062831484]
+      ]
+    ]
+  ],
+  Venus: [
+    [
+      [
+        [3.17614666774, 0, 0],
+        [0.01353968419, 5.59313319619, 10213.285546211],
+        [89891645e-11, 5.30650047764, 20426.571092422],
+        [5477194e-11, 4.41630661466, 7860.4193924392],
+        [3455741e-11, 2.6996444782, 11790.6290886588],
+        [2372061e-11, 2.99377542079, 3930.2096962196],
+        [1317168e-11, 5.18668228402, 26.2983197998],
+        [1664146e-11, 4.25018630147, 1577.3435424478],
+        [1438387e-11, 4.15745084182, 9683.5945811164],
+        [1200521e-11, 6.15357116043, 30639.856638633]
+      ],
+      [
+        [10213.28554621638, 0, 0],
+        [95617813e-11, 2.4640651111, 10213.285546211],
+        [7787201e-11, 0.6247848222, 20426.571092422]
+      ]
+    ],
+    [
+      [
+        [0.05923638472, 0.26702775812, 10213.285546211],
+        [40107978e-11, 1.14737178112, 20426.571092422],
+        [32814918e-11, 3.14159265359, 0]
+      ],
+      [
+        [0.00287821243, 1.88964962838, 10213.285546211]
+      ]
+    ],
+    [
+      [
+        [0.72334820891, 0, 0],
+        [0.00489824182, 4.02151831717, 10213.285546211],
+        [1658058e-11, 4.90206728031, 20426.571092422],
+        [1378043e-11, 1.12846591367, 11790.6290886588],
+        [1632096e-11, 2.84548795207, 7860.4193924392],
+        [498395e-11, 2.58682193892, 9683.5945811164],
+        [221985e-11, 2.01346696541, 19367.1891622328],
+        [237454e-11, 2.55136053886, 15720.8387848784]
+      ],
+      [
+        [34551041e-11, 0.89198706276, 10213.285546211]
+      ]
+    ]
+  ],
+  Earth: [
+    [
+      [
+        [1.75347045673, 0, 0],
+        [0.03341656453, 4.66925680415, 6283.0758499914],
+        [34894275e-11, 4.62610242189, 12566.1516999828],
+        [3417572e-11, 2.82886579754, 3.523118349],
+        [3497056e-11, 2.74411783405, 5753.3848848968],
+        [3135899e-11, 3.62767041756, 77713.7714681205],
+        [2676218e-11, 4.41808345438, 7860.4193924392],
+        [2342691e-11, 6.13516214446, 3930.2096962196],
+        [1273165e-11, 2.03709657878, 529.6909650946],
+        [1324294e-11, 0.74246341673, 11506.7697697936],
+        [901854e-11, 2.04505446477, 26.2983197998],
+        [1199167e-11, 1.10962946234, 1577.3435424478],
+        [857223e-11, 3.50849152283, 398.1490034082],
+        [779786e-11, 1.17882681962, 5223.6939198022],
+        [99025e-10, 5.23268072088, 5884.9268465832],
+        [753141e-11, 2.53339052847, 5507.5532386674],
+        [505267e-11, 4.58292599973, 18849.2275499742],
+        [492392e-11, 4.20505711826, 775.522611324],
+        [356672e-11, 2.91954114478, 0.0673103028],
+        [284125e-11, 1.89869240932, 796.2980068164],
+        [242879e-11, 0.34481445893, 5486.777843175],
+        [317087e-11, 5.84901948512, 11790.6290886588],
+        [271112e-11, 0.31486255375, 10977.078804699],
+        [206217e-11, 4.80646631478, 2544.3144198834],
+        [205478e-11, 1.86953770281, 5573.1428014331],
+        [202318e-11, 2.45767790232, 6069.7767545534],
+        [126225e-11, 1.08295459501, 20.7753954924],
+        [155516e-11, 0.83306084617, 213.299095438]
+      ],
+      [
+        [6283.0758499914, 0, 0],
+        [0.00206058863, 2.67823455808, 6283.0758499914],
+        [4303419e-11, 2.63512233481, 12566.1516999828]
+      ],
+      [
+        [8721859e-11, 1.07253635559, 6283.0758499914]
+      ]
+    ],
+    [
+      [],
+      [
+        [0.00227777722, 3.4137662053, 6283.0758499914],
+        [3805678e-11, 3.37063423795, 12566.1516999828]
+      ]
+    ],
+    [
+      [
+        [1.00013988784, 0, 0],
+        [0.01670699632, 3.09846350258, 6283.0758499914],
+        [13956024e-11, 3.05524609456, 12566.1516999828],
+        [308372e-10, 5.19846674381, 77713.7714681205],
+        [1628463e-11, 1.17387558054, 5753.3848848968],
+        [1575572e-11, 2.84685214877, 7860.4193924392],
+        [924799e-11, 5.45292236722, 11506.7697697936],
+        [542439e-11, 4.56409151453, 3930.2096962196],
+        [47211e-10, 3.66100022149, 5884.9268465832],
+        [85831e-11, 1.27079125277, 161000.6857376741],
+        [57056e-11, 2.01374292245, 83996.84731811189],
+        [55736e-11, 5.2415979917, 71430.69561812909],
+        [174844e-11, 3.01193636733, 18849.2275499742],
+        [243181e-11, 4.2734953079, 11790.6290886588]
+      ],
+      [
+        [0.00103018607, 1.10748968172, 6283.0758499914],
+        [1721238e-11, 1.06442300386, 12566.1516999828]
+      ],
+      [
+        [4359385e-11, 5.78455133808, 6283.0758499914]
+      ]
+    ]
+  ],
+  Mars: [
+    [
+      [
+        [6.20347711581, 0, 0],
+        [0.18656368093, 5.0503710027, 3340.6124266998],
+        [0.01108216816, 5.40099836344, 6681.2248533996],
+        [91798406e-11, 5.75478744667, 10021.8372800994],
+        [27744987e-11, 5.97049513147, 3.523118349],
+        [10610235e-11, 2.93958560338, 2281.2304965106],
+        [12315897e-11, 0.84956094002, 2810.9214616052],
+        [8926784e-11, 4.15697846427, 0.0172536522],
+        [8715691e-11, 6.11005153139, 13362.4497067992],
+        [6797556e-11, 0.36462229657, 398.1490034082],
+        [7774872e-11, 3.33968761376, 5621.8429232104],
+        [3575078e-11, 1.6618650571, 2544.3144198834],
+        [4161108e-11, 0.22814971327, 2942.4634232916],
+        [3075252e-11, 0.85696614132, 191.4482661116],
+        [2628117e-11, 0.64806124465, 3337.0893083508],
+        [2937546e-11, 6.07893711402, 0.0673103028],
+        [2389414e-11, 5.03896442664, 796.2980068164],
+        [2579844e-11, 0.02996736156, 3344.1355450488],
+        [1528141e-11, 1.14979301996, 6151.533888305],
+        [1798806e-11, 0.65634057445, 529.6909650946],
+        [1264357e-11, 3.62275122593, 5092.1519581158],
+        [1286228e-11, 3.06796065034, 2146.1654164752],
+        [1546404e-11, 2.91579701718, 1751.539531416],
+        [1024902e-11, 3.69334099279, 8962.4553499102],
+        [891566e-11, 0.18293837498, 16703.062133499],
+        [858759e-11, 2.4009381194, 2914.0142358238],
+        [832715e-11, 2.46418619474, 3340.5951730476],
+        [83272e-10, 4.49495782139, 3340.629680352],
+        [712902e-11, 3.66335473479, 1059.3819301892],
+        [748723e-11, 3.82248614017, 155.4203994342],
+        [723861e-11, 0.67497311481, 3738.761430108],
+        [635548e-11, 2.92182225127, 8432.7643848156],
+        [655162e-11, 0.48864064125, 3127.3133312618],
+        [550474e-11, 3.81001042328, 0.9803210682],
+        [55275e-10, 4.47479317037, 1748.016413067],
+        [425966e-11, 0.55364317304, 6283.0758499914],
+        [415131e-11, 0.49662285038, 213.299095438],
+        [472167e-11, 3.62547124025, 1194.4470102246],
+        [306551e-11, 0.38052848348, 6684.7479717486],
+        [312141e-11, 0.99853944405, 6677.7017350506],
+        [293198e-11, 4.22131299634, 20.7753954924],
+        [302375e-11, 4.48618007156, 3532.0606928114],
+        [274027e-11, 0.54222167059, 3340.545116397],
+        [281079e-11, 5.88163521788, 1349.8674096588],
+        [231183e-11, 1.28242156993, 3870.3033917944],
+        [283602e-11, 5.7688543494, 3149.1641605882],
+        [236117e-11, 5.75503217933, 3333.498879699],
+        [274033e-11, 0.13372524985, 3340.6797370026],
+        [299395e-11, 2.78323740866, 6254.6266625236]
+      ],
+      [
+        [3340.61242700512, 0, 0],
+        [0.01457554523, 3.60433733236, 3340.6124266998],
+        [0.00168414711, 3.92318567804, 6681.2248533996],
+        [20622975e-11, 4.26108844583, 10021.8372800994],
+        [3452392e-11, 4.7321039319, 3.523118349],
+        [2586332e-11, 4.60670058555, 13362.4497067992],
+        [841535e-11, 4.45864030426, 2281.2304965106]
+      ],
+      [
+        [58152577e-11, 2.04961712429, 3340.6124266998],
+        [13459579e-11, 2.45738706163, 6681.2248533996]
+      ]
+    ],
+    [
+      [
+        [0.03197134986, 3.76832042431, 3340.6124266998],
+        [0.00298033234, 4.10616996305, 6681.2248533996],
+        [0.00289104742, 0, 0],
+        [31365539e-11, 4.4465105309, 10021.8372800994],
+        [34841e-9, 4.7881254926, 13362.4497067992]
+      ],
+      [
+        [0.00217310991, 6.04472194776, 3340.6124266998],
+        [20976948e-11, 3.14159265359, 0],
+        [12834709e-11, 1.60810667915, 6681.2248533996]
+      ]
+    ],
+    [
+      [
+        [1.53033488271, 0, 0],
+        [0.1418495316, 3.47971283528, 3340.6124266998],
+        [0.00660776362, 3.81783443019, 6681.2248533996],
+        [46179117e-11, 4.15595316782, 10021.8372800994],
+        [8109733e-11, 5.55958416318, 2810.9214616052],
+        [7485318e-11, 1.77239078402, 5621.8429232104],
+        [5523191e-11, 1.3643630377, 2281.2304965106],
+        [382516e-10, 4.49407183687, 13362.4497067992],
+        [2306537e-11, 0.09081579001, 2544.3144198834],
+        [1999396e-11, 5.36059617709, 3337.0893083508],
+        [2484394e-11, 4.9254563992, 2942.4634232916],
+        [1960195e-11, 4.74249437639, 3344.1355450488],
+        [1167119e-11, 2.11260868341, 5092.1519581158],
+        [1102816e-11, 5.00908403998, 398.1490034082],
+        [899066e-11, 4.40791133207, 529.6909650946],
+        [992252e-11, 5.83861961952, 6151.533888305],
+        [807354e-11, 2.10217065501, 1059.3819301892],
+        [797915e-11, 3.44839203899, 796.2980068164],
+        [740975e-11, 1.49906336885, 2146.1654164752]
+      ],
+      [
+        [0.01107433345, 2.03250524857, 3340.6124266998],
+        [0.00103175887, 2.37071847807, 6681.2248533996],
+        [128772e-9, 0, 0],
+        [1081588e-10, 2.70888095665, 10021.8372800994]
+      ],
+      [
+        [44242249e-11, 0.47930604954, 3340.6124266998],
+        [8138042e-11, 0.86998389204, 6681.2248533996]
+      ]
+    ]
+  ],
+  Jupiter: [
+    [
+      [
+        [0.59954691494, 0, 0],
+        [0.09695898719, 5.06191793158, 529.6909650946],
+        [0.00573610142, 1.44406205629, 7.1135470008],
+        [0.00306389205, 5.41734730184, 1059.3819301892],
+        [97178296e-11, 4.14264726552, 632.7837393132],
+        [72903078e-11, 3.64042916389, 522.5774180938],
+        [64263975e-11, 3.41145165351, 103.0927742186],
+        [39806064e-11, 2.29376740788, 419.4846438752],
+        [38857767e-11, 1.27231755835, 316.3918696566],
+        [27964629e-11, 1.7845459182, 536.8045120954],
+        [1358973e-10, 5.7748104079, 1589.0728952838],
+        [8246349e-11, 3.5822792584, 206.1855484372],
+        [8768704e-11, 3.63000308199, 949.1756089698],
+        [7368042e-11, 5.0810119427, 735.8765135318],
+        [626315e-10, 0.02497628807, 213.299095438],
+        [6114062e-11, 4.51319998626, 1162.4747044078],
+        [4905396e-11, 1.32084470588, 110.2063212194],
+        [5305285e-11, 1.30671216791, 14.2270940016],
+        [5305441e-11, 4.18625634012, 1052.2683831884],
+        [4647248e-11, 4.69958103684, 3.9321532631],
+        [3045023e-11, 4.31676431084, 426.598190876],
+        [2609999e-11, 1.56667394063, 846.0828347512],
+        [2028191e-11, 1.06376530715, 3.1813937377],
+        [1764763e-11, 2.14148655117, 1066.49547719],
+        [1722972e-11, 3.88036268267, 1265.5674786264],
+        [1920945e-11, 0.97168196472, 639.897286314],
+        [1633223e-11, 3.58201833555, 515.463871093],
+        [1431999e-11, 4.29685556046, 625.6701923124],
+        [973272e-11, 4.09764549134, 95.9792272178]
+      ],
+      [
+        [529.69096508814, 0, 0],
+        [0.00489503243, 4.2208293947, 529.6909650946],
+        [0.00228917222, 6.02646855621, 7.1135470008],
+        [30099479e-11, 4.54540782858, 1059.3819301892],
+        [2072092e-10, 5.45943156902, 522.5774180938],
+        [12103653e-11, 0.16994816098, 536.8045120954],
+        [6067987e-11, 4.42422292017, 103.0927742186],
+        [5433968e-11, 3.98480737746, 419.4846438752],
+        [4237744e-11, 5.89008707199, 14.2270940016]
+      ],
+      [
+        [47233601e-11, 4.32148536482, 7.1135470008],
+        [30649436e-11, 2.929777887, 529.6909650946],
+        [14837605e-11, 3.14159265359, 0]
+      ]
+    ],
+    [
+      [
+        [0.02268615702, 3.55852606721, 529.6909650946],
+        [0.00109971634, 3.90809347197, 1059.3819301892],
+        [0.00110090358, 0, 0],
+        [8101428e-11, 3.60509572885, 522.5774180938],
+        [6043996e-11, 4.25883108339, 1589.0728952838],
+        [6437782e-11, 0.30627119215, 536.8045120954]
+      ],
+      [
+        [78203446e-11, 1.52377859742, 529.6909650946]
+      ]
+    ],
+    [
+      [
+        [5.20887429326, 0, 0],
+        [0.25209327119, 3.49108639871, 529.6909650946],
+        [0.00610599976, 3.84115365948, 1059.3819301892],
+        [0.00282029458, 2.57419881293, 632.7837393132],
+        [0.00187647346, 2.07590383214, 522.5774180938],
+        [86792905e-11, 0.71001145545, 419.4846438752],
+        [72062974e-11, 0.21465724607, 536.8045120954],
+        [65517248e-11, 5.9799588479, 316.3918696566],
+        [29134542e-11, 1.67759379655, 103.0927742186],
+        [30135335e-11, 2.16132003734, 949.1756089698],
+        [23453271e-11, 3.54023522184, 735.8765135318],
+        [22283743e-11, 4.19362594399, 1589.0728952838],
+        [23947298e-11, 0.2745803748, 7.1135470008],
+        [13032614e-11, 2.96042965363, 1162.4747044078],
+        [970336e-10, 1.90669633585, 206.1855484372],
+        [12749023e-11, 2.71550286592, 1052.2683831884],
+        [7057931e-11, 2.18184839926, 1265.5674786264],
+        [6137703e-11, 6.26418240033, 846.0828347512],
+        [2616976e-11, 2.00994012876, 1581.959348283]
+      ],
+      [
+        [0.0127180152, 2.64937512894, 529.6909650946],
+        [61661816e-11, 3.00076460387, 1059.3819301892],
+        [53443713e-11, 3.89717383175, 522.5774180938],
+        [31185171e-11, 4.88276958012, 536.8045120954],
+        [41390269e-11, 0, 0]
+      ]
+    ]
+  ],
+  Saturn: [
+    [
+      [
+        [0.87401354025, 0, 0],
+        [0.11107659762, 3.96205090159, 213.299095438],
+        [0.01414150957, 4.58581516874, 7.1135470008],
+        [0.00398379389, 0.52112032699, 206.1855484372],
+        [0.00350769243, 3.30329907896, 426.598190876],
+        [0.00206816305, 0.24658372002, 103.0927742186],
+        [792713e-9, 3.84007056878, 220.4126424388],
+        [23990355e-11, 4.66976924553, 110.2063212194],
+        [16573588e-11, 0.43719228296, 419.4846438752],
+        [14906995e-11, 5.76903183869, 316.3918696566],
+        [1582029e-10, 0.93809155235, 632.7837393132],
+        [14609559e-11, 1.56518472, 3.9321532631],
+        [13160301e-11, 4.44891291899, 14.2270940016],
+        [15053543e-11, 2.71669915667, 639.897286314],
+        [13005299e-11, 5.98119023644, 11.0457002639],
+        [10725067e-11, 3.12939523827, 202.2533951741],
+        [5863206e-11, 0.23656938524, 529.6909650946],
+        [5227757e-11, 4.20783365759, 3.1813937377],
+        [6126317e-11, 1.76328667907, 277.0349937414],
+        [5019687e-11, 3.17787728405, 433.7117378768],
+        [459255e-10, 0.61977744975, 199.0720014364],
+        [4005867e-11, 2.24479718502, 63.7358983034],
+        [2953796e-11, 0.98280366998, 95.9792272178],
+        [387367e-10, 3.22283226966, 138.5174968707],
+        [2461186e-11, 2.03163875071, 735.8765135318],
+        [3269484e-11, 0.77492638211, 949.1756089698],
+        [1758145e-11, 3.2658010994, 522.5774180938],
+        [1640172e-11, 5.5050445305, 846.0828347512],
+        [1391327e-11, 4.02333150505, 323.5054166574],
+        [1580648e-11, 4.37265307169, 309.2783226558],
+        [1123498e-11, 2.83726798446, 415.5524906121],
+        [1017275e-11, 3.71700135395, 227.5261894396],
+        [848642e-11, 3.1915017083, 209.3669421749]
+      ],
+      [
+        [213.2990952169, 0, 0],
+        [0.01297370862, 1.82834923978, 213.299095438],
+        [0.00564345393, 2.88499717272, 7.1135470008],
+        [93734369e-11, 1.06311793502, 426.598190876],
+        [0.00107674962, 2.27769131009, 206.1855484372],
+        [40244455e-11, 2.04108104671, 220.4126424388],
+        [19941774e-11, 1.2795439047, 103.0927742186],
+        [10511678e-11, 2.7488034213, 14.2270940016],
+        [6416106e-11, 0.38238295041, 639.897286314],
+        [4848994e-11, 2.43037610229, 419.4846438752],
+        [4056892e-11, 2.92133209468, 110.2063212194],
+        [3768635e-11, 3.6496533078, 3.9321532631]
+      ],
+      [
+        [0.0011644133, 1.17988132879, 7.1135470008],
+        [91841837e-11, 0.0732519584, 213.299095438],
+        [36661728e-11, 0, 0],
+        [15274496e-11, 4.06493179167, 206.1855484372]
+      ]
+    ],
+    [
+      [
+        [0.04330678039, 3.60284428399, 213.299095438],
+        [0.00240348302, 2.85238489373, 426.598190876],
+        [84745939e-11, 0, 0],
+        [30863357e-11, 3.48441504555, 220.4126424388],
+        [34116062e-11, 0.57297307557, 206.1855484372],
+        [1473407e-10, 2.11846596715, 639.897286314],
+        [9916667e-11, 5.79003188904, 419.4846438752],
+        [6993564e-11, 4.7360468972, 7.1135470008],
+        [4807588e-11, 5.43305312061, 316.3918696566]
+      ],
+      [
+        [0.00198927992, 4.93901017903, 213.299095438],
+        [36947916e-11, 3.14159265359, 0],
+        [17966989e-11, 0.5197943111, 426.598190876]
+      ]
+    ],
+    [
+      [
+        [9.55758135486, 0, 0],
+        [0.52921382865, 2.39226219573, 213.299095438],
+        [0.01873679867, 5.2354960466, 206.1855484372],
+        [0.01464663929, 1.64763042902, 426.598190876],
+        [0.00821891141, 5.93520042303, 316.3918696566],
+        [0.00547506923, 5.0153261898, 103.0927742186],
+        [0.0037168465, 2.27114821115, 220.4126424388],
+        [0.00361778765, 3.13904301847, 7.1135470008],
+        [0.00140617506, 5.70406606781, 632.7837393132],
+        [0.00108974848, 3.29313390175, 110.2063212194],
+        [69006962e-11, 5.94099540992, 419.4846438752],
+        [61053367e-11, 0.94037691801, 639.897286314],
+        [48913294e-11, 1.55733638681, 202.2533951741],
+        [34143772e-11, 0.19519102597, 277.0349937414],
+        [32401773e-11, 5.47084567016, 949.1756089698],
+        [20936596e-11, 0.46349251129, 735.8765135318],
+        [9796004e-11, 5.20477537945, 1265.5674786264],
+        [11993338e-11, 5.98050967385, 846.0828347512],
+        [208393e-9, 1.52102476129, 433.7117378768],
+        [15298404e-11, 3.0594381494, 529.6909650946],
+        [6465823e-11, 0.17732249942, 1052.2683831884],
+        [11380257e-11, 1.7310542704, 522.5774180938],
+        [3419618e-11, 4.94550542171, 1581.959348283]
+      ],
+      [
+        [0.0618298134, 0.2584351148, 213.299095438],
+        [0.00506577242, 0.71114625261, 206.1855484372],
+        [0.00341394029, 5.79635741658, 426.598190876],
+        [0.00188491195, 0.47215589652, 220.4126424388],
+        [0.00186261486, 3.14159265359, 0],
+        [0.00143891146, 1.40744822888, 7.1135470008]
+      ],
+      [
+        [0.00436902572, 4.78671677509, 213.299095438]
+      ]
+    ]
+  ],
+  Uranus: [
+    [
+      [
+        [5.48129294297, 0, 0],
+        [0.09260408234, 0.89106421507, 74.7815985673],
+        [0.01504247898, 3.6271926092, 1.4844727083],
+        [0.00365981674, 1.89962179044, 73.297125859],
+        [0.00272328168, 3.35823706307, 149.5631971346],
+        [70328461e-11, 5.39254450063, 63.7358983034],
+        [68892678e-11, 6.09292483287, 76.2660712756],
+        [61998615e-11, 2.26952066061, 2.9689454166],
+        [61950719e-11, 2.85098872691, 11.0457002639],
+        [2646877e-10, 3.14152083966, 71.8126531507],
+        [25710476e-11, 6.11379840493, 454.9093665273],
+        [2107885e-10, 4.36059339067, 148.0787244263],
+        [17818647e-11, 1.74436930289, 36.6485629295],
+        [14613507e-11, 4.73732166022, 3.9321532631],
+        [11162509e-11, 5.8268179635, 224.3447957019],
+        [1099791e-10, 0.48865004018, 138.5174968707],
+        [9527478e-11, 2.95516862826, 35.1640902212],
+        [7545601e-11, 5.236265824, 109.9456887885],
+        [4220241e-11, 3.23328220918, 70.8494453042],
+        [40519e-9, 2.277550173, 151.0476698429],
+        [3354596e-11, 1.0654900738, 4.4534181249],
+        [2926718e-11, 4.62903718891, 9.5612275556],
+        [349034e-10, 5.48306144511, 146.594251718],
+        [3144069e-11, 4.75199570434, 77.7505439839],
+        [2922333e-11, 5.35235361027, 85.8272988312],
+        [2272788e-11, 4.36600400036, 70.3281804424],
+        [2051219e-11, 1.51773566586, 0.1118745846],
+        [2148602e-11, 0.60745949945, 38.1330356378],
+        [1991643e-11, 4.92437588682, 277.0349937414],
+        [1376226e-11, 2.04283539351, 65.2203710117],
+        [1666902e-11, 3.62744066769, 380.12776796],
+        [1284107e-11, 3.11347961505, 202.2533951741],
+        [1150429e-11, 0.93343589092, 3.1813937377],
+        [1533221e-11, 2.58594681212, 52.6901980395],
+        [1281604e-11, 0.54271272721, 222.8603229936],
+        [1372139e-11, 4.19641530878, 111.4301614968],
+        [1221029e-11, 0.1990065003, 108.4612160802],
+        [946181e-11, 1.19253165736, 127.4717966068],
+        [1150989e-11, 4.17898916639, 33.6796175129]
+      ],
+      [
+        [74.7815986091, 0, 0],
+        [0.00154332863, 5.24158770553, 74.7815985673],
+        [24456474e-11, 1.71260334156, 1.4844727083],
+        [9258442e-11, 0.4282973235, 11.0457002639],
+        [8265977e-11, 1.50218091379, 63.7358983034],
+        [915016e-10, 1.41213765216, 149.5631971346]
+      ]
+    ],
+    [
+      [
+        [0.01346277648, 2.61877810547, 74.7815985673],
+        [623414e-9, 5.08111189648, 149.5631971346],
+        [61601196e-11, 3.14159265359, 0],
+        [9963722e-11, 1.61603805646, 76.2660712756],
+        [992616e-10, 0.57630380333, 73.297125859]
+      ],
+      [
+        [34101978e-11, 0.01321929936, 74.7815985673]
+      ]
+    ],
+    [
+      [
+        [19.21264847206, 0, 0],
+        [0.88784984413, 5.60377527014, 74.7815985673],
+        [0.03440836062, 0.32836099706, 73.297125859],
+        [0.0205565386, 1.7829515933, 149.5631971346],
+        [0.0064932241, 4.52247285911, 76.2660712756],
+        [0.00602247865, 3.86003823674, 63.7358983034],
+        [0.00496404167, 1.40139935333, 454.9093665273],
+        [0.00338525369, 1.58002770318, 138.5174968707],
+        [0.00243509114, 1.57086606044, 71.8126531507],
+        [0.00190522303, 1.99809394714, 1.4844727083],
+        [0.00161858838, 2.79137786799, 148.0787244263],
+        [0.00143706183, 1.38368544947, 11.0457002639],
+        [93192405e-11, 0.17437220467, 36.6485629295],
+        [71424548e-11, 4.24509236074, 224.3447957019],
+        [89806014e-11, 3.66105364565, 109.9456887885],
+        [39009723e-11, 1.66971401684, 70.8494453042],
+        [46677296e-11, 1.39976401694, 35.1640902212],
+        [39025624e-11, 3.36234773834, 277.0349937414],
+        [36755274e-11, 3.88649278513, 146.594251718],
+        [30348723e-11, 0.70100838798, 151.0476698429],
+        [29156413e-11, 3.180563367, 77.7505439839],
+        [22637073e-11, 0.72518687029, 529.6909650946],
+        [11959076e-11, 1.7504339214, 984.6003316219],
+        [25620756e-11, 5.25656086672, 380.12776796]
+      ],
+      [
+        [0.01479896629, 3.67205697578, 74.7815985673]
+      ]
+    ]
+  ],
+  Neptune: [
+    [
+      [
+        [5.31188633046, 0, 0],
+        [0.0179847553, 2.9010127389, 38.1330356378],
+        [0.01019727652, 0.48580922867, 1.4844727083],
+        [0.00124531845, 4.83008090676, 36.6485629295],
+        [42064466e-11, 5.41054993053, 2.9689454166],
+        [37714584e-11, 6.09221808686, 35.1640902212],
+        [33784738e-11, 1.24488874087, 76.2660712756],
+        [16482741e-11, 7727998e-11, 491.5579294568],
+        [9198584e-11, 4.93747051954, 39.6175083461],
+        [899425e-10, 0.27462171806, 175.1660598002]
+      ],
+      [
+        [38.13303563957, 0, 0],
+        [16604172e-11, 4.86323329249, 1.4844727083],
+        [15744045e-11, 2.27887427527, 38.1330356378]
+      ]
+    ],
+    [
+      [
+        [0.03088622933, 1.44104372644, 38.1330356378],
+        [27780087e-11, 5.91271884599, 76.2660712756],
+        [27623609e-11, 0, 0],
+        [15355489e-11, 2.52123799551, 36.6485629295],
+        [15448133e-11, 3.50877079215, 39.6175083461]
+      ]
+    ],
+    [
+      [
+        [30.07013205828, 0, 0],
+        [0.27062259632, 1.32999459377, 38.1330356378],
+        [0.01691764014, 3.25186135653, 36.6485629295],
+        [0.00807830553, 5.18592878704, 1.4844727083],
+        [0.0053776051, 4.52113935896, 35.1640902212],
+        [0.00495725141, 1.5710564165, 491.5579294568],
+        [0.00274571975, 1.84552258866, 175.1660598002],
+        [1201232e-10, 1.92059384991, 1021.2488945514],
+        [0.00121801746, 5.79754470298, 76.2660712756],
+        [0.00100896068, 0.3770272493, 73.297125859],
+        [0.00135134092, 3.37220609835, 39.6175083461],
+        [7571796e-11, 1.07149207335, 388.4651552382]
+      ]
+    ]
+  ]
+};
+function DeltaT_EspenakMeeus(ut) {
+  var u, u2, u3, u4, u5, u6, u7;
+  const y = 2e3 + (ut - 14) / DAYS_PER_TROPICAL_YEAR;
+  if (y < -500) {
+    u = (y - 1820) / 100;
+    return -20 + 32 * u * u;
+  }
+  if (y < 500) {
+    u = y / 100;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    u5 = u2 * u3;
+    u6 = u3 * u3;
+    return 10583.6 - 1014.41 * u + 33.78311 * u2 - 5.952053 * u3 - 0.1798452 * u4 + 0.022174192 * u5 + 0.0090316521 * u6;
+  }
+  if (y < 1600) {
+    u = (y - 1e3) / 100;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    u5 = u2 * u3;
+    u6 = u3 * u3;
+    return 1574.2 - 556.01 * u + 71.23472 * u2 + 0.319781 * u3 - 0.8503463 * u4 - 5050998e-9 * u5 + 0.0083572073 * u6;
+  }
+  if (y < 1700) {
+    u = y - 1600;
+    u2 = u * u;
+    u3 = u * u2;
+    return 120 - 0.9808 * u - 0.01532 * u2 + u3 / 7129;
+  }
+  if (y < 1800) {
+    u = y - 1700;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    return 8.83 + 0.1603 * u - 59285e-7 * u2 + 13336e-8 * u3 - u4 / 1174e3;
+  }
+  if (y < 1860) {
+    u = y - 1800;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    u5 = u2 * u3;
+    u6 = u3 * u3;
+    u7 = u3 * u4;
+    return 13.72 - 0.332447 * u + 68612e-7 * u2 + 41116e-7 * u3 - 37436e-8 * u4 + 121272e-10 * u5 - 1699e-10 * u6 + 875e-12 * u7;
+  }
+  if (y < 1900) {
+    u = y - 1860;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    u5 = u2 * u3;
+    return 7.62 + 0.5737 * u - 0.251754 * u2 + 0.01680668 * u3 - 4473624e-10 * u4 + u5 / 233174;
+  }
+  if (y < 1920) {
+    u = y - 1900;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    return -2.79 + 1.494119 * u - 0.0598939 * u2 + 61966e-7 * u3 - 197e-6 * u4;
+  }
+  if (y < 1941) {
+    u = y - 1920;
+    u2 = u * u;
+    u3 = u * u2;
+    return 21.2 + 0.84493 * u - 0.0761 * u2 + 20936e-7 * u3;
+  }
+  if (y < 1961) {
+    u = y - 1950;
+    u2 = u * u;
+    u3 = u * u2;
+    return 29.07 + 0.407 * u - u2 / 233 + u3 / 2547;
+  }
+  if (y < 1986) {
+    u = y - 1975;
+    u2 = u * u;
+    u3 = u * u2;
+    return 45.45 + 1.067 * u - u2 / 260 - u3 / 718;
+  }
+  if (y < 2005) {
+    u = y - 2e3;
+    u2 = u * u;
+    u3 = u * u2;
+    u4 = u2 * u2;
+    u5 = u2 * u3;
+    return 63.86 + 0.3345 * u - 0.060374 * u2 + 17275e-7 * u3 + 651814e-9 * u4 + 2373599e-11 * u5;
+  }
+  if (y < 2050) {
+    u = y - 2e3;
+    return 62.92 + 0.32217 * u + 5589e-6 * u * u;
+  }
+  if (y < 2150) {
+    u = (y - 1820) / 100;
+    return -20 + 32 * u * u - 0.5628 * (2150 - y);
+  }
+  u = (y - 1820) / 100;
+  return -20 + 32 * u * u;
+}
+var DeltaT = DeltaT_EspenakMeeus;
+function TerrestrialTime(ut) {
+  return ut + DeltaT(ut) / 86400;
+}
+var AstroTime = class _AstroTime {
+  /**
+   * @param {FlexibleDateTime} date
+   *      A JavaScript Date object, a numeric UTC value expressed in J2000 days, or another AstroTime object.
+   */
+  constructor(date) {
+    if (date instanceof _AstroTime) {
+      this.date = date.date;
+      this.ut = date.ut;
+      this.tt = date.tt;
+      return;
+    }
+    const MillisPerDay = 1e3 * 3600 * 24;
+    if (date instanceof Date && Number.isFinite(date.getTime())) {
+      this.date = date;
+      this.ut = (date.getTime() - J2000.getTime()) / MillisPerDay;
+      this.tt = TerrestrialTime(this.ut);
+      return;
+    }
+    if (Number.isFinite(date)) {
+      this.date = new Date(J2000.getTime() + date * MillisPerDay);
+      this.ut = date;
+      this.tt = TerrestrialTime(this.ut);
+      return;
+    }
+    throw "Argument must be a Date object, an AstroTime object, or a numeric UTC Julian date.";
+  }
+  /**
+   * @brief Creates an `AstroTime` value from a Terrestrial Time (TT) day value.
+   *
+   * This function can be used in rare cases where a time must be based
+   * on Terrestrial Time (TT) rather than Universal Time (UT).
+   * Most developers will want to invoke `new AstroTime(ut)` with a universal time
+   * instead of this function, because usually time is based on civil time adjusted
+   * by leap seconds to match the Earth's rotation, rather than the uniformly
+   * flowing TT used to calculate solar system dynamics. In rare cases
+   * where the caller already knows TT, this function is provided to create
+   * an `AstroTime` value that can be passed to Astronomy Engine functions.
+   *
+   * @param {number} tt
+   *      The number of days since the J2000 epoch as expressed in Terrestrial Time.
+   *
+   * @returns {AstroTime}
+   *      An `AstroTime` object for the specified terrestrial time.
+   */
+  static FromTerrestrialTime(tt) {
+    let time = new _AstroTime(tt);
+    for (; ; ) {
+      const err = tt - time.tt;
+      if (Math.abs(err) < 1e-12)
+        return time;
+      time = time.AddDays(err);
+    }
+  }
+  /**
+   * Formats an `AstroTime` object as an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)
+   * date/time string in UTC, to millisecond resolution.
+   * Example: `2018-08-17T17:22:04.050Z`
+   * @returns {string}
+   */
+  toString() {
+    return this.date.toISOString();
+  }
+  /**
+   * Returns a new `AstroTime` object adjusted by the floating point number of days.
+   * Does NOT modify the original `AstroTime` object.
+   *
+   * @param {number} days
+   *      The floating point number of days by which to adjust the given date and time.
+   *      Positive values adjust the date toward the future, and
+   *      negative values adjust the date toward the past.
+   *
+   * @returns {AstroTime}
+   */
+  AddDays(days) {
+    return new _AstroTime(this.ut + days);
+  }
+};
+function InterpolateTime(time1, time2, fraction) {
+  return new AstroTime(time1.ut + fraction * (time2.ut - time1.ut));
+}
+function MakeTime(date) {
+  if (date instanceof AstroTime) {
+    return date;
+  }
+  return new AstroTime(date);
+}
+function iau2000b(time) {
+  function mod(x) {
+    return x % ASEC360 * ASEC2RAD;
+  }
+  const t = time.tt / 36525;
+  const elp = mod(128710479305e-5 + t * 1295965810481e-4);
+  const f = mod(335779.526232 + t * 17395272628478e-4);
+  const d = mod(107226070369e-5 + t * 1602961601209e-3);
+  const om = mod(450160.398036 - t * 69628905431e-4);
+  let sarg = Math.sin(om);
+  let carg = Math.cos(om);
+  let dp = (-172064161 - 174666 * t) * sarg + 33386 * carg;
+  let de = (92052331 + 9086 * t) * carg + 15377 * sarg;
+  let arg = 2 * (f - d + om);
+  sarg = Math.sin(arg);
+  carg = Math.cos(arg);
+  dp += (-13170906 - 1675 * t) * sarg - 13696 * carg;
+  de += (5730336 - 3015 * t) * carg - 4587 * sarg;
+  arg = 2 * (f + om);
+  sarg = Math.sin(arg);
+  carg = Math.cos(arg);
+  dp += (-2276413 - 234 * t) * sarg + 2796 * carg;
+  de += (978459 - 485 * t) * carg + 1374 * sarg;
+  arg = 2 * om;
+  sarg = Math.sin(arg);
+  carg = Math.cos(arg);
+  dp += (2074554 + 207 * t) * sarg - 698 * carg;
+  de += (-897492 + 470 * t) * carg - 291 * sarg;
+  sarg = Math.sin(elp);
+  carg = Math.cos(elp);
+  dp += (1475877 - 3633 * t) * sarg + 11817 * carg;
+  de += (73871 - 184 * t) * carg - 1924 * sarg;
+  return {
+    dpsi: -135e-6 + dp * 1e-7,
+    deps: 388e-6 + de * 1e-7
+  };
+}
+function mean_obliq(time) {
+  var t = time.tt / 36525;
+  var asec = ((((-4.34e-8 * t - 576e-9) * t + 20034e-7) * t - 1831e-7) * t - 46.836769) * t + 84381.406;
+  return asec / 3600;
+}
+var cache_e_tilt;
+function e_tilt(time) {
+  if (!cache_e_tilt || Math.abs(cache_e_tilt.tt - time.tt) > 1e-6) {
+    const nut = iau2000b(time);
+    const mean_ob = mean_obliq(time);
+    const true_ob = mean_ob + nut.deps / 3600;
+    cache_e_tilt = {
+      tt: time.tt,
+      dpsi: nut.dpsi,
+      deps: nut.deps,
+      ee: nut.dpsi * Math.cos(mean_ob * DEG2RAD) / 15,
+      mobl: mean_ob,
+      tobl: true_ob
+    };
+  }
+  return cache_e_tilt;
+}
+function obl_ecl2equ_vec(oblDegrees, pos) {
+  const obl = oblDegrees * DEG2RAD;
+  const cos_obl = Math.cos(obl);
+  const sin_obl = Math.sin(obl);
+  return [
+    pos[0],
+    pos[1] * cos_obl - pos[2] * sin_obl,
+    pos[1] * sin_obl + pos[2] * cos_obl
+  ];
+}
+function ecl2equ_vec(time, pos) {
+  return obl_ecl2equ_vec(mean_obliq(time), pos);
+}
+function CalcMoon(time) {
+  const T = time.tt / 36525;
+  function DeclareArray1(xmin, xmax) {
+    const array = [];
+    let i;
+    for (i = 0; i <= xmax - xmin; ++i) {
+      array.push(0);
+    }
+    return { min: xmin, array };
+  }
+  function DeclareArray2(xmin, xmax, ymin, ymax) {
+    const array = [];
+    for (let i = 0; i <= xmax - xmin; ++i) {
+      array.push(DeclareArray1(ymin, ymax));
+    }
+    return { min: xmin, array };
+  }
+  function ArrayGet2(a, x, y) {
+    const m = a.array[x - a.min];
+    return m.array[y - m.min];
+  }
+  function ArraySet2(a, x, y, v) {
+    const m = a.array[x - a.min];
+    m.array[y - m.min] = v;
+  }
+  let S, MAX, ARG, FAC, I, J, T2, DGAM, DLAM, N, GAM1C, SINPI, L0, L, LS, F, D, DL0, DL, DLS, DF, DD, DS;
+  let coArray = DeclareArray2(-6, 6, 1, 4);
+  let siArray = DeclareArray2(-6, 6, 1, 4);
+  function CO(x, y) {
+    return ArrayGet2(coArray, x, y);
+  }
+  function SI(x, y) {
+    return ArrayGet2(siArray, x, y);
+  }
+  function SetCO(x, y, v) {
+    return ArraySet2(coArray, x, y, v);
+  }
+  function SetSI(x, y, v) {
+    return ArraySet2(siArray, x, y, v);
+  }
+  function AddThe(c1, s1, c2, s2, func) {
+    func(c1 * c2 - s1 * s2, s1 * c2 + c1 * s2);
+  }
+  function Sine(phi) {
+    return Math.sin(PI2 * phi);
+  }
+  T2 = T * T;
+  DLAM = 0;
+  DS = 0;
+  GAM1C = 0;
+  SINPI = 3422.7;
+  var S1 = Sine(0.19833 + 0.05611 * T);
+  var S2 = Sine(0.27869 + 0.04508 * T);
+  var S3 = Sine(0.16827 - 0.36903 * T);
+  var S4 = Sine(0.34734 - 5.37261 * T);
+  var S5 = Sine(0.10498 - 5.37899 * T);
+  var S6 = Sine(0.42681 - 0.41855 * T);
+  var S7 = Sine(0.14943 - 5.37511 * T);
+  DL0 = 0.84 * S1 + 0.31 * S2 + 14.27 * S3 + 7.26 * S4 + 0.28 * S5 + 0.24 * S6;
+  DL = 2.94 * S1 + 0.31 * S2 + 14.27 * S3 + 9.34 * S4 + 1.12 * S5 + 0.83 * S6;
+  DLS = -6.4 * S1 - 1.89 * S6;
+  DF = 0.21 * S1 + 0.31 * S2 + 14.27 * S3 - 88.7 * S4 - 15.3 * S5 + 0.24 * S6 - 1.86 * S7;
+  DD = DL0 - DLS;
+  DGAM = -3332e-9 * Sine(0.59734 - 5.37261 * T) - 539e-9 * Sine(0.35498 - 5.37899 * T) - 64e-9 * Sine(0.39943 - 5.37511 * T);
+  L0 = PI2 * Frac(0.60643382 + 1336.85522467 * T - 313e-8 * T2) + DL0 / ARC;
+  L = PI2 * Frac(0.37489701 + 1325.55240982 * T + 2565e-8 * T2) + DL / ARC;
+  LS = PI2 * Frac(0.99312619 + 99.99735956 * T - 44e-8 * T2) + DLS / ARC;
+  F = PI2 * Frac(0.25909118 + 1342.2278298 * T - 892e-8 * T2) + DF / ARC;
+  D = PI2 * Frac(0.82736186 + 1236.85308708 * T - 397e-8 * T2) + DD / ARC;
+  for (I = 1; I <= 4; ++I) {
+    switch (I) {
+      case 1:
+        ARG = L;
+        MAX = 4;
+        FAC = 1.000002208;
+        break;
+      case 2:
+        ARG = LS;
+        MAX = 3;
+        FAC = 0.997504612 - 2495388e-9 * T;
+        break;
+      case 3:
+        ARG = F;
+        MAX = 4;
+        FAC = 1.000002708 + 139.978 * DGAM;
+        break;
+      case 4:
+        ARG = D;
+        MAX = 6;
+        FAC = 1;
+        break;
+      default:
+        throw `Internal error: I = ${I}`;
+    }
+    SetCO(0, I, 1);
+    SetCO(1, I, Math.cos(ARG) * FAC);
+    SetSI(0, I, 0);
+    SetSI(1, I, Math.sin(ARG) * FAC);
+    for (J = 2; J <= MAX; ++J) {
+      AddThe(CO(J - 1, I), SI(J - 1, I), CO(1, I), SI(1, I), (c, s) => (SetCO(J, I, c), SetSI(J, I, s)));
+    }
+    for (J = 1; J <= MAX; ++J) {
+      SetCO(-J, I, CO(J, I));
+      SetSI(-J, I, -SI(J, I));
+    }
+  }
+  function Term(p, q, r, s) {
+    var result = { x: 1, y: 0 };
+    var I2 = [0, p, q, r, s];
+    for (var k = 1; k <= 4; ++k)
+      if (I2[k] !== 0)
+        AddThe(result.x, result.y, CO(I2[k], k), SI(I2[k], k), (c, s2) => (result.x = c, result.y = s2));
+    return result;
+  }
+  function AddSol(coeffl, coeffs, coeffg, coeffp, p, q, r, s) {
+    var result = Term(p, q, r, s);
+    DLAM += coeffl * result.y;
+    DS += coeffs * result.y;
+    GAM1C += coeffg * result.x;
+    SINPI += coeffp * result.x;
+  }
+  AddSol(13.902, 14.06, -1e-3, 0.2607, 0, 0, 0, 4);
+  AddSol(0.403, -4.01, 0.394, 23e-4, 0, 0, 0, 3);
+  AddSol(2369.912, 2373.36, 0.601, 28.2333, 0, 0, 0, 2);
+  AddSol(-125.154, -112.79, -0.725, -0.9781, 0, 0, 0, 1);
+  AddSol(1.979, 6.98, -0.445, 0.0433, 1, 0, 0, 4);
+  AddSol(191.953, 192.72, 0.029, 3.0861, 1, 0, 0, 2);
+  AddSol(-8.466, -13.51, 0.455, -0.1093, 1, 0, 0, 1);
+  AddSol(22639.5, 22609.07, 0.079, 186.5398, 1, 0, 0, 0);
+  AddSol(18.609, 3.59, -0.094, 0.0118, 1, 0, 0, -1);
+  AddSol(-4586.465, -4578.13, -0.077, 34.3117, 1, 0, 0, -2);
+  AddSol(3.215, 5.44, 0.192, -0.0386, 1, 0, 0, -3);
+  AddSol(-38.428, -38.64, 1e-3, 0.6008, 1, 0, 0, -4);
+  AddSol(-0.393, -1.43, -0.092, 86e-4, 1, 0, 0, -6);
+  AddSol(-0.289, -1.59, 0.123, -53e-4, 0, 1, 0, 4);
+  AddSol(-24.42, -25.1, 0.04, -0.3, 0, 1, 0, 2);
+  AddSol(18.023, 17.93, 7e-3, 0.1494, 0, 1, 0, 1);
+  AddSol(-668.146, -126.98, -1.302, -0.3997, 0, 1, 0, 0);
+  AddSol(0.56, 0.32, -1e-3, -37e-4, 0, 1, 0, -1);
+  AddSol(-165.145, -165.06, 0.054, 1.9178, 0, 1, 0, -2);
+  AddSol(-1.877, -6.46, -0.416, 0.0339, 0, 1, 0, -4);
+  AddSol(0.213, 1.02, -0.074, 54e-4, 2, 0, 0, 4);
+  AddSol(14.387, 14.78, -0.017, 0.2833, 2, 0, 0, 2);
+  AddSol(-0.586, -1.2, 0.054, -0.01, 2, 0, 0, 1);
+  AddSol(769.016, 767.96, 0.107, 10.1657, 2, 0, 0, 0);
+  AddSol(1.75, 2.01, -0.018, 0.0155, 2, 0, 0, -1);
+  AddSol(-211.656, -152.53, 5.679, -0.3039, 2, 0, 0, -2);
+  AddSol(1.225, 0.91, -0.03, -88e-4, 2, 0, 0, -3);
+  AddSol(-30.773, -34.07, -0.308, 0.3722, 2, 0, 0, -4);
+  AddSol(-0.57, -1.4, -0.074, 0.0109, 2, 0, 0, -6);
+  AddSol(-2.921, -11.75, 0.787, -0.0484, 1, 1, 0, 2);
+  AddSol(1.267, 1.52, -0.022, 0.0164, 1, 1, 0, 1);
+  AddSol(-109.673, -115.18, 0.461, -0.949, 1, 1, 0, 0);
+  AddSol(-205.962, -182.36, 2.056, 1.4437, 1, 1, 0, -2);
+  AddSol(0.233, 0.36, 0.012, -25e-4, 1, 1, 0, -3);
+  AddSol(-4.391, -9.66, -0.471, 0.0673, 1, 1, 0, -4);
+  AddSol(0.283, 1.53, -0.111, 6e-3, 1, -1, 0, 4);
+  AddSol(14.577, 31.7, -1.54, 0.2302, 1, -1, 0, 2);
+  AddSol(147.687, 138.76, 0.679, 1.1528, 1, -1, 0, 0);
+  AddSol(-1.089, 0.55, 0.021, 0, 1, -1, 0, -1);
+  AddSol(28.475, 23.59, -0.443, -0.2257, 1, -1, 0, -2);
+  AddSol(-0.276, -0.38, -6e-3, -36e-4, 1, -1, 0, -3);
+  AddSol(0.636, 2.27, 0.146, -0.0102, 1, -1, 0, -4);
+  AddSol(-0.189, -1.68, 0.131, -28e-4, 0, 2, 0, 2);
+  AddSol(-7.486, -0.66, -0.037, -86e-4, 0, 2, 0, 0);
+  AddSol(-8.096, -16.35, -0.74, 0.0918, 0, 2, 0, -2);
+  AddSol(-5.741, -0.04, 0, -9e-4, 0, 0, 2, 2);
+  AddSol(0.255, 0, 0, 0, 0, 0, 2, 1);
+  AddSol(-411.608, -0.2, 0, -0.0124, 0, 0, 2, 0);
+  AddSol(0.584, 0.84, 0, 71e-4, 0, 0, 2, -1);
+  AddSol(-55.173, -52.14, 0, -0.1052, 0, 0, 2, -2);
+  AddSol(0.254, 0.25, 0, -17e-4, 0, 0, 2, -3);
+  AddSol(0.025, -1.67, 0, 31e-4, 0, 0, 2, -4);
+  AddSol(1.06, 2.96, -0.166, 0.0243, 3, 0, 0, 2);
+  AddSol(36.124, 50.64, -1.3, 0.6215, 3, 0, 0, 0);
+  AddSol(-13.193, -16.4, 0.258, -0.1187, 3, 0, 0, -2);
+  AddSol(-1.187, -0.74, 0.042, 74e-4, 3, 0, 0, -4);
+  AddSol(-0.293, -0.31, -2e-3, 46e-4, 3, 0, 0, -6);
+  AddSol(-0.29, -1.45, 0.116, -51e-4, 2, 1, 0, 2);
+  AddSol(-7.649, -10.56, 0.259, -0.1038, 2, 1, 0, 0);
+  AddSol(-8.627, -7.59, 0.078, -0.0192, 2, 1, 0, -2);
+  AddSol(-2.74, -2.54, 0.022, 0.0324, 2, 1, 0, -4);
+  AddSol(1.181, 3.32, -0.212, 0.0213, 2, -1, 0, 2);
+  AddSol(9.703, 11.67, -0.151, 0.1268, 2, -1, 0, 0);
+  AddSol(-0.352, -0.37, 1e-3, -28e-4, 2, -1, 0, -1);
+  AddSol(-2.494, -1.17, -3e-3, -17e-4, 2, -1, 0, -2);
+  AddSol(0.36, 0.2, -0.012, -43e-4, 2, -1, 0, -4);
+  AddSol(-1.167, -1.25, 8e-3, -0.0106, 1, 2, 0, 0);
+  AddSol(-7.412, -6.12, 0.117, 0.0484, 1, 2, 0, -2);
+  AddSol(-0.311, -0.65, -0.032, 44e-4, 1, 2, 0, -4);
+  AddSol(0.757, 1.82, -0.105, 0.0112, 1, -2, 0, 2);
+  AddSol(2.58, 2.32, 0.027, 0.0196, 1, -2, 0, 0);
+  AddSol(2.533, 2.4, -0.014, -0.0212, 1, -2, 0, -2);
+  AddSol(-0.344, -0.57, -0.025, 36e-4, 0, 3, 0, -2);
+  AddSol(-0.992, -0.02, 0, 0, 1, 0, 2, 2);
+  AddSol(-45.099, -0.02, 0, -1e-3, 1, 0, 2, 0);
+  AddSol(-0.179, -9.52, 0, -0.0833, 1, 0, 2, -2);
+  AddSol(-0.301, -0.33, 0, 14e-4, 1, 0, 2, -4);
+  AddSol(-6.382, -3.37, 0, -0.0481, 1, 0, -2, 2);
+  AddSol(39.528, 85.13, 0, -0.7136, 1, 0, -2, 0);
+  AddSol(9.366, 0.71, 0, -0.0112, 1, 0, -2, -2);
+  AddSol(0.202, 0.02, 0, 0, 1, 0, -2, -4);
+  AddSol(0.415, 0.1, 0, 13e-4, 0, 1, 2, 0);
+  AddSol(-2.152, -2.26, 0, -66e-4, 0, 1, 2, -2);
+  AddSol(-1.44, -1.3, 0, 14e-4, 0, 1, -2, 2);
+  AddSol(0.384, -0.04, 0, 0, 0, 1, -2, -2);
+  AddSol(1.938, 3.6, -0.145, 0.0401, 4, 0, 0, 0);
+  AddSol(-0.952, -1.58, 0.052, -0.013, 4, 0, 0, -2);
+  AddSol(-0.551, -0.94, 0.032, -97e-4, 3, 1, 0, 0);
+  AddSol(-0.482, -0.57, 5e-3, -45e-4, 3, 1, 0, -2);
+  AddSol(0.681, 0.96, -0.026, 0.0115, 3, -1, 0, 0);
+  AddSol(-0.297, -0.27, 2e-3, -9e-4, 2, 2, 0, -2);
+  AddSol(0.254, 0.21, -3e-3, 0, 2, -2, 0, -2);
+  AddSol(-0.25, -0.22, 4e-3, 14e-4, 1, 3, 0, -2);
+  AddSol(-3.996, 0, 0, 4e-4, 2, 0, 2, 0);
+  AddSol(0.557, -0.75, 0, -9e-3, 2, 0, 2, -2);
+  AddSol(-0.459, -0.38, 0, -53e-4, 2, 0, -2, 2);
+  AddSol(-1.298, 0.74, 0, 4e-4, 2, 0, -2, 0);
+  AddSol(0.538, 1.14, 0, -0.0141, 2, 0, -2, -2);
+  AddSol(0.263, 0.02, 0, 0, 1, 1, 2, 0);
+  AddSol(0.426, 0.07, 0, -6e-4, 1, 1, -2, -2);
+  AddSol(-0.304, 0.03, 0, 3e-4, 1, -1, 2, 0);
+  AddSol(-0.372, -0.19, 0, -27e-4, 1, -1, -2, 2);
+  AddSol(0.418, 0, 0, 0, 0, 0, 4, 0);
+  AddSol(-0.33, -0.04, 0, 0, 3, 0, 2, 0);
+  function ADDN(coeffn, p, q, r, s) {
+    return coeffn * Term(p, q, r, s).y;
+  }
+  N = 0;
+  N += ADDN(-526.069, 0, 0, 1, -2);
+  N += ADDN(-3.352, 0, 0, 1, -4);
+  N += ADDN(44.297, 1, 0, 1, -2);
+  N += ADDN(-6, 1, 0, 1, -4);
+  N += ADDN(20.599, -1, 0, 1, 0);
+  N += ADDN(-30.598, -1, 0, 1, -2);
+  N += ADDN(-24.649, -2, 0, 1, 0);
+  N += ADDN(-2, -2, 0, 1, -2);
+  N += ADDN(-22.571, 0, 1, 1, -2);
+  N += ADDN(10.985, 0, -1, 1, -2);
+  DLAM += 0.82 * Sine(0.7736 - 62.5512 * T) + 0.31 * Sine(0.0466 - 125.1025 * T) + 0.35 * Sine(0.5785 - 25.1042 * T) + 0.66 * Sine(0.4591 + 1335.8075 * T) + 0.64 * Sine(0.313 - 91.568 * T) + 1.14 * Sine(0.148 + 1331.2898 * T) + 0.21 * Sine(0.5918 + 1056.5859 * T) + 0.44 * Sine(0.5784 + 1322.8595 * T) + 0.24 * Sine(0.2275 - 5.7374 * T) + 0.28 * Sine(0.2965 + 2.6929 * T) + 0.33 * Sine(0.3132 + 6.3368 * T);
+  S = F + DS / ARC;
+  let lat_seconds = (1.000002708 + 139.978 * DGAM) * (18518.511 + 1.189 + GAM1C) * Math.sin(S) - 6.24 * Math.sin(3 * S) + N;
+  return {
+    geo_eclip_lon: PI2 * Frac((L0 + DLAM / ARC) / PI2),
+    geo_eclip_lat: Math.PI / (180 * 3600) * lat_seconds,
+    distance_au: ARC * EARTH_EQUATORIAL_RADIUS_AU / (0.999953253 * SINPI)
+  };
+}
+function rotate(rot, vec) {
+  return [
+    rot.rot[0][0] * vec[0] + rot.rot[1][0] * vec[1] + rot.rot[2][0] * vec[2],
+    rot.rot[0][1] * vec[0] + rot.rot[1][1] * vec[1] + rot.rot[2][1] * vec[2],
+    rot.rot[0][2] * vec[0] + rot.rot[1][2] * vec[1] + rot.rot[2][2] * vec[2]
+  ];
+}
+function precession(pos, time, dir) {
+  const r = precession_rot(time, dir);
+  return rotate(r, pos);
+}
+function precession_rot(time, dir) {
+  const t = time.tt / 36525;
+  let eps0 = 84381.406;
+  let psia = ((((-9.51e-8 * t + 132851e-9) * t - 114045e-8) * t - 1.0790069) * t + 5038.481507) * t;
+  let omegaa = ((((3337e-10 * t - 467e-9) * t - 772503e-8) * t + 0.0512623) * t - 0.025754) * t + eps0;
+  let chia = ((((-56e-9 * t + 170663e-9) * t - 121197e-8) * t - 2.3814292) * t + 10.556403) * t;
+  eps0 *= ASEC2RAD;
+  psia *= ASEC2RAD;
+  omegaa *= ASEC2RAD;
+  chia *= ASEC2RAD;
+  const sa2 = Math.sin(eps0);
+  const ca = Math.cos(eps0);
+  const sb = Math.sin(-psia);
+  const cb = Math.cos(-psia);
+  const sc = Math.sin(-omegaa);
+  const cc = Math.cos(-omegaa);
+  const sd = Math.sin(chia);
+  const cd = Math.cos(chia);
+  const xx = cd * cb - sb * sd * cc;
+  const yx = cd * sb * ca + sd * cc * cb * ca - sa2 * sd * sc;
+  const zx = cd * sb * sa2 + sd * cc * cb * sa2 + ca * sd * sc;
+  const xy = -sd * cb - sb * cd * cc;
+  const yy = -sd * sb * ca + cd * cc * cb * ca - sa2 * cd * sc;
+  const zy = -sd * sb * sa2 + cd * cc * cb * sa2 + ca * cd * sc;
+  const xz = sb * sc;
+  const yz = -sc * cb * ca - sa2 * cc;
+  const zz = -sc * cb * sa2 + cc * ca;
+  if (dir === PrecessDirection.Into2000) {
+    return new RotationMatrix([
+      [xx, yx, zx],
+      [xy, yy, zy],
+      [xz, yz, zz]
+    ]);
+  }
+  if (dir === PrecessDirection.From2000) {
+    return new RotationMatrix([
+      [xx, xy, xz],
+      [yx, yy, yz],
+      [zx, zy, zz]
+    ]);
+  }
+  throw "Invalid precess direction";
+}
+function era(time) {
+  const thet1 = 0.779057273264 + 0.00273781191135448 * time.ut;
+  const thet3 = time.ut % 1;
+  let theta = 360 * ((thet1 + thet3) % 1);
+  if (theta < 0) {
+    theta += 360;
+  }
+  return theta;
+}
+var sidereal_time_cache;
+function sidereal_time(time) {
+  if (!sidereal_time_cache || sidereal_time_cache.tt !== time.tt) {
+    const t = time.tt / 36525;
+    let eqeq = 15 * e_tilt(time).ee;
+    const theta = era(time);
+    const st = eqeq + 0.014506 + ((((-3.68e-8 * t - 29956e-9) * t - 44e-8) * t + 1.3915817) * t + 4612.156534) * t;
+    let gst = (st / 3600 + theta) % 360 / 15;
+    if (gst < 0) {
+      gst += 24;
+    }
+    sidereal_time_cache = {
+      tt: time.tt,
+      st: gst
+    };
+  }
+  return sidereal_time_cache.st;
+}
+function terra(observer, st) {
+  const phi = observer.latitude * DEG2RAD;
+  const sinphi = Math.sin(phi);
+  const cosphi = Math.cos(phi);
+  const c = 1 / Math.hypot(cosphi, EARTH_FLATTENING * sinphi);
+  const s = EARTH_FLATTENING_SQUARED * c;
+  const ht_km = observer.height / 1e3;
+  const ach = EARTH_EQUATORIAL_RADIUS_KM * c + ht_km;
+  const ash = EARTH_EQUATORIAL_RADIUS_KM * s + ht_km;
+  const stlocl = (15 * st + observer.longitude) * DEG2RAD;
+  const sinst = Math.sin(stlocl);
+  const cosst = Math.cos(stlocl);
+  return {
+    pos: [ach * cosphi * cosst / KM_PER_AU, ach * cosphi * sinst / KM_PER_AU, ash * sinphi / KM_PER_AU],
+    vel: [-ANGVEL * ach * cosphi * sinst * 86400 / KM_PER_AU, ANGVEL * ach * cosphi * cosst * 86400 / KM_PER_AU, 0]
+  };
+}
+function nutation(pos, time, dir) {
+  const r = nutation_rot(time, dir);
+  return rotate(r, pos);
+}
+function nutation_rot(time, dir) {
+  const tilt = e_tilt(time);
+  const oblm = tilt.mobl * DEG2RAD;
+  const oblt = tilt.tobl * DEG2RAD;
+  const psi = tilt.dpsi * ASEC2RAD;
+  const cobm = Math.cos(oblm);
+  const sobm = Math.sin(oblm);
+  const cobt = Math.cos(oblt);
+  const sobt = Math.sin(oblt);
+  const cpsi = Math.cos(psi);
+  const spsi = Math.sin(psi);
+  const xx = cpsi;
+  const yx = -spsi * cobm;
+  const zx = -spsi * sobm;
+  const xy = spsi * cobt;
+  const yy = cpsi * cobm * cobt + sobm * sobt;
+  const zy = cpsi * sobm * cobt - cobm * sobt;
+  const xz = spsi * sobt;
+  const yz = cpsi * cobm * sobt - sobm * cobt;
+  const zz = cpsi * sobm * sobt + cobm * cobt;
+  if (dir === PrecessDirection.From2000) {
+    return new RotationMatrix([
+      [xx, xy, xz],
+      [yx, yy, yz],
+      [zx, zy, zz]
+    ]);
+  }
+  if (dir === PrecessDirection.Into2000) {
+    return new RotationMatrix([
+      [xx, yx, zx],
+      [xy, yy, zy],
+      [xz, yz, zz]
+    ]);
+  }
+  throw "Invalid precess direction";
+}
+function gyration(pos, time, dir) {
+  return dir === PrecessDirection.Into2000 ? precession(nutation(pos, time, dir), time, dir) : nutation(precession(pos, time, dir), time, dir);
+}
+function geo_pos(time, observer) {
+  const gast = sidereal_time(time);
+  const pos = terra(observer, gast).pos;
+  return gyration(pos, time, PrecessDirection.Into2000);
+}
+var Vector = class {
+  constructor(x, y, z, t) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.t = t;
+  }
+  /**
+   * Returns the length of the vector in astronomical units (AU).
+   * @returns {number}
+   */
+  Length() {
+    return Math.hypot(this.x, this.y, this.z);
+  }
+};
+var StateVector = class {
+  constructor(x, y, z, vx, vy, vz, t) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.vx = vx;
+    this.vy = vy;
+    this.vz = vz;
+    this.t = t;
+  }
+};
+var Spherical = class {
+  constructor(lat, lon, dist) {
+    this.lat = VerifyNumber(lat);
+    this.lon = VerifyNumber(lon);
+    this.dist = VerifyNumber(dist);
+  }
+};
+var EquatorialCoordinates = class {
+  constructor(ra, dec, dist, vec) {
+    this.ra = VerifyNumber(ra);
+    this.dec = VerifyNumber(dec);
+    this.dist = VerifyNumber(dist);
+    this.vec = vec;
+  }
+};
+var RotationMatrix = class {
+  constructor(rot) {
+    this.rot = rot;
+  }
+};
+var HorizontalCoordinates = class {
+  constructor(azimuth, altitude, ra, dec) {
+    this.azimuth = VerifyNumber(azimuth);
+    this.altitude = VerifyNumber(altitude);
+    this.ra = VerifyNumber(ra);
+    this.dec = VerifyNumber(dec);
+  }
+};
+var EclipticCoordinates = class {
+  constructor(vec, elat, elon) {
+    this.vec = vec;
+    this.elat = VerifyNumber(elat);
+    this.elon = VerifyNumber(elon);
+  }
+};
+function VectorFromArray(av, time) {
+  return new Vector(av[0], av[1], av[2], time);
+}
+function vector2radec(pos, time) {
+  const vec = VectorFromArray(pos, time);
+  const xyproj = vec.x * vec.x + vec.y * vec.y;
+  const dist = Math.sqrt(xyproj + vec.z * vec.z);
+  if (xyproj === 0) {
+    if (vec.z === 0)
+      throw "Indeterminate sky coordinates";
+    return new EquatorialCoordinates(0, vec.z < 0 ? -90 : 90, dist, vec);
+  }
+  let ra = RAD2HOUR * Math.atan2(vec.y, vec.x);
+  if (ra < 0)
+    ra += 24;
+  const dec = RAD2DEG * Math.atan2(pos[2], Math.sqrt(xyproj));
+  return new EquatorialCoordinates(ra, dec, dist, vec);
+}
+function spin(angle, pos) {
+  const angr = angle * DEG2RAD;
+  const c = Math.cos(angr);
+  const s = Math.sin(angr);
+  return [c * pos[0] + s * pos[1], c * pos[1] - s * pos[0], pos[2]];
+}
+function Horizon(date, observer, ra, dec, refraction) {
+  let time = MakeTime(date);
+  VerifyObserver(observer);
+  VerifyNumber(ra);
+  VerifyNumber(dec);
+  const sinlat = Math.sin(observer.latitude * DEG2RAD);
+  const coslat = Math.cos(observer.latitude * DEG2RAD);
+  const sinlon = Math.sin(observer.longitude * DEG2RAD);
+  const coslon = Math.cos(observer.longitude * DEG2RAD);
+  const sindc = Math.sin(dec * DEG2RAD);
+  const cosdc = Math.cos(dec * DEG2RAD);
+  const sinra = Math.sin(ra * HOUR2RAD);
+  const cosra = Math.cos(ra * HOUR2RAD);
+  let uze = [coslat * coslon, coslat * sinlon, sinlat];
+  let une = [-sinlat * coslon, -sinlat * sinlon, coslat];
+  let uwe = [sinlon, -coslon, 0];
+  const spin_angle = -15 * sidereal_time(time);
+  let uz = spin(spin_angle, uze);
+  let un = spin(spin_angle, une);
+  let uw = spin(spin_angle, uwe);
+  let p = [cosdc * cosra, cosdc * sinra, sindc];
+  const pz = p[0] * uz[0] + p[1] * uz[1] + p[2] * uz[2];
+  const pn = p[0] * un[0] + p[1] * un[1] + p[2] * un[2];
+  const pw = p[0] * uw[0] + p[1] * uw[1] + p[2] * uw[2];
+  let proj = Math.hypot(pn, pw);
+  let az;
+  if (proj > 0) {
+    az = -RAD2DEG * Math.atan2(pw, pn);
+    if (az < 0)
+      az += 360;
+  } else {
+    az = 0;
+  }
+  let zd = RAD2DEG * Math.atan2(proj, pz);
+  let out_ra = ra;
+  let out_dec = dec;
+  return new HorizontalCoordinates(az, 90 - zd, out_ra, out_dec);
+}
+function VerifyObserver(observer) {
+  if (!(observer instanceof Observer)) {
+    throw `Not an instance of the Observer class: ${observer}`;
+  }
+  VerifyNumber(observer.latitude);
+  VerifyNumber(observer.longitude);
+  VerifyNumber(observer.height);
+  if (observer.latitude < -90 || observer.latitude > 90) {
+    throw `Latitude ${observer.latitude} is out of range. Must be -90..+90.`;
+  }
+  return observer;
+}
+var Observer = class {
+  constructor(latitude, longitude, height) {
+    this.latitude = latitude;
+    this.longitude = longitude;
+    this.height = height;
+    VerifyObserver(this);
+  }
+};
+function SunPosition(date) {
+  const time = MakeTime(date).AddDays(-1 / C_AUDAY);
+  const earth2000 = CalcVsop(vsop.Earth, time);
+  const sun2000 = [-earth2000.x, -earth2000.y, -earth2000.z];
+  const [gx, gy, gz] = gyration(sun2000, time, PrecessDirection.From2000);
+  const true_obliq = DEG2RAD * e_tilt(time).tobl;
+  const cos_ob = Math.cos(true_obliq);
+  const sin_ob = Math.sin(true_obliq);
+  const vec = new Vector(gx, gy, gz, time);
+  const sun_ecliptic = RotateEquatorialToEcliptic(vec, cos_ob, sin_ob);
+  return sun_ecliptic;
+}
+function Equator(body, date, observer, ofdate, aberration) {
+  VerifyObserver(observer);
+  const time = MakeTime(date);
+  const gc_observer = geo_pos(time, observer);
+  const gc = GeoVector(body, time, aberration);
+  const j2000 = [
+    gc.x - gc_observer[0],
+    gc.y - gc_observer[1],
+    gc.z - gc_observer[2]
+  ];
+  const datevect = gyration(j2000, time, PrecessDirection.From2000);
+  return vector2radec(datevect, time);
+}
+function RotateEquatorialToEcliptic(equ, cos_ob, sin_ob) {
+  const ex = equ.x;
+  const ey = equ.y * cos_ob + equ.z * sin_ob;
+  const ez = -equ.y * sin_ob + equ.z * cos_ob;
+  const xyproj = Math.hypot(ex, ey);
+  let elon = 0;
+  if (xyproj > 0) {
+    elon = RAD2DEG * Math.atan2(ey, ex);
+    if (elon < 0)
+      elon += 360;
+  }
+  let elat = RAD2DEG * Math.atan2(ez, xyproj);
+  let ecl = new Vector(ex, ey, ez, equ.t);
+  return new EclipticCoordinates(ecl, elat, elon);
+}
+function Ecliptic(eqj) {
+  const et = e_tilt(eqj.t);
+  const eqj_pos = [eqj.x, eqj.y, eqj.z];
+  const mean_pos = precession(eqj_pos, eqj.t, PrecessDirection.From2000);
+  const [x, y, z] = nutation(mean_pos, eqj.t, PrecessDirection.From2000);
+  const eqd = new Vector(x, y, z, eqj.t);
+  const tobl = et.tobl * DEG2RAD;
+  return RotateEquatorialToEcliptic(eqd, Math.cos(tobl), Math.sin(tobl));
+}
+function GeoMoon(date) {
+  const time = MakeTime(date);
+  const moon = CalcMoon(time);
+  const dist_cos_lat = moon.distance_au * Math.cos(moon.geo_eclip_lat);
+  const gepos = [
+    dist_cos_lat * Math.cos(moon.geo_eclip_lon),
+    dist_cos_lat * Math.sin(moon.geo_eclip_lon),
+    moon.distance_au * Math.sin(moon.geo_eclip_lat)
+  ];
+  const mpos1 = ecl2equ_vec(time, gepos);
+  const mpos2 = precession(mpos1, time, PrecessDirection.Into2000);
+  return new Vector(mpos2[0], mpos2[1], mpos2[2], time);
+}
+function GeoMoonState(date) {
+  const time = MakeTime(date);
+  const dt = 1e-5;
+  const t1 = time.AddDays(-dt);
+  const t2 = time.AddDays(+dt);
+  const r1 = GeoMoon(t1);
+  const r2 = GeoMoon(t2);
+  return new StateVector((r1.x + r2.x) / 2, (r1.y + r2.y) / 2, (r1.z + r2.z) / 2, (r2.x - r1.x) / (2 * dt), (r2.y - r1.y) / (2 * dt), (r2.z - r1.z) / (2 * dt), time);
+}
+function GeoEmbState(date) {
+  const time = MakeTime(date);
+  const s = GeoMoonState(time);
+  const d = 1 + EARTH_MOON_MASS_RATIO;
+  return new StateVector(s.x / d, s.y / d, s.z / d, s.vx / d, s.vy / d, s.vz / d, time);
+}
+function VsopFormula(formula, t, clamp_angle) {
+  let tpower = 1;
+  let coord = 0;
+  for (let series of formula) {
+    let sum = 0;
+    for (let [ampl, phas, freq] of series)
+      sum += ampl * Math.cos(phas + t * freq);
+    let incr = tpower * sum;
+    if (clamp_angle)
+      incr %= PI2;
+    coord += incr;
+    tpower *= t;
+  }
+  return coord;
+}
+function VsopDeriv(formula, t) {
+  let tpower = 1;
+  let dpower = 0;
+  let deriv = 0;
+  let s = 0;
+  for (let series of formula) {
+    let sin_sum = 0;
+    let cos_sum = 0;
+    for (let [ampl, phas, freq] of series) {
+      let angle = phas + t * freq;
+      sin_sum += ampl * freq * Math.sin(angle);
+      if (s > 0)
+        cos_sum += ampl * Math.cos(angle);
+    }
+    deriv += s * dpower * cos_sum - tpower * sin_sum;
+    dpower = tpower;
+    tpower *= t;
+    ++s;
+  }
+  return deriv;
+}
+var DAYS_PER_MILLENNIUM = 365250;
+var LON_INDEX = 0;
+var LAT_INDEX = 1;
+var RAD_INDEX = 2;
+function VsopRotate(eclip) {
+  return new TerseVector(eclip[0] + 44036e-11 * eclip[1] - 190919e-12 * eclip[2], -4.79966e-7 * eclip[0] + 0.917482137087 * eclip[1] - 0.397776982902 * eclip[2], 0.397776982902 * eclip[1] + 0.917482137087 * eclip[2]);
+}
+function VsopSphereToRect(lon, lat, radius) {
+  const r_coslat = radius * Math.cos(lat);
+  const coslon = Math.cos(lon);
+  const sinlon = Math.sin(lon);
+  return [
+    r_coslat * coslon,
+    r_coslat * sinlon,
+    radius * Math.sin(lat)
+  ];
+}
+function CalcVsop(model, time) {
+  const t = time.tt / DAYS_PER_MILLENNIUM;
+  const lon = VsopFormula(model[LON_INDEX], t, true);
+  const lat = VsopFormula(model[LAT_INDEX], t, false);
+  const rad = VsopFormula(model[RAD_INDEX], t, false);
+  const eclip = VsopSphereToRect(lon, lat, rad);
+  return VsopRotate(eclip).ToAstroVector(time);
+}
+function CalcVsopPosVel(model, tt) {
+  const t = tt / DAYS_PER_MILLENNIUM;
+  const lon = VsopFormula(model[LON_INDEX], t, true);
+  const lat = VsopFormula(model[LAT_INDEX], t, false);
+  const rad = VsopFormula(model[RAD_INDEX], t, false);
+  const dlon_dt = VsopDeriv(model[LON_INDEX], t);
+  const dlat_dt = VsopDeriv(model[LAT_INDEX], t);
+  const drad_dt = VsopDeriv(model[RAD_INDEX], t);
+  const coslon = Math.cos(lon);
+  const sinlon = Math.sin(lon);
+  const coslat = Math.cos(lat);
+  const sinlat = Math.sin(lat);
+  const vx = +(drad_dt * coslat * coslon) - rad * sinlat * coslon * dlat_dt - rad * coslat * sinlon * dlon_dt;
+  const vy = +(drad_dt * coslat * sinlon) - rad * sinlat * sinlon * dlat_dt + rad * coslat * coslon * dlon_dt;
+  const vz = +(drad_dt * sinlat) + rad * coslat * dlat_dt;
+  const eclip_pos = VsopSphereToRect(lon, lat, rad);
+  const eclip_vel = [
+    vx / DAYS_PER_MILLENNIUM,
+    vy / DAYS_PER_MILLENNIUM,
+    vz / DAYS_PER_MILLENNIUM
+  ];
+  const equ_pos = VsopRotate(eclip_pos);
+  const equ_vel = VsopRotate(eclip_vel);
+  return new body_state_t(tt, equ_pos, equ_vel);
+}
+function AdjustBarycenter(ssb, time, body, pmass) {
+  const shift = pmass / (pmass + SUN_GM);
+  const planet = CalcVsop(vsop[body], time);
+  ssb.x += shift * planet.x;
+  ssb.y += shift * planet.y;
+  ssb.z += shift * planet.z;
+}
+function CalcSolarSystemBarycenter(time) {
+  const ssb = new Vector(0, 0, 0, time);
+  AdjustBarycenter(ssb, time, Body.Jupiter, JUPITER_GM);
+  AdjustBarycenter(ssb, time, Body.Saturn, SATURN_GM);
+  AdjustBarycenter(ssb, time, Body.Uranus, URANUS_GM);
+  AdjustBarycenter(ssb, time, Body.Neptune, NEPTUNE_GM);
+  return ssb;
+}
+var PLUTO_NUM_STATES = 51;
+var PLUTO_TIME_STEP = 29200;
+var PLUTO_DT = 146;
+var PLUTO_NSTEPS = 201;
+var PlutoStateTable = [
+  [-73e4, [-26.118207232108, -14.376168177825, 3.384402515299], [0.0016339372163656, -0.0027861699588508, -0.0013585880229445]],
+  [-700800, [41.974905202127, -0.448502952929, -12.770351505989], [73458569351457e-17, 0.0022785014891658, 48619778602049e-17]],
+  [-671600, [14.706930780744, 44.269110540027, 9.353698474772], [-0.00210001479998, 22295915939915e-17, 70143443551414e-17]],
+  [-642400, [-29.441003929957, -6.43016153057, 6.858481011305], [84495803960544e-17, -0.0030783914758711, -0.0012106305981192]],
+  [-613200, [39.444396946234, -6.557989760571, -13.913760296463], [0.0011480029005873, 0.0022400006880665, 35168075922288e-17]],
+  [-584e3, [20.2303809507, 43.266966657189, 7.382966091923], [-0.0019754081700585, 53457141292226e-17, 75929169129793e-17]],
+  [-554800, [-30.65832536462, 2.093818874552, 9.880531138071], [61010603013347e-18, -0.0031326500935382, -99346125151067e-17]],
+  [-525600, [35.737703251673, -12.587706024764, -14.677847247563], [0.0015802939375649, 0.0021347678412429, 19074436384343e-17]],
+  [-496400, [25.466295188546, 41.367478338417, 5.216476873382], [-0.0018054401046468, 8328308359951e-16, 80260156912107e-17]],
+  [-467200, [-29.847174904071, 10.636426313081, 12.297904180106], [-63257063052907e-17, -0.0029969577578221, -74476074151596e-17]],
+  [-438e3, [30.774692107687, -18.236637015304, -14.945535879896], [0.0020113162005465, 0.0019353827024189, -20937793168297e-19]],
+  [-408800, [30.243153324028, 38.656267888503, 2.938501750218], [-0.0016052508674468, 0.0011183495337525, 83333973416824e-17]],
+  [-379600, [-27.288984772533, 18.643162147874, 14.023633623329], [-0.0011856388898191, -0.0027170609282181, -49015526126399e-17]],
+  [-350400, [24.519605196774, -23.245756064727, -14.626862367368], [0.0024322321483154, 0.0016062008146048, -23369181613312e-17]],
+  [-321200, [34.505274805875, 35.125338586954, 0.557361475637], [-0.0013824391637782, 0.0013833397561817, 84823598806262e-17]],
+  [-292e3, [-23.275363915119, 25.818514298769, 15.055381588598], [-0.0016062295460975, -0.0023395961498533, -24377362639479e-17]],
+  [-262800, [17.050384798092, -27.180376290126, -13.608963321694], [0.0028175521080578, 0.0011358749093955, -49548725258825e-17]],
+  [-233600, [38.093671910285, 30.880588383337, -1.843688067413], [-0.0011317697153459, 0.0016128814698472, 84177586176055e-17]],
+  [-204400, [-18.197852930878, 31.932869934309, 15.438294826279], [-0.0019117272501813, -0.0019146495909842, -19657304369835e-18]],
+  [-175200, [8.528924039997, -29.618422200048, -11.805400994258], [0.0031034370787005, 5139363329243e-16, -77293066202546e-17]],
+  [-146e3, [40.94685725864, 25.904973592021, -4.256336240499], [-83652705194051e-17, 0.0018129497136404, 8156422827306e-16]],
+  [-116800, [-12.326958895325, 36.881883446292, 15.217158258711], [-0.0021166103705038, -0.001481442003599, 17401209844705e-17]],
+  [-87600, [-0.633258375909, -30.018759794709, -9.17193287495], [0.0032016994581737, -25279858672148e-17, -0.0010411088271861]],
+  [-58400, [42.936048423883, 20.344685584452, -6.588027007912], [-50525450073192e-17, 0.0019910074335507, 77440196540269e-17]],
+  [-29200, [-5.975910552974, 40.61180995846, 14.470131723673], [-0.0022184202156107, -0.0010562361130164, 33652250216211e-17]],
+  [0, [-9.875369580774, -27.978926224737, -5.753711824704], [0.0030287533248818, -0.0011276087003636, -0.0012651326732361]],
+  [29200, [43.958831986165, 14.214147973292, -8.808306227163], [-14717608981871e-17, 0.0021404187242141, 71486567806614e-17]],
+  [58400, [0.67813676352, 43.094461639362, 13.243238780721], [-0.0022358226110718, -63233636090933e-17, 47664798895648e-17]],
+  [87600, [-18.282602096834, -23.30503958666, -1.766620508028], [0.0025567245263557, -0.0019902940754171, -0.0013943491701082]],
+  [116800, [43.873338744526, 7.700705617215, -10.814273666425], [23174803055677e-17, 0.0022402163127924, 62988756452032e-17]],
+  [146e3, [7.392949027906, 44.382678951534, 11.629500214854], [-0.002193281545383, -21751799585364e-17, 59556516201114e-17]],
+  [175200, [-24.981690229261, -16.204012851426, 2.466457544298], [0.001819398914958, -0.0026765419531201, -0.0013848283502247]],
+  [204400, [42.530187039511, 0.845935508021, -12.554907527683], [65059779150669e-17, 0.0022725657282262, 51133743202822e-17]],
+  [233600, [13.999526486822, 44.462363044894, 9.669418486465], [-0.0021079296569252, 17533423831993e-17, 69128485798076e-17]],
+  [262800, [-29.184024803031, -7.371243995762, 6.493275957928], [93581363109681e-17, -0.0030610357109184, -0.0012364201089345]],
+  [292e3, [39.831980671753, -6.078405766765, -13.909815358656], [0.0011117769689167, 0.0022362097830152, 36230548231153e-17]],
+  [321200, [20.294955108476, 43.417190420251, 7.450091985932], [-0.0019742157451535, 53102050468554e-17, 75938408813008e-17]],
+  [350400, [-30.66999230216, 2.318743558955, 9.973480913858], [45605107450676e-18, -0.0031308219926928, -99066533301924e-17]],
+  [379600, [35.626122155983, -12.897647509224, -14.777586508444], [0.0016015684949743, 0.0021171931182284, 18002516202204e-17]],
+  [408800, [26.133186148561, 41.232139187599, 5.00640132622], [-0.0017857704419579, 86046232702817e-17, 80614690298954e-17]],
+  [438e3, [-29.57674022923, 11.863535943587, 12.631323039872], [-72292830060955e-17, -0.0029587820140709, -708242964503e-15]],
+  [467200, [29.910805787391, -19.159019294, -15.013363865194], [0.0020871080437997, 0.0018848372554514, -38528655083926e-18]],
+  [496400, [31.375957451819, 38.050372720763, 2.433138343754], [-0.0015546055556611, 0.0011699815465629, 83565439266001e-17]],
+  [525600, [-26.360071336928, 20.662505904952, 14.414696258958], [-0.0013142373118349, -0.0026236647854842, -42542017598193e-17]],
+  [554800, [22.599441488648, -24.508879898306, -14.484045731468], [0.0025454108304806, 0.0014917058755191, -30243665086079e-17]],
+  [584e3, [35.877864013014, 33.894226366071, -0.224524636277], [-0.0012941245730845, 0.0014560427668319, 84762160640137e-17]],
+  [613200, [-21.538149762417, 28.204068269761, 15.321973799534], [-0.001731211740901, -0.0021939631314577, -1631691327518e-16]],
+  [642400, [13.971521374415, -28.339941764789, -13.083792871886], [0.0029334630526035, 91860931752944e-17, -59939422488627e-17]],
+  [671600, [39.526942044143, 28.93989736011, -2.872799527539], [-0.0010068481658095, 0.001702113288809, 83578230511981e-17]],
+  [700800, [-15.576200701394, 34.399412961275, 15.466033737854], [-0.0020098814612884, -0.0017191109825989, 70414782780416e-18]],
+  [73e4, [4.24325283709, -30.118201690825, -10.707441231349], [0.0031725847067411, 1609846120227e-16, -90672150593868e-17]]
+];
+var TerseVector = class _TerseVector {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  clone() {
+    return new _TerseVector(this.x, this.y, this.z);
+  }
+  ToAstroVector(t) {
+    return new Vector(this.x, this.y, this.z, t);
+  }
+  static zero() {
+    return new _TerseVector(0, 0, 0);
+  }
+  quadrature() {
+    return this.x * this.x + this.y * this.y + this.z * this.z;
+  }
+  add(other) {
+    return new _TerseVector(this.x + other.x, this.y + other.y, this.z + other.z);
+  }
+  sub(other) {
+    return new _TerseVector(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+  incr(other) {
+    this.x += other.x;
+    this.y += other.y;
+    this.z += other.z;
+  }
+  decr(other) {
+    this.x -= other.x;
+    this.y -= other.y;
+    this.z -= other.z;
+  }
+  mul(scalar) {
+    return new _TerseVector(scalar * this.x, scalar * this.y, scalar * this.z);
+  }
+  div(scalar) {
+    return new _TerseVector(this.x / scalar, this.y / scalar, this.z / scalar);
+  }
+  mean(other) {
+    return new _TerseVector((this.x + other.x) / 2, (this.y + other.y) / 2, (this.z + other.z) / 2);
+  }
+  neg() {
+    return new _TerseVector(-this.x, -this.y, -this.z);
+  }
+};
+var body_state_t = class _body_state_t {
+  constructor(tt, r, v) {
+    this.tt = tt;
+    this.r = r;
+    this.v = v;
+  }
+  clone() {
+    return new _body_state_t(this.tt, this.r, this.v);
+  }
+  sub(other) {
+    return new _body_state_t(this.tt, this.r.sub(other.r), this.v.sub(other.v));
+  }
+};
+function BodyStateFromTable(entry) {
+  let [tt, [rx, ry, rz], [vx, vy, vz]] = entry;
+  return new body_state_t(tt, new TerseVector(rx, ry, rz), new TerseVector(vx, vy, vz));
+}
+function AdjustBarycenterPosVel(ssb, tt, body, planet_gm) {
+  const shift = planet_gm / (planet_gm + SUN_GM);
+  const planet = CalcVsopPosVel(vsop[body], tt);
+  ssb.r.incr(planet.r.mul(shift));
+  ssb.v.incr(planet.v.mul(shift));
+  return planet;
+}
+function AccelerationIncrement(small_pos, gm, major_pos) {
+  const delta = major_pos.sub(small_pos);
+  const r2 = delta.quadrature();
+  return delta.mul(gm / (r2 * Math.sqrt(r2)));
+}
+var major_bodies_t = class {
+  constructor(tt) {
+    let ssb = new body_state_t(tt, new TerseVector(0, 0, 0), new TerseVector(0, 0, 0));
+    this.Jupiter = AdjustBarycenterPosVel(ssb, tt, Body.Jupiter, JUPITER_GM);
+    this.Saturn = AdjustBarycenterPosVel(ssb, tt, Body.Saturn, SATURN_GM);
+    this.Uranus = AdjustBarycenterPosVel(ssb, tt, Body.Uranus, URANUS_GM);
+    this.Neptune = AdjustBarycenterPosVel(ssb, tt, Body.Neptune, NEPTUNE_GM);
+    this.Jupiter.r.decr(ssb.r);
+    this.Jupiter.v.decr(ssb.v);
+    this.Saturn.r.decr(ssb.r);
+    this.Saturn.v.decr(ssb.v);
+    this.Uranus.r.decr(ssb.r);
+    this.Uranus.v.decr(ssb.v);
+    this.Neptune.r.decr(ssb.r);
+    this.Neptune.v.decr(ssb.v);
+    this.Sun = new body_state_t(tt, ssb.r.mul(-1), ssb.v.mul(-1));
+  }
+  Acceleration(pos) {
+    let acc = AccelerationIncrement(pos, SUN_GM, this.Sun.r);
+    acc.incr(AccelerationIncrement(pos, JUPITER_GM, this.Jupiter.r));
+    acc.incr(AccelerationIncrement(pos, SATURN_GM, this.Saturn.r));
+    acc.incr(AccelerationIncrement(pos, URANUS_GM, this.Uranus.r));
+    acc.incr(AccelerationIncrement(pos, NEPTUNE_GM, this.Neptune.r));
+    return acc;
+  }
+};
+var body_grav_calc_t = class _body_grav_calc_t {
+  constructor(tt, r, v, a) {
+    this.tt = tt;
+    this.r = r;
+    this.v = v;
+    this.a = a;
+  }
+  clone() {
+    return new _body_grav_calc_t(this.tt, this.r.clone(), this.v.clone(), this.a.clone());
+  }
+};
+var grav_sim_t = class {
+  constructor(bary, grav) {
+    this.bary = bary;
+    this.grav = grav;
+  }
+};
+function UpdatePosition(dt, r, v, a) {
+  return new TerseVector(r.x + dt * (v.x + dt * a.x / 2), r.y + dt * (v.y + dt * a.y / 2), r.z + dt * (v.z + dt * a.z / 2));
+}
+function UpdateVelocity(dt, v, a) {
+  return new TerseVector(v.x + dt * a.x, v.y + dt * a.y, v.z + dt * a.z);
+}
+function GravSim(tt2, calc1) {
+  const dt = tt2 - calc1.tt;
+  const bary2 = new major_bodies_t(tt2);
+  const approx_pos = UpdatePosition(dt, calc1.r, calc1.v, calc1.a);
+  const mean_acc = bary2.Acceleration(approx_pos).mean(calc1.a);
+  const pos = UpdatePosition(dt, calc1.r, calc1.v, mean_acc);
+  const vel = calc1.v.add(mean_acc.mul(dt));
+  const acc = bary2.Acceleration(pos);
+  const grav = new body_grav_calc_t(tt2, pos, vel, acc);
+  return new grav_sim_t(bary2, grav);
+}
+var pluto_cache = [];
+function ClampIndex(frac, nsteps) {
+  const index = Math.floor(frac);
+  if (index < 0)
+    return 0;
+  if (index >= nsteps)
+    return nsteps - 1;
+  return index;
+}
+function GravFromState(entry) {
+  const state = BodyStateFromTable(entry);
+  const bary = new major_bodies_t(state.tt);
+  const r = state.r.add(bary.Sun.r);
+  const v = state.v.add(bary.Sun.v);
+  const a = bary.Acceleration(r);
+  const grav = new body_grav_calc_t(state.tt, r, v, a);
+  return new grav_sim_t(bary, grav);
+}
+function GetSegment(cache, tt) {
+  const t0 = PlutoStateTable[0][0];
+  if (tt < t0 || tt > PlutoStateTable[PLUTO_NUM_STATES - 1][0]) {
+    return null;
+  }
+  const seg_index = ClampIndex((tt - t0) / PLUTO_TIME_STEP, PLUTO_NUM_STATES - 1);
+  if (!cache[seg_index]) {
+    const seg = cache[seg_index] = [];
+    seg[0] = GravFromState(PlutoStateTable[seg_index]).grav;
+    seg[PLUTO_NSTEPS - 1] = GravFromState(PlutoStateTable[seg_index + 1]).grav;
+    let i;
+    let step_tt = seg[0].tt;
+    for (i = 1; i < PLUTO_NSTEPS - 1; ++i)
+      seg[i] = GravSim(step_tt += PLUTO_DT, seg[i - 1]).grav;
+    step_tt = seg[PLUTO_NSTEPS - 1].tt;
+    var reverse = [];
+    reverse[PLUTO_NSTEPS - 1] = seg[PLUTO_NSTEPS - 1];
+    for (i = PLUTO_NSTEPS - 2; i > 0; --i)
+      reverse[i] = GravSim(step_tt -= PLUTO_DT, reverse[i + 1]).grav;
+    for (i = PLUTO_NSTEPS - 2; i > 0; --i) {
+      const ramp = i / (PLUTO_NSTEPS - 1);
+      seg[i].r = seg[i].r.mul(1 - ramp).add(reverse[i].r.mul(ramp));
+      seg[i].v = seg[i].v.mul(1 - ramp).add(reverse[i].v.mul(ramp));
+      seg[i].a = seg[i].a.mul(1 - ramp).add(reverse[i].a.mul(ramp));
+    }
+  }
+  return cache[seg_index];
+}
+function CalcPlutoOneWay(entry, target_tt, dt) {
+  let sim = GravFromState(entry);
+  const n = Math.ceil((target_tt - sim.grav.tt) / dt);
+  for (let i = 0; i < n; ++i)
+    sim = GravSim(i + 1 === n ? target_tt : sim.grav.tt + dt, sim.grav);
+  return sim;
+}
+function CalcPluto(time, helio) {
+  let r, v, bary;
+  const seg = GetSegment(pluto_cache, time.tt);
+  if (!seg) {
+    let sim;
+    if (time.tt < PlutoStateTable[0][0])
+      sim = CalcPlutoOneWay(PlutoStateTable[0], time.tt, -PLUTO_DT);
+    else
+      sim = CalcPlutoOneWay(PlutoStateTable[PLUTO_NUM_STATES - 1], time.tt, +PLUTO_DT);
+    r = sim.grav.r;
+    v = sim.grav.v;
+    bary = sim.bary;
+  } else {
+    const left = ClampIndex((time.tt - seg[0].tt) / PLUTO_DT, PLUTO_NSTEPS - 1);
+    const s1 = seg[left];
+    const s2 = seg[left + 1];
+    const acc = s1.a.mean(s2.a);
+    const ra = UpdatePosition(time.tt - s1.tt, s1.r, s1.v, acc);
+    const va = UpdateVelocity(time.tt - s1.tt, s1.v, acc);
+    const rb = UpdatePosition(time.tt - s2.tt, s2.r, s2.v, acc);
+    const vb = UpdateVelocity(time.tt - s2.tt, s2.v, acc);
+    const ramp = (time.tt - s1.tt) / PLUTO_DT;
+    r = ra.mul(1 - ramp).add(rb.mul(ramp));
+    v = va.mul(1 - ramp).add(vb.mul(ramp));
+  }
+  {
+    if (!bary)
+      bary = new major_bodies_t(time.tt);
+    r = r.sub(bary.Sun.r);
+    v = v.sub(bary.Sun.v);
+  }
+  return new StateVector(r.x, r.y, r.z, v.x, v.y, v.z, time);
+}
+function HelioVector(body, date) {
+  var time = MakeTime(date);
+  if (body in vsop)
+    return CalcVsop(vsop[body], time);
+  if (body === Body.Pluto) {
+    const p = CalcPluto(time);
+    return new Vector(p.x, p.y, p.z, time);
+  }
+  if (body === Body.Sun)
+    return new Vector(0, 0, 0, time);
+  if (body === Body.Moon) {
+    var e = CalcVsop(vsop.Earth, time);
+    var m = GeoMoon(time);
+    return new Vector(e.x + m.x, e.y + m.y, e.z + m.z, time);
+  }
+  if (body === Body.EMB) {
+    const e2 = CalcVsop(vsop.Earth, time);
+    const m2 = GeoMoon(time);
+    const denom = 1 + EARTH_MOON_MASS_RATIO;
+    return new Vector(e2.x + m2.x / denom, e2.y + m2.y / denom, e2.z + m2.z / denom, time);
+  }
+  if (body === Body.SSB)
+    return CalcSolarSystemBarycenter(time);
+  const star = UserDefinedStar(body);
+  if (star) {
+    const sphere = new Spherical(star.dec, 15 * star.ra, star.dist);
+    return VectorFromSphere(sphere, time);
+  }
+  throw `HelioVector: Unknown body "${body}"`;
+}
+function CorrectLightTravel(func, time) {
+  let ltime = time;
+  let dt = 0;
+  for (let iter = 0; iter < 10; ++iter) {
+    const pos = func(ltime);
+    const lt = pos.Length() / C_AUDAY;
+    if (lt > 1)
+      throw `Object is too distant for light-travel solver.`;
+    const ltime2 = time.AddDays(-lt);
+    dt = Math.abs(ltime2.tt - ltime.tt);
+    if (dt < 1e-9)
+      return pos;
+    ltime = ltime2;
+  }
+  throw `Light-travel time solver did not converge: dt = ${dt}`;
+}
+var BodyPosition = class {
+  constructor(observerBody, targetBody, aberration, observerPos) {
+    this.observerBody = observerBody;
+    this.targetBody = targetBody;
+    this.aberration = aberration;
+    this.observerPos = observerPos;
+  }
+  Position(time) {
+    if (this.aberration) {
+      this.observerPos = HelioVector(this.observerBody, time);
+    }
+    const targetPos = HelioVector(this.targetBody, time);
+    return new Vector(targetPos.x - this.observerPos.x, targetPos.y - this.observerPos.y, targetPos.z - this.observerPos.z, time);
+  }
+};
+function BackdatePosition(date, observerBody, targetBody, aberration) {
+  const time = MakeTime(date);
+  if (UserDefinedStar(targetBody)) {
+    const tvec = HelioVector(targetBody, time);
+    {
+      const ostate = HelioState(observerBody, time);
+      const rvec = new Vector(tvec.x - ostate.x, tvec.y - ostate.y, tvec.z - ostate.z, time);
+      const s = C_AUDAY / rvec.Length();
+      return new Vector(rvec.x + ostate.vx / s, rvec.y + ostate.vy / s, rvec.z + ostate.vz / s, time);
+    }
+  }
+  let observerPos;
+  {
+    observerPos = new Vector(0, 0, 0, time);
+  }
+  const bpos = new BodyPosition(observerBody, targetBody, aberration, observerPos);
+  return CorrectLightTravel((t) => bpos.Position(t), time);
+}
+function GeoVector(body, date, aberration) {
+  const time = MakeTime(date);
+  switch (body) {
+    case Body.Earth:
+      return new Vector(0, 0, 0, time);
+    case Body.Moon:
+      return GeoMoon(time);
+    default:
+      const vec = BackdatePosition(time, Body.Earth, body, aberration);
+      vec.t = time;
+      return vec;
+  }
+}
+function ExportState(terse, time) {
+  return new StateVector(terse.r.x, terse.r.y, terse.r.z, terse.v.x, terse.v.y, terse.v.z, time);
+}
+function HelioState(body, date) {
+  const time = MakeTime(date);
+  switch (body) {
+    case Body.Sun:
+      return new StateVector(0, 0, 0, 0, 0, 0, time);
+    case Body.SSB:
+      const bary = new major_bodies_t(time.tt);
+      return new StateVector(-bary.Sun.r.x, -bary.Sun.r.y, -bary.Sun.r.z, -bary.Sun.v.x, -bary.Sun.v.y, -bary.Sun.v.z, time);
+    case Body.Mercury:
+    case Body.Venus:
+    case Body.Earth:
+    case Body.Mars:
+    case Body.Jupiter:
+    case Body.Saturn:
+    case Body.Uranus:
+    case Body.Neptune:
+      const planet = CalcVsopPosVel(vsop[body], time.tt);
+      return ExportState(planet, time);
+    case Body.Pluto:
+      return CalcPluto(time);
+    case Body.Moon:
+    case Body.EMB:
+      const earth = CalcVsopPosVel(vsop.Earth, time.tt);
+      const state = body == Body.Moon ? GeoMoonState(time) : GeoEmbState(time);
+      return new StateVector(state.x + earth.r.x, state.y + earth.r.y, state.z + earth.r.z, state.vx + earth.v.x, state.vy + earth.v.y, state.vz + earth.v.z, time);
+    default:
+      if (UserDefinedStar(body)) {
+        const vec = HelioVector(body, time);
+        return new StateVector(vec.x, vec.y, vec.z, 0, 0, 0, time);
+      }
+      throw `HelioState: Unsupported body "${body}"`;
+  }
+}
+function QuadInterp(tm, dt, fa, fm, fb) {
+  let Q = (fb + fa) / 2 - fm;
+  let R = (fb - fa) / 2;
+  let S = fm;
+  let x;
+  if (Q == 0) {
+    if (R == 0) {
+      return null;
+    }
+    x = -S / R;
+    if (x < -1 || x > 1)
+      return null;
+  } else {
+    let u = R * R - 4 * Q * S;
+    if (u <= 0)
+      return null;
+    let ru = Math.sqrt(u);
+    let x1 = (-R + ru) / (2 * Q);
+    let x2 = (-R - ru) / (2 * Q);
+    if (-1 <= x1 && x1 <= 1) {
+      if (-1 <= x2 && x2 <= 1)
+        return null;
+      x = x1;
+    } else if (-1 <= x2 && x2 <= 1) {
+      x = x2;
+    } else {
+      return null;
+    }
+  }
+  let t = tm + x * dt;
+  let df_dt = (2 * Q * x + R) / dt;
+  return { t, df_dt };
+}
+function Search(f, t1, t2, options) {
+  const dt_tolerance_seconds = VerifyNumber(options && options.dt_tolerance_seconds || 1);
+  const dt_days = Math.abs(dt_tolerance_seconds / SECONDS_PER_DAY);
+  let f1 = options && options.init_f1 || f(t1);
+  let f2 = options && options.init_f2 || f(t2);
+  let fmid = NaN;
+  let iter = 0;
+  let iter_limit = options && options.iter_limit || 20;
+  let calc_fmid = true;
+  while (true) {
+    if (++iter > iter_limit)
+      throw `Excessive iteration in Search()`;
+    let tmid = InterpolateTime(t1, t2, 0.5);
+    let dt = tmid.ut - t1.ut;
+    if (Math.abs(dt) < dt_days) {
+      return tmid;
+    }
+    if (calc_fmid)
+      fmid = f(tmid);
+    else
+      calc_fmid = true;
+    let q = QuadInterp(tmid.ut, t2.ut - tmid.ut, f1, fmid, f2);
+    if (q) {
+      let tq = MakeTime(q.t);
+      let fq = f(tq);
+      if (q.df_dt !== 0) {
+        if (Math.abs(fq / q.df_dt) < dt_days) {
+          return tq;
+        }
+        let dt_guess = 1.2 * Math.abs(fq / q.df_dt);
+        if (dt_guess < dt / 10) {
+          let tleft = tq.AddDays(-dt_guess);
+          let tright = tq.AddDays(+dt_guess);
+          if ((tleft.ut - t1.ut) * (tleft.ut - t2.ut) < 0) {
+            if ((tright.ut - t1.ut) * (tright.ut - t2.ut) < 0) {
+              let fleft = f(tleft);
+              let fright = f(tright);
+              if (fleft < 0 && fright >= 0) {
+                f1 = fleft;
+                f2 = fright;
+                t1 = tleft;
+                t2 = tright;
+                fmid = fq;
+                calc_fmid = false;
+                continue;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (f1 < 0 && fmid >= 0) {
+      t2 = tmid;
+      f2 = fmid;
+      continue;
+    }
+    if (fmid < 0 && f2 >= 0) {
+      t1 = tmid;
+      f1 = fmid;
+      continue;
+    }
+    return null;
+  }
+}
+var AtmosphereInfo = class {
+  constructor(pressure, temperature, density) {
+    this.pressure = pressure;
+    this.temperature = temperature;
+    this.density = density;
+  }
+};
+function Atmosphere(elevationMeters) {
+  const P0 = 101325;
+  const T0 = 288.15;
+  const T1 = 216.65;
+  if (!Number.isFinite(elevationMeters) || elevationMeters < -500 || elevationMeters > 1e5)
+    throw `Invalid elevation: ${elevationMeters}`;
+  let temperature;
+  let pressure;
+  if (elevationMeters <= 11e3) {
+    temperature = T0 - 65e-4 * elevationMeters;
+    pressure = P0 * Math.pow(T0 / temperature, -5.25577);
+  } else if (elevationMeters <= 2e4) {
+    temperature = T1;
+    pressure = 22632 * Math.exp(-15768832e-11 * (elevationMeters - 11e3));
+  } else {
+    temperature = T1 + 1e-3 * (elevationMeters - 2e4);
+    pressure = 5474.87 * Math.pow(T1 / temperature, 34.16319);
+  }
+  const density = pressure / temperature / (P0 / T0);
+  return new AtmosphereInfo(pressure, temperature, density);
+}
+function HorizonDipAngle(observer, metersAboveGround) {
+  const phi = observer.latitude * DEG2RAD;
+  const sinphi = Math.sin(phi);
+  const cosphi = Math.cos(phi);
+  const c = 1 / Math.hypot(cosphi, sinphi * EARTH_FLATTENING);
+  const s = c * (EARTH_FLATTENING * EARTH_FLATTENING);
+  const ht_km = (observer.height - metersAboveGround) / 1e3;
+  const ach = EARTH_EQUATORIAL_RADIUS_KM * c + ht_km;
+  const ash = EARTH_EQUATORIAL_RADIUS_KM * s + ht_km;
+  const radius_m = 1e3 * Math.hypot(ach * cosphi, ash * sinphi);
+  const k = 0.175 * Math.pow(1 - 65e-4 / 283.15 * (observer.height - 2 / 3 * metersAboveGround), 3.256);
+  return RAD2DEG * -(Math.sqrt(2 * (1 - k) * metersAboveGround / radius_m) / (1 - k));
+}
+function BodyRadiusAu(body) {
+  switch (body) {
+    case Body.Sun:
+      return SUN_RADIUS_AU;
+    case Body.Moon:
+      return MOON_EQUATORIAL_RADIUS_AU;
+    default:
+      return 0;
+  }
+}
+function SearchRiseSet(body, observer, direction, dateStart, limitDays, metersAboveGround = 0) {
+  if (!Number.isFinite(metersAboveGround) || metersAboveGround < 0)
+    throw `Invalid value for metersAboveGround: ${metersAboveGround}`;
+  const body_radius_au = BodyRadiusAu(body);
+  const atmos = Atmosphere(observer.height - metersAboveGround);
+  const dip = HorizonDipAngle(observer, metersAboveGround);
+  const altitude = dip - REFRACTION_NEAR_HORIZON * atmos.density;
+  return InternalSearchAltitude(body, observer, direction, dateStart, limitDays, body_radius_au, altitude);
+}
+var AscentInfo = class {
+  constructor(tx, ty, ax, ay) {
+    this.tx = tx;
+    this.ty = ty;
+    this.ax = ax;
+    this.ay = ay;
+  }
+};
+function FindAscent(depth, altdiff, max_deriv_alt, t1, t2, a1, a2) {
+  if (a1 < 0 && a2 >= 0) {
+    return new AscentInfo(t1, t2, a1, a2);
+  }
+  if (a1 >= 0 && a2 < 0) {
+    return null;
+  }
+  if (depth > 17) {
+    throw `Excessive recursion in rise/set ascent search.`;
+  }
+  const dt = t2.ut - t1.ut;
+  if (dt * SECONDS_PER_DAY < 1)
+    return null;
+  const da = Math.min(Math.abs(a1), Math.abs(a2));
+  if (da > max_deriv_alt * (dt / 2)) {
+    return null;
+  }
+  const tmid = new AstroTime((t1.ut + t2.ut) / 2);
+  const amid = altdiff(tmid);
+  return FindAscent(1 + depth, altdiff, max_deriv_alt, t1, tmid, a1, amid) || FindAscent(1 + depth, altdiff, max_deriv_alt, tmid, t2, amid, a2);
+}
+function MaxAltitudeSlope(body, latitude) {
+  if (latitude < -90 || latitude > 90)
+    throw `Invalid geographic latitude: ${latitude}`;
+  let deriv_ra;
+  let deriv_dec;
+  switch (body) {
+    case Body.Moon:
+      deriv_ra = 4.5;
+      deriv_dec = 8.2;
+      break;
+    case Body.Sun:
+      deriv_ra = 0.8;
+      deriv_dec = 0.5;
+      break;
+    case Body.Mercury:
+      deriv_ra = -1.6;
+      deriv_dec = 1;
+      break;
+    case Body.Venus:
+      deriv_ra = -0.8;
+      deriv_dec = 0.6;
+      break;
+    case Body.Mars:
+      deriv_ra = -0.5;
+      deriv_dec = 0.4;
+      break;
+    case Body.Jupiter:
+    case Body.Saturn:
+    case Body.Uranus:
+    case Body.Neptune:
+    case Body.Pluto:
+      deriv_ra = -0.2;
+      deriv_dec = 0.2;
+      break;
+    case Body.Star1:
+    case Body.Star2:
+    case Body.Star3:
+    case Body.Star4:
+    case Body.Star5:
+    case Body.Star6:
+    case Body.Star7:
+    case Body.Star8:
+      deriv_ra = -8e-3;
+      deriv_dec = 8e-3;
+      break;
+    default:
+      throw `Body not allowed for altitude search: ${body}`;
+  }
+  const latrad = DEG2RAD * latitude;
+  return Math.abs((360 / SOLAR_DAYS_PER_SIDEREAL_DAY - deriv_ra) * Math.cos(latrad)) + Math.abs(deriv_dec * Math.sin(latrad));
+}
+function InternalSearchAltitude(body, observer, direction, dateStart, limitDays, bodyRadiusAu, targetAltitude) {
+  VerifyObserver(observer);
+  VerifyNumber(limitDays);
+  VerifyNumber(bodyRadiusAu);
+  VerifyNumber(targetAltitude);
+  if (targetAltitude < -90 || targetAltitude > 90)
+    throw `Invalid target altitude angle: ${targetAltitude}`;
+  const max_deriv_alt = MaxAltitudeSlope(body, observer.latitude);
+  function altdiff(time) {
+    const ofdate = Equator(body, time, observer, true, true);
+    const hor = Horizon(time, observer, ofdate.ra, ofdate.dec);
+    const altitude = hor.altitude + RAD2DEG * Math.asin(bodyRadiusAu / ofdate.dist);
+    return direction * (altitude - targetAltitude);
+  }
+  const startTime = MakeTime(dateStart);
+  let t1 = startTime;
+  let t2 = startTime;
+  let a1 = altdiff(t1);
+  let a2 = a1;
+  for (; ; ) {
+    if (limitDays < 0) {
+      t1 = t2.AddDays(-0.42);
+      a1 = altdiff(t1);
+    } else {
+      t2 = t1.AddDays(0.42);
+      a2 = altdiff(t2);
+    }
+    const ascent = FindAscent(0, altdiff, max_deriv_alt, t1, t2, a1, a2);
+    if (ascent) {
+      const time = Search(altdiff, ascent.tx, ascent.ty, {
+        dt_tolerance_seconds: 0.1,
+        init_f1: ascent.ax,
+        init_f2: ascent.ay
+      });
+      if (time) {
+        if (limitDays < 0) {
+          if (time.ut < startTime.ut + limitDays)
+            return null;
+        } else {
+          if (time.ut > startTime.ut + limitDays)
+            return null;
+        }
+        return time;
+      }
+      throw `Rise/set search failed after finding ascent: t1=${t1}, t2=${t2}, a1=${a1}, a2=${a2}`;
+    }
+    if (limitDays < 0) {
+      if (t1.ut < startTime.ut + limitDays)
+        return null;
+      t2 = t1;
+      a2 = a1;
+    } else {
+      if (t2.ut > startTime.ut + limitDays)
+        return null;
+      t1 = t2;
+      a1 = a2;
+    }
+  }
+}
+var ApsisKind;
+(function(ApsisKind2) {
+  ApsisKind2[ApsisKind2["Pericenter"] = 0] = "Pericenter";
+  ApsisKind2[ApsisKind2["Apocenter"] = 1] = "Apocenter";
+})(ApsisKind || (ApsisKind = {}));
+function VectorFromSphere(sphere, time) {
+  time = MakeTime(time);
+  const radlat = sphere.lat * DEG2RAD;
+  const radlon = sphere.lon * DEG2RAD;
+  const rcoslat = sphere.dist * Math.cos(radlat);
+  return new Vector(rcoslat * Math.cos(radlon), rcoslat * Math.sin(radlon), sphere.dist * Math.sin(radlat), time);
+}
+var EclipseKind;
+(function(EclipseKind2) {
+  EclipseKind2["Penumbral"] = "penumbral";
+  EclipseKind2["Partial"] = "partial";
+  EclipseKind2["Annular"] = "annular";
+  EclipseKind2["Total"] = "total";
+})(EclipseKind || (EclipseKind = {}));
+var NodeEventKind;
+(function(NodeEventKind2) {
+  NodeEventKind2[NodeEventKind2["Invalid"] = 0] = "Invalid";
+  NodeEventKind2[NodeEventKind2["Ascending"] = 1] = "Ascending";
+  NodeEventKind2[NodeEventKind2["Descending"] = -1] = "Descending";
+})(NodeEventKind || (NodeEventKind = {}));
+
+// src/astronomy/ayanamsa.ts
+function computeAyanamsa(date, type = "lahiri") {
+  const T = julianCenturiesFromJ2000(date);
+  switch (type) {
+    case "lahiri":
+      return lahiriAyanamsa(T);
+    case "raman":
+      return ramanAyanamsa(T);
+    case "krishnamurti":
+      return kpAyanamsa(T);
+    default:
+      throw new PanchangError(`Unknown ayanamsa type: ${type}`, "INVALID_AYANAMSA");
+  }
+}
+function lahiriAyanamsa(T) {
+  const REF_J2000_DEG = 23.853211;
+  const precessionArcsec = 5029.0966 * T + 1.112 * T * T - 6e-6 * T * T * T;
+  return REF_J2000_DEG + precessionArcsec / 3600;
+}
+function ramanAyanamsa(T) {
+  const REF_J2000_DEG = 22.460489;
+  const annualRateDeg = 50.3304 / 3600;
+  return REF_J2000_DEG + annualRateDeg * T * 100;
+}
+function kpAyanamsa(T) {
+  const REF_J2000_DEG = 23.773606;
+  const precessionArcsec = 5029.0966 * T + 1.112 * T * T - 6e-6 * T * T * T;
+  return REF_J2000_DEG + precessionArcsec / 3600;
+}
+function julianCenturiesFromJ2000(date) {
+  const jd = dateToJulianDay(date);
+  return (jd - 2451545) / 36525;
+}
+function dateToJulianDay(date) {
+  return date.getTime() / 864e5 + 24405875e-1;
+}
+
+// src/utils/angle.ts
+function normalize360(degrees) {
+  const r = degrees % 360;
+  if (r === 0) return 0;
+  return r < 0 ? r + 360 : r;
+}
+
+// src/astronomy/moon.ts
+function getSiderealMoonLongitude(date, ayanamsaType) {
+  const astroTime = MakeTime(date);
+  const tropicalLon = Ecliptic(GeoMoon(astroTime)).elon;
+  const ayanamsa = computeAyanamsa(date, ayanamsaType);
+  return normalize360(tropicalLon - ayanamsa);
+}
+
+// src/astronomy/sun.ts
+function getSiderealSunLongitude(date, ayanamsaType) {
+  const astroTime = MakeTime(date);
+  const tropicalLon = SunPosition(astroTime).elon;
+  const ayanamsa = computeAyanamsa(date, ayanamsaType);
+  return normalize360(tropicalLon - ayanamsa);
+}
+
+// src/astronomy/cache.ts
+var BUCKET_MS = 6e4;
+var LongitudeCache = class {
+  constructor(ayanamsaType) {
+    this.moonCache = /* @__PURE__ */ new Map();
+    this.sunCache = /* @__PURE__ */ new Map();
+    this.hits = 0;
+    this.misses = 0;
+    this.ayanamsaType = ayanamsaType;
+  }
+  getMoon(date) {
+    const bucket = Math.floor(date.getTime() / BUCKET_MS);
+    const cached = this.moonCache.get(bucket);
+    if (cached !== void 0) {
+      this.hits++;
+      return cached;
+    }
+    this.misses++;
+    const lon = getSiderealMoonLongitude(date, this.ayanamsaType);
+    this.moonCache.set(bucket, lon);
+    return lon;
+  }
+  getSun(date) {
+    const bucket = Math.floor(date.getTime() / BUCKET_MS);
+    const cached = this.sunCache.get(bucket);
+    if (cached !== void 0) {
+      this.hits++;
+      return cached;
+    }
+    this.misses++;
+    const lon = getSiderealSunLongitude(date, this.ayanamsaType);
+    this.sunCache.set(bucket, lon);
+    return lon;
+  }
+  get size() {
+    return this.moonCache.size + this.sunCache.size;
+  }
+};
+
+// src/astronomy/sunrise.ts
+function computeSunrise(searchFromUtc, location, limitDays = 2) {
+  const observer = new Observer(
+    location.latitude,
+    location.longitude,
+    location.elevation ?? 0
+  );
+  const astroTime = MakeTime(searchFromUtc);
+  const result = SearchRiseSet(Body.Sun, observer, 1, astroTime, limitDays);
+  if (!result) {
+    throw new PanchangError(
+      `No sunrise found within ${limitDays} days for (${location.latitude}\xB0, ${location.longitude}\xB0) near ${searchFromUtc.toISOString()}. This location may be experiencing midnight sun or polar night.`,
+      "NO_SUNRISE"
+    );
+  }
+  return result.date;
+}
+function computeSunset(searchFromUtc, location, limitDays = 2) {
+  const observer = new Observer(
+    location.latitude,
+    location.longitude,
+    location.elevation ?? 0
+  );
+  const astroTime = MakeTime(searchFromUtc);
+  const result = SearchRiseSet(Body.Sun, observer, -1, astroTime, limitDays);
+  if (!result) {
+    throw new PanchangError(
+      `No sunset found within ${limitDays} days for (${location.latitude}\xB0, ${location.longitude}\xB0) near ${searchFromUtc.toISOString()}.`,
+      "NO_SUNSET"
+    );
+  }
+  return result.date;
+}
+
+// src/utils/search.ts
+function findTransitionTime(startUtc, maxEndUtc, currentIndex, getIndexAtTime, maxIterations = 15, toleranceMs = 3e4) {
+  let lo = startUtc.getTime();
+  let hi2 = maxEndUtc.getTime();
+  if (getIndexAtTime(new Date(hi2)) === currentIndex) {
+    const extensions = [6, 12, 18, 24];
+    let found = false;
+    for (const ext of extensions) {
+      hi2 = maxEndUtc.getTime() + ext * 36e5;
+      if (getIndexAtTime(new Date(hi2)) !== currentIndex) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      throw new PanchangError(
+        `Binary search could not find transition for element index ${currentIndex} within 48h+ of ${startUtc.toISOString()}`,
+        "SEARCH_DIVERGED"
+      );
+    }
+  }
+  let iterations = 0;
+  while (hi2 - lo > toleranceMs && iterations < maxIterations) {
+    const mid = lo + (hi2 - lo) / 2;
+    if (getIndexAtTime(new Date(mid)) === currentIndex) {
+      lo = mid;
+    } else {
+      hi2 = mid;
+    }
+    iterations++;
+  }
+  return new Date(hi2);
+}
+function findStartTime(fromUtc, currentIndex, totalElements, getIndexAtTime, maxSearchBackHours = 36, maxIterations = 15, toleranceMs = 3e4) {
+  const searchStart = new Date(fromUtc.getTime() - maxSearchBackHours * 36e5);
+  const previousIndex = (currentIndex - 1 + totalElements) % totalElements;
+  if (getIndexAtTime(new Date(searchStart.getTime())) !== previousIndex) {
+    return searchStart;
+  }
+  let lo = searchStart.getTime();
+  let hi2 = fromUtc.getTime();
+  let iterations = 0;
+  while (hi2 - lo > toleranceMs && iterations < maxIterations) {
+    const mid = lo + (hi2 - lo) / 2;
+    if (getIndexAtTime(new Date(mid)) === previousIndex) {
+      lo = mid;
+    } else {
+      hi2 = mid;
+    }
+    iterations++;
+  }
+  return new Date(hi2);
+}
+function findDailyElements(sunriseUtc, nextSunriseUtc, elementAtSunrise, getIndexAtTime, computeElementAtTime, totalElements, searchWindowHours, maxIterations, maxPerDay) {
+  const results = [];
+  let cursor = new Date(sunriseUtc.getTime());
+  while (cursor.getTime() < nextSunriseUtc.getTime()) {
+    const element = results.length === 0 ? elementAtSunrise : computeElementAtTime(cursor);
+    const startTime = results.length === 0 ? findStartTime(sunriseUtc, element.index, totalElements, getIndexAtTime) : cursor;
+    const isActiveAtSunrise = results.length === 0;
+    const indexAtNextSunrise = getIndexAtTime(nextSunriseUtc);
+    if (indexAtNextSunrise === element.index) {
+      results.push(Object.assign({}, element, {
+        startTime,
+        endTime: new Date(nextSunriseUtc.getTime()),
+        isActiveAtSunrise
+      }));
+      break;
+    }
+    const searchEnd = new Date(cursor.getTime() + searchWindowHours * 36e5);
+    const rawEnd = findTransitionTime(cursor, searchEnd, element.index, getIndexAtTime, maxIterations);
+    const endTime = rawEnd.getTime() > nextSunriseUtc.getTime() ? new Date(nextSunriseUtc.getTime()) : rawEnd;
+    results.push(Object.assign({}, element, {
+      startTime,
+      endTime,
+      isActiveAtSunrise
+    }));
+    if (rawEnd.getTime() >= nextSunriseUtc.getTime()) break;
+    cursor = new Date(rawEnd.getTime() + 1);
+    if (results.length >= maxPerDay) break;
+  }
+  return results;
+}
+
+// src/utils/constants.ts
+var TITHI_SPAN = 12;
+var NAKSHATRA_SPAN = 360 / 27;
+var NAKSHATRA_PADA_SPAN = NAKSHATRA_SPAN / 4;
+var YOGA_SPAN = 360 / 27;
+var KARANA_SPAN = 6;
+var RAHU_KALAM_SLOTS = [7, 1, 6, 4, 5, 3, 2];
+var YAMAGANDA_SLOTS = [4, 3, 2, 1, 0, 6, 5];
+var GULIKA_SLOTS = [6, 5, 4, 3, 2, 1, 0];
+var ENGLISH_DAY_NAMES = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+
+// src/utils/timezone.ts
+function resolveUtcOffset(timezone, referenceDate) {
+  if (typeof timezone === "number") {
+    validateOffset(timezone);
+    return timezone;
+  }
+  try {
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      timeZoneName: "shortOffset"
+    });
+    const parts = formatter.formatToParts(referenceDate);
+    const tzPart = parts.find((p) => p.type === "timeZoneName");
+    if (!tzPart) throw new Error("No timeZoneName part found");
+    return parseGmtOffset(tzPart.value);
+  } catch {
+    throw new PanchangError(
+      `Cannot resolve timezone "${timezone}". On React Native (Hermes), pass a numeric UTC offset in minutes instead (e.g. 330 for IST +05:30, -300 for EST -05:00).`,
+      "TIMEZONE_RESOLUTION_FAILED"
+    );
+  }
+}
+function getLocalMidnightUtc(date, offsetMinutes) {
+  const y = date.getFullYear();
+  const m = date.getMonth();
+  const d = date.getDate();
+  const midnightUtc = Date.UTC(y, m, d, 0, 0, 0, 0);
+  return new Date(midnightUtc - offsetMinutes * 6e4);
+}
+function utcToLocalDisplay(utcDate, offsetMinutes) {
+  return new Date(utcDate.getTime() + offsetMinutes * 6e4);
+}
+function parseGmtOffset(gmtString) {
+  if (gmtString === "GMT") return 0;
+  const match = gmtString.match(/GMT([+-])(\d{1,2})(?::(\d{2}))?/);
+  if (!match) return 0;
+  const sign = match[1] === "+" ? 1 : -1;
+  const hours = parseInt(match[2], 10);
+  const mins = parseInt(match[3] ?? "0", 10);
+  return sign * (hours * 60 + mins);
+}
+function validateOffset(offset) {
+  if (offset < -720 || offset > 840 || !Number.isInteger(offset)) {
+    throw new PanchangError(
+      `UTC offset must be an integer between -720 and 840, got ${offset}`,
+      "INVALID_TIMEZONE"
+    );
+  }
+}
+
+// src/core/tithi.ts
+function computeTithiFromLongitudes(siderealMoon, siderealSun, name) {
+  const angle = normalize360(siderealMoon - siderealSun);
+  const index = Math.floor(angle / TITHI_SPAN);
+  const elapsed = angle - index * TITHI_SPAN;
+  const completionPercentage = elapsed / TITHI_SPAN * 100;
+  const paksha = index < 15 ? "Shukla" : "Krishna";
+  const number = index < 15 ? index + 1 : index - 14;
+  return {
+    index,
+    name,
+    paksha,
+    number,
+    completionPercentage: Math.round(completionPercentage * 100) / 100,
+    endTime: null
+  };
+}
+function getTithiIndexAtTime(date, getCachedMoon, getCachedSun) {
+  const angle = normalize360(getCachedMoon(date) - getCachedSun(date));
+  return Math.floor(angle / TITHI_SPAN);
+}
+function getTithiIndexFromLons(siderealMoon, siderealSun) {
+  return Math.floor(normalize360(siderealMoon - siderealSun) / TITHI_SPAN);
+}
+
+// src/core/nakshatra.ts
+function computeNakshatraFromLongitude(siderealMoon, name) {
+  const index = Math.floor(siderealMoon / NAKSHATRA_SPAN);
+  const degreesInNakshatra = siderealMoon - index * NAKSHATRA_SPAN;
+  const pada = Math.min(Math.floor(degreesInNakshatra / NAKSHATRA_PADA_SPAN) + 1, 4);
+  const completionPercentage = degreesInNakshatra / NAKSHATRA_SPAN * 100;
+  return {
+    index,
+    name,
+    pada,
+    degreesInNakshatra: Math.round(degreesInNakshatra * 1e4) / 1e4,
+    completionPercentage: Math.round(completionPercentage * 100) / 100,
+    endTime: null
+  };
+}
+function getNakshatraIndexAtTime(date, getCachedMoon) {
+  return Math.floor(getCachedMoon(date) / NAKSHATRA_SPAN);
+}
+
+// src/core/yoga.ts
+function computeYogaFromLongitudes(siderealMoon, siderealSun, name) {
+  const angle = normalize360(siderealSun + siderealMoon);
+  const index = Math.floor(angle / YOGA_SPAN);
+  const elapsed = angle - index * YOGA_SPAN;
+  const completionPercentage = elapsed / YOGA_SPAN * 100;
+  return {
+    index,
+    name,
+    completionPercentage: Math.round(completionPercentage * 100) / 100,
+    endTime: null
+  };
+}
+function getYogaIndexAtTime(date, getCachedMoon, getCachedSun) {
+  const angle = normalize360(getCachedSun(date) + getCachedMoon(date));
+  return Math.floor(angle / YOGA_SPAN);
+}
+function getYogaIndex(siderealMoon, siderealSun) {
+  return Math.floor(normalize360(siderealSun + siderealMoon) / YOGA_SPAN);
+}
+
+// src/core/karana.ts
+function computeKaranaFromLongitudes(siderealMoon, siderealSun, name) {
+  const angle = normalize360(siderealMoon - siderealSun);
+  const index = Math.floor(angle / KARANA_SPAN);
+  const elapsed = angle - index * KARANA_SPAN;
+  const completionPercentage = elapsed / KARANA_SPAN * 100;
+  return {
+    index,
+    name,
+    type: getKaranaType(index),
+    completionPercentage: Math.round(completionPercentage * 100) / 100,
+    endTime: null
+  };
+}
+function getKaranaType(index) {
+  return index === 0 || index >= 57 ? "fixed" : "movable";
+}
+function getKaranaIndexAtTime(date, getCachedMoon, getCachedSun) {
+  const angle = normalize360(getCachedMoon(date) - getCachedSun(date));
+  return Math.floor(angle / KARANA_SPAN);
+}
+function getKaranaIndex(siderealMoon, siderealSun) {
+  return Math.floor(normalize360(siderealMoon - siderealSun) / KARANA_SPAN);
+}
+
+// src/core/vara.ts
+function computeVara(dateUtc, sunriseUtc, varaNames) {
+  let d = new Date(dateUtc);
+  if (dateUtc.getTime() < sunriseUtc.getTime()) {
+    d = new Date(dateUtc.getTime() - 864e5);
+  }
+  const index = d.getUTCDay();
+  return {
+    index,
+    name: varaNames[index].name,
+    shortName: varaNames[index].short,
+    englishName: ENGLISH_DAY_NAMES[index]
+  };
+}
+
+// src/core/inauspicious.ts
+function computeInauspiciousPeriod(sunrise, sunset, varaIndex, slotTable) {
+  const dayDurationMs = sunset.getTime() - sunrise.getTime();
+  const slotDurationMs = dayDurationMs / 8;
+  const slotIndex = slotTable[varaIndex];
+  const start = new Date(sunrise.getTime() + slotIndex * slotDurationMs);
+  const end = new Date(start.getTime() + slotDurationMs);
+  return { start, end };
+}
+function computeRahuKalam(sunrise, sunset, varaIndex) {
+  return computeInauspiciousPeriod(sunrise, sunset, varaIndex, RAHU_KALAM_SLOTS);
+}
+function computeGulikaKalam(sunrise, sunset, varaIndex) {
+  return computeInauspiciousPeriod(sunrise, sunset, varaIndex, GULIKA_SLOTS);
+}
+function computeYamaganda(sunrise, sunset, varaIndex) {
+  return computeInauspiciousPeriod(sunrise, sunset, varaIndex, YAMAGANDA_SLOTS);
+}
+
+// src/core/muhurta.ts
+function computeAbhijitMuhurta(sunrise, sunset) {
+  const dayDurationMs = sunset.getTime() - sunrise.getTime();
+  const muhurtaDurationMs = dayDurationMs / 15;
+  const start = new Date(sunrise.getTime() + 7 * muhurtaDurationMs);
+  const end = new Date(start.getTime() + muhurtaDurationMs);
+  return { start, end };
+}
+
+// src/core/masa.ts
+var MASA_NAMES_EN = [
+  "Mesha",
+  "Vrishabha",
+  "Mithuna",
+  "Karka",
+  "Simha",
+  "Kanya",
+  "Tula",
+  "Vrischika",
+  "Dhanus",
+  "Makara",
+  "Kumbha",
+  "Meena"
+];
+function computeMasa(siderealSunLon) {
+  const index = Math.floor(siderealSunLon / 30);
+  return {
+    index,
+    name: MASA_NAMES_EN[index]
+  };
+}
+
+// src/i18n/en.ts
+var en = {
+  tithiNames: [
+    "Pratipad",
+    "Dwitiya",
+    "Tritiya",
+    "Chaturthi",
+    "Panchami",
+    "Shashthi",
+    "Saptami",
+    "Ashtami",
+    "Navami",
+    "Dashami",
+    "Ekadashi",
+    "Dwadashi",
+    "Trayodashi",
+    "Chaturdashi"
+  ],
+  nakshatraNames: [
+    "Ashwini",
+    "Bharani",
+    "Krittika",
+    "Rohini",
+    "Mrigashira",
+    "Ardra",
+    "Punarvasu",
+    "Pushya",
+    "Ashlesha",
+    "Magha",
+    "Purva Phalguni",
+    "Uttara Phalguni",
+    "Hasta",
+    "Chitra",
+    "Swati",
+    "Vishakha",
+    "Anuradha",
+    "Jyeshtha",
+    "Mula",
+    "Purva Ashadha",
+    "Uttara Ashadha",
+    "Shravana",
+    "Dhanishta",
+    "Shatabhisha",
+    "Purva Bhadrapada",
+    "Uttara Bhadrapada",
+    "Revati"
+  ],
+  yogaNames: [
+    "Vishkamba",
+    "Priti",
+    "Ayushman",
+    "Saubhagya",
+    "Shobhana",
+    "Atiganda",
+    "Sukarma",
+    "Dhriti",
+    "Shula",
+    "Ganda",
+    "Vriddhi",
+    "Dhruva",
+    "Vyaghata",
+    "Harshana",
+    "Vajra",
+    "Siddhi",
+    "Vyatipata",
+    "Variyan",
+    "Parigha",
+    "Shiva",
+    "Siddha",
+    "Sadhya",
+    "Shubha",
+    "Shukla",
+    "Brahma",
+    "Indra",
+    "Vaidhriti"
+  ],
+  karanaNames: {
+    movable: ["Bava", "Balava", "Kaulava", "Taitila", "Gara", "Vanija", "Vishti"],
+    fixed: ["Kimstughna", "Shakuni", "Chatushpada", "Naga"]
+  },
+  varaNames: [
+    { name: "Ravivara", short: "Ravi" },
+    { name: "Somavara", short: "Soma" },
+    { name: "Mangalavara", short: "Mangal" },
+    { name: "Budhavara", short: "Budh" },
+    { name: "Guruvara", short: "Guru" },
+    { name: "Shukravara", short: "Shukra" },
+    { name: "Shanivara", short: "Shani" }
+  ],
+  pakshaNames: { shukla: "Shukla", krishna: "Krishna" },
+  masaNames: [
+    "Mesha",
+    "Vrishabha",
+    "Mithuna",
+    "Karka",
+    "Simha",
+    "Kanya",
+    "Tula",
+    "Vrischika",
+    "Dhanus",
+    "Makara",
+    "Kumbha",
+    "Meena"
+  ],
+  misc: { purnima: "Purnima", amavasya: "Amavasya" }
+};
+
+// src/i18n/sa.ts
+var sa = {
+  tithiNames: [
+    "\u092A\u094D\u0930\u0924\u093F\u092A\u0926\u093E",
+    "\u0926\u094D\u0935\u093F\u0924\u0940\u092F\u093E",
+    "\u0924\u0943\u0924\u0940\u092F\u093E",
+    "\u091A\u0924\u0941\u0930\u094D\u0925\u0940",
+    "\u092A\u091E\u094D\u091A\u092E\u0940",
+    "\u0937\u0937\u094D\u0920\u0940",
+    "\u0938\u092A\u094D\u0924\u092E\u0940",
+    "\u0905\u0937\u094D\u091F\u092E\u0940",
+    "\u0928\u0935\u092E\u0940",
+    "\u0926\u0936\u092E\u0940",
+    "\u090F\u0915\u093E\u0926\u0936\u0940",
+    "\u0926\u094D\u0935\u093E\u0926\u0936\u0940",
+    "\u0924\u094D\u0930\u092F\u094B\u0926\u0936\u0940",
+    "\u091A\u0924\u0941\u0930\u094D\u0926\u0936\u0940"
+  ],
+  nakshatraNames: [
+    "\u0905\u0936\u094D\u0935\u093F\u0928\u0940",
+    "\u092D\u0930\u0923\u0940",
+    "\u0915\u0943\u0924\u094D\u0924\u093F\u0915\u093E",
+    "\u0930\u094B\u0939\u093F\u0923\u0940",
+    "\u092E\u0943\u0917\u0936\u093F\u0930\u093E",
+    "\u0906\u0930\u094D\u0926\u094D\u0930\u093E",
+    "\u092A\u0941\u0928\u0930\u094D\u0935\u0938\u0941",
+    "\u092A\u0941\u0937\u094D\u092F",
+    "\u0906\u0936\u094D\u0932\u0947\u0937\u093E",
+    "\u092E\u0918\u093E",
+    "\u092A\u0942\u0930\u094D\u0935\u092B\u093E\u0932\u094D\u0917\u0941\u0928\u0940",
+    "\u0909\u0924\u094D\u0924\u0930\u092B\u093E\u0932\u094D\u0917\u0941\u0928\u0940",
+    "\u0939\u0938\u094D\u0924",
+    "\u091A\u093F\u0924\u094D\u0930\u093E",
+    "\u0938\u094D\u0935\u093E\u0924\u0940",
+    "\u0935\u093F\u0936\u093E\u0916\u093E",
+    "\u0905\u0928\u0941\u0930\u093E\u0927\u093E",
+    "\u091C\u094D\u092F\u0947\u0937\u094D\u0920\u093E",
+    "\u092E\u0942\u0932",
+    "\u092A\u0942\u0930\u094D\u0935\u093E\u0937\u093E\u0922\u093E",
+    "\u0909\u0924\u094D\u0924\u0930\u093E\u0937\u093E\u0922\u093E",
+    "\u0936\u094D\u0930\u0935\u0923",
+    "\u0927\u0928\u093F\u0937\u094D\u0920\u093E",
+    "\u0936\u0924\u092D\u093F\u0937\u093E",
+    "\u092A\u0942\u0930\u094D\u0935\u092D\u093E\u0926\u094D\u0930\u092A\u0926\u093E",
+    "\u0909\u0924\u094D\u0924\u0930\u092D\u093E\u0926\u094D\u0930\u092A\u0926\u093E",
+    "\u0930\u0947\u0935\u0924\u0940"
+  ],
+  yogaNames: [
+    "\u0935\u093F\u0937\u094D\u0915\u092E\u094D\u092D",
+    "\u092A\u094D\u0930\u0940\u0924\u093F",
+    "\u0906\u092F\u0941\u0937\u094D\u092E\u093E\u0928\u094D",
+    "\u0938\u094C\u092D\u093E\u0917\u094D\u092F",
+    "\u0936\u094B\u092D\u0928",
+    "\u0905\u0924\u093F\u0917\u0923\u094D\u0921",
+    "\u0938\u0941\u0915\u0930\u094D\u092E\u093E",
+    "\u0927\u0943\u0924\u093F",
+    "\u0936\u0942\u0932",
+    "\u0917\u0923\u094D\u0921",
+    "\u0935\u0943\u0926\u094D\u0927\u093F",
+    "\u0927\u094D\u0930\u0941\u0935",
+    "\u0935\u094D\u092F\u093E\u0918\u093E\u0924",
+    "\u0939\u0930\u094D\u0937\u0923",
+    "\u0935\u091C\u094D\u0930",
+    "\u0938\u093F\u0926\u094D\u0927\u093F",
+    "\u0935\u094D\u092F\u0924\u0940\u092A\u093E\u0924",
+    "\u0935\u0930\u0940\u092F\u093E\u0928\u094D",
+    "\u092A\u0930\u093F\u0918",
+    "\u0936\u093F\u0935",
+    "\u0938\u093F\u0926\u094D\u0927",
+    "\u0938\u093E\u0927\u094D\u092F",
+    "\u0936\u0941\u092D",
+    "\u0936\u0941\u0915\u094D\u0932",
+    "\u092C\u094D\u0930\u0939\u094D\u092E",
+    "\u0907\u0928\u094D\u0926\u094D\u0930",
+    "\u0935\u0948\u0927\u0943\u0924\u093F"
+  ],
+  karanaNames: {
+    movable: ["\u092C\u0935", "\u092C\u093E\u0932\u0935", "\u0915\u094C\u0932\u0935", "\u0924\u0948\u0924\u093F\u0932", "\u0917\u0930", "\u0935\u0923\u093F\u091C", "\u0935\u093F\u0937\u094D\u091F\u093F"],
+    fixed: ["\u0915\u093F\u0902\u0938\u094D\u0924\u0941\u0918\u094D\u0928", "\u0936\u0915\u0941\u0928\u093F", "\u091A\u0924\u0941\u0937\u094D\u092A\u093E\u0926", "\u0928\u093E\u0917"]
+  },
+  varaNames: [
+    { name: "\u0930\u0935\u093F\u0935\u093E\u0930", short: "\u0930\u0935\u093F" },
+    { name: "\u0938\u094B\u092E\u0935\u093E\u0930", short: "\u0938\u094B\u092E" },
+    { name: "\u092E\u0919\u094D\u0917\u0932\u0935\u093E\u0930", short: "\u092E\u0919\u094D\u0917\u0932" },
+    { name: "\u092C\u0941\u0927\u0935\u093E\u0930", short: "\u092C\u0941\u0927" },
+    { name: "\u0917\u0941\u0930\u0941\u0935\u093E\u0930", short: "\u0917\u0941\u0930\u0941" },
+    { name: "\u0936\u0941\u0915\u094D\u0930\u0935\u093E\u0930", short: "\u0936\u0941\u0915\u094D\u0930" },
+    { name: "\u0936\u0928\u093F\u0935\u093E\u0930", short: "\u0936\u0928\u093F" }
+  ],
+  pakshaNames: { shukla: "\u0936\u0941\u0915\u094D\u0932", krishna: "\u0915\u0943\u0937\u094D\u0923" },
+  masaNames: [
+    "\u092E\u0947\u0937",
+    "\u0935\u0943\u0937\u092D",
+    "\u092E\u093F\u0925\u0941\u0928",
+    "\u0915\u0930\u094D\u0915",
+    "\u0938\u093F\u0902\u0939",
+    "\u0915\u0928\u094D\u092F\u093E",
+    "\u0924\u0941\u0932\u093E",
+    "\u0935\u0943\u0936\u094D\u091A\u093F\u0915",
+    "\u0927\u0928\u0941",
+    "\u092E\u0915\u0930",
+    "\u0915\u0941\u092E\u094D\u092D",
+    "\u092E\u0940\u0928"
+  ],
+  misc: { purnima: "\u092A\u0942\u0930\u094D\u0923\u093F\u092E\u093E", amavasya: "\u0905\u092E\u093E\u0935\u093E\u0938\u094D\u092F\u093E" }
+};
+
+// src/i18n/hi.ts
+var hi = { ...sa };
+
+// src/i18n/resolver.ts
+var TRANSLATIONS = { en, sa, hi };
+function getTranslations(lang) {
+  return TRANSLATIONS[lang] ?? en;
+}
+function resolveTithiName(index, lang) {
+  const t = getTranslations(lang);
+  if (index === 14) return t.misc.purnima;
+  if (index === 29) return t.misc.amavasya;
+  const paksha = index < 15 ? t.pakshaNames.shukla : t.pakshaNames.krishna;
+  const nameIndex = index < 15 ? index : index - 15;
+  return `${paksha} ${t.tithiNames[nameIndex]}`;
+}
+function resolveNakshatraName(index, lang) {
+  return getTranslations(lang).nakshatraNames[index];
+}
+function resolveYogaName(index, lang) {
+  return getTranslations(lang).yogaNames[index];
+}
+function resolveKaranaName(index, lang) {
+  const t = getTranslations(lang);
+  if (index === 0) return t.karanaNames.fixed[0];
+  if (index >= 57) return t.karanaNames.fixed[index - 56];
+  return t.karanaNames.movable[(index - 1) % 7];
+}
+
+// src/core/panchang.ts
+function getInstantPanchang(date, location, options) {
+  validateDate(date);
+  validateLocation(location);
+  const ayanamsaType = options?.ayanamsa ?? "lahiri";
+  const lang = options?.language ?? "en";
+  const doEndTimes = options?.computeEndTimes !== false;
+  const maxIter = options?.precision === "high" ? 25 : 15;
+  const cache = new LongitudeCache(ayanamsaType);
+  const getMoon = (d) => cache.getMoon(d);
+  const getSun = (d) => cache.getSun(d);
+  const siderealMoon = getMoon(date);
+  const siderealSun = getSun(date);
+  const ayanamsaValue = computeAyanamsa(date, ayanamsaType);
+  const tithi = computeTithiFromLongitudes(
+    siderealMoon,
+    siderealSun,
+    resolveTithiName(getTithiIndexFromLons(siderealMoon, siderealSun), lang)
+  );
+  const nakshatra = computeNakshatraFromLongitude(
+    siderealMoon,
+    resolveNakshatraName(Math.floor(siderealMoon / NAKSHATRA_SPAN), lang)
+  );
+  const yoga = computeYogaFromLongitudes(
+    siderealMoon,
+    siderealSun,
+    resolveYogaName(getYogaIndex(siderealMoon, siderealSun), lang)
+  );
+  const karana = computeKaranaFromLongitudes(
+    siderealMoon,
+    siderealSun,
+    resolveKaranaName(getKaranaIndex(siderealMoon, siderealSun), lang)
+  );
+  const sunriseUtc = computeSunrise(
+    new Date(date.getTime() - 12 * 36e5),
+    location
+  );
+  const vara = computeVara(date, sunriseUtc, getTranslations(lang).varaNames);
+  if (doEndTimes) {
+    tithi.endTime = findTransitionTime(
+      date,
+      new Date(date.getTime() + 36 * 36e5),
+      tithi.index,
+      (d) => getTithiIndexAtTime(d, getMoon, getSun),
+      maxIter
+    );
+    nakshatra.endTime = findTransitionTime(
+      date,
+      new Date(date.getTime() + 36 * 36e5),
+      nakshatra.index,
+      (d) => getNakshatraIndexAtTime(d, getMoon),
+      maxIter
+    );
+    yoga.endTime = findTransitionTime(
+      date,
+      new Date(date.getTime() + 36 * 36e5),
+      yoga.index,
+      (d) => getYogaIndexAtTime(d, getMoon, getSun),
+      maxIter
+    );
+    karana.endTime = findTransitionTime(
+      date,
+      new Date(date.getTime() + 18 * 36e5),
+      karana.index,
+      (d) => getKaranaIndexAtTime(d, getMoon, getSun),
+      maxIter
+    );
+  }
+  return {
+    timestamp: date,
+    location,
+    tithi,
+    nakshatra,
+    yoga,
+    karana,
+    vara,
+    ayanamsa: ayanamsaValue,
+    siderealSun,
+    siderealMoon
+  };
+}
+function getDailyPanchang(date, location, options) {
+  validateDate(date);
+  validateLocation(location);
+  const offsetMinutes = resolveUtcOffset(options.timezone, date);
+  const ayanamsaType = options.ayanamsa ?? "lahiri";
+  const lang = options.language ?? "en";
+  const doEndTimes = options.computeEndTimes !== false;
+  const maxIter = options.precision === "high" ? 25 : 15;
+  const cache = new LongitudeCache(ayanamsaType);
+  const getMoon = (d) => cache.getMoon(d);
+  const getSun = (d) => cache.getSun(d);
+  const localMidnightUtc = getLocalMidnightUtc(date, offsetMinutes);
+  const sunriseUtc = computeSunrise(localMidnightUtc, location);
+  const sunsetUtc = computeSunset(sunriseUtc, location);
+  const nextSunriseUtc = computeSunrise(sunsetUtc, location);
+  const siderealMoonAtSunrise = getMoon(sunriseUtc);
+  const siderealSunAtSunrise = getSun(sunriseUtc);
+  const ayanamsaValue = computeAyanamsa(sunriseUtc, ayanamsaType);
+  const tithiAtSunrise = computeTithiFromLongitudes(
+    siderealMoonAtSunrise,
+    siderealSunAtSunrise,
+    resolveTithiName(getTithiIndexFromLons(siderealMoonAtSunrise, siderealSunAtSunrise), lang)
+  );
+  const nakshatraAtSunrise = computeNakshatraFromLongitude(
+    siderealMoonAtSunrise,
+    resolveNakshatraName(Math.floor(siderealMoonAtSunrise / NAKSHATRA_SPAN), lang)
+  );
+  const yogaAtSunrise = computeYogaFromLongitudes(
+    siderealMoonAtSunrise,
+    siderealSunAtSunrise,
+    resolveYogaName(getYogaIndex(siderealMoonAtSunrise, siderealSunAtSunrise), lang)
+  );
+  const karanaAtSunrise = computeKaranaFromLongitudes(
+    siderealMoonAtSunrise,
+    siderealSunAtSunrise,
+    resolveKaranaName(getKaranaIndex(siderealMoonAtSunrise, siderealSunAtSunrise), lang)
+  );
+  const vara = computeVara(sunriseUtc, sunriseUtc, getTranslations(lang).varaNames);
+  const masa = computeMasa(siderealSunAtSunrise);
+  let tithis;
+  let nakshatras;
+  let yogas;
+  let karanas;
+  if (doEndTimes) {
+    tithis = findDailyElements(
+      sunriseUtc,
+      nextSunriseUtc,
+      tithiAtSunrise,
+      (d) => getTithiIndexAtTime(d, getMoon, getSun),
+      (d) => {
+        const moon = getMoon(d), sun = getSun(d);
+        return computeTithiFromLongitudes(moon, sun, resolveTithiName(getTithiIndexFromLons(moon, sun), lang));
+      },
+      30,
+      36,
+      maxIter,
+      2
+    );
+    nakshatras = findDailyElements(
+      sunriseUtc,
+      nextSunriseUtc,
+      nakshatraAtSunrise,
+      (d) => getNakshatraIndexAtTime(d, getMoon),
+      (d) => {
+        const moon = getMoon(d);
+        return computeNakshatraFromLongitude(moon, resolveNakshatraName(Math.floor(moon / NAKSHATRA_SPAN), lang));
+      },
+      27,
+      36,
+      maxIter,
+      2
+    );
+    yogas = findDailyElements(
+      sunriseUtc,
+      nextSunriseUtc,
+      yogaAtSunrise,
+      (d) => getYogaIndexAtTime(d, getMoon, getSun),
+      (d) => {
+        const moon = getMoon(d), sun = getSun(d);
+        return computeYogaFromLongitudes(moon, sun, resolveYogaName(getYogaIndex(moon, sun), lang));
+      },
+      27,
+      36,
+      maxIter,
+      2
+    );
+    karanas = findDailyElements(
+      sunriseUtc,
+      nextSunriseUtc,
+      karanaAtSunrise,
+      (d) => getKaranaIndexAtTime(d, getMoon, getSun),
+      (d) => {
+        const moon = getMoon(d), sun = getSun(d);
+        return computeKaranaFromLongitudes(moon, sun, resolveKaranaName(getKaranaIndex(moon, sun), lang));
+      },
+      60,
+      18,
+      maxIter,
+      4
+    );
+  } else {
+    tithis = [{ ...tithiAtSunrise, startTime: null, isActiveAtSunrise: true }];
+    nakshatras = [{ ...nakshatraAtSunrise, startTime: null, isActiveAtSunrise: true }];
+    yogas = [{ ...yogaAtSunrise, startTime: null, isActiveAtSunrise: true }];
+    karanas = [{ ...karanaAtSunrise, startTime: null, isActiveAtSunrise: true }];
+  }
+  const rahuKalam = computeRahuKalam(sunriseUtc, sunsetUtc, vara.index);
+  const gulikaKalam = computeGulikaKalam(sunriseUtc, sunsetUtc, vara.index);
+  const yamaganda = computeYamaganda(sunriseUtc, sunsetUtc, vara.index);
+  const abhijitMuhurta = computeAbhijitMuhurta(sunriseUtc, sunsetUtc);
+  const toLocal = (d) => utcToLocalDisplay(d, offsetMinutes);
+  const toLocalOrNull = (d) => d ? toLocal(d) : null;
+  const convertTimePeriod = (tp) => ({
+    start: toLocal(tp.start),
+    end: toLocal(tp.end)
+  });
+  const dayDurationMs = sunsetUtc.getTime() - sunriseUtc.getTime();
+  const nightDurationMs = nextSunriseUtc.getTime() - sunsetUtc.getTime();
+  for (const t of tithis) {
+    t.endTime = toLocalOrNull(t.endTime);
+    t.startTime = toLocalOrNull(t.startTime);
+  }
+  for (const n of nakshatras) {
+    n.endTime = toLocalOrNull(n.endTime);
+    n.startTime = toLocalOrNull(n.startTime);
+  }
+  for (const y of yogas) {
+    y.endTime = toLocalOrNull(y.endTime);
+    y.startTime = toLocalOrNull(y.startTime);
+  }
+  for (const k of karanas) {
+    k.endTime = toLocalOrNull(k.endTime);
+    k.startTime = toLocalOrNull(k.startTime);
+  }
+  return {
+    date,
+    location,
+    timezone: offsetMinutes,
+    sunrise: toLocal(sunriseUtc),
+    sunset: toLocal(sunsetUtc),
+    nextSunrise: toLocal(nextSunriseUtc),
+    dayDurationMinutes: Math.round(dayDurationMs / 6e4),
+    nightDurationMinutes: Math.round(nightDurationMs / 6e4),
+    tithis,
+    nakshatras,
+    yogas,
+    karanas,
+    vara,
+    rahuKalam: convertTimePeriod(rahuKalam),
+    gulikaKalam: convertTimePeriod(gulikaKalam),
+    yamaganda: convertTimePeriod(yamaganda),
+    abhijitMuhurta: convertTimePeriod(abhijitMuhurta),
+    ayanamsa: ayanamsaValue,
+    siderealSunAtSunrise,
+    siderealMoonAtSunrise,
+    masa
+  };
+}
+/*! Bundled license information:
+
+astronomy-engine/esm/astronomy.js:
+  (**
+      @preserve
+  
+      Astronomy library for JavaScript (browser and Node.js).
+      https://github.com/cosinekitty/astronomy
+  
+      MIT License
+  
+      Copyright (c) 2019-2023 Don Cross <cosinekitty@gmail.com>
+  
+      Permission is hereby granted, free of charge, to any person obtaining a copy
+      of this software and associated documentation files (the "Software"), to deal
+      in the Software without restriction, including without limitation the rights
+      to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+      copies of the Software, and to permit persons to whom the Software is
+      furnished to do so, subject to the following conditions:
+  
+      The above copyright notice and this permission notice shall be included in all
+      copies or substantial portions of 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.
+  *)
+  (**
+   * @fileoverview Astronomy calculation library for browser scripting and Node.js.
+   * @author Don Cross <cosinekitty@gmail.com>
+   * @license MIT
+   *)
+*/
+
+exports.PanchangError = PanchangError;
+exports.computeAbhijitMuhurta = computeAbhijitMuhurta;
+exports.computeGulikaKalam = computeGulikaKalam;
+exports.computeRahuKalam = computeRahuKalam;
+exports.computeYamaganda = computeYamaganda;
+exports.getAyanamsa = computeAyanamsa;
+exports.getDailyPanchang = getDailyPanchang;
+exports.getInstantPanchang = getInstantPanchang;
+exports.getSiderealMoonLongitude = getSiderealMoonLongitude;
+exports.getSiderealSunLongitude = getSiderealSunLongitude;
+exports.getSunrise = computeSunrise;
+exports.getSunset = computeSunset;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map