mihrab-methods 0.0.0-stage → 1.0.1

package/dist/cjs/sun/preciseSun.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * A precise apparent Sun: the Earth's VSOP87 series (truncated), IAU 2006
+ * precession, IAU 2000B nutation and light time, after Don Cross's
+ * Astronomy Engine (MIT licence). It agrees with JPL DE421 to about 0.05 s
+ * in the equation of time and 0.5″ in declination, where Meeus's short
+ * series (`meeusApparentSun`) drifts by about a second over the year —
+ * enough to move a published minute.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deltaT = deltaT;
+exports.preciseApparentSun = preciseApparentSun;
+const ASEC2RAD = 4.848136811095359935899141e-6;
+const ASEC360 = 1296000;
+const DEG = Math.PI / 180;
+const C_AUDAY = 173.1446326846693;
+const DAYS_PER_MILLENNIUM = 365250;
+/** Heliocentric ecliptic (J2000) longitude, latitude and radius of the Earth: [ampl, phase, freq] per power of t. */
+const EARTH = [
+    [
+        [
+            [1.75347045673, 0, 0], [0.03341656453, 4.66925680415, 6283.0758499914], [0.00034894275, 4.62610242189, 12566.1516999828],
+            [0.00003417572, 2.82886579754, 3.523118349], [0.00003497056, 2.74411783405, 5753.3848848968], [0.00003135899, 3.62767041756, 77713.7714681205],
+            [0.00002676218, 4.41808345438, 7860.4193924392], [0.00002342691, 6.13516214446, 3930.2096962196], [0.00001273165, 2.03709657878, 529.6909650946],
+            [0.00001324294, 0.74246341673, 11506.7697697936], [0.00000901854, 2.04505446477, 26.2983197998], [0.00001199167, 1.10962946234, 1577.3435424478],
+            [0.00000857223, 3.50849152283, 398.1490034082], [0.00000779786, 1.17882681962, 5223.6939198022], [0.0000099025, 5.23268072088, 5884.9268465832],
+            [0.00000753141, 2.53339052847, 5507.5532386674], [0.00000505267, 4.58292599973, 18849.2275499742], [0.00000492392, 4.20505711826, 775.522611324],
+            [0.00000356672, 2.91954114478, 0.0673103028], [0.00000284125, 1.89869240932, 796.2980068164], [0.00000242879, 0.34481445893, 5486.777843175],
+            [0.00000317087, 5.84901948512, 11790.6290886588], [0.00000271112, 0.31486255375, 10977.078804699], [0.00000206217, 4.80646631478, 2544.3144198834],
+            [0.00000205478, 1.86953770281, 5573.1428014331], [0.00000202318, 2.45767790232, 6069.7767545534], [0.00000126225, 1.08295459501, 20.7753954924],
+            [0.00000155516, 0.83306084617, 213.299095438],
+        ],
+        [[6283.0758499914, 0, 0], [0.00206058863, 2.67823455808, 6283.0758499914], [0.00004303419, 2.63512233481, 12566.1516999828]],
+        [[0.00008721859, 1.07253635559, 6283.0758499914]],
+    ],
+    [[], [[0.00227777722, 3.4137662053, 6283.0758499914], [0.00003805678, 3.37063423795, 12566.1516999828]]],
+    [
+        [
+            [1.00013988784, 0, 0], [0.01670699632, 3.09846350258, 6283.0758499914], [0.00013956024, 3.05524609456, 12566.1516999828],
+            [0.0000308372, 5.19846674381, 77713.7714681205], [0.00001628463, 1.17387558054, 5753.3848848968], [0.00001575572, 2.84685214877, 7860.4193924392],
+            [0.00000924799, 5.45292236722, 11506.7697697936], [0.00000542439, 4.56409151453, 3930.2096962196], [0.0000047211, 3.66100022149, 5884.9268465832],
+            [0.00000085831, 1.27079125277, 161000.6857376741], [0.00000057056, 2.01374292245, 83996.84731811189], [0.00000055736, 5.2415979917, 71430.69561812909],
+            [0.00000174844, 3.01193636733, 18849.2275499742], [0.00000243181, 4.2734953079, 11790.6290886588],
+        ],
+        [[0.00103018607, 1.10748968172, 6283.0758499914], [0.00001721238, 1.06442300386, 12566.1516999828]],
+        [[0.00004359385, 5.78455133808, 6283.0758499914]],
+    ],
+];
+function vsop(formula, t, clamp) {
+    let tp = 1;
+    let out = 0;
+    for (const series of formula) {
+        let sum = 0;
+        for (const [a, p, f] of series)
+            sum += a * Math.cos(p + t * f);
+        let incr = tp * sum;
+        if (clamp)
+            incr %= 2 * Math.PI;
+        out += incr;
+        tp *= t;
+    }
+    return out;
+}
+/** Earth−J2000 equatorial position (AU) at `tt` days from J2000. */
+function earthJ2000(tt) {
+    const t = tt / DAYS_PER_MILLENNIUM;
+    const lon = vsop(EARTH[0], t, true);
+    const lat = vsop(EARTH[1], t, false);
+    const r = vsop(EARTH[2], t, false);
+    const x = r * Math.cos(lat) * Math.cos(lon);
+    const y = r * Math.cos(lat) * Math.sin(lon);
+    const z = r * Math.sin(lat);
+    return [
+        x + 0.00000044036 * y - 0.000000190919 * z,
+        -0.000000479966 * x + 0.917482137087 * y - 0.397776982902 * z,
+        0.397776982902 * y + 0.917482137087 * z,
+    ];
+}
+/** ΔT (s), Espenak & Meeus, for UT days from J2000 — held at its 2017 value onward (about 69 s, as observed), as JPL Horizons does. */
+function deltaT(ut) {
+    const y = 2000 + (Math.min(ut, 17 * 365.24217) - 14) / 365.24217;
+    if (y >= 2005 && y < 2050) {
+        const u = y - 2000;
+        return 62.92 + 0.32217 * u + 0.005589 * u * u;
+    }
+    if (y >= 2050 && y < 2150) {
+        const u = (y - 1820) / 100;
+        return -20 + 32 * u * u - 0.5628 * (2150 - y);
+    }
+    if (y >= 1986 && y < 2005) {
+        const u = y - 2000;
+        return 63.86 + 0.3345 * u - 0.060374 * u ** 2 + 0.0017275 * u ** 3 + 0.000651814 * u ** 4 + 0.00002373599 * u ** 5;
+    }
+    const u = (y - 1820) / 100;
+    return -20 + 32 * u * u;
+}
+function nutation(tt) {
+    const mod = (x) => (x % ASEC360) * ASEC2RAD;
+    const t = tt / 36525;
+    const elp = mod(1287104.79305 + t * 129596581.0481);
+    const f = mod(335779.526232 + t * 1739527262.8478);
+    const d = mod(1072260.70369 + t * 1602961601.209);
+    const om = mod(450160.398036 - t * 6962890.5431);
+    let dp = (-172064161.0 - 174666.0 * t) * Math.sin(om) + 33386.0 * Math.cos(om);
+    let de = (92052331.0 + 9086.0 * t) * Math.cos(om) + 15377.0 * Math.sin(om);
+    let a = 2 * (f - d + om);
+    dp += (-13170906.0 - 1675.0 * t) * Math.sin(a) - 13696.0 * Math.cos(a);
+    de += (5730336.0 - 3015.0 * t) * Math.cos(a) - 4587.0 * Math.sin(a);
+    a = 2 * (f + om);
+    dp += (-2276413.0 - 234.0 * t) * Math.sin(a) + 2796.0 * Math.cos(a);
+    de += (978459.0 - 485.0 * t) * Math.cos(a) + 1374.0 * Math.sin(a);
+    a = 2 * om;
+    dp += (2074554.0 + 207.0 * t) * Math.sin(a) - 698.0 * Math.cos(a);
+    de += (-897492.0 + 470.0 * t) * Math.cos(a) - 291.0 * Math.sin(a);
+    dp += (1475877.0 - 3633.0 * t) * Math.sin(elp) + 11817.0 * Math.cos(elp);
+    de += (73871.0 - 184.0 * t) * Math.cos(elp) - 1924.0 * Math.sin(elp);
+    return { dpsi: -0.000135 + dp * 1e-7, deps: 0.000388 + de * 1e-7 };
+}
+function meanObliquity(tt) {
+    const t = tt / 36525;
+    return ((((-0.0000000434 * t - 0.000000576) * t + 0.0020034) * t - 0.0001831) * t - 46.836769) * t + 84381.406;
+}
+/** J2000 equatorial → mean equator and equinox of date (IAU 2006). */
+function precess(v, tt) {
+    const t = tt / 36525;
+    const eps0 = 84381.406 * ASEC2RAD;
+    const psia = (((((-0.0000000951 * t + 0.000132851) * t - 0.00114045) * t - 1.0790069) * t + 5038.481507) * t) * ASEC2RAD;
+    const omegaa = (((((0.0000003337 * t - 0.000000467) * t - 0.00772503) * t + 0.0512623) * t - 0.025754) * t + 84381.406) * ASEC2RAD;
+    const chia = (((((-0.000000056 * t + 0.000170663) * t - 0.00121197) * t - 2.3814292) * t + 10.556403) * t) * ASEC2RAD;
+    const sa = Math.sin(eps0), ca = Math.cos(eps0);
+    const sb = Math.sin(-psia), cb = Math.cos(-psia);
+    const sc = Math.sin(-omegaa), cc = Math.cos(-omegaa);
+    const sd = Math.sin(chia), cd = Math.cos(chia);
+    const xx = cd * cb - sb * sd * cc;
+    const yx = cd * sb * ca + sd * cc * cb * ca - sa * sd * sc;
+    const zx = cd * sb * sa + sd * cc * cb * sa + ca * sd * sc;
+    const xy = -sd * cb - sb * cd * cc;
+    const yy = -sd * sb * ca + cd * cc * cb * ca - sa * cd * sc;
+    const zy = -sd * sb * sa + cd * cc * cb * sa + ca * cd * sc;
+    const xz = sb * sc;
+    const yz = -sc * cb * ca - sa * cc;
+    const zz = -sc * cb * sa + cc * ca;
+    return [xx * v[0] + yx * v[1] + zx * v[2], xy * v[0] + yy * v[1] + zy * v[2], xz * v[0] + yz * v[1] + zz * v[2]];
+}
+/** Mean → true equator and equinox of date. */
+function nutate(v, oblm, oblt, psi) {
+    const cobm = Math.cos(oblm), sobm = Math.sin(oblm);
+    const cobt = Math.cos(oblt), sobt = Math.sin(oblt);
+    const cpsi = Math.cos(psi), 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;
+    return [xx * v[0] + yx * v[1] + zx * v[2], xy * v[0] + yy * v[1] + zy * v[2], xz * v[0] + yz * v[1] + zz * v[2]];
+}
+/**
+ * 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`.
+ */
+function preciseApparentSun(d) {
+    const tt = d + deltaT(d) / 86400;
+    const e = earthJ2000(tt - 1 / C_AUDAY);
+    const nut = nutation(tt);
+    const mobl = meanObliquity(tt);
+    const oblm = (mobl / 3600) * DEG;
+    const oblt = ((mobl + nut.deps) / 3600) * DEG;
+    const v = nutate(precess([-e[0], -e[1], -e[2]], tt), oblm, oblt, nut.dpsi * ASEC2RAD);
+    const ra = Math.atan2(v[1], v[0]) / DEG;
+    const dec = Math.atan2(v[2], Math.hypot(v[0], v[1]));
+    // Greenwich apparent sidereal time (degrees): Earth rotation angle + the precession and equation of the equinoxes.
+    const t = tt / 36525;
+    const era = 360 * (((0.779057273264 + 0.00273781191135448 * d + (d % 1)) % 1) + 1);
+    const eqeq = nut.dpsi * Math.cos(oblm);
+    const st = eqeq + 0.014506 + ((((-0.0000000368 * t - 0.000029956) * t - 0.00000044) * t + 1.3915817) * t + 4612.156534) * t;
+    const gast = era + st / 3600;
+    const tmin = (d - Math.floor(d + 0.5) + 0.5) * 1440; // minutes past 0h UT
+    const eotDeg = ((((gast - ra - (tmin - 720) / 4 + 180) % 360) + 360) % 360) - 180;
+    return { dec, eot: 4 * eotDeg };
+}

package/dist/cjs/sweden.d.ts

@@ -0,0 +1,4 @@
+/** mihrab-methods/sweden — the sweden method with its places and correction list, and nothing else's. */
+import './authorities/sweden.js';
+export * from './core/index.js';
+export { places } from './authorities/sweden.js';

package/dist/cjs/sweden.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.places = void 0;
+/** mihrab-methods/sweden — the sweden method with its places and correction list, and nothing else's. */
+require("./authorities/sweden.js");
+__exportStar(require("./core/index.js"), exports);
+var sweden_js_1 = require("./authorities/sweden.js");
+Object.defineProperty(exports, "places", { enumerable: true, get: function () { return sweden_js_1.places; } });

package/dist/esm/algeria.d.ts

@@ -0,0 +1,4 @@
+/** mihrab-methods/algeria — the algeria method with its places and correction list, and nothing else's. */
+import './authorities/algeria.js';
+export * from './core/index.js';
+export { places } from './authorities/algeria.js';

package/dist/esm/algeria.js

@@ -0,0 +1,4 @@
+/** mihrab-methods/algeria — the algeria method with its places and correction list, and nothing else's. */
+import './authorities/algeria.js';
+export * from './core/index.js';
+export { places } from './authorities/algeria.js';

package/dist/esm/authorities/algeria.d.ts

@@ -0,0 +1,3 @@
+import type { Place } from '../core/types.js';
+export declare const algeria: import("../core/registry.js").AuthorityData;
+export declare const places: readonly Place[];

package/dist/esm/authorities/algeria.js

@@ -0,0 +1,51 @@
+/**
+ * Algeria — the Ministry of Religious Affairs and Wakfs: its cities at the
+ * points its table is computed at.
+ */
+import cities from '../data/generated/algeriaCities.js';
+import points from '../data/generated/algeriaMethodPoints.js';
+import corrections from '../data/generated/algeriaCorrections.js';
+import certification from '../data/generated/algeriaCertification.js';
+import { METHOD_REVISION } from '../methods/revisions.js';
+import { registerAuthority } from '../core/registry.js';
+const AUTHORITY = 'algeria';
+function buildPlaces() {
+    return cities.map(c => {
+        const key = String(c.id);
+        return {
+            authority: AUTHORITY,
+            id: `${AUTHORITY}:${key}`,
+            key,
+            name: c.nameEn ?? c.name,
+            country: 'DZ',
+            lat: points[key]?.[0] ?? c.lat,
+            lon: points[key]?.[1] ?? c.lon,
+            tz: 'Africa/Algiers',
+        };
+    });
+}
+export const algeria = registerAuthority({
+    authority: AUTHORITY,
+    revision: METHOD_REVISION.algeria,
+    places: buildPlaces(),
+    corrections,
+    certification,
+    description: {
+        name: 'Algeria — Ministry of Religious Affairs and Wakfs',
+        method: 'NOAA’s solar formulas; Dhuhr at the transit; every other time the transit plus or minus the hour angle, the declination taken at that prayer’s own moment and the equation of time kept at noon’s; Fajr 18°, Isha 17°, sunrise and sunset at −0.833°; Asr from the signed noon shadow; Maghrib three minutes after sunset; every time rounded up to the minute.',
+        countries: ['DZ'],
+        parameters: {
+            fajrAngle: 18,
+            ishaAngle: 17,
+            sunriseAltitude: -0.833,
+            asrShadow: 1,
+            asrNoonShadow: 'tan(φ − δ) with its sign',
+            maghribAfterSunsetMinutes: 3,
+            rounding: 'up to the minute',
+            sun: 'NOAA solar calculator series; declination iterated at each prayer, equation of time at noon',
+        },
+        sources: [{ title: 'Ministry of Religious Affairs and Wakfs — مواقيت الصلاة', url: 'https://www.marw.dz/' }],
+        spec: 'docs/methods.md#algeria',
+    },
+});
+export const places = algeria.places;

package/dist/esm/authorities/diyanet.d.ts

@@ -0,0 +1,9 @@
+import type { Place } from '../core/types.js';
+/** Diyanet's own country numbers → ISO 3166-1 alpha-2 (Northern Cyprus is 'CY'). */
+export declare function diyanetCountry(id: string): {
+    name: string;
+    iso: string;
+};
+declare const places: Place[];
+export declare const diyanet: import("../core/registry.js").AuthorityData;
+export { places };

package/dist/esm/authorities/diyanet.js

@@ -0,0 +1,83 @@
+/**
+ * Diyanet — Türkiye's districts (a point per prayer per year) and its
+ * places worldwide, each at the point Diyanet computes it, in the zone its
+ * table is printed in, with Isha's angle for its country.
+ */
+import world from '../data/generated/diyanetWorldPoints.js';
+import turkey from '../data/generated/diyanetTurkeyPoints.js';
+import countries from '../data/generated/diyanetCountries.js';
+import corrections from '../data/generated/diyanetCorrections.js';
+import certification from '../data/generated/diyanetCertification.js';
+import { METHOD_REVISION } from '../methods/revisions.js';
+import { registerAuthority } from '../core/registry.js';
+const AUTHORITY = 'diyanet';
+/** Diyanet's own country numbers → ISO 3166-1 alpha-2 (Northern Cyprus is 'CY'). */
+export function diyanetCountry(id) {
+    return countries[id] ?? { name: `Country ${id}`, iso: 'ZZ' };
+}
+function buildPlaces() {
+    const out = Object.entries(world).map(([iid, v]) => ({
+        authority: AUTHORITY,
+        id: `${AUTHORITY}:${iid}`,
+        key: iid,
+        name: v.name,
+        country: diyanetCountry(v.country).iso,
+        lat: v.lat,
+        lon: v.lon,
+        tz: v.tz,
+        ishaDeg: v.ishaDeg,
+        ...(v.clock ? { clock: v.clock } : {}),
+    }));
+    // Türkiye's districts (and Northern Cyprus's), with a point per prayer per year
+    for (const [iid, v] of Object.entries(turkey)) {
+        const base = v.years['2026'] ?? Object.values(v.years)[0];
+        out.push({
+            authority: AUTHORITY,
+            id: `${AUTHORITY}:${iid}`,
+            key: iid,
+            name: v.name,
+            country: v.country === '1' ? 'CY' : 'TR',
+            lat: base[1][0],
+            lon: base[1][1],
+            tz: v.country === '1' ? 'Asia/Nicosia' : 'Europe/Istanbul',
+            ishaDeg: 17,
+            prayerPoints: v.years,
+        });
+    }
+    return out;
+}
+const places = buildPlaces();
+export const diyanet = registerAuthority({
+    authority: AUTHORITY,
+    revision: METHOD_REVISION.diyanet,
+    places,
+    corrections,
+    certification,
+    description: {
+        name: 'Diyanet — Türkiye and worldwide',
+        method: 'The Congress method as Diyanet computes it (see Sweden), with Isha at 16° in most of Europe, Russia, Central Asia, China and North America and 17° elsewhere; in Türkiye and Northern Cyprus each prayer at a point of its own per district and year; tables printed on their own clocks where Diyanet keeps one.',
+        countries: [...new Set(places.map(p => p.country))].sort(),
+        parameters: {
+            fajrAngle: 18,
+            ishaAngle: '16 or 17, by country (Place.ishaDeg)',
+            sunriseAltitude: -0.833,
+            asrShadow: 1,
+            'temkin.sunrise': -7,
+            'temkin.dhuhr': 5,
+            'temkin.asr': 4,
+            'temkin.maghrib': 7,
+            minimumDayMinutes: 300,
+            minimumNightMinutes: 300,
+            transitionBandMinutes: 20,
+            highLatitudeRule: 'the Congress’s, worked at 16° whatever the printed Isha angle; midsummer is the takdir’s day where its true Isha falls later than the carried share',
+            rounding: 'to the nearest minute, after the method’s own temkin',
+            coordinatePrecision: '0.001°',
+        },
+        sources: [
+            { title: 'Diyanet — Namaz Vakitleri', url: 'https://namazvakti.diyanet.gov.tr/' },
+            { title: 'Diyanet — the Congress’s criteria (Tespit Kriterleri)', url: 'https://awqatsalah.com/' },
+        ],
+        spec: 'docs/methods.md#sweden-and-diyanet',
+    },
+});
+export { places };

package/dist/esm/authorities/indonesia.d.ts

@@ -0,0 +1,4 @@
+import type { Place } from '../core/types.js';
+export declare function indonesiaZone(province: string): string;
+export declare const indonesia: import("../core/registry.js").AuthorityData;
+export declare const places: readonly Place[];

package/dist/esm/authorities/indonesia.js

@@ -0,0 +1,75 @@
+/**
+ * Indonesia — Kemenag: every regency and city, at the point its table is
+ * computed at, in the zone it is printed in.
+ */
+import regencies from '../data/generated/kemenagPlaces.js';
+import points from '../data/generated/kemenagMethodPoints.js';
+import corrections from '../data/generated/indonesiaCorrections.js';
+import certification from '../data/generated/indonesiaCertification.js';
+import { METHOD_REVISION } from '../methods/revisions.js';
+import { registerAuthority } from '../core/registry.js';
+const AUTHORITY = 'indonesia';
+/** Indonesia prints each regency in its own zone; the province says which. */
+const WITA = new Set([
+    'Kalimantan Selatan', 'Kalimantan Timur', 'Kalimantan Utara', 'Bali',
+    'Nusa Tenggara Barat', 'Nusa Tenggara Timur', 'Sulawesi Barat', 'Sulawesi Selatan',
+    'Sulawesi Tengah', 'Sulawesi Tenggara', 'Sulawesi Utara', 'Gorontalo',
+]);
+const WIT = new Set(['Maluku', 'Maluku Utara', 'Papua', 'Papua Barat']);
+export function indonesiaZone(province) {
+    if (WIT.has(province))
+        return 'Asia/Jayapura';
+    if (WITA.has(province))
+        return 'Asia/Makassar';
+    return 'Asia/Jakarta';
+}
+function buildPlaces() {
+    return regencies.map(c => {
+        const key = String(c.id);
+        const province = /\(([^)]*)\)\s*$/.exec(c.nameEn ?? '')?.[1] ?? '';
+        const p = points[key];
+        return {
+            authority: AUTHORITY,
+            id: `${AUTHORITY}:${key}`,
+            key,
+            name: c.nameEn ?? c.name,
+            country: 'ID',
+            lat: p?.[0] ?? c.lat,
+            lon: p?.[1] ?? c.lon,
+            tz: indonesiaZone(province),
+            highland: p ? (p[2] & 1) !== 0 : false,
+            twilightDip: p ? (p[2] & 2) !== 0 : false,
+            ...(p && p.length >= 5 ? { afternoon: [p[3], p[4]] } : {}),
+        };
+    });
+}
+export const indonesia = registerAuthority({
+    authority: AUTHORITY,
+    revision: METHOD_REVISION.indonesia,
+    places: buildPlaces(),
+    corrections,
+    certification,
+    description: {
+        name: 'Indonesia — Kemenag (Ministry of Religious Affairs)',
+        method: 'The precise apparent sun (VSOP87, as JPL’s to a tenth of a second) taken at each prayer’s own moment; Fajr 20°, Isha 18°; sunrise and Maghrib at −1° (−2° in the highland class); Asr when the shadow is its length plus the noon shadow, the noon shadow from the declination at 00:00 UT; every time rounded up after a margin of two minutes (three for Dhuhr, minus three for sunrise).',
+        countries: ['ID'],
+        parameters: {
+            fajrAngle: 20,
+            ishaAngle: 18,
+            sunriseAltitude: '−1°, or −2° in the highland class (Place.highland); the highland degree on Fajr and Isha too where Place.twilightDip',
+            asrShadow: 1,
+            asrNoonShadow: 'from the declination at 00:00 UT of the day',
+            'margin.fajr': 2,
+            'margin.sunrise': -3,
+            'margin.dhuhr': 3,
+            'margin.asr': 2,
+            'margin.maghrib': 2,
+            'margin.isha': 2,
+            rounding: 'up to the minute, after the margin',
+            sun: 'VSOP87 apparent sun (src/sun/preciseSun.ts), iterated at each prayer',
+        },
+        sources: [{ title: 'Kemenag — Jadwal Shalat', url: 'https://bimasislam.kemenag.go.id/jadwalshalat' }],
+        spec: 'docs/methods.md#indonesia',
+    },
+});
+export const places = indonesia.places;

package/dist/esm/authorities/morocco.d.ts

@@ -0,0 +1,5 @@
+import type { Place } from '../core/types.js';
+/** The ministry's clock: GMT+1, then GMT — its tables print GMT from 17 September 2026, three days before the clocks moved. */
+export declare const MOROCCO_CLOCK: [string, number][];
+export declare const morocco: import("../core/registry.js").AuthorityData;
+export declare const places: readonly Place[];

package/dist/esm/authorities/morocco.js

@@ -0,0 +1,59 @@
+/**
+ * Morocco — the Ministry of Habous and Islamic Affairs: its cities at the
+ * points and horizons its tables are computed with.
+ */
+import cities from '../data/generated/moroccoCities.js';
+import points from '../data/generated/moroccoMethodPoints.js';
+import corrections from '../data/generated/moroccoCorrections.js';
+import certification from '../data/generated/moroccoCertification.js';
+import { METHOD_REVISION } from '../methods/revisions.js';
+import { registerAuthority } from '../core/registry.js';
+const AUTHORITY = 'morocco';
+/**
+ * Morocco left GMT+1 for GMT on 2026-09-20 for good; the tz databases still
+ * move its clock, so the zone is pinned rather than named.
+ */
+const MOROCCO_TZ = 'Etc/GMT';
+/** The ministry's clock: GMT+1, then GMT — its tables print GMT from 17 September 2026, three days before the clocks moved. */
+export const MOROCCO_CLOCK = [['2020-01-01', 60], ['2026-09-17', 0]];
+const MOROCCO_DIP_PER_SQRT_M = 0.02;
+function buildPlaces() {
+    return cities
+        .filter(c => typeof c.lat === 'number' && typeof c.lng === 'number')
+        .map(c => {
+        const key = String(c.id);
+        const base = { authority: AUTHORITY, id: `${AUTHORITY}:${key}`, key, name: c.name, country: 'MA', tz: MOROCCO_TZ, clock: MOROCCO_CLOCK };
+        const p = points[key];
+        return p
+            ? { ...base, lat: p[0], lon: p[1], dipDeg: p[2], ...(p.length > 3 ? { dipMaghribDeg: p[3] } : {}) }
+            : { ...base, lat: c.lat, lon: c.lng, dipDeg: MOROCCO_DIP_PER_SQRT_M * Math.sqrt(c.heightM ?? 0) };
+    });
+}
+export const morocco = registerAuthority({
+    authority: AUTHORITY,
+    revision: METHOD_REVISION.morocco,
+    places: buildPlaces(),
+    corrections,
+    certification,
+    description: {
+        name: 'Morocco — Ministry of Habous and Islamic Affairs',
+        method: 'Meeus’s apparent sun taken at each prayer’s own moment; Fajr 19°, Isha 17°, Asr one shadow; Dhuhr five minutes after transit; sunrise 2.85 minutes before and Maghrib 3.7 minutes after the upper limb on the horizon, less each city’s own horizon dip east and west; Fajr rounded down, the rest to the nearest minute; printed on the ministry’s clock (GMT+1 until 17 September 2026, then GMT).',
+        countries: ['MA'],
+        parameters: {
+            fajrAngle: 19,
+            ishaAngle: 17,
+            asrShadow: 1,
+            dhuhrAfterTransitMinutes: 5,
+            sunriseMarginMinutes: -2.85,
+            maghribMarginMinutes: 3.7,
+            refractionArcmin: 34,
+            sunSemidiameter: 'by the sun’s distance that day',
+            horizonDip: 'per city and per side, fitted (Place.dipDeg, Place.dipMaghribDeg); else 0.02°·√height, 0.86 of it at Maghrib',
+            rounding: 'Fajr down to the minute, the rest to the nearest',
+            sun: 'Meeus, apparent, with the full nutation; chapter-28 equation of time; iterated at each prayer',
+        },
+        sources: [{ title: 'Ministry of Habous and Islamic Affairs — horaires des prières', url: 'https://www.habous.gov.ma/' }],
+        spec: 'docs/methods.md#morocco',
+    },
+});
+export const places = morocco.places;

package/dist/esm/authorities/slug.d.ts

@@ -0,0 +1,2 @@
+/** Islamiska Förbundet's file names for its cities (the Swedish places' keys). */
+export declare function citySlug(name: string): string;

package/dist/esm/authorities/slug.js

@@ -0,0 +1,14 @@
+/** Islamiska Förbundet's file names for its cities (the Swedish places' keys). */
+export function citySlug(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[àáâã]/g, 'a')
+        .replace(/[å]/g, 'a')
+        .replace(/[ä]/g, 'a')
+        .replace(/[ö]/g, 'o')
+        .replace(/[ø]/g, 'o')
+        .replace(/[é]/g, 'e')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}

package/dist/esm/authorities/sweden.d.ts

@@ -0,0 +1,3 @@
+import type { Place } from '../core/types.js';
+export declare const sweden: import("../core/registry.js").AuthorityData;
+export declare const places: readonly Place[];

package/dist/esm/authorities/sweden.js

@@ -0,0 +1,52 @@
+/**
+ * Sweden — Diyanet's Congress method, as Islamiska Förbundet's timetables
+ * print it: the towns at the points Diyanet computes them.
+ */
+import coords from '../data/generated/swedenPlaces.js';
+import corrections from '../data/generated/swedenCorrections.js';
+import certification from '../data/generated/swedenCertification.js';
+import { METHOD_REVISION } from '../methods/revisions.js';
+import { registerAuthority } from '../core/registry.js';
+import { citySlug } from './slug.js';
+const AUTHORITY = 'sweden';
+function buildPlaces() {
+    return Object.entries(coords).map(([name, c]) => {
+        const key = citySlug(name);
+        return { authority: AUTHORITY, id: `${AUTHORITY}:${key}`, key, name, country: 'SE', lat: c.lat, lon: c.lng, tz: 'Europe/Stockholm' };
+    });
+}
+export const sweden = registerAuthority({
+    authority: AUTHORITY,
+    revision: METHOD_REVISION.sweden,
+    places: buildPlaces(),
+    corrections,
+    certification,
+    description: {
+        name: 'Sweden — Diyanet’s method, as used by Islamiska Förbundet',
+        method: 'The International Prayer Times Congress method (Istanbul, 2021) as Diyanet computes it: true Fajr at 18° and Isha at 16°, with the night’s share carried through the summer gap, five-hour floors on the day and the night, and gradual transitions; the sun taken once a day from Meeus’s mean elements.',
+        countries: ['SE'],
+        parameters: {
+            fajrAngle: 18,
+            ishaAngle: 16,
+            sunriseAltitude: -0.833,
+            asrShadow: 1,
+            'temkin.sunrise': -7,
+            'temkin.dhuhr': 5,
+            'temkin.asr': 4,
+            'temkin.maghrib': 7,
+            minimumDayMinutes: 300,
+            minimumNightMinutes: 300,
+            transitionBandMinutes: 20,
+            highLatitudeRule: 'the share of the night carried from the last day the 18° dawn formed; Fajr’s share scaled by 18/16',
+            rounding: 'to the nearest minute, after the method’s own temkin',
+            coordinatePrecision: '0.001°',
+        },
+        sources: [
+            { title: 'Islamiska Förbundet i Sverige — bönetider', url: 'https://www.islamiskaforbundet.se/' },
+            { title: 'Diyanet — Namaz Vakitleri', url: 'https://namazvakti.diyanet.gov.tr/' },
+            { title: 'Diyanet — the Congress’s criteria (Tespit Kriterleri)', url: 'https://awqatsalah.com/' },
+        ],
+        spec: 'docs/methods.md#sweden-and-diyanet',
+    },
+});
+export const places = sweden.places;