kiahk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WizardLabz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/amir-magdy-of-wizardlabz/kiahk/master/assets/kiahk.png" alt="Kiahk logo" width="160">
+</p>
+
+# kiahk (JavaScript / TypeScript)
+
+Coptic calendar arithmetic — date conversion, Easter, and feast days. The reference port of [kiahk](https://github.com/amir-magdy-of-wizardlabz/kiahk). Identical results to all other ports against `core/test-vectors.json`.
+
+Works in **Node.js and the browser** — no Node-only APIs at runtime.
+
+**Live demo:** <https://raw.githack.com/amir-magdy-of-wizardlabz/kiahk/master/demo/index.html>
+
+## Install
+
+```bash
+npm install kiahk
+```
+
+Or from this repo for development:
+
+```bash
+cd js
+npm install
+npm run build
+npm test
+```
+
+## Quick start
+
+```js
+import { CopticDate, GregorianDate, CopticCalendar } from 'kiahk'
+
+// Convert Gregorian → Coptic
+const g = new GregorianDate(2025, 1, 11)
+const c = g.toCoptic()
+console.log(c.year, c.month, c.day) // 1741 5 3
+
+// Convert Coptic → Gregorian
+const c2 = new CopticDate(1742, 1, 1)
+const g2 = c2.toGregorian()
+console.log(g2.year, g2.month, g2.day) // 2025 9 11
+
+// Coptic Easter for a Gregorian year
+const easter = CopticCalendar.easterDate(2025)
+console.log(easter.year, easter.month, easter.day) // 2025 4 20
+
+// All major feasts for a Gregorian year, sorted by date
+for (const feast of CopticCalendar.yearFeasts(2025)) {
+  const d = feast.gregorianDate
+  const pad = n => String(n).padStart(2, '0')
+  console.log(`${d.year}-${pad(d.month)}-${pad(d.day)}  ${feast.name('en')}`)
+}
+```
+
+**Sample output:**
+
+```
+1741 5 3
+2025 9 11
+2025 4 20
+2025-01-07  Nativity of Christ
+2025-01-19  Epiphany (Theophany)
+2025-02-10  Nineveh Fast
+2025-02-24  Great Lent (start)
+2025-04-07  Annunciation
+2025-04-13  Palm Sunday
+2025-04-20  Easter Sunday
+2025-05-29  Ascension
+2025-06-08  Pentecost
+2025-08-22  Assumption of Mary
+2025-09-27  Feast of the Cross
+```
+
+## Render a date in English and Arabic
+
+The library exposes Coptic month names in `en` + `ar` via `CopticCalendar.monthName(month, locale)`. The full 13-entry table is also re-exported as `COPTIC_MONTHS` for callers that prefer raw data.
+
+```js
+import { GregorianDate, CopticCalendar } from 'kiahk'
+
+const g = new GregorianDate(2025, 4, 20)
+const c = g.toCoptic()
+console.log(`${c.day} ${CopticCalendar.monthName(c.month, 'en')} ${c.year} AM`)
+console.log(`${c.day} ${CopticCalendar.monthName(c.month, 'ar')} ${c.year} للشهداء`)
+```
+
+**Sample output:**
+
+```
+12 Parmouti 1741 AM
+12 برمودة 1741 للشهداء
+```
+
+## API at a glance
+
+| Type / method | Purpose |
+| --- | --- |
+| `new GregorianDate(y, m, d)` | Validating constructor; throws `InvalidGregorianDateException` on bad input |
+| `GregorianDate#toCoptic() → CopticDate` | Convert |
+| `GregorianDate#toNativeDate()` / `GregorianDate.fromNativeDate(d)` | Interop with JS `Date` |
+| `new CopticDate(y, m, d)` | Validating constructor; throws `InvalidCopticDateException` on bad input |
+| `CopticDate#toGregorian() → GregorianDate` | Convert |
+| `Feast` | `id`, `type`, `category`, `gregorianDate`, `name(locale)` |
+| `feast.name('fr')` | Throws `UnsupportedLocaleException` for unknown locale |
+| `CopticCalendar.easterDate(year) → GregorianDate` | Coptic Easter |
+| `CopticCalendar.moveableFeast(feastId, year) → Feast` | One moveable feast |
+| `CopticCalendar.yearFeasts(year) → Feast[]` | All feasts, sorted ascending |
+| `CopticCalendar.monthName(month, locale) → string` | Coptic month name; throws `InvalidCopticMonthException` / `UnsupportedLocaleException` |
+| `COPTIC_MONTHS` | 13-entry array (mirrors `core/coptic_months.json`) |
+
+Supported locales for `Feast#name(...)` and `CopticCalendar.monthName(...)`: `en`, `ar`.
+
+## Run tests
+
+```bash
+cd js
+npm test
+```
+
+## License
+
+Licensed under the [MIT License](../LICENSE).
+
+Maintained by Amir Magdy at WizardLabz.

package/dist/CopticCalendar.d.ts

@@ -0,0 +1,10 @@
+import { GregorianDate } from './GregorianDate.js';
+import { Feast } from './Feast.js';
+export declare class CopticCalendar {
+    private constructor();
+    static monthName(month: number, locale: string): string;
+    static easterDate(gregorianYear: number): GregorianDate;
+    static moveableFeast(feastId: string, gregorianYear: number): Feast;
+    static fixedFeasts(gregorianYear: number): Feast[];
+    static yearFeasts(gregorianYear: number): Feast[];
+}

package/dist/CopticCalendar.js

@@ -0,0 +1,63 @@
+import { computeEaster, addDays } from './algorithms.js';
+import { GregorianDate } from './GregorianDate.js';
+import { CopticDate } from './CopticDate.js';
+import { Feast } from './Feast.js';
+import { FEASTS } from './feasts-data.js';
+import { COPTIC_MONTHS } from './coptic-months-data.js';
+import { InvalidCopticMonthException, UnsupportedLocaleException } from './errors.js';
+export class CopticCalendar {
+    constructor() { }
+    static monthName(month, locale) {
+        if (!Number.isInteger(month) || month < 1 || month > 13) {
+            throw new InvalidCopticMonthException(month);
+        }
+        const record = COPTIC_MONTHS[month - 1];
+        if (!(locale in record.names))
+            throw new UnsupportedLocaleException(locale);
+        return record.names[locale];
+    }
+    static easterDate(gregorianYear) {
+        const [y, m, d] = computeEaster(gregorianYear);
+        return new GregorianDate(y, m, d);
+    }
+    static moveableFeast(feastId, gregorianYear) {
+        const data = FEASTS.find(f => f.id === feastId && f.type === 'moveable');
+        if (!data)
+            throw new Error(`Unknown moveable feast: ${feastId}`);
+        const easter = this.easterDate(gregorianYear);
+        const [y, m, d] = addDays(easter.year, easter.month, easter.day, data.easter_offset);
+        const gDate = new GregorianDate(y, m, d);
+        return new Feast(data, gDate, gDate.toCoptic());
+    }
+    static fixedFeasts(gregorianYear) {
+        // A Gregorian year spans two Coptic years — check both
+        const cYearStart = new GregorianDate(gregorianYear, 1, 1).toCoptic().year;
+        const result = [];
+        const seen = new Set();
+        for (const copticYear of [cYearStart, cYearStart + 1]) {
+            for (const data of FEASTS.filter(f => f.type === 'fixed')) {
+                try {
+                    const c = new CopticDate(copticYear, data.coptic_month, data.coptic_day);
+                    const g = c.toGregorian();
+                    if (g.year === gregorianYear && !seen.has(data.id)) {
+                        seen.add(data.id);
+                        result.push(new Feast(data, g, c));
+                    }
+                }
+                catch { /* invalid date for this coptic year, skip */ }
+            }
+        }
+        return result;
+    }
+    static yearFeasts(gregorianYear) {
+        const moveable = FEASTS
+            .filter(f => f.type === 'moveable')
+            .map(data => this.moveableFeast(data.id, gregorianYear));
+        const fixed = this.fixedFeasts(gregorianYear);
+        return [...fixed, ...moveable].sort((a, b) => {
+            const ag = a.gregorianDate, bg = b.gregorianDate;
+            return new Date(ag.year, ag.month - 1, ag.day).getTime()
+                - new Date(bg.year, bg.month - 1, bg.day).getTime();
+        });
+    }
+}

package/dist/CopticDate.d.ts

@@ -0,0 +1,9 @@
+import { GregorianDate } from './GregorianDate.js';
+export declare class CopticDate {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    constructor(year: number, month: number, day: number);
+    toGregorian(): GregorianDate;
+    toString(): string;
+}

package/dist/CopticDate.js

@@ -0,0 +1,28 @@
+import { copticToGregorian } from './algorithms.js';
+import { InvalidCopticDateException } from './errors.js';
+import { GregorianDate } from './GregorianDate.js';
+function daysInCopticMonth(month, year) {
+    if (month >= 1 && month <= 12)
+        return 30;
+    if (month === 13)
+        return year % 4 === 3 ? 6 : 5;
+    return 0;
+}
+export class CopticDate {
+    constructor(year, month, day) {
+        const maxDay = daysInCopticMonth(month, year);
+        if (month < 1 || month > 13 || day < 1 || day > maxDay) {
+            throw new InvalidCopticDateException(year, month, day);
+        }
+        this.year = year;
+        this.month = month;
+        this.day = day;
+    }
+    toGregorian() {
+        const [y, m, d] = copticToGregorian(this.year, this.month, this.day);
+        return new GregorianDate(y, m, d);
+    }
+    toString() {
+        return `${this.year}/${String(this.month).padStart(2, '0')}/${String(this.day).padStart(2, '0')}`;
+    }
+}

package/dist/Feast.d.ts

@@ -0,0 +1,24 @@
+import type { GregorianDate } from './GregorianDate.js';
+import type { CopticDate } from './CopticDate.js';
+export type FeastType = 'moveable' | 'fixed';
+export type FeastCategory = 'major' | 'minor';
+export interface FeastData {
+    id: string;
+    names: Record<string, string>;
+    type: FeastType;
+    category: FeastCategory;
+    easter_offset?: number;
+    coptic_month?: number;
+    coptic_day?: number;
+}
+export declare class Feast {
+    readonly id: string;
+    readonly type: FeastType;
+    readonly category: FeastCategory;
+    readonly easterOffset: number | null;
+    readonly gregorianDate: GregorianDate;
+    readonly copticDate: CopticDate;
+    private readonly _names;
+    constructor(data: FeastData, gregorianDate: GregorianDate, copticDate: CopticDate);
+    name(locale: string): string;
+}

package/dist/Feast.js

@@ -0,0 +1,17 @@
+import { UnsupportedLocaleException } from './errors.js';
+export class Feast {
+    constructor(data, gregorianDate, copticDate) {
+        this.id = data.id;
+        this.type = data.type;
+        this.category = data.category;
+        this.easterOffset = data.easter_offset ?? null;
+        this.gregorianDate = gregorianDate;
+        this.copticDate = copticDate;
+        this._names = data.names;
+    }
+    name(locale) {
+        if (!(locale in this._names))
+            throw new UnsupportedLocaleException(locale);
+        return this._names[locale];
+    }
+}

package/dist/GregorianDate.d.ts

@@ -0,0 +1,11 @@
+import { CopticDate } from './CopticDate.js';
+export declare class GregorianDate {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    constructor(year: number, month: number, day: number);
+    toCoptic(): CopticDate;
+    toNativeDate(): Date;
+    static fromNativeDate(date: Date): GregorianDate;
+    toString(): string;
+}

package/dist/GregorianDate.js

@@ -0,0 +1,34 @@
+import { gregorianToCoptic } from './algorithms.js';
+import { InvalidGregorianDateException } from './errors.js';
+import { CopticDate } from './CopticDate.js';
+const DAYS_IN_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeap(y) { return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0; }
+function daysInGregorianMonth(month, year) {
+    if (month === 2 && isLeap(year))
+        return 29;
+    return DAYS_IN_MONTH[month] ?? 0;
+}
+export class GregorianDate {
+    constructor(year, month, day) {
+        const maxDay = daysInGregorianMonth(month, year);
+        if (month < 1 || month > 12 || day < 1 || day > maxDay) {
+            throw new InvalidGregorianDateException(year, month, day);
+        }
+        this.year = year;
+        this.month = month;
+        this.day = day;
+    }
+    toCoptic() {
+        const [y, m, d] = gregorianToCoptic(this.year, this.month, this.day);
+        return new CopticDate(y, m, d);
+    }
+    toNativeDate() {
+        return new Date(this.year, this.month - 1, this.day);
+    }
+    static fromNativeDate(date) {
+        return new GregorianDate(date.getFullYear(), date.getMonth() + 1, date.getDate());
+    }
+    toString() {
+        return `${this.year}-${String(this.month).padStart(2, '0')}-${String(this.day).padStart(2, '0')}`;
+    }
+}

package/dist/algorithms.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Calendar conversion primitives for the Coptic (Alexandrian) calendar.
+ *
+ * The Coptic calendar:
+ *   - 12 months of 30 days, plus a 13th "little month" (Nasie) of 5 days
+ *     (6 in leap years).
+ *   - Leap rule: Coptic year Y is a leap year iff Y mod 4 == 3 (Julian rule).
+ *   - Era: Anno Martyrum (AM), starting 29 August 284 CE (Julian) =
+ *     11 September 284 CE (proleptic Gregorian) = JDN 1825030
+ *     (= 1 Tout 1 AM).
+ *
+ * Algorithm references:
+ *   - Reingold & Dershowitz, "Calendrical Calculations" (3rd ed., 2008),
+ *     §4.1 (Coptic calendar).
+ *   - Fourmilab/Meeus port in the Python `convertdate` package
+ *     (https://github.com/fitnr/convertdate, src/convertdate/coptic.py).
+ *   - Wikipedia: https://en.wikipedia.org/wiki/Coptic_calendar
+ */
+/** Gregorian date → Julian Day Number (Fliegel & Van Flandern). */
+export declare function gregorianToJdn(year: number, month: number, day: number): number;
+/** Julian Day Number → Gregorian date. */
+export declare function jdnToGregorian(jdn: number): [number, number, number];
+/** Coptic date → Julian Day Number. */
+export declare function copticToJdn(cYear: number, cMonth: number, cDay: number): number;
+/** Julian Day Number → Coptic date. */
+export declare function jdnToCoptic(jdn: number): [number, number, number];
+/** Gregorian → Coptic. */
+export declare function gregorianToCoptic(gYear: number, gMonth: number, gDay: number): [number, number, number];
+/** Coptic → Gregorian. */
+export declare function copticToGregorian(cYear: number, cMonth: number, cDay: number): [number, number, number];
+/**
+ * Coptic / Orthodox Easter (Meeus's Julian computus + Julian-to-Gregorian shift).
+ *
+ * The Meeus formula yields Easter Sunday in the *Julian* calendar. To express
+ * the same instant on the *Gregorian* calendar we add the Julian-Gregorian
+ * offset (13 days for any date in the 20th–21st century: 1900-03-01 through
+ * 2100-02-28). Since this library targets the modern era we hard-code +13.
+ */
+export declare function computeEaster(gregorianYear: number): [number, number, number];
+/** Add N days to a Gregorian date, returning [year, month, day]. */
+export declare function addDays(year: number, month: number, day: number, days: number): [number, number, number];

package/dist/algorithms.js

@@ -0,0 +1,95 @@
+/**
+ * Calendar conversion primitives for the Coptic (Alexandrian) calendar.
+ *
+ * The Coptic calendar:
+ *   - 12 months of 30 days, plus a 13th "little month" (Nasie) of 5 days
+ *     (6 in leap years).
+ *   - Leap rule: Coptic year Y is a leap year iff Y mod 4 == 3 (Julian rule).
+ *   - Era: Anno Martyrum (AM), starting 29 August 284 CE (Julian) =
+ *     11 September 284 CE (proleptic Gregorian) = JDN 1825030
+ *     (= 1 Tout 1 AM).
+ *
+ * Algorithm references:
+ *   - Reingold & Dershowitz, "Calendrical Calculations" (3rd ed., 2008),
+ *     §4.1 (Coptic calendar).
+ *   - Fourmilab/Meeus port in the Python `convertdate` package
+ *     (https://github.com/fitnr/convertdate, src/convertdate/coptic.py).
+ *   - Wikipedia: https://en.wikipedia.org/wiki/Coptic_calendar
+ */
+/** Gregorian date → Julian Day Number (Fliegel & Van Flandern). */
+export function gregorianToJdn(year, month, day) {
+    const a = Math.floor((14 - month) / 12);
+    const y = year + 4800 - a;
+    const m = month + 12 * a - 3;
+    return day + Math.floor((153 * m + 2) / 5) + 365 * y +
+        Math.floor(y / 4) - Math.floor(y / 100) + Math.floor(y / 400) - 32045;
+}
+/** Julian Day Number → Gregorian date. */
+export function jdnToGregorian(jdn) {
+    const a = jdn + 32044;
+    const b = Math.floor((4 * a + 3) / 146097);
+    const c = a - Math.floor((146097 * b) / 4);
+    const d = Math.floor((4 * c + 3) / 1461);
+    const e = c - Math.floor((1461 * d) / 4);
+    const m = Math.floor((5 * e + 2) / 153);
+    const day = e - Math.floor((153 * m + 2) / 5) + 1;
+    const month = m + 3 - 12 * Math.floor(m / 10);
+    const year = 100 * b + d - 4800 + Math.floor(m / 10);
+    return [year, month, day];
+}
+/** JDN of 1 Tout, year 1 AM (Coptic epoch). */
+const COPTIC_EPOCH = 1825030;
+/** Coptic date → Julian Day Number. */
+export function copticToJdn(cYear, cMonth, cDay) {
+    // Days before year cYear (within the AM era):
+    //   365 * (cYear - 1) full years + one extra day for every leap year
+    //   in [1, cYear - 1] (Coptic leap year: Y mod 4 == 3).
+    // The count of leap years in [1, cYear - 1] equals floor(cYear / 4).
+    return COPTIC_EPOCH - 1
+        + 365 * (cYear - 1)
+        + Math.floor(cYear / 4)
+        + 30 * (cMonth - 1)
+        + cDay;
+}
+/** Julian Day Number → Coptic date. */
+export function jdnToCoptic(jdn) {
+    const r = jdn - COPTIC_EPOCH; // 0 = 1 Tout 1 AM
+    // Solve for cYear given r = 365*(cYear-1) + floor(cYear/4) + dayOfYear (0..365).
+    // Closed form: cYear = floor((4*r + 1463) / 1461).
+    const cYear = Math.floor((4 * r + 1463) / 1461);
+    const dayOfYear = r - 365 * (cYear - 1) - Math.floor(cYear / 4); // 0-indexed
+    const cMonth = Math.floor(dayOfYear / 30) + 1;
+    const cDay = dayOfYear - 30 * (cMonth - 1) + 1;
+    return [cYear, cMonth, cDay];
+}
+/** Gregorian → Coptic. */
+export function gregorianToCoptic(gYear, gMonth, gDay) {
+    return jdnToCoptic(gregorianToJdn(gYear, gMonth, gDay));
+}
+/** Coptic → Gregorian. */
+export function copticToGregorian(cYear, cMonth, cDay) {
+    return jdnToGregorian(copticToJdn(cYear, cMonth, cDay));
+}
+/**
+ * Coptic / Orthodox Easter (Meeus's Julian computus + Julian-to-Gregorian shift).
+ *
+ * The Meeus formula yields Easter Sunday in the *Julian* calendar. To express
+ * the same instant on the *Gregorian* calendar we add the Julian-Gregorian
+ * offset (13 days for any date in the 20th–21st century: 1900-03-01 through
+ * 2100-02-28). Since this library targets the modern era we hard-code +13.
+ */
+export function computeEaster(gregorianYear) {
+    const a = gregorianYear % 4;
+    const b = gregorianYear % 7;
+    const c = gregorianYear % 19;
+    const d = (19 * c + 15) % 30;
+    const e = (2 * a + 4 * b - d + 34) % 7;
+    const f = Math.floor((d + e + 114) / 31); // Julian-calendar month
+    const g = ((d + e + 114) % 31) + 1; // Julian-calendar day
+    const jdn = gregorianToJdn(gregorianYear, f, g) + 13;
+    return jdnToGregorian(jdn);
+}
+/** Add N days to a Gregorian date, returning [year, month, day]. */
+export function addDays(year, month, day, days) {
+    return jdnToGregorian(gregorianToJdn(year, month, day) + days);
+}

package/dist/coptic-months-data.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hand-maintained mirror of core/coptic_months.json. Keep order identical
+ * (months 1..13) for cross-port test parity. Inlined (not read from disk)
+ * so this module works in both Node and browser environments.
+ */
+export interface CopticMonthRecord {
+    month: number;
+    names: Record<string, string>;
+}
+export declare const COPTIC_MONTHS: CopticMonthRecord[];

package/dist/coptic-months-data.js

@@ -0,0 +1,15 @@
+export const COPTIC_MONTHS = [
+    { month: 1, names: { en: 'Thout', ar: 'توت' } },
+    { month: 2, names: { en: 'Paopi', ar: 'بابة' } },
+    { month: 3, names: { en: 'Hathor', ar: 'هاتور' } },
+    { month: 4, names: { en: 'Koiak', ar: 'كيهك' } },
+    { month: 5, names: { en: 'Tobi', ar: 'طوبة' } },
+    { month: 6, names: { en: 'Meshir', ar: 'أمشير' } },
+    { month: 7, names: { en: 'Paremhat', ar: 'برمهات' } },
+    { month: 8, names: { en: 'Parmouti', ar: 'برمودة' } },
+    { month: 9, names: { en: 'Pashons', ar: 'بشنس' } },
+    { month: 10, names: { en: 'Paoni', ar: 'بؤونة' } },
+    { month: 11, names: { en: 'Epip', ar: 'أبيب' } },
+    { month: 12, names: { en: 'Mesori', ar: 'مسرى' } },
+    { month: 13, names: { en: 'Nasie', ar: 'نسيء' } }
+];

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class InvalidCopticDateException extends Error {
+    constructor(year: number, month: number, day: number);
+}
+export declare class InvalidGregorianDateException extends Error {
+    constructor(year: number, month: number, day: number);
+}
+export declare class UnsupportedLocaleException extends Error {
+    constructor(locale: string);
+}
+export declare class InvalidCopticMonthException extends Error {
+    constructor(month: number);
+}

package/dist/errors.js

@@ -0,0 +1,24 @@
+export class InvalidCopticDateException extends Error {
+    constructor(year, month, day) {
+        super(`Invalid Coptic date: ${year}/${month}/${day}`);
+        this.name = 'InvalidCopticDateException';
+    }
+}
+export class InvalidGregorianDateException extends Error {
+    constructor(year, month, day) {
+        super(`Invalid Gregorian date: ${year}/${month}/${day}`);
+        this.name = 'InvalidGregorianDateException';
+    }
+}
+export class UnsupportedLocaleException extends Error {
+    constructor(locale) {
+        super(`Unsupported locale: ${locale}`);
+        this.name = 'UnsupportedLocaleException';
+    }
+}
+export class InvalidCopticMonthException extends Error {
+    constructor(month) {
+        super(`Invalid Coptic month: ${month} (expected 1..13)`);
+        this.name = 'InvalidCopticMonthException';
+    }
+}

package/dist/feasts-data.d.ts

@@ -0,0 +1,7 @@
+import type { FeastData } from './Feast.js';
+/**
+ * Hand-maintained mirror of core/feasts.json. Keep order identical for
+ * cross-port test parity. Inlined (not read from disk) so this module works
+ * in both Node and browser environments.
+ */
+export declare const FEASTS: FeastData[];

package/dist/feasts-data.js

@@ -0,0 +1,73 @@
+/**
+ * Hand-maintained mirror of core/feasts.json. Keep order identical for
+ * cross-port test parity. Inlined (not read from disk) so this module works
+ * in both Node and browser environments.
+ */
+export const FEASTS = [
+    {
+        id: 'nativity',
+        names: { en: 'Nativity of Christ', ar: 'عيد الميلاد المجيد' },
+        type: 'fixed', category: 'major',
+        coptic_month: 4, coptic_day: 29
+    },
+    {
+        id: 'epiphany',
+        names: { en: 'Epiphany (Theophany)', ar: 'عيد الغطاس' },
+        type: 'fixed', category: 'major',
+        coptic_month: 5, coptic_day: 11
+    },
+    {
+        id: 'annunciation',
+        names: { en: 'Annunciation', ar: 'عيد البشارة' },
+        type: 'fixed', category: 'major',
+        coptic_month: 7, coptic_day: 29
+    },
+    {
+        id: 'assumption',
+        names: { en: 'Assumption of Mary', ar: 'عيد انتقال العذراء' },
+        type: 'fixed', category: 'major',
+        coptic_month: 12, coptic_day: 16
+    },
+    {
+        id: 'cross',
+        names: { en: 'Feast of the Cross', ar: 'عيد الصليب' },
+        type: 'fixed', category: 'major',
+        coptic_month: 1, coptic_day: 17
+    },
+    {
+        id: 'nineveh_fast',
+        names: { en: 'Nineveh Fast', ar: 'صوم نينوى' },
+        type: 'moveable', category: 'major',
+        easter_offset: -69
+    },
+    {
+        id: 'great_lent',
+        names: { en: 'Great Lent (start)', ar: 'بداية الصوم الكبير' },
+        type: 'moveable', category: 'major',
+        easter_offset: -55
+    },
+    {
+        id: 'palm_sunday',
+        names: { en: 'Palm Sunday', ar: 'أحد الشعانين' },
+        type: 'moveable', category: 'major',
+        easter_offset: -7
+    },
+    {
+        id: 'easter',
+        names: { en: 'Easter Sunday', ar: 'عيد القيامة المجيد' },
+        type: 'moveable', category: 'major',
+        easter_offset: 0
+    },
+    {
+        id: 'ascension',
+        names: { en: 'Ascension', ar: 'عيد الصعود' },
+        type: 'moveable', category: 'major',
+        easter_offset: 39
+    },
+    {
+        id: 'pentecost',
+        names: { en: 'Pentecost', ar: 'عيد العنصرة' },
+        type: 'moveable', category: 'major',
+        easter_offset: 49
+    }
+];

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { CopticDate } from './CopticDate.js';
+export { GregorianDate } from './GregorianDate.js';
+export type { FeastType, FeastCategory } from './Feast.js';
+export { Feast } from './Feast.js';
+export { CopticCalendar } from './CopticCalendar.js';
+export type { CopticMonthRecord } from './coptic-months-data.js';
+export { COPTIC_MONTHS } from './coptic-months-data.js';
+export { InvalidCopticDateException, InvalidGregorianDateException, InvalidCopticMonthException, UnsupportedLocaleException } from './errors.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { CopticDate } from './CopticDate.js';
+export { GregorianDate } from './GregorianDate.js';
+export { Feast } from './Feast.js';
+export { CopticCalendar } from './CopticCalendar.js';
+export { COPTIC_MONTHS } from './coptic-months-data.js';
+export { InvalidCopticDateException, InvalidGregorianDateException, InvalidCopticMonthException, UnsupportedLocaleException } from './errors.js';

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "kiahk",
+  "version": "0.1.0",
+  "description": "Coptic calendar arithmetic — date conversion, Easter, and feast days. Works in Node and the browser.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "keywords": [
+    "coptic",
+    "calendar",
+    "easter",
+    "coptic-calendar",
+    "kiahk",
+    "kiahk-calendar",
+    "orthodox",
+    "feast",
+    "aboqty",
+    "قبطي",
+    "تقويم",
+    "كيهك",
+    "عيد",
+    "القيامة",
+    "القيامه",
+    "أبوقطي"
+  ],
+  "author": "WizardLabz",
+  "contributors": [
+    { "name": "Amir Magdy" }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amir-magdy-of-wizardlabz/kiahk.git",
+    "directory": "js"
+  },
+  "homepage": "https://github.com/amir-magdy-of-wizardlabz/kiahk#readme",
+  "bugs": {
+    "url": "https://github.com/amir-magdy-of-wizardlabz/kiahk/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0",
+    "@types/node": "^20.0.0"
+  }
+}