mihrab-methods 1.0.2 → 1.2.0

package/dist/esm/methods/morocco.js

@@ -2,26 +2,44 @@
  * Morocco — the Ministry of Habous and Islamic Affairs's method, as its
  * timetable is computed (issue #10).
  *
- * Read off 77 days of the ministry's tables for its 164 located cities:
+ * Read off the ministry's tables: 96 days of 2026 for its 164 located
+ * cities, and — through the Internet Archive — its pages of 2014–2025 for
+ * Rabat, Figuig, Tangier, Casablanca, Laayoune and a dozen more, every
+ * month of the year. The ministry's program changed between 2019 and
+ * 2023; this is the one it has used since (2023–2026), and what it does:
  *
  *   • a precise Sun — Meeus's apparent Sun with the full nutation and his
  *     chapter-28 equation of time; a JPL ephemeris fits no better, NOAA's
  *     and the Almanac's series far worse — taken at each prayer's own
  *     moment (iterated), declination and equation of time alike;
- *   • Fajr 19°, Isha 17°, Asr one shadow length (Shafi'i);
+ *   • Fajr 19° and Isha 17°, true altitudes;
  *   • Dhuhr five minutes after the transit;
- *   • sunrise 2.85 minutes before, and Maghrib 3.7 after, the Sun's upper
- *     limb on the horizon — refraction 34′ and the Sun's semi-diameter for
- *     its distance that day — less the city's own horizon dip;
+ *   • Asr on the APPARENT Sun, by the classical rule: a gnomon's shadow at
+ *     noon (the noon declination, the noon altitude raised by refraction)
+ *     plus one length (Shafi'i), and the moment the apparent Sun casts it
+ *     — refraction by Sæmundsson's formula from the true altitude at noon,
+ *     Bennett's from the apparent at Asr (Meeus 16.4 and 16.3);
+ *   • sunrise one minute before, and Maghrib 1.8 minutes after, the Sun
+ *     on an altitude −(34′ + s) − dip: refraction, the semi-diameter for
+ *     its distance that day, and the city's own allowance for its horizon;
  *   • Fajr rounded down to the minute, the rest to the nearest.
  *
- * The dip is the ministry's own per city and per side — the horizon east
- * at sunrise, west at Maghrib, which mountains or the sea make different —
- * fitted from its tables with the city's point (`data/moroccoMethodPoints.json`,
- * about 0.02° per √metre of height); elsewhere 0.02°·√height, 0.86 of it at
- * Maghrib. On 77 days of the ministry's tables for its 164 located cities
- * this is its printed minute for 99.12 % of times, and never further than
- * one; `data/corrections/morocco.json` holds the rest.
+ * The horizon allowance ("dip") is the ministry's own per city and per
+ * side — east at sunrise, west at Maghrib — fitted from its tables with
+ * the city's point (`data/moroccoMethodPoints.json`); it follows the
+ * city's height closely (about 0.32° + 0.025°·√metres east, 0.37° +
+ * 0.021°·√metres west; 92 % correlation), which is what a city off the
+ * list gets. It is an angle, not minutes: the allowance in minutes grows
+ * towards the solstices, as the ministry's does, and the fixed minute
+ * margins are the small rest. Fitted on the autumn alone (the first
+ * version of this method) the two could not be told apart, and the method
+ * drifted a tenth of a minute by late November.
+ *
+ * On the 2026 tables this is the ministry's printed minute for 99.88 % of
+ * times (114 of 94,350 off, each within a second or two of a minute's
+ * edge: the ministry's Sun and this one differ by that much), and never
+ * further than one; `data/corrections/morocco.json` holds the rest. On
+ * the archive's 2023–2026 pages, every month of the year, 99.3 %.
  */
 const RAD = Math.PI / 180;
 const DAY_MS = 86_400_000;
@@ -49,16 +67,21 @@ export function meeusApparentSun(d) {
 }
 const ITERATIONS = 3;
 /** Minutes before the horizon crossing that the ministry prints sunrise, and after it Maghrib. */
-export const MOROCCO_SUNRISE_MARGIN = -2.85;
-export const MOROCCO_MAGHRIB_MARGIN = 3.7;
-/** The share of the horizon dip Maghrib takes, against sunrise's whole, where a city's own is not known. */
-export const MOROCCO_MAGHRIB_DIP_SHARE = 0.86;
-/** Degrees of dip per √metre where the ministry's own value is not known. */
-export const MOROCCO_DIP_PER_SQRT_M = 0.02;
+export const MOROCCO_SUNRISE_MARGIN = -1.0;
+export const MOROCCO_MAGHRIB_MARGIN = 1.8;
+/** The horizon allowance of a city whose own is not known: degrees, from its height in metres, east (sunrise) and west (Maghrib). */
+export const moroccoDipEast = (heightM) => 0.32 + 0.025 * Math.sqrt(Math.max(heightM, 0));
+export const moroccoDipWest = (heightM) => 0.37 + 0.021 * Math.sqrt(Math.max(heightM, 0));
+/** Refraction (degrees) that lifts a TRUE altitude h (degrees) to its apparent one — Sæmundsson, Meeus 16.4. */
+export const refractionFromTrue = (h) => (1.02 / Math.tan((h + 10.3 / (h + 5.11)) * RAD)) / 60;
+/** Refraction (degrees) under an APPARENT altitude h (degrees) — Bennett, Meeus 16.3. */
+export const refractionFromApparent = (h) => (1 / Math.tan((h + 7.31 / (h + 4.4)) * RAD)) / 60;
 /** Exact times, minutes past 00:00 UT of the civil date, margins applied, before rounding. NaN where one does not form. */
-export function moroccoRawMinutes(latitude, longitude, year, month, day, dipDeg = 0, asrShadow = 1, 
-/** The horizon's dip westward, at Maghrib; MOROCCO_MAGHRIB_DIP_SHARE of `dipDeg` when not known. */
-dipMaghribDeg = MOROCCO_MAGHRIB_DIP_SHARE * dipDeg) {
+export function moroccoRawMinutes(latitude, longitude, year, month, day, 
+/** The horizon allowance eastward, at sunrise, degrees: the city's own, else `moroccoDipEast(height)`. */
+dipDeg = moroccoDipEast(0), asrShadow = 1, 
+/** The horizon allowance westward, at Maghrib; `moroccoDipWest(0)` offset by the east's excess when not known. */
+dipMaghribDeg = dipDeg + (moroccoDipWest(0) - moroccoDipEast(0))) {
     const d0 = (Date.UTC(year, month, day) - Date.UTC(2000, 0, 1)) / DAY_MS - 0.5;
     const at = (t) => meeusApparentSun(d0 + t / 1440);
     let noon = 720 - 4 * longitude;
@@ -82,12 +105,19 @@ dipMaghribDeg = MOROCCO_MAGHRIB_DIP_SHARE * dipDeg) {
         return t;
     };
     const fixed = (a) => () => a;
-    const asrAltitude = (dec) => Math.atan(1 / (asrShadow + Math.tan(Math.abs(latitude - dec / RAD) * RAD))) / RAD;
+    // Asr on the apparent Sun: the noon shadow of a gnomon from the apparent noon altitude (the noon
+    // declination), plus `asrShadow` lengths; the Sun's apparent altitude that casts it; the true
+    // altitude under it is what the hour angle is solved for, with the declination at the event.
+    const noonDec = at(noon).dec;
+    const noonTrue = 90 - Math.abs(latitude - noonDec / RAD);
+    const noonApparent = noonTrue + refractionFromTrue(noonTrue);
+    const asrApparent = Math.atan(1 / (asrShadow + 1 / Math.tan(noonApparent * RAD))) / RAD;
+    const asrTrue = asrApparent - refractionFromApparent(asrApparent);
     return {
         fajr: event(fixed(-19), -1, noon - 420) - 0.5,
         sunrise: event(fixed(horizon - dipDeg), -1, noon - 360) + MOROCCO_SUNRISE_MARGIN,
         dhuhr: noon + 5,
-        asr: event(asrAltitude, 1, noon + 200),
+        asr: event(fixed(asrTrue), 1, noon + 200),
         maghrib: event(fixed(horizon - dipMaghribDeg), 1, noon + 360) + MOROCCO_MAGHRIB_MARGIN,
         isha: event(fixed(-17), 1, noon + 420),
     };
@@ -96,7 +126,7 @@ dipMaghribDeg = MOROCCO_MAGHRIB_DIP_SHARE * dipDeg) {
  * The ministry's times for a point and civil date (month 0-based), on the
  * minute. Null when a time does not form there.
  */
-export function moroccoTimes(latitude, longitude, year, month, day, dipDeg = 0, asrShadow = 1, dipMaghribDeg) {
+export function moroccoTimes(latitude, longitude, year, month, day, dipDeg, asrShadow = 1, dipMaghribDeg) {
     const r = moroccoRawMinutes(latitude, longitude, year, month, day, dipDeg, asrShadow, dipMaghribDeg);
     const all = [r.fajr, r.sunrise, r.dhuhr, r.asr, r.maghrib, r.isha];
     if (!all.every(Number.isFinite))

package/dist/esm/methods/revisions.d.ts

@@ -9,7 +9,7 @@
 export declare const METHOD_REVISION: {
     readonly sweden: 1;
     readonly diyanet: 1;
-    readonly morocco: 1;
+    readonly morocco: 2;
     readonly algeria: 1;
-    readonly indonesia: 1;
+    readonly indonesia: 2;
 };

package/dist/esm/methods/revisions.js

@@ -9,7 +9,7 @@
 export const METHOD_REVISION = {
     sweden: 1,
     diyanet: 1,
-    morocco: 1,
+    morocco: 2,
     algeria: 1,
-    indonesia: 1,
+    indonesia: 2,
 };

package/dist/esm/server.d.ts

@@ -0,0 +1,12 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** The answer to a request path and query. Throws HttpError, UncertifiedMethodError, RangeError or TypeError. */
+export declare function handle(url: URL): unknown;
+/** Status, body and headers for a request, errors included — what both servers send. */
+export declare function respond(url: URL): {
+    status: number;
+    body: string;
+    headers: Record<string, string>;
+};

package/dist/esm/server.js

@@ -0,0 +1,126 @@
+/**
+ * The HTTP API over the library — one handler, served two ways: by
+ * `tools/serve.ts` on Node (`npm run serve`) and by `api/worker.ts` at the
+ * edge (the public API). Nothing is logged or stored; every answer is JSON.
+ *
+ *   GET /                                            the routes, the methods' certification
+ *   GET /v1/methods                                  every method, as methodInfo gives it
+ *   GET /v1/places?authority=algeria                 the authority's places (id, name, country, lat, lon, tz)
+ *   GET /v1/nearest?authority=algeria&lat=36.75&lng=3.06
+ *   GET /v1/times?place=algeria:27&date=2026-10-15   one day, as timesFor gives it
+ *   GET /v1/times?authority=algeria&lat=36.75&lng=3.06&date=2026-10-15
+ *   GET /v1/times?place=algeria:27&from=2026-10-01&to=2026-10-31
+ *   GET /v1/authority?lat=36.75&lng=3.06             defaultAuthorityFor, with the country
+ *
+ * Options on /v1/times: asr=2 for the Hanafi Asr; strict=1 to refuse a date
+ * outside the certified span (HTTP 422) instead of answering 'method-only'.
+ */
+import { AUTHORITIES, methodInfo, nearestPlace, placeById, placesOf, timesFor, timesForRange, UncertifiedMethodError } from './index.js';
+import { countryAt, defaultAuthorityFor } from './locate.js';
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const isAuthority = (x) => !!x && AUTHORITIES.includes(x);
+const num = (q, k) => {
+    const v = Number(q.get(k));
+    if (q.get(k) === null || !Number.isFinite(v))
+        throw new HttpError(400, `${k}: a number is needed`);
+    return v;
+};
+const authorityOf = (q) => {
+    const a = q.get('authority');
+    if (!isAuthority(a))
+        throw new HttpError(400, `authority: one of ${AUTHORITIES.join(', ')}`);
+    return a;
+};
+const placeOf = (q) => {
+    const id = q.get('place');
+    if (id) {
+        const p = placeById(id);
+        if (!p)
+            throw new HttpError(404, `no place ${id}`);
+        return p;
+    }
+    const near = nearestPlace(authorityOf(q), num(q, 'lat'), num(q, 'lng'));
+    if (!near)
+        throw new HttpError(404, 'no place near there');
+    return near.place;
+};
+const brief = (p) => ({ id: p.id, name: p.name, country: p.country, lat: p.lat, lon: p.lon, tz: p.tz });
+const ROUTES = [
+    '/v1/methods',
+    '/v1/places?authority=<authority>',
+    '/v1/nearest?authority=<authority>&lat=<lat>&lng=<lng>',
+    '/v1/times?place=<authority:id>&date=<YYYY-MM-DD>[&asr=2][&strict=1]',
+    '/v1/times?authority=<authority>&lat=<lat>&lng=<lng>&date=<YYYY-MM-DD>',
+    '/v1/times?place=<authority:id>&from=<YYYY-MM-DD>&to=<YYYY-MM-DD>',
+    '/v1/authority?lat=<lat>&lng=<lng>',
+];
+/** The answer to a request path and query. Throws HttpError, UncertifiedMethodError, RangeError or TypeError. */
+export function handle(url) {
+    const q = url.searchParams;
+    switch (url.pathname.replace(/\/+$/, '') || '/') {
+        case '/':
+            return {
+                name: 'mihrab-methods',
+                description: 'The prayer-time authorities’ own calculation methods, each reproducing its published timetable to the minute.',
+                docs: 'https://github.com/MihrabHQ/mihrab-methods#readme',
+                routes: ROUTES,
+                authorities: AUTHORITIES,
+                // each method's record, as the library carries it (the feed on main may be newer: methodInfo says the date)
+                methods: AUTHORITIES.map(a => {
+                    const m = methodInfo(a);
+                    return { authority: a, name: m.name, revision: m.revision, certified: m.certified, checkedAt: m.certification?.checkedAt ?? null, places: m.places };
+                }),
+            };
+        case '/v1/methods':
+            return AUTHORITIES.map(methodInfo);
+        case '/v1/places':
+            return placesOf(authorityOf(q)).map(brief);
+        case '/v1/nearest': {
+            const near = nearestPlace(authorityOf(q), num(q, 'lat'), num(q, 'lng'));
+            return near && { place: brief(near.place), distanceKm: Math.round(near.distanceKm * 10) / 10 };
+        }
+        case '/v1/authority': {
+            const lat = num(q, 'lat'), lng = num(q, 'lng');
+            return { country: countryAt(lat, lng), authority: defaultAuthorityFor(lat, lng) };
+        }
+        case '/v1/times': {
+            const place = placeOf(q);
+            const opts = { asrShadow: q.get('asr') === '2' ? 2 : 1, strict: q.get('strict') === '1' };
+            const from = q.get('from'), to = q.get('to');
+            if (from && to)
+                return { place: brief(place), days: timesForRange(place, from, to, opts) };
+            return { place: brief(place), ...timesFor(place, q.get('date') ?? new Date().toISOString().slice(0, 10), opts) };
+        }
+        default:
+            throw new HttpError(404, `no such route; the routes are ${ROUTES.join(' · ')}`);
+    }
+}
+/** Status, body and headers for a request, errors included — what both servers send. */
+export function respond(url) {
+    let status = 200;
+    let body;
+    try {
+        body = handle(url);
+    }
+    catch (e) {
+        status = e instanceof HttpError ? e.status : e instanceof UncertifiedMethodError ? 422 : e instanceof RangeError || e instanceof TypeError ? 400 : 500;
+        body = { error: e.message };
+    }
+    return {
+        status,
+        body: JSON.stringify(body),
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            'access-control-allow-origin': '*',
+            'access-control-allow-methods': 'GET, OPTIONS',
+            // A day's times never change between releases: let browsers and the edge keep an answer for an hour.
+            'cache-control': status === 200 ? 'public, max-age=3600' : 'no-store',
+        },
+    };
+}

package/dist/esm/sun/preciseSun.d.ts

@@ -12,8 +12,13 @@ export declare function deltaT(ut: number): number;
  * The apparent Sun at `d` days from J2000.0 (UT): declination (rad) and
  * equation of time (minutes), such that the transit at longitude λ (east) is
  * 720 − 4λ − eot minutes UT. Same contract as `meeusApparentSun`.
+ *
+ * `deltaTSeconds` is what is added to UT for the ephemeris' own time (TT):
+ * ΔT as it is (about 70 s in the 2020s) unless given. A program that takes
+ * its clock time for the ephemeris' time is 0 here — the Sun 70 seconds
+ * behind where it is, a fifth of a second on every time of the day.
  */
-export declare function preciseApparentSun(d: number): {
+export declare function preciseApparentSun(d: number, deltaTSeconds?: number): {
     dec: number;
     eot: number;
 };

package/dist/esm/sun/preciseSun.js

@@ -158,9 +158,14 @@ function nutate(v, oblm, oblt, psi) {
  * The apparent Sun at `d` days from J2000.0 (UT): declination (rad) and
  * equation of time (minutes), such that the transit at longitude λ (east) is
  * 720 − 4λ − eot minutes UT. Same contract as `meeusApparentSun`.
+ *
+ * `deltaTSeconds` is what is added to UT for the ephemeris' own time (TT):
+ * ΔT as it is (about 70 s in the 2020s) unless given. A program that takes
+ * its clock time for the ephemeris' time is 0 here — the Sun 70 seconds
+ * behind where it is, a fifth of a second on every time of the day.
  */
-export function preciseApparentSun(d) {
-    const tt = d + deltaT(d) / 86400;
+export function preciseApparentSun(d, deltaTSeconds = deltaT(d)) {
+    const tt = d + deltaTSeconds / 86400;
     const e = earthJ2000(tt - 1 / C_AUDAY);
     const nut = nutation(tt);
     const mobl = meanObliquity(tt);

package/docs/methods.md

@@ -110,7 +110,11 @@ statement of it that gives the tables.
 ## Morocco
 
 `src/methods/morocco.ts`. The Ministry of Habous and Islamic Affairs, read
-off its tables for 164 cities.
+off its tables for 164 cities: 96 days of 2026 for all of them, and — through
+the Internet Archive's copies of its pages — 2014 to 2025 for Rabat, Figuig,
+Tangier, Casablanca, Laayoune and a dozen more, every month of the year. The
+ministry's program changed between 2019 and 2023 (until then Asr was the
+noon shadow on the true sun); this is the program it has used since.
 
 - The sun is **Meeus's apparent sun** with the full nutation (the mean
   elements above; apparent longitude `L0 + C − 0.00569 + Δψ`, with
@@ -118,14 +122,26 @@ off its tables for 164 cities.
   and his chapter-28 equation of time
   `E = L0 − 0.0057183 − α + Δψ cos ε`, taken at **each prayer's own
   moment** (iterated), declination and equation of time alike.
-- Fajr −19°, Isha −17°, Asr one shadow length (Shafiʿi).
+- Fajr −19°, Isha −17°, true altitudes.
 - Dhuhr five minutes after the transit.
-- Sunrise 2.85 minutes before, and Maghrib 3.7 minutes after, the sun's
-  upper limb on the horizon: altitude `−(34′ + s) − dip`, with s the sun's
-  semi-diameter for its distance that day and dip the city's own horizon
-  dip — eastward at sunrise (`Place.dipDeg`), westward at Maghrib
-  (`Place.dipMaghribDeg`), each fitted from the tables with the city's
-  point; where not fitted, `0.02°·√height(m)`, and 0.86 of it at Maghrib.
+- Asr on the **apparent** sun, by the classical rule: with δ the noon
+  declination, the noon altitude `h = 90° − |φ − δ|` is raised by
+  refraction, `h' = h + R(h)`, `R(h) = 1.02′ / tan(h + 10.3/(h + 5.11))`
+  (Sæmundsson, Meeus 16.4, h in degrees); the gnomon's shadow is `cot h'`,
+  and Asr is when the apparent sun's shadow is one length more:
+  apparent altitude `a' = arctan(1 / (1 + cot h'))`, and the true altitude
+  the hour angle is solved for, `a = a' − R'(a')`,
+  `R'(a') = 1′ / tan(a' + 7.31/(a' + 4.4))` (Bennett, Meeus 16.3), with the
+  declination at the event. Hanafi takes two lengths.
+- Sunrise one minute before, and Maghrib 1.8 minutes after, the sun on the
+  altitude `−(34′ + s) − dip`, with s the sun's semi-diameter for its
+  distance that day and dip the city's own horizon allowance — eastward at
+  sunrise (`Place.dipDeg`), westward at Maghrib (`Place.dipMaghribDeg`),
+  each fitted from the tables with the city's point. It is an angle: the
+  minutes it is worth grow towards the solstices, as the ministry's do.
+  It follows the city's height (92 % correlation), and a city not fitted
+  gets `0.32° + 0.025°·√height(m)` east and `0.37° + 0.021°·√height(m)`
+  west.
 - Fajr rounded **down** to the minute, every other time to the nearest.
 - The ministry's clock is GMT+1 until 17 September 2026 and GMT from then
   on (`Place.clock`); the zone databases still move Morocco's clock, so the
@@ -164,6 +180,11 @@ cities.
   after Astronomy Engine, within 0.05 s and 0.5″ of JPL's DE421), taken at
   each prayer's own moment, iterated three times. Meeus's shorter series
   drifts by a second and leaves a minute in two hundred off.
+- **No ΔT**: the ministry's program takes the clock's Universal Time for
+  the ephemeris' own time, so its sun stands about 70 seconds behind and
+  every time of the day comes a fifth of a second early
+  (`preciseApparentSun(d, 0)`). A port that adds ΔT is a minute off on
+  about one time in two hundred.
 - Fajr −20°, Isha −18°.
 - Sunrise and Maghrib at −1°, and at −2° in the regencies the ministry
   classes as highland (`Place.highland`); in six highland regencies of Papua
@@ -173,8 +194,11 @@ cities.
   entry gives it), the hour angle from the sun at Asr (four iterations).
 - Every time rounded **up**, after a margin: +2 minutes on Fajr, Asr,
   Maghrib and Isha, +3 on Dhuhr, −3 on sunrise.
-- Each regency at its own fitted point; Karawang's Asr, Maghrib and Isha at a
-  second point about 2 km north-east (`Place.afternoon`).
+- Each regency at the **coordinates the ministry gives for it**, to a
+  hundredth of an arc-second. Nothing is fitted. One is written with a minus
+  and a hemisphere both (Pekajang, "−01° 12′ S"), and the ministry's program
+  reads it as −1° + 12′ and then south of that: 0.8° north, which is where
+  its table is computed.
 - Each regency is printed in its province's zone (WIB, WITA or WIT).
 
 ## Checking a port

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mihrab-methods",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "The prayer-time authorities' own calculation methods, each reproducing its published timetable to the minute: Sweden (Diyanet, as Islamiska Förbundet prints it), Diyanet worldwide, Morocco (Habous), Algeria (Ministry of Religious Affairs), Indonesia (Kemenag).",
   "license": "MPL-2.0",
   "author": "Hassan El Ghamri",
@@ -28,7 +28,14 @@
     "./dist/*/morocco.js",
     "./dist/*/algeria.js",
     "./dist/*/indonesia.js",
-    "./dist/*/authorities/*.js"
+    "./dist/*/authorities/*.js",
+    "./src/index.ts",
+    "./src/sweden.ts",
+    "./src/diyanet.ts",
+    "./src/morocco.ts",
+    "./src/algeria.ts",
+    "./src/indonesia.ts",
+    "./src/authorities/*.ts"
   ],
   "engines": {
     "node": ">=18"
@@ -169,6 +176,8 @@
     "precertify": "npm run embed",
     "certify": "tsx tools/certify.ts",
     "vectors": "npm run embed && tsx tools/vectors.ts",
+    "prefeed-check": "npm run embed",
+    "feed-check": "tsx tools/feed-check.ts",
     "readme": "node scripts/readme.mjs",
     "preflight": "npm run typecheck && npm test && node scripts/readme.mjs --check",
     "serve": "npm run embed && tsx tools/serve.ts"

package/dist/cjs/methods/scratch-congress.d.ts

@@ -1,87 +0,0 @@
-/**
- * The International Prayer Times Congress method (Istanbul, 2021 — the
- * Diyanet and the European Council for Fatwa and Research) as Diyanet's
- * tables realise it. Islamiska Förbundet's Swedish tables are those
- * tables, row for row, so this is Sweden's method (id 24).
- *
- * The published rules (awqatsalah.com, "Tespit Kriterleri"):
- *  - Dhuhr five minutes after transit; Asr one shadow (Dhuhr when the
- *    shadow never forms), four minutes late; sunrise seven early,
- *    Maghrib seven late ("temkin").
- *  - Neither the day nor the night is shorter than five hours.
- *  - True Fajr at 18°, true Isha at 16°. Where the 18° dawn no longer
- *    forms, the share of the night the sharia night's third took on the
- *    last day it did is carried: Isha that share of the night after
- *    Maghrib, Fajr the same share scaled by 18/16 before sunrise.
- *  - The move from true times to the carried ones is gradual, starting
- *    twenty minutes before (Isha) or after (Fajr) the takdir.
- *
- * What the tables turn out to do with them, read off Diyanet's own tables
- * for all 160 Swedish places, 2024–2027 (99.98 % of times on the printed
- * minute, the rest a fraction of a second from the rounding point):
- *  - The sun is taken once a day, at 0h UT less 45 s: Meeus's mean
- *    elements and equation of the centre, the TRUE (geometric) longitude,
- *    the apparent obliquity (mean plus nutation), the equation of time as
- *    the mean longitude less the right ascension, 0.106 s later; and
- *    two small waves by the mean longitude the formula leaves out: a few
- *    hundredths of a second on the transit, a tenth of an arc-second on
- *    the declination.
- *  - Coordinates are kept to three decimals of a degree.
- *  - Asr that never forms is printed at Dhuhr's time.
- *  - The night a share is taken of is the day's own: 24 h less the
- *    printed day, sunrise to Maghrib.
- *  - The five-hour floors hold each end separately, 150 minutes from the
- *    printed Dhuhr or from the midnight after it. Where midsummer's
- *    night is floored at both ends (to within a minute), that night
- *    anchors the season, and the floored times never step back: before
- *    midsummer no sunrise earlier than midsummer's and a floored Maghrib
- *    no earlier than the day before; after it no sunrise earlier nor
- *    Maghrib later than on any day since midsummer — and Fajr and Isha
- *    carried the same way.
- *  - The gradual transition is a straight line across the days next to
- *    the gap on which the true time lies within twenty minutes of the
- *    takdir at the gap's edge: twenty minutes away at the far end, the
- *    takdir at the edge.
- *
- * Beyond Sweden the same code gives Diyanet's tables worldwide, read off
- * them for places on six continents:
- *  - Where the dawn forms all summer but midsummer's true Isha (at 16°)
- *    falls later than the share carried from that night, midsummer is the
- *    takdir's day — a gap of one day, with its ramps (from about 44.4°
- *    north: Austria, central France, northern Bosnia).
- *  - Isha is printed at 16° in some countries and 17° in others; the
- *    high-latitude rules are worked at 16° either way (`ishaDeg`).
- *
- * Times are minutes past 0h UT of the date, a frame the clock changes
- * cannot bend; `congressTimes` turns them into instants.
- */
-/**
- * Isha's depression: the Congress's 16° (Diyanet's in much of Europe,
- * Russia, Central Asia, China and North America), or Diyanet's own 17°
- * (elsewhere). The high-latitude rules are the Congress's at 16° either way;
- * the angle sets only the true Isha printed.
- */
-export declare const CONGRESS_ISHA_DEG = 16;
-export declare const DIYANET_ISHA_DEG = 17;
-export type CongressInstants = {
-    fajr: Date;
-    sunrise: Date;
-    dhuhr: Date;
-    asr: Date;
-    maghrib: Date;
-    isha: Date;
-};
-/**
- * The Congress method's times for a calendar date (year, month 0–11, day),
- * as instants, unrounded. `asrShadow` is 1 for the standard Asr, 2 for the
- * Hanafi one; the tables print the standard. `ishaDeg` is Isha's depression:
- * 16° (the Congress's, Diyanet's in Europe and North America) or 17°
- * (Diyanet's everywhere else).
- */
-export declare function congressTimes(latitude: number, longitude: number, year: number, month: number, day: number, asrShadow?: number, ishaDeg?: number): CongressInstants;
-/** For tests and the verification tool: the year's structure as the method sees it. */
-export declare function congressYearInfo(latitude: number, longitude: number, year: number): {
-    gap: [string, string] | null;
-    ratio: number | null;
-    midsummerFloors: boolean;
-};