mihrab-methods 0.0.0-stage → 1.0.1

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,61 @@
+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 where there is one, else a built-in digest. */
+    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;
+/** UTF-8 bytes of a string, without TextEncoder (not every runtime has it). */
+export declare function utf8(text: string): Uint8Array;
+/** SHA-256 (FIPS 180-4) of bytes. */
+export declare function sha256(data: Uint8Array): Uint8Array;
+/** 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,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FEED_URL = void 0;
+exports.summarize = summarize;
+exports.utf8 = utf8;
+exports.sha256 = sha256;
+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;
+/**
+ * SHA-256 as lowercase hex. WebCrypto where the runtime has it (browsers,
+ * Node 18+, Deno, Bun); elsewhere — Hermes in React Native has none — the
+ * plain-JavaScript digest below. No `node:crypto` import: a bundler for a
+ * phone or a browser fails on the import itself, used or not.
+ */
+async function defaultSha256(text) {
+    const bytes = utf8(text);
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle) {
+        try {
+            const buf = await subtle.digest('SHA-256', bytes);
+            return hex(new Uint8Array(buf));
+        }
+        catch {
+            /* a subtle that refuses (an insecure context): the digest below */
+        }
+    }
+    return hex(sha256(bytes));
+}
+const hex = (b) => Array.from(b, x => x.toString(16).padStart(2, '0')).join('');
+/** UTF-8 bytes of a string, without TextEncoder (not every runtime has it). */
+function utf8(text) {
+    const out = [];
+    for (let i = 0; i < text.length; i++) {
+        let c = text.charCodeAt(i);
+        if (c >= 0xd800 && c < 0xdc00 && i + 1 < text.length) {
+            const d = text.charCodeAt(i + 1);
+            if (d >= 0xdc00 && d < 0xe000) {
+                c = 0x10000 + ((c - 0xd800) << 10) + (d - 0xdc00);
+                i++;
+            }
+        }
+        if (c < 0x80)
+            out.push(c);
+        else if (c < 0x800)
+            out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+        else if (c < 0x10000)
+            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+        else
+            out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    }
+    return Uint8Array.from(out);
+}
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/** SHA-256 (FIPS 180-4) of bytes. */
+function sha256(data) {
+    const bitLen = data.length * 8;
+    const padded = new Uint8Array(((data.length + 9 + 63) >> 6) << 6);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bitLen / 0x100000000));
+    view.setUint32(padded.length - 4, bitLen >>> 0);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < padded.length; off += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(off + i * 4);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K[i] + w[i]) >>> 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] += a;
+        h[1] += b;
+        h[2] += c;
+        h[3] += d;
+        h[4] += e;
+        h[5] += f;
+        h[6] += g;
+        h[7] += hh;
+    }
+    const out = new Uint8Array(32);
+    const ov = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++)
+        ov.setUint32(i * 4, h[i]);
+    return out;
+}
+/** 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 };
+    // A certification without a hash (one written before 1.0.0) is taken on its identity alone.
+    let integrity = 'unchecked';
+    if (named.sha256) {
+        const hash = opts.sha256 ? await opts.sha256(text) : await defaultSha256(text);
+        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: readonly 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,34 @@
+"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;
+    // Frozen: every caller shares these objects, and a place moved by one
+    // (`place.lat = …`) would move the corrections it is looked up by for all.
+    for (const p of entry.places)
+        Object.freeze(p);
+    Object.freeze(entry.places);
+    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);
+}