mihrab-methods 0.0.0-stage → 1.0.1

package/dist/cjs/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/cjs/authorities/indonesia.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.places = exports.indonesia = void 0;
+exports.indonesiaZone = indonesiaZone;
+/**
+ * Indonesia — Kemenag: every regency and city, at the point its table is
+ * computed at, in the zone it is printed in.
+ */
+const kemenagPlaces_js_1 = __importDefault(require("../data/generated/kemenagPlaces.js"));
+const kemenagMethodPoints_js_1 = __importDefault(require("../data/generated/kemenagMethodPoints.js"));
+const indonesiaCorrections_js_1 = __importDefault(require("../data/generated/indonesiaCorrections.js"));
+const indonesiaCertification_js_1 = __importDefault(require("../data/generated/indonesiaCertification.js"));
+const revisions_js_1 = require("../methods/revisions.js");
+const registry_js_1 = require("../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']);
+function indonesiaZone(province) {
+    if (WIT.has(province))
+        return 'Asia/Jayapura';
+    if (WITA.has(province))
+        return 'Asia/Makassar';
+    return 'Asia/Jakarta';
+}
+function buildPlaces() {
+    return kemenagPlaces_js_1.default.map(c => {
+        const key = String(c.id);
+        const province = /\(([^)]*)\)\s*$/.exec(c.nameEn ?? '')?.[1] ?? '';
+        const p = kemenagMethodPoints_js_1.default[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]] } : {}),
+        };
+    });
+}
+exports.indonesia = (0, registry_js_1.registerAuthority)({
+    authority: AUTHORITY,
+    revision: revisions_js_1.METHOD_REVISION.indonesia,
+    places: buildPlaces(),
+    corrections: indonesiaCorrections_js_1.default,
+    certification: indonesiaCertification_js_1.default,
+    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',
+    },
+});
+exports.places = exports.indonesia.places;

package/dist/cjs/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/cjs/authorities/morocco.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.places = exports.morocco = exports.MOROCCO_CLOCK = void 0;
+/**
+ * Morocco — the Ministry of Habous and Islamic Affairs: its cities at the
+ * points and horizons its tables are computed with.
+ */
+const moroccoCities_js_1 = __importDefault(require("../data/generated/moroccoCities.js"));
+const moroccoMethodPoints_js_1 = __importDefault(require("../data/generated/moroccoMethodPoints.js"));
+const moroccoCorrections_js_1 = __importDefault(require("../data/generated/moroccoCorrections.js"));
+const moroccoCertification_js_1 = __importDefault(require("../data/generated/moroccoCertification.js"));
+const revisions_js_1 = require("../methods/revisions.js");
+const registry_js_1 = require("../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. */
+exports.MOROCCO_CLOCK = [['2020-01-01', 60], ['2026-09-17', 0]];
+const MOROCCO_DIP_PER_SQRT_M = 0.02;
+function buildPlaces() {
+    return moroccoCities_js_1.default
+        .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: exports.MOROCCO_CLOCK };
+        const p = moroccoMethodPoints_js_1.default[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) };
+    });
+}
+exports.morocco = (0, registry_js_1.registerAuthority)({
+    authority: AUTHORITY,
+    revision: revisions_js_1.METHOD_REVISION.morocco,
+    places: buildPlaces(),
+    corrections: moroccoCorrections_js_1.default,
+    certification: moroccoCertification_js_1.default,
+    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',
+    },
+});
+exports.places = exports.morocco.places;

package/dist/cjs/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/cjs/authorities/slug.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.citySlug = citySlug;
+/** Islamiska Förbundet's file names for its cities (the Swedish places' keys). */
+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/cjs/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/cjs/authorities/sweden.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.places = exports.sweden = void 0;
+/**
+ * Sweden — Diyanet's Congress method, as Islamiska Förbundet's timetables
+ * print it: the towns at the points Diyanet computes them.
+ */
+const swedenPlaces_js_1 = __importDefault(require("../data/generated/swedenPlaces.js"));
+const swedenCorrections_js_1 = __importDefault(require("../data/generated/swedenCorrections.js"));
+const swedenCertification_js_1 = __importDefault(require("../data/generated/swedenCertification.js"));
+const revisions_js_1 = require("../methods/revisions.js");
+const registry_js_1 = require("../core/registry.js");
+const slug_js_1 = require("./slug.js");
+const AUTHORITY = 'sweden';
+function buildPlaces() {
+    return Object.entries(swedenPlaces_js_1.default).map(([name, c]) => {
+        const key = (0, slug_js_1.citySlug)(name);
+        return { authority: AUTHORITY, id: `${AUTHORITY}:${key}`, key, name, country: 'SE', lat: c.lat, lon: c.lng, tz: 'Europe/Stockholm' };
+    });
+}
+exports.sweden = (0, registry_js_1.registerAuthority)({
+    authority: AUTHORITY,
+    revision: revisions_js_1.METHOD_REVISION.sweden,
+    places: buildPlaces(),
+    corrections: swedenCorrections_js_1.default,
+    certification: swedenCertification_js_1.default,
+    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',
+    },
+});
+exports.places = exports.sweden.places;

package/dist/cjs/core/api.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The library's calls. Each works for whichever authorities are loaded —
+ * `mihrab-methods` loads all five, `mihrab-methods/<authority>` one.
+ */
+import { type ComputeOptions } from './compute.js';
+import { type Authority, type Certification, type CivilDate, type DayTimes, type MethodInfo, type Place, type TimesOptions } from './types.js';
+/**
+ * Certified: every check of the authority's tables has every time on the
+ * printed minute (and checked something). The flag alone is not trusted.
+ */
+export declare function isCertified(authority: Authority): boolean;
+/** The authority's record from certification.json, or null. */
+export declare function certificationOf(authority: Authority): Certification | null;
+/** The span of dates the method was checked over (and so is certified for), or null. */
+export declare function certifiedSpan(authority: Authority): {
+    from: string;
+    to: string;
+} | null;
+/** The authority's places, each at the point its method is computed at. */
+export declare function placesOf(authority: Authority): readonly Place[];
+/** The authorities this build has loaded. */
+export declare function loadedAuthorityIds(): Authority[];
+/** A place by its stable id (`<authority>:<key>`), among the loaded authorities. */
+export declare function placeById(id: string): Place | null;
+/** Great-circle distance, km. */
+export declare function distanceKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+export type NearestPlace = {
+    place: Place;
+    distanceKm: number;
+};
+/**
+ * The authority's place nearest a point — how an app finds the table for a
+ * location. `maxKm` (default: no limit) returns null beyond that distance.
+ * Türkiye's districts and Diyanet's worldwide places are both 'diyanet'.
+ */
+export declare function nearestPlace(authority: Authority, lat: number, lon: number, opts?: {
+    maxKm?: number;
+}): NearestPlace | null;
+/**
+ * The place's prayer times on a civil date, as the authority prints them:
+ * each prayer's exact moment and its wall-clock minute on the table's clock.
+ *
+ * Inside the dates the method was certified over, `status` is 'certified':
+ * the authority's own printed minute. Outside them it is 'method-only': the
+ * method alone, which is on the printed minute all but rarely and never a
+ * minute further — the honest answer for a date the authority has not
+ * published yet. `{ strict: true }` throws `UncertifiedMethodError` there
+ * instead. A method not certified at all throws either way: it is not for
+ * showing anyone their prayer times (`candidateTimes` runs it regardless).
+ */
+export declare function timesFor(place: Place, date: CivilDate, opts?: TimesOptions): DayTimes;
+/** `timesFor` for every date from `from` to `to`, both inclusive — a month's timetable, a year's. */
+export declare function timesForRange(place: Place, from: CivilDate, to: CivilDate, opts?: TimesOptions): DayTimes[];
+/**
+ * The method as it stands, certified or not, with or without its correction
+ * list (`corrections: false`): for research and for checking the method
+ * against the tables. `status` says what it would be served as.
+ */
+export declare function candidateTimes(place: Place, date: CivilDate, opts?: TimesOptions & ComputeOptions): DayTimes;
+/** What the method is: its parameters, revision, certification, correction list and sources. */
+export declare function methodInfo(authority: Authority): MethodInfo;

package/dist/cjs/core/api.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCertified = isCertified;
+exports.certificationOf = certificationOf;
+exports.certifiedSpan = certifiedSpan;
+exports.placesOf = placesOf;
+exports.loadedAuthorityIds = loadedAuthorityIds;
+exports.placeById = placeById;
+exports.distanceKm = distanceKm;
+exports.nearestPlace = nearestPlace;
+exports.timesFor = timesFor;
+exports.timesForRange = timesForRange;
+exports.candidateTimes = candidateTimes;
+exports.methodInfo = methodInfo;
+/**
+ * The library's calls. Each works for whichever authorities are loaded —
+ * `mihrab-methods` loads all five, `mihrab-methods/<authority>` one.
+ */
+const compute_js_1 = require("./compute.js");
+const civilDate_js_1 = require("./civilDate.js");
+const clock_js_1 = require("./clock.js");
+const registry_js_1 = require("./registry.js");
+const types_js_1 = require("./types.js");
+/**
+ * Certified: every check of the authority's tables has every time on the
+ * printed minute (and checked something). The flag alone is not trusted.
+ */
+function isCertified(authority) {
+    const c = certificationOf(authority);
+    return !!c && c.certified && c.checks.length > 0 && c.checks.every(k => k.times > 0 && k.off === 0);
+}
+/** The authority's record from certification.json, or null. */
+function certificationOf(authority) {
+    return (0, registry_js_1.authorityData)(authority).certification;
+}
+/** The span of dates the method was checked over (and so is certified for), or null. */
+function certifiedSpan(authority) {
+    if (!isCertified(authority))
+        return null;
+    const checks = certificationOf(authority).checks;
+    const tos = checks.map(c => c.to).sort();
+    return { from: checks.map(c => c.from).sort()[0], to: tos[tos.length - 1] };
+}
+/** The authority's places, each at the point its method is computed at. */
+function placesOf(authority) {
+    return (0, registry_js_1.authorityData)(authority).places;
+}
+/** The authorities this build has loaded. */
+function loadedAuthorityIds() {
+    return (0, registry_js_1.loadedAuthorities)();
+}
+/** A place by its stable id (`<authority>:<key>`), among the loaded authorities. */
+function placeById(id) {
+    const i = id.indexOf(':');
+    if (i < 0)
+        return null;
+    const authority = id.slice(0, i);
+    if (!(0, registry_js_1.isLoaded)(authority))
+        return null;
+    return byId(authority).get(id) ?? null;
+}
+const idIndexes = new Map();
+function byId(authority) {
+    let m = idIndexes.get(authority);
+    if (!m)
+        idIndexes.set(authority, (m = new Map(placesOf(authority).map(p => [p.id, p]))));
+    return m;
+}
+const RAD = Math.PI / 180;
+/** Great-circle distance, km. */
+function distanceKm(lat1, lon1, lat2, lon2) {
+    const dLat = (lat2 - lat1) * RAD;
+    const dLon = (lon2 - lon1) * RAD;
+    const a = Math.sin(dLat / 2) ** 2 + Math.cos(lat1 * RAD) * Math.cos(lat2 * RAD) * Math.sin(dLon / 2) ** 2;
+    return 2 * 6371.0088 * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+/**
+ * The authority's place nearest a point — how an app finds the table for a
+ * location. `maxKm` (default: no limit) returns null beyond that distance.
+ * Türkiye's districts and Diyanet's worldwide places are both 'diyanet'.
+ */
+function nearestPlace(authority, lat, lon, opts = {}) {
+    if (!Number.isFinite(lat) || !Number.isFinite(lon))
+        return null;
+    let best = null;
+    for (const place of placesOf(authority)) {
+        const d = distanceKm(lat, lon, place.lat, place.lon);
+        if (!best || d < best.distanceKm)
+            best = { place, distanceKm: d };
+    }
+    if (best && opts.maxKm !== undefined && best.distanceKm > opts.maxKm)
+        return null;
+    return best;
+}
+function dayTimes(place, d, instants, status) {
+    const data = (0, registry_js_1.authorityData)(place.authority);
+    const span = certifiedSpan(place.authority);
+    const clock = (0, clock_js_1.tableClockAt)(place, d.year, d.month0, d.day);
+    let times = null;
+    if (instants) {
+        times = {};
+        for (const k of types_js_1.PRAYER_KEYS)
+            times[k] = { instant: instants[k], printed: (0, clock_js_1.printedAt)(instants[k], clock.offsetMinutes) };
+    }
+    return {
+        authority: place.authority,
+        placeId: place.id,
+        date: d.iso,
+        status,
+        certifiedFrom: span?.from ?? null,
+        certifiedUntil: span?.to ?? null,
+        revision: data.revision,
+        clock,
+        times,
+    };
+}
+function statusFor(authority, iso) {
+    const span = certifiedSpan(authority);
+    if (!span)
+        return 'uncertified';
+    return iso < span.from || iso > span.to ? 'method-only' : 'certified';
+}
+/**
+ * The place's prayer times on a civil date, as the authority prints them:
+ * each prayer's exact moment and its wall-clock minute on the table's clock.
+ *
+ * Inside the dates the method was certified over, `status` is 'certified':
+ * the authority's own printed minute. Outside them it is 'method-only': the
+ * method alone, which is on the printed minute all but rarely and never a
+ * minute further — the honest answer for a date the authority has not
+ * published yet. `{ strict: true }` throws `UncertifiedMethodError` there
+ * instead. A method not certified at all throws either way: it is not for
+ * showing anyone their prayer times (`candidateTimes` runs it regardless).
+ */
+function timesFor(place, date, opts = {}) {
+    if (!isCertified(place.authority))
+        throw new types_js_1.UncertifiedMethodError(place.authority);
+    const d = (0, civilDate_js_1.parseCivilDate)(date);
+    const status = statusFor(place.authority, d.iso);
+    if (status === 'method-only' && opts.strict)
+        throw new types_js_1.UncertifiedMethodError(place.authority, d.iso);
+    return dayTimes(place, d, (0, compute_js_1.candidateInstants)(place, d.year, d.month0, d.day, opts.asrShadow ?? 1), status);
+}
+/** `timesFor` for every date from `from` to `to`, both inclusive — a month's timetable, a year's. */
+function timesForRange(place, from, to, opts = {}) {
+    const a = (0, civilDate_js_1.parseCivilDate)(from);
+    const b = (0, civilDate_js_1.parseCivilDate)(to);
+    if (a.iso > b.iso)
+        throw new RangeError(`The range runs backwards: ${a.iso} to ${b.iso}.`);
+    const out = [];
+    for (let d = a; d.iso <= b.iso; d = (0, civilDate_js_1.nextDay)(d))
+        out.push(timesFor(place, d.iso, opts));
+    return out;
+}
+/**
+ * The method as it stands, certified or not, with or without its correction
+ * list (`corrections: false`): for research and for checking the method
+ * against the tables. `status` says what it would be served as.
+ */
+function candidateTimes(place, date, opts = {}) {
+    const d = (0, civilDate_js_1.parseCivilDate)(date);
+    return dayTimes(place, d, (0, compute_js_1.candidateInstants)(place, d.year, d.month0, d.day, opts.asrShadow ?? 1, { corrections: opts.corrections }), statusFor(place.authority, d.iso));
+}
+/** What the method is: its parameters, revision, certification, correction list and sources. */
+function methodInfo(authority) {
+    const data = (0, registry_js_1.authorityData)(authority);
+    const cov = data.corrections.coverage();
+    return {
+        authority,
+        ...data.description,
+        revision: data.revision,
+        certified: isCertified(authority),
+        certification: data.certification,
+        corrections: { from: cov.from, to: cov.to, entries: data.corrections.entries() },
+        places: data.places.length,
+    };
+}

package/dist/cjs/core/civilDate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Civil dates as the library takes them: 'YYYY-MM-DD', or { year, month,
+ * day } with January = 1. The methods themselves count months from 0, as
+ * JavaScript's Date does; that habit stops at this file.
+ */
+import type { CivilDate } from './types.js';
+export type Ymd = {
+    year: number;
+    month0: number;
+    day: number;
+    iso: string;
+};
+export declare function parseCivilDate(date: CivilDate): Ymd;
+/** 'YYYY-MM-DD' from a year, a 0-based month and a day. */
+export declare function isoOf(year: number, month0: number, day: number): string;
+/** The day after, as a civil date (UTC arithmetic: no zone, no summer time). */
+export declare function nextDay(d: Ymd): Ymd;

package/dist/cjs/core/civilDate.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCivilDate = parseCivilDate;
+exports.isoOf = isoOf;
+exports.nextDay = nextDay;
+const ISO = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseCivilDate(date) {
+    let year, month, day;
+    if (typeof date === 'string') {
+        const m = ISO.exec(date);
+        if (!m)
+            throw new TypeError(`Not a date: ${JSON.stringify(date)} — expected 'YYYY-MM-DD' or { year, month, day }.`);
+        [year, month, day] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    }
+    else if (date && typeof date === 'object' && typeof date.year === 'number' && typeof date.month === 'number' && typeof date.day === 'number') {
+        ({ year, month, day } = date);
+    }
+    else {
+        throw new TypeError(typeof date === 'number'
+            ? 'timesFor(place, year, month, day) is no longer the call: pass one date, as \'YYYY-MM-DD\' or { year, month, day } with January = 1.'
+            : `Not a date: ${JSON.stringify(date)} — expected 'YYYY-MM-DD' or { year, month, day }.`);
+    }
+    if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || month < 1 || month > 12 || day < 1 || day > 31) {
+        throw new RangeError(`Not a calendar date: ${isoOf(year, month - 1, day)} (months run 1–12).`);
+    }
+    // 31 April, 30 February: a Date would roll these over without a word.
+    const probe = new Date(Date.UTC(year, month - 1, day));
+    if (probe.getUTCMonth() !== month - 1 || probe.getUTCDate() !== day) {
+        throw new RangeError(`Not a calendar date: ${isoOf(year, month - 1, day)}.`);
+    }
+    return { year, month0: month - 1, day, iso: isoOf(year, month - 1, day) };
+}
+/** 'YYYY-MM-DD' from a year, a 0-based month and a day. */
+function isoOf(year, month0, day) {
+    return `${String(year).padStart(4, '0')}-${String(month0 + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+}
+/** The day after, as a civil date (UTC arithmetic: no zone, no summer time). */
+function nextDay(d) {
+    const n = new Date(Date.UTC(d.year, d.month0, d.day + 1));
+    return { year: n.getUTCFullYear(), month0: n.getUTCMonth(), day: n.getUTCDate(), iso: isoOf(n.getUTCFullYear(), n.getUTCMonth(), n.getUTCDate()) };
+}

package/dist/cjs/core/clock.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The clock a table prints a day in: the place's zone as kept at noon, or
+ * the table's own clock where it keeps one no zone does (`Place.clock`). A
+ * table prints the whole day in the clock kept at noon, so on the morning
+ * the clocks go forward a Fajr before the change is printed in the new time.
+ */
+import type { Place, TableClock } from './types.js';
+/**
+ * Minutes east of UTC that a zone keeps at noon UTC of a date (month 0-based).
+ *
+ * Read from the zone's wall clock (year … minute, as every Intl has them),
+ * not from `timeZoneName: 'longOffset'`, which not every runtime supports:
+ * where it is missing the name comes back as 'GMT+1' or a zone's own
+ * abbreviation, and an offset parsed from that is silently wrong.
+ */
+export declare function clockOffsetAt(tz: string, year: number, month: number, day: number): number;
+/** The clock a place's table prints a date in: its own (`Place.clock`) where it has one, else its zone's. Month 0-based. */
+export declare function placeClockAt(place: Place, year: number, month: number, day: number): number;
+export declare function offsetLabel(offsetMinutes: number): string;
+export declare function tableClockAt(place: Place, year: number, month: number, day: number): TableClock;
+/** 'HH:MM' of an instant on a clock, as a table prints it. */
+export declare function printedAt(instant: Date, offsetMinutes: number): string;

package/dist/cjs/core/clock.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clockOffsetAt = clockOffsetAt;
+exports.placeClockAt = placeClockAt;
+exports.offsetLabel = offsetLabel;
+exports.tableClockAt = tableClockAt;
+exports.printedAt = printedAt;
+const formats = new Map();
+/**
+ * Minutes east of UTC that a zone keeps at noon UTC of a date (month 0-based).
+ *
+ * Read from the zone's wall clock (year … minute, as every Intl has them),
+ * not from `timeZoneName: 'longOffset'`, which not every runtime supports:
+ * where it is missing the name comes back as 'GMT+1' or a zone's own
+ * abbreviation, and an offset parsed from that is silently wrong.
+ */
+function clockOffsetAt(tz, year, month, day) {
+    const at = Date.UTC(year, month, day, 12);
+    let f = formats.get(tz);
+    if (!f) {
+        f = new Intl.DateTimeFormat('en-US', {
+            timeZone: tz,
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            hourCycle: 'h23',
+        });
+        formats.set(tz, f);
+    }
+    const parts = f.formatToParts(new Date(at));
+    const n = (type) => Number(parts.find(p => p.type === type)?.value);
+    const wall = Date.UTC(n('year'), n('month') - 1, n('day'), n('hour') % 24, n('minute'));
+    if (!Number.isFinite(wall))
+        throw new RangeError(`The zone ${tz} could not be read on this runtime.`);
+    return Math.round((wall - at) / 60_000);
+}
+/** The clock a place's table prints a date in: its own (`Place.clock`) where it has one, else its zone's. Month 0-based. */
+function placeClockAt(place, year, month, day) {
+    if (place.clock) {
+        const date = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        let off = place.clock[0][1];
+        for (const [from, o] of place.clock)
+            if (from <= date)
+                off = o;
+        return off;
+    }
+    return clockOffsetAt(place.tz, year, month, day);
+}
+function offsetLabel(offsetMinutes) {
+    const sign = offsetMinutes < 0 ? '-' : '+';
+    const abs = Math.abs(offsetMinutes);
+    return `UTC${sign}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+}
+function tableClockAt(place, year, month, day) {
+    const offsetMinutes = placeClockAt(place, year, month, day);
+    return place.clock
+        ? { zone: null, offsetMinutes, label: offsetLabel(offsetMinutes) }
+        : { zone: place.tz, offsetMinutes, label: place.tz };
+}
+/** 'HH:MM' of an instant on a clock, as a table prints it. */
+function printedAt(instant, offsetMinutes) {
+    const local = Math.floor(instant.getTime() / 60_000) + offsetMinutes;
+    const m = ((local % 1440) + 1440) % 1440;
+    return `${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`;
+}

package/dist/cjs/core/compute.d.ts

@@ -0,0 +1,10 @@
+import type { Instants, Place } from './types.js';
+export type ComputeOptions = {
+    corrections?: boolean;
+};
+/**
+ * The method as it stands, certified or not, for a civil date with the
+ * month 0-based. Null where the method gives no times for the day. Not for
+ * showing anyone their prayer times: `timesFor` is.
+ */
+export declare function candidateInstants(place: Place, year: number, month: number, day: number, asrShadow?: 1 | 2, opts?: ComputeOptions): Instants | null;