mihrab-methods 0.0.0-stage → 1.0.0

package/dist/cjs/core/compute.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.candidateInstants = candidateInstants;
+/**
+ * The methods, run for a place and a civil date (month 0-based, as the
+ * methods count): the authority's own formula, then its correction list.
+ * This is the computation `timesFor` and the checks share; the API around
+ * it is in `api.ts`.
+ */
+const sweden_js_1 = require("../methods/sweden.js");
+const morocco_js_1 = require("../methods/morocco.js");
+const algeria_js_1 = require("../methods/algeria.js");
+const indonesia_js_1 = require("../methods/indonesia.js");
+const registry_js_1 = require("./registry.js");
+const clock_js_1 = require("./clock.js");
+/**
+ * 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.
+ */
+function candidateInstants(place, year, month, day, asrShadow = 1, opts = {}) {
+    const fix = opts.corrections === false ? null : (0, registry_js_1.authorityData)(place.authority).corrections;
+    switch (place.authority) {
+        case 'sweden':
+        case 'diyanet': {
+            // The Congress method's own rounding is inside it; its instants land on the minute (rounded, as the app does).
+            const clock = (0, clock_js_1.placeClockAt)(place, year, month, day);
+            const t = place.prayerPoints ? perPrayer(place, place.prayerPoints, year, month, day, asrShadow) : (0, sweden_js_1.congressTimes)(place.lat, place.lon, year, month, day, asrShadow, place.ishaDeg, clock);
+            // then the correction list: the few times Diyanet's program rounds the other way (the standard Asr only)
+            const c = fix?.correction(place.lat, place.lon, year, month, day);
+            const min = (d, k) => new Date((Math.round(d.getTime() / 60_000) + (k === 'asr' && asrShadow !== 1 ? 0 : (c?.[k] ?? 0))) * 60_000);
+            return { fajr: min(t.fajr, 'fajr'), sunrise: min(t.sunrise, 'sunrise'), dhuhr: min(t.dhuhr, 'dhuhr'), asr: min(t.asr, 'asr'), maghrib: min(t.maghrib, 'maghrib'), isha: min(t.isha, 'isha') };
+        }
+        case 'morocco':
+        case 'algeria':
+        case 'indonesia': {
+            const t = place.authority === 'morocco'
+                ? (0, morocco_js_1.moroccoTimes)(place.lat, place.lon, year, month, day, place.dipDeg ?? 0, asrShadow, place.dipMaghribDeg)
+                : place.authority === 'algeria'
+                    ? (0, algeria_js_1.algeriaTimes)(place.lat, place.lon, year, month, day, asrShadow)
+                    : (0, indonesia_js_1.kemenagTimes)(place.lat, place.lon, year, month, day, { highland: place.highland, twilightDip: place.twilightDip, asrShadow, afternoon: place.afternoon });
+            // the correction list: the authority's few times on the other side of a minute (the standard Asr only)
+            const c = !t || !fix ? undefined : fix.correction(place.lat, place.lon, year, month, day);
+            if (!t || !c)
+                return t;
+            const mv = (d, k) => new Date(d.getTime() + (k === 'asr' && asrShadow !== 1 ? 0 : (c[k] ?? 0)) * 60_000);
+            return { fajr: mv(t.fajr, 'fajr'), sunrise: mv(t.sunrise, 'sunrise'), dhuhr: mv(t.dhuhr, 'dhuhr'), asr: mv(t.asr, 'asr'), maghrib: mv(t.maghrib, 'maghrib'), isha: mv(t.isha, 'isha') };
+        }
+    }
+}
+/** Türkiye's districts: each prayer at its own point for the year (the nearest year's beyond the tables). */
+function perPrayer(place, pts, year, month, day, asrShadow) {
+    const years = Object.keys(pts).map(Number).sort((a, b) => a - b);
+    const y = years.reduce((b, v) => (Math.abs(v - year) < Math.abs(b - year) ? v : b), years[0]);
+    const p = pts[String(y)];
+    const clock = (0, clock_js_1.placeClockAt)(place, year, month, day);
+    const at = (i) => (0, sweden_js_1.congressTimes)(p[i][0], p[i][1], year, month, day, asrShadow, place.ishaDeg, clock);
+    return { fajr: at(0).fajr, sunrise: at(1).sunrise, dhuhr: at(2).dhuhr, asr: at(3).asr, maghrib: at(4).maghrib, isha: at(5).isha };
+}

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

@@ -0,0 +1,25 @@
+/**
+ * A correction list, indexed for lookup: point → date → the minutes to add
+ * to each printed time. Built from the embedded data (or, for the tools,
+ * from a file read into the same shape).
+ */
+import type { CorrectionsFile, PrayerKey } from './types.js';
+export declare const pointKey: (lat: number, lon: number) => string;
+export declare class CorrectionList {
+    private source;
+    private index;
+    constructor(source: CorrectionsFile);
+    private load;
+    /** The minutes to add to the point's printed times on a date (month 0-based), if any. */
+    correction(lat: number, lon: number, year: number, month: number, day: number): Partial<Record<PrayerKey, number>> | undefined;
+    coverage(): {
+        from: string;
+        to: string;
+    };
+    entries(): number;
+    file(): CorrectionsFile;
+    /** Put another list in force (a newer one for the same method revision). */
+    replace(source: CorrectionsFile): void;
+}
+/** A list that does not have the shape of one is refused whole. */
+export declare function isCorrectionsFile(x: unknown): x is CorrectionsFile;

package/dist/cjs/core/correctionList.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrectionList = exports.pointKey = void 0;
+exports.isCorrectionsFile = isCorrectionsFile;
+const pointKey = (lat, lon) => `${lat.toFixed(3)},${lon.toFixed(3)}`;
+exports.pointKey = pointKey;
+class CorrectionList {
+    source;
+    index = null;
+    constructor(source) {
+        this.source = source;
+    }
+    load() {
+        if (this.index)
+            return this.index;
+        const index = new Map();
+        for (const [point, list] of Object.entries(this.source.points)) {
+            const byDate = new Map();
+            for (const e of list) {
+                const [date, key, step] = e.split(' ');
+                const c = byDate.get(date) ?? {};
+                c[key] = Number(step);
+                byDate.set(date, c);
+            }
+            index.set(point, byDate);
+        }
+        return (this.index = index);
+    }
+    /** The minutes to add to the point's printed times on a date (month 0-based), if any. */
+    correction(lat, lon, year, month, day) {
+        const date = `${year}-${String(month + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+        return this.load().get((0, exports.pointKey)(lat, lon))?.get(date);
+    }
+    coverage() {
+        return { from: this.source.from, to: this.source.to };
+    }
+    entries() {
+        return Object.values(this.source.points).reduce((n, e) => n + e.length, 0);
+    }
+    file() {
+        return this.source;
+    }
+    /** Put another list in force (a newer one for the same method revision). */
+    replace(source) {
+        this.source = source;
+        this.index = null;
+    }
+}
+exports.CorrectionList = CorrectionList;
+/** A list that does not have the shape of one is refused whole. */
+function isCorrectionsFile(x) {
+    if (!x || typeof x !== 'object')
+        return false;
+    const c = x;
+    const date = /^\d{4}-\d{2}-\d{2}$/;
+    if (typeof c.from !== 'string' || typeof c.to !== 'string' || !date.test(c.from) || !date.test(c.to) || c.from > c.to)
+        return false;
+    if (!c.points || typeof c.points !== 'object')
+        return false;
+    const entry = /^\d{4}-\d{2}-\d{2} (fajr|sunrise|dhuhr|asr|maghrib|isha) [+-]1$/;
+    return Object.entries(c.points).every(([k, v]) => /^-?\d+\.\d{3},-?\d+\.\d{3}$/.test(k) && Array.isArray(v) && v.every(e => typeof e === 'string' && entry.test(e)));
+}

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

@@ -0,0 +1,57 @@
+import type { Authority, CorrectionsFile } from './types.js';
+/** Where the feed lives. A tagged release (`.../v1.2.0/...`) can replace `main` for a pinned address. */
+export declare const DEFAULT_FEED_URL = "https://raw.githubusercontent.com/MihrabHQ/mihrab-methods/main";
+export type FetchOptions = {
+    authority: Authority;
+    /** The revision this build computes; default: the loaded method's. */
+    revision?: number;
+    /** The feed's base URL (default `DEFAULT_FEED_URL`): `<base>/certification.json`, `<base>/data/corrections/<authority>.json`. */
+    baseUrl?: string;
+    /** The fetch to use (default: the global one). */
+    fetch?: typeof fetch;
+    /** SHA-256 of a UTF-8 string as lowercase hex; default: WebCrypto, else node:crypto, else the hash is not checked. */
+    sha256?: (text: string) => Promise<string>;
+    /** Put a newer list in force in this process (default true). */
+    apply?: boolean;
+};
+export type ListSummary = {
+    from: string;
+    to: string;
+    entries: number;
+};
+export type FetchResult = 
+/** The certification names the list this build already has (or an older one). */
+{
+    status: 'current';
+    have: ListSummary;
+    certified: boolean;
+}
+/** A newer list for this revision: its contents, and whether the hash matched (or could not be checked). */
+ | {
+    status: 'updated';
+    list: CorrectionsFile;
+    summary: ListSummary;
+    integrity: 'verified' | 'unchecked';
+    applied: boolean;
+}
+/** The method itself has moved on: its lists no longer fit this build, which should be updated. */
+ | {
+    status: 'method-moved';
+    remoteRevision: number;
+    have: ListSummary;
+}
+/** The authority has published tables the method is not yet certified on: keep the list in force. */
+ | {
+    status: 'uncertified';
+    have: ListSummary;
+}
+/** Something did not add up (a list not matching what the certification names, a bad hash): nothing taken. */
+ | {
+    status: 'rejected';
+    reason: string;
+    have: ListSummary;
+};
+export declare function summarize(list: CorrectionsFile): ListSummary;
+/** Put a list in force for the process — one verified by `fetchLatestCorrections`, or restored from the app's own storage. */
+export declare function applyCorrections(authority: Authority, list: CorrectionsFile, revision: number): boolean;
+export declare function fetchLatestCorrections(opts: FetchOptions): Promise<FetchResult>;

package/dist/cjs/core/fetchLatest.js

@@ -0,0 +1,137 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FEED_URL = void 0;
+exports.summarize = summarize;
+exports.applyCorrections = applyCorrections;
+exports.fetchLatestCorrections = fetchLatestCorrections;
+/**
+ * Keeping an app current without a release: the repository publishes
+ * `certification.json` and the correction lists it certifies, and an app
+ * that computes a method's revision can take any newer list certified for
+ * that revision. This is the check done right — the revision, the list's
+ * identity, and its SHA-256 as the certification names it.
+ */
+const registry_js_1 = require("./registry.js");
+const correctionList_js_1 = require("./correctionList.js");
+/** Where the feed lives. A tagged release (`.../v1.2.0/...`) can replace `main` for a pinned address. */
+exports.DEFAULT_FEED_URL = 'https://raw.githubusercontent.com/MihrabHQ/mihrab-methods/main';
+function summarize(list) {
+    return { from: list.from, to: list.to, entries: Object.values(list.points).reduce((n, e) => n + e.length, 0) };
+}
+const same = (a, b) => a.from === b.from && a.to === b.to && a.entries === b.entries;
+async function defaultSha256(text) {
+    const bytes = new TextEncoder().encode(text);
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle) {
+        const buf = await subtle.digest('SHA-256', bytes);
+        return [...new Uint8Array(buf)].map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    try {
+        const { createHash } = await Promise.resolve().then(() => __importStar(require('node:crypto')));
+        return createHash('sha256').update(bytes).digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+/** Put a list in force for the process — one verified by `fetchLatestCorrections`, or restored from the app's own storage. */
+function applyCorrections(authority, list, revision) {
+    const data = (0, registry_js_1.authorityData)(authority);
+    if (revision !== data.revision || !(0, correctionList_js_1.isCorrectionsFile)(list))
+        return false;
+    const now = data.corrections.coverage();
+    if (list.to < now.to)
+        return false;
+    data.corrections.replace(list);
+    return true;
+}
+async function fetchLatestCorrections(opts) {
+    const data = (0, registry_js_1.authorityData)(opts.authority);
+    const have = { ...data.corrections.coverage(), entries: data.corrections.entries() };
+    const revision = opts.revision ?? data.revision;
+    const base = (opts.baseUrl ?? exports.DEFAULT_FEED_URL).replace(/\/+$/, '');
+    const doFetch = opts.fetch ?? globalThis.fetch;
+    if (!doFetch)
+        return { status: 'rejected', reason: 'no fetch available', have };
+    const certRes = await doFetch(`${base}/certification.json`);
+    if (!certRes.ok)
+        return { status: 'rejected', reason: `certification.json: HTTP ${certRes.status}`, have };
+    const cert = (await certRes.json());
+    const entry = cert?.[opts.authority];
+    if (!entry || typeof entry !== 'object' || typeof entry.certified !== 'boolean') {
+        return { status: 'rejected', reason: `certification.json has no entry for ${opts.authority}`, have };
+    }
+    if (typeof entry.revision === 'number' && entry.revision > revision) {
+        return { status: 'method-moved', remoteRevision: entry.revision, have };
+    }
+    if (!entry.certified)
+        return { status: 'uncertified', have };
+    if (entry.revision !== revision)
+        return { status: 'rejected', reason: `certified for revision ${entry.revision}, this build computes ${revision}`, have };
+    const named = entry.corrections;
+    if (!named || typeof named.from !== 'string' || typeof named.to !== 'string' || typeof named.entries !== 'number') {
+        return { status: 'rejected', reason: 'the certification names no correction list', have };
+    }
+    if (same(have, named) || named.to < have.to)
+        return { status: 'current', have, certified: true };
+    const listRes = await doFetch(`${base}/data/corrections/${opts.authority}.json`);
+    if (!listRes.ok)
+        return { status: 'rejected', reason: `${opts.authority}.json: HTTP ${listRes.status}`, have };
+    const text = await listRes.text();
+    let list;
+    try {
+        list = JSON.parse(text);
+    }
+    catch {
+        return { status: 'rejected', reason: 'the list is not JSON', have };
+    }
+    if (!(0, correctionList_js_1.isCorrectionsFile)(list))
+        return { status: 'rejected', reason: 'the list does not have the shape of one', have };
+    const summary = summarize(list);
+    if (!same(summary, named))
+        return { status: 'rejected', reason: 'the list is not the one the certification names', have };
+    let integrity = 'unchecked';
+    if (named.sha256) {
+        const hash = opts.sha256 ? await opts.sha256(text) : await defaultSha256(text);
+        if (hash !== null) {
+            if (hash.toLowerCase() !== named.sha256.toLowerCase())
+                return { status: 'rejected', reason: 'the list’s SHA-256 is not the one the certification names', have };
+            integrity = 'verified';
+        }
+    }
+    const applied = opts.apply === false ? false : applyCorrections(opts.authority, list, revision);
+    return { status: 'updated', list, summary, integrity, applied };
+}

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

@@ -0,0 +1,14 @@
+/**
+ * The library without any authority's data: the calls, the types, the sun.
+ * Load an authority (`mihrab-methods/<authority>`, or `mihrab-methods` for
+ * all) before calling anything that needs its places or its list.
+ */
+export { candidateTimes, certificationOf, certifiedSpan, distanceKm, isCertified, loadedAuthorityIds, methodInfo, nearestPlace, placeById, placesOf, timesFor, timesForRange, type NearestPlace, } from './api.js';
+export { candidateInstants, type ComputeOptions } from './compute.js';
+export { parseCivilDate, isoOf } from './civilDate.js';
+export { placeClockAt, clockOffsetAt, tableClockAt, printedAt } from './clock.js';
+export { fetchLatestCorrections, applyCorrections, type FetchOptions, type FetchResult } from './fetchLatest.js';
+export { isCorrectionsFile, pointKey } from './correctionList.js';
+export { METHOD_REVISION } from '../methods/revisions.js';
+export { preciseApparentSun } from '../sun/preciseSun.js';
+export { AUTHORITIES, PRAYER_KEYS, UncertifiedMethodError, type Authority, type Certification, type CheckRecord, type CivilDate, type CorrectionsFile, type DayStatus, type DayTimes, type Instants, type MethodInfo, type Place, type PrayerKey, type PrayerTime, type TableClock, type TimesOptions, } from './types.js';

package/dist/cjs/core/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UncertifiedMethodError = exports.PRAYER_KEYS = exports.AUTHORITIES = exports.preciseApparentSun = exports.METHOD_REVISION = exports.pointKey = exports.isCorrectionsFile = exports.applyCorrections = exports.fetchLatestCorrections = exports.printedAt = exports.tableClockAt = exports.clockOffsetAt = exports.placeClockAt = exports.isoOf = exports.parseCivilDate = exports.candidateInstants = exports.timesForRange = exports.timesFor = exports.placesOf = exports.placeById = exports.nearestPlace = exports.methodInfo = exports.loadedAuthorityIds = exports.isCertified = exports.distanceKm = exports.certifiedSpan = exports.certificationOf = exports.candidateTimes = void 0;
+/**
+ * The library without any authority's data: the calls, the types, the sun.
+ * Load an authority (`mihrab-methods/<authority>`, or `mihrab-methods` for
+ * all) before calling anything that needs its places or its list.
+ */
+var api_js_1 = require("./api.js");
+Object.defineProperty(exports, "candidateTimes", { enumerable: true, get: function () { return api_js_1.candidateTimes; } });
+Object.defineProperty(exports, "certificationOf", { enumerable: true, get: function () { return api_js_1.certificationOf; } });
+Object.defineProperty(exports, "certifiedSpan", { enumerable: true, get: function () { return api_js_1.certifiedSpan; } });
+Object.defineProperty(exports, "distanceKm", { enumerable: true, get: function () { return api_js_1.distanceKm; } });
+Object.defineProperty(exports, "isCertified", { enumerable: true, get: function () { return api_js_1.isCertified; } });
+Object.defineProperty(exports, "loadedAuthorityIds", { enumerable: true, get: function () { return api_js_1.loadedAuthorityIds; } });
+Object.defineProperty(exports, "methodInfo", { enumerable: true, get: function () { return api_js_1.methodInfo; } });
+Object.defineProperty(exports, "nearestPlace", { enumerable: true, get: function () { return api_js_1.nearestPlace; } });
+Object.defineProperty(exports, "placeById", { enumerable: true, get: function () { return api_js_1.placeById; } });
+Object.defineProperty(exports, "placesOf", { enumerable: true, get: function () { return api_js_1.placesOf; } });
+Object.defineProperty(exports, "timesFor", { enumerable: true, get: function () { return api_js_1.timesFor; } });
+Object.defineProperty(exports, "timesForRange", { enumerable: true, get: function () { return api_js_1.timesForRange; } });
+var compute_js_1 = require("./compute.js");
+Object.defineProperty(exports, "candidateInstants", { enumerable: true, get: function () { return compute_js_1.candidateInstants; } });
+var civilDate_js_1 = require("./civilDate.js");
+Object.defineProperty(exports, "parseCivilDate", { enumerable: true, get: function () { return civilDate_js_1.parseCivilDate; } });
+Object.defineProperty(exports, "isoOf", { enumerable: true, get: function () { return civilDate_js_1.isoOf; } });
+var clock_js_1 = require("./clock.js");
+Object.defineProperty(exports, "placeClockAt", { enumerable: true, get: function () { return clock_js_1.placeClockAt; } });
+Object.defineProperty(exports, "clockOffsetAt", { enumerable: true, get: function () { return clock_js_1.clockOffsetAt; } });
+Object.defineProperty(exports, "tableClockAt", { enumerable: true, get: function () { return clock_js_1.tableClockAt; } });
+Object.defineProperty(exports, "printedAt", { enumerable: true, get: function () { return clock_js_1.printedAt; } });
+var fetchLatest_js_1 = require("./fetchLatest.js");
+Object.defineProperty(exports, "fetchLatestCorrections", { enumerable: true, get: function () { return fetchLatest_js_1.fetchLatestCorrections; } });
+Object.defineProperty(exports, "applyCorrections", { enumerable: true, get: function () { return fetchLatest_js_1.applyCorrections; } });
+var correctionList_js_1 = require("./correctionList.js");
+Object.defineProperty(exports, "isCorrectionsFile", { enumerable: true, get: function () { return correctionList_js_1.isCorrectionsFile; } });
+Object.defineProperty(exports, "pointKey", { enumerable: true, get: function () { return correctionList_js_1.pointKey; } });
+var revisions_js_1 = require("../methods/revisions.js");
+Object.defineProperty(exports, "METHOD_REVISION", { enumerable: true, get: function () { return revisions_js_1.METHOD_REVISION; } });
+var preciseSun_js_1 = require("../sun/preciseSun.js");
+Object.defineProperty(exports, "preciseApparentSun", { enumerable: true, get: function () { return preciseSun_js_1.preciseApparentSun; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "AUTHORITIES", { enumerable: true, get: function () { return types_js_1.AUTHORITIES; } });
+Object.defineProperty(exports, "PRAYER_KEYS", { enumerable: true, get: function () { return types_js_1.PRAYER_KEYS; } });
+Object.defineProperty(exports, "UncertifiedMethodError", { enumerable: true, get: function () { return types_js_1.UncertifiedMethodError; } });

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

@@ -0,0 +1,28 @@
+/**
+ * What each authority's entry point brings: its places, its correction
+ * list, its certification and its description. `mihrab-methods/indonesia`
+ * registers Indonesia and nothing else, so an app ships only the data it
+ * uses; `mihrab-methods` registers all five.
+ */
+import type { Authority, Certification, CorrectionsFile, MethodInfo, Place } from './types.js';
+import { CorrectionList } from './correctionList.js';
+export type MethodDescription = Pick<MethodInfo, 'name' | 'method' | 'countries' | 'parameters' | 'sources' | 'spec'>;
+export type AuthorityData = {
+    authority: Authority;
+    revision: number;
+    places: Place[];
+    corrections: CorrectionList;
+    certification: Certification | null;
+    description: MethodDescription;
+};
+export declare function registerAuthority(entry: {
+    authority: Authority;
+    revision: number;
+    places: Place[];
+    corrections: CorrectionsFile;
+    certification: Certification | null;
+    description: MethodDescription;
+}): AuthorityData;
+export declare function authorityData(authority: Authority): AuthorityData;
+export declare function loadedAuthorities(): Authority[];
+export declare function isLoaded(authority: Authority): boolean;

package/dist/cjs/core/registry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAuthority = registerAuthority;
+exports.authorityData = authorityData;
+exports.loadedAuthorities = loadedAuthorities;
+exports.isLoaded = isLoaded;
+const correctionList_js_1 = require("./correctionList.js");
+const registry = new Map();
+function registerAuthority(entry) {
+    const have = registry.get(entry.authority);
+    if (have)
+        return have;
+    const data = { ...entry, corrections: new correctionList_js_1.CorrectionList(entry.corrections) };
+    registry.set(entry.authority, data);
+    return data;
+}
+function authorityData(authority) {
+    const data = registry.get(authority);
+    if (!data) {
+        throw new Error(`The ${authority} method is not loaded: import 'mihrab-methods/${authority}' (or 'mihrab-methods' for all of them) first.`);
+    }
+    return data;
+}
+function loadedAuthorities() {
+    return [...registry.keys()];
+}
+function isLoaded(authority) {
+    return registry.has(authority);
+}

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

@@ -0,0 +1,193 @@
+/**
+ * The shapes the library speaks in. Nothing here computes anything.
+ */
+export type Authority = 'sweden' | 'diyanet' | 'morocco' | 'algeria' | 'indonesia';
+export declare const AUTHORITIES: readonly Authority[];
+export type PrayerKey = 'fajr' | 'sunrise' | 'dhuhr' | 'asr' | 'maghrib' | 'isha';
+export declare const PRAYER_KEYS: readonly PrayerKey[];
+/** A place an authority publishes a table for, at the point its method is computed at. */
+export type Place = {
+    authority: Authority;
+    /**
+     * A stable identifier: `<authority>:<key>`, where the key is the
+     * authority's own number for the place (Diyanet's, the ministries') or,
+     * for Sweden, Islamiska Förbundet's slug of its name. It does not change
+     * between versions.
+     */
+    id: string;
+    /** The authority's own key for the place (the part of `id` after the colon). */
+    key: string;
+    name: string;
+    /** ISO 3166-1 alpha-2 of the country the table is for. */
+    country: string;
+    lat: number;
+    lon: number;
+    /** The IANA zone the authority prints the place's table in. */
+    tz: string;
+    /** Morocco: the horizon's dip, degrees (fitted, or 0.02°·√height) — eastward, at sunrise. */
+    dipDeg?: number;
+    /** Morocco: the horizon's dip westward, at Maghrib (fitted per city). */
+    dipMaghribDeg?: number;
+    /** Indonesia: Kemenag's highland class (sunrise and Maghrib at −2°). */
+    highland?: boolean;
+    /** Indonesia: the highland degree on Fajr and Isha too (six regencies of Papua). */
+    twilightDip?: boolean;
+    /** Indonesia: where the ministry computes the regency's Asr, Maghrib and Isha, when not at its point. */
+    afternoon?: readonly [number, number];
+    /** Diyanet: Isha's depression, 16° or 17° by country. */
+    ishaDeg?: number;
+    /**
+     * Diyanet in Türkiye and Northern Cyprus: each prayer is computed at a point
+     * of its own, and the points move by a few thousandths of a degree from one
+     * year's tables to the next — year → [fajr, sunrise, dhuhr, asr, maghrib, isha]
+     * as [lat, lon]. `lat`/`lon` are the district's own point (its sunrise).
+     */
+    prayerPoints?: Record<string, [number, number][]>;
+    /**
+     * A table printed on a clock no zone keeps (Diyanet's for Alberta, with
+     * summer time into December; Morocco's on GMT+1 until September 2026):
+     * the clock read off the table itself, [from date, minutes east of UTC], in
+     * place of `tz`. The instants are the method's; only the labels differ.
+     */
+    clock?: [string, number][];
+};
+/** The six instants of a day, each on the minute the authority prints. */
+export type Instants = {
+    fajr: Date;
+    sunrise: Date;
+    dhuhr: Date;
+    asr: Date;
+    maghrib: Date;
+    isha: Date;
+};
+/**
+ * A method's correction list: the few times its authority's program puts on
+ * the other side of a minute's rounding point. "lat,lon" (three decimals) →
+ * "YYYY-MM-DD prayer ±1". See schemas/corrections.schema.json.
+ */
+export type CorrectionsFile = {
+    from: string;
+    to: string;
+    points: Record<string, string[]>;
+};
+export type CheckRecord = {
+    /** The tables checked: Islamiska Förbundet's or Diyanet's own for Sweden, the authority's for the rest. */
+    tables: string;
+    places: number;
+    times: number;
+    /** Times not on the printed minute. Certified only at 0. */
+    off: number;
+    from: string;
+    to: string;
+    /** What the check set aside as the source's fault, not the method's: listed so it can be judged. */
+    setAside?: {
+        misplaced: string[];
+        sourceFaults: number;
+        copiedRows: number;
+    };
+};
+/** One authority's entry in certification.json. See schemas/certification.schema.json. */
+export type Certification = {
+    certified: boolean;
+    checkedAt: string;
+    checks: CheckRecord[];
+    /**
+     * The correction list this certification is for: the dates it covers, how
+     * many times it moves, and the SHA-256 of the file as published. An app
+     * holding a list with another `to` or count holds another list.
+     */
+    corrections?: {
+        from: string;
+        to: string;
+        entries: number;
+        sha256?: string;
+    };
+    /** The method's revision (`src/methods/revisions.ts`) the list is for. */
+    revision?: number;
+};
+/** A civil date: 'YYYY-MM-DD', or { year, month, day } with January = 1. */
+export type CivilDate = string | {
+    year: number;
+    month: number;
+    day: number;
+};
+/** One prayer's time: the exact moment, and the wall-clock minute the authority prints. */
+export type PrayerTime = {
+    instant: Date;
+    /** 'HH:MM' on the table's clock (`DayTimes.clock`). */
+    printed: string;
+};
+/** The clock a day's times are printed in. */
+export type TableClock = {
+    /** The IANA zone, or null where the table keeps a clock no zone does. */
+    zone: string | null;
+    /** Minutes east of UTC on this date. */
+    offsetMinutes: number;
+    /** The zone's name, or 'UTC+01:00' where there is none. */
+    label: string;
+};
+export type DayStatus = 
+/** The date lies within the span the method was certified over: the authority's printed minute. */
+'certified'
+/** Outside that span: the method alone, on the printed minute all but rarely, never a minute further. */
+ | 'method-only'
+/** The method does not yet reproduce every time of its authority's tables (`candidateTimes` only). */
+ | 'uncertified';
+export type DayTimes = {
+    authority: Authority;
+    placeId: string;
+    /** 'YYYY-MM-DD' */
+    date: string;
+    status: DayStatus;
+    /** The span the method is certified over, or null for an uncertified method. */
+    certifiedFrom: string | null;
+    certifiedUntil: string | null;
+    /** The method's revision that computed this. */
+    revision: number;
+    clock: TableClock;
+    /** Null on a day the method gives no times for the place. */
+    times: Record<PrayerKey, PrayerTime> | null;
+};
+export type TimesOptions = {
+    /** 2 for the Hanafi Asr; the tables print the standard one (1). */
+    asrShadow?: 1 | 2;
+    /** Throw `UncertifiedMethodError` for a date outside the certified span, instead of returning `status: 'method-only'`. */
+    strict?: boolean;
+};
+/** What `methodInfo` says about a method. */
+export type MethodInfo = {
+    authority: Authority;
+    /** The authority, in words. */
+    name: string;
+    /** The method, in a sentence. */
+    method: string;
+    /** ISO 3166-1 alpha-2 of the countries the authority's tables cover (Diyanet: many). */
+    countries: string[];
+    revision: number;
+    certified: boolean;
+    /** The certification record, as in certification.json. */
+    certification: Certification | null;
+    /** The correction list this build carries. */
+    corrections: {
+        from: string;
+        to: string;
+        entries: number;
+    };
+    /** How many places this build knows for the authority. */
+    places: number;
+    /** The method's parameters, in words and numbers. */
+    parameters: Record<string, string | number | boolean>;
+    /** Where the authority publishes the tables the method was fitted to. */
+    sources: {
+        title: string;
+        url: string;
+    }[];
+    /** The method's own documentation. */
+    spec: string;
+};
+/** The method has not reproduced its authority's tables to the minute (or not for this date). */
+export declare class UncertifiedMethodError extends Error {
+    readonly authority: string;
+    readonly date?: string | undefined;
+    constructor(authority: string, date?: string | undefined);
+}