calendaryjs-plugin-hijri 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 calendaryjs
+
+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,116 @@
+# calendaryjs-plugin-hijri
+
+Islamic (Hijri) calendar plugin for [calendaryjs](https://github.com/calendaryjs/calendaryjs). Gregorian ↔ Hijri date conversion + Hijri recurring events. Uses the **tabular (civil) Islamic calendar** — arithmetic, deterministic, and round-trip safe.
+
+> The tabular variant is computed, not observed. A sighting- or announcement-based calendar (e.g. Umm al-Qurā) may differ by ±1 day.
+
+## Features
+
+- **🌙 Hijri events** — define events by Hijri date (`type: "hijri"`)
+- **🔄 Date conversion** — Gregorian ↔ Hijri, exact inverses (round-trip safe)
+- **📅 Drift-aware** — a Hijri date can fall 0, 1, or 2 times in a Gregorian year; all occurrences are returned
+- **🗓 Leap years** — standard 30-year tabular cycle (11 leap years)
+
+## Installation
+
+```bash
+pnpm add calendaryjs calendaryjs-plugin-hijri
+```
+
+## Requirements
+
+- `calendaryjs` >= 0.1.0
+
+## Quick Start
+
+```typescript
+import { calendary } from "calendaryjs";
+import { hijri } from "calendaryjs-plugin-hijri";
+
+const cal = calendary();
+cal.use(hijri());
+
+cal.addGroup({
+  id: "islamic-holidays",
+  name: "Islamic Holidays",
+  events: [
+    {
+      type: "hijri",
+      id: "islamic-new-year",
+      hijriMonth: 1,
+      hijriDay: 1,
+      title: "Islamic New Year",
+    },
+    { type: "hijri", id: "eid-al-fitr", hijriMonth: 10, hijriDay: 1, title: "Eid al-Fitr" },
+    { type: "hijri", id: "eid-al-adha", hijriMonth: 12, hijriDay: 10, title: "Eid al-Adha" },
+  ],
+});
+
+// Resolves Hijri dates to Gregorian automatically
+const events = cal.getEventsInRange("2025-01-01", "2025-12-31");
+```
+
+## Event Type
+
+### `hijri`
+
+Events based on Hijri calendar dates.
+
+```typescript
+{
+  type: 'hijri';
+  id: string;
+  hijriMonth: number;  // 1-12
+  hijriDay: number;    // 1-30
+  title?: string;
+  // ... other standard event properties
+}
+```
+
+Because a Hijri month/day drifts ~11 days earlier each Gregorian year, an event
+may occur **twice** (early January + late December) or **not at all** within a
+given Gregorian year. The engine returns every occurrence that lands in range.
+
+## Date Conversion
+
+```typescript
+import { gregorianToHijri, hijriToGregorian } from "calendaryjs-plugin-hijri";
+
+// Gregorian → Hijri
+gregorianToHijri({ year: 2024, month: 7, day: 8 });
+// → { year: 1446, month: 1, day: 1 }
+
+// Hijri → Gregorian
+hijriToGregorian({ year: 1446, month: 1, day: 1 });
+// → { year: 2024, month: 7, day: 8 }
+```
+
+### Calendar helpers
+
+```typescript
+import { isHijriLeapYear, hijriMonthLength, isValidHijriDate } from "calendaryjs-plugin-hijri";
+
+isHijriLeapYear(1447); // → true  (355-day year)
+hijriMonthLength(1446, 1); // → 30 (odd months are 30 days)
+isValidHijriDate({ year: 1446, month: 12, day: 30 }); // → false (not a leap year)
+```
+
+## Optional: enrich days with Hijri info
+
+```typescript
+const cal = calendary().use(hijri({ enrichDays: true }));
+cal.addGroup({ id: "g", events: [] });
+
+const [day] = cal.getDays({ from: "2024-07-08", to: "2024-07-08" });
+day.hijri; // → { year: 1446, month: 1, day: 1 }
+```
+
+## Related Packages
+
+- [calendaryjs](https://github.com/calendaryjs/calendaryjs/tree/main/packages/calendaryjs) - Core package
+- [calendaryjs-plugin-lunar](https://github.com/calendaryjs/calendaryjs/tree/main/packages/lunar) - Lunisolar calendar
+- [calendaryjs-plugin-liturgical](https://github.com/calendaryjs/calendaryjs/tree/main/packages/liturgical) - Liturgical calendar
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,112 @@
+'use strict';
+
+// package.json
+var package_default = {
+  name: "calendaryjs-plugin-hijri",
+  version: "0.1.0"};
+
+// src/converter.ts
+var ISLAMIC_EPOCH = 1948440;
+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;
+}
+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);
+  return {
+    year: 100 * b + d - 4800 + Math.floor(m / 10),
+    month: m + 3 - 12 * Math.floor(m / 10),
+    day: e - Math.floor((153 * m + 2) / 5) + 1
+  };
+}
+function hijriToJDN(year, month, day) {
+  return day + Math.ceil(29.5 * (month - 1)) + (year - 1) * 354 + Math.floor((3 + 11 * year) / 30) + ISLAMIC_EPOCH - 1;
+}
+function gregorianToHijri(g) {
+  const jdn = gregorianToJDN(g.year, g.month, g.day);
+  const year = Math.floor((30 * (jdn - ISLAMIC_EPOCH) + 10646) / 10631);
+  const month = Math.min(12, Math.ceil((jdn - (29 + hijriToJDN(year, 1, 1))) / 29.5) + 1);
+  const day = jdn - hijriToJDN(year, month, 1) + 1;
+  return { year, month, day };
+}
+function hijriToGregorian(h) {
+  return jdnToGregorian(hijriToJDN(h.year, h.month, h.day));
+}
+function isHijriLeapYear(year) {
+  return (11 * year + 14) % 30 < 11;
+}
+function hijriMonthLength(year, month) {
+  if (month % 2 === 1) return 30;
+  if (month === 12 && isHijriLeapYear(year)) return 30;
+  return 29;
+}
+function isValidHijriDate(h) {
+  if (h.month < 1 || h.month > 12) return false;
+  if (h.day < 1 || h.day > hijriMonthLength(h.year, h.month)) return false;
+  return true;
+}
+
+// src/generator.ts
+var hijriEventHandler = {
+  validate(event) {
+    if (typeof event !== "object" || event === null) return false;
+    const e = event;
+    return e.type === "hijri" && typeof e.hijriMonth === "number" && e.hijriMonth >= 1 && e.hijriMonth <= 12 && typeof e.hijriDay === "number" && e.hijriDay >= 1 && e.hijriDay <= 30 && typeof e.title === "string" && typeof e.id === "string";
+  },
+  generate(event, gregorianYear) {
+    const e = event;
+    const dates = [];
+    const hyStart = gregorianToHijri({ year: gregorianYear, month: 1, day: 1 }).year;
+    const hyEnd = gregorianToHijri({ year: gregorianYear, month: 12, day: 31 }).year;
+    for (let hy = hyStart; hy <= hyEnd; hy++) {
+      const g = hijriToGregorian({ year: hy, month: e.hijriMonth, day: e.hijriDay });
+      if (g.year === gregorianYear) dates.push(new Date(g.year, g.month - 1, g.day));
+    }
+    return dates;
+  }
+};
+
+// src/plugin.ts
+var hijriDayEnricher = {
+  name: "hijri",
+  priority: 10,
+  enrich: (day) => {
+    const h = gregorianToHijri({ year: day.year, month: day.month, day: day.day });
+    return { ...day, hijri: { year: h.year, month: h.month, day: h.day } };
+  }
+};
+function hijriPlugin(options = {}) {
+  const { enrichDays = false } = options;
+  return {
+    name: package_default.name,
+    version: package_default.version,
+    install(calendary) {
+      if (enrichDays) {
+        calendary.registerDayEnricher(hijriDayEnricher);
+      }
+    },
+    eventTypes: {
+      hijri: hijriEventHandler
+    }
+  };
+}
+var hijri = Object.assign(hijriPlugin, {
+  /** Builder selector for a hijri date — `every("year").on(hijri.date(9, 1))`. */
+  date(month, day) {
+    return { type: "hijri", fields: { hijriMonth: month, hijriDay: day } };
+  }
+});
+
+exports.gregorianToHijri = gregorianToHijri;
+exports.hijri = hijri;
+exports.hijriMonthLength = hijriMonthLength;
+exports.hijriToGregorian = hijriToGregorian;
+exports.isHijriLeapYear = isHijriLeapYear;
+exports.isValidHijriDate = isValidHijriDate;

package/dist/index.d.cts

@@ -0,0 +1,94 @@
+import { CalendarDay, CalendaryPlugin, BaseEventProperties } from 'calendaryjs';
+import { Selector } from 'calendaryjs/builder';
+
+/** Hijri date info added by the hijri plugin. */
+interface HijriInfo {
+    year: number;
+    month: number;
+    day: number;
+}
+/** CalendarDay with hijri enrichment. */
+interface CalendarDayWithHijri extends CalendarDay {
+    hijri: HijriInfo;
+}
+/** Options for the hijri plugin. */
+interface HijriPluginOptions {
+    /**
+     * Whether to enrich days with Hijri date information.
+     * When true, getDays()/getDay() include `hijri` on each day.
+     * @default false
+     */
+    enrichDays?: boolean;
+}
+/**
+ * Islamic (Hijri) calendar plugin for calendaryjs — tabular/civil variant.
+ *
+ * Provides:
+ * - a `hijri` event type (recurring by Hijri month/day, resolved to Gregorian)
+ * - an optional day enricher adding `hijri` info to CalendarDay (opt-in via enrichDays)
+ *
+ * @example
+ * ```typescript
+ * const cal = calendary().use(hijri());
+ * cal.addGroup({
+ *   id: "islamic",
+ *   name: "Islamic",
+ *   events: [{ type: "hijri", id: "eid-al-fitr", title: "Eid al-Fitr", hijriMonth: 10, hijriDay: 1 }],
+ * });
+ * ```
+ */
+declare function hijriPlugin(options?: HijriPluginOptions): CalendaryPlugin;
+/**
+ * The hijri plugin, plus a builder selector:
+ * - `calendary().use(hijri())` registers the `hijri` event type.
+ * - `every("year").on(hijri.date(9, 1))` authors a hijri event via the builder.
+ */
+declare const hijri: typeof hijriPlugin & {
+    /** Builder selector for a hijri date — `every("year").on(hijri.date(9, 1))`. */
+    date(month: number, day: number): Selector;
+};
+
+/**
+ * Module augmentation for CalendarDay.
+ * When this plugin is imported, TypeScript recognizes the optional `hijri` property
+ * on CalendarDay objects returned by getDays() and getDay().
+ */
+declare module "calendaryjs" {
+    interface CalendarDay {
+        /** Hijri date information (available when the hijri plugin is used with enrichDays: true) */
+        hijri?: HijriInfo;
+    }
+}
+/** Calendar date representation (year, month, day). */
+interface CalendarDate {
+    year: number;
+    month: number;
+    day: number;
+}
+/** Gregorian (solar) date. */
+type GregorianDate = CalendarDate;
+/** Hijri (Islamic) date. */
+type HijriDate = CalendarDate;
+/**
+ * Hijri event configuration. The developer provides hijriMonth + hijriDay; the
+ * plugin resolves the Gregorian date(s) at which it falls in a queried year.
+ * @template TMetadata - Custom metadata type extending Record<string, unknown>
+ */
+interface HijriEvent<TMetadata extends Record<string, unknown> = Record<string, unknown>> extends BaseEventProperties<TMetadata> {
+    type: "hijri";
+    hijriMonth: number;
+    hijriDay: number;
+}
+
+/** Convert a Gregorian date to its tabular Hijri date. */
+declare function gregorianToHijri(g: GregorianDate): HijriDate;
+/** Convert a tabular Hijri date to its Gregorian date. */
+declare function hijriToGregorian(h: HijriDate): GregorianDate;
+/** Whether a Hijri year is a leap year (355 days) in the 30-year tabular cycle. */
+declare function isHijriLeapYear(year: number): boolean;
+/** Number of days in a Hijri month (1–12). */
+declare function hijriMonthLength(year: number, month: number): number;
+/** Whether a Hijri date is structurally valid. */
+declare function isValidHijriDate(h: HijriDate): boolean;
+
+export { type CalendarDate, type CalendarDayWithHijri, type GregorianDate, type HijriDate, type HijriEvent, type HijriInfo, type HijriPluginOptions, gregorianToHijri, hijri, hijriMonthLength, hijriToGregorian, isHijriLeapYear, isValidHijriDate };

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { CalendarDay, CalendaryPlugin, BaseEventProperties } from 'calendaryjs';
+import { Selector } from 'calendaryjs/builder';
+
+/** Hijri date info added by the hijri plugin. */
+interface HijriInfo {
+    year: number;
+    month: number;
+    day: number;
+}
+/** CalendarDay with hijri enrichment. */
+interface CalendarDayWithHijri extends CalendarDay {
+    hijri: HijriInfo;
+}
+/** Options for the hijri plugin. */
+interface HijriPluginOptions {
+    /**
+     * Whether to enrich days with Hijri date information.
+     * When true, getDays()/getDay() include `hijri` on each day.
+     * @default false
+     */
+    enrichDays?: boolean;
+}
+/**
+ * Islamic (Hijri) calendar plugin for calendaryjs — tabular/civil variant.
+ *
+ * Provides:
+ * - a `hijri` event type (recurring by Hijri month/day, resolved to Gregorian)
+ * - an optional day enricher adding `hijri` info to CalendarDay (opt-in via enrichDays)
+ *
+ * @example
+ * ```typescript
+ * const cal = calendary().use(hijri());
+ * cal.addGroup({
+ *   id: "islamic",
+ *   name: "Islamic",
+ *   events: [{ type: "hijri", id: "eid-al-fitr", title: "Eid al-Fitr", hijriMonth: 10, hijriDay: 1 }],
+ * });
+ * ```
+ */
+declare function hijriPlugin(options?: HijriPluginOptions): CalendaryPlugin;
+/**
+ * The hijri plugin, plus a builder selector:
+ * - `calendary().use(hijri())` registers the `hijri` event type.
+ * - `every("year").on(hijri.date(9, 1))` authors a hijri event via the builder.
+ */
+declare const hijri: typeof hijriPlugin & {
+    /** Builder selector for a hijri date — `every("year").on(hijri.date(9, 1))`. */
+    date(month: number, day: number): Selector;
+};
+
+/**
+ * Module augmentation for CalendarDay.
+ * When this plugin is imported, TypeScript recognizes the optional `hijri` property
+ * on CalendarDay objects returned by getDays() and getDay().
+ */
+declare module "calendaryjs" {
+    interface CalendarDay {
+        /** Hijri date information (available when the hijri plugin is used with enrichDays: true) */
+        hijri?: HijriInfo;
+    }
+}
+/** Calendar date representation (year, month, day). */
+interface CalendarDate {
+    year: number;
+    month: number;
+    day: number;
+}
+/** Gregorian (solar) date. */
+type GregorianDate = CalendarDate;
+/** Hijri (Islamic) date. */
+type HijriDate = CalendarDate;
+/**
+ * Hijri event configuration. The developer provides hijriMonth + hijriDay; the
+ * plugin resolves the Gregorian date(s) at which it falls in a queried year.
+ * @template TMetadata - Custom metadata type extending Record<string, unknown>
+ */
+interface HijriEvent<TMetadata extends Record<string, unknown> = Record<string, unknown>> extends BaseEventProperties<TMetadata> {
+    type: "hijri";
+    hijriMonth: number;
+    hijriDay: number;
+}
+
+/** Convert a Gregorian date to its tabular Hijri date. */
+declare function gregorianToHijri(g: GregorianDate): HijriDate;
+/** Convert a tabular Hijri date to its Gregorian date. */
+declare function hijriToGregorian(h: HijriDate): GregorianDate;
+/** Whether a Hijri year is a leap year (355 days) in the 30-year tabular cycle. */
+declare function isHijriLeapYear(year: number): boolean;
+/** Number of days in a Hijri month (1–12). */
+declare function hijriMonthLength(year: number, month: number): number;
+/** Whether a Hijri date is structurally valid. */
+declare function isValidHijriDate(h: HijriDate): boolean;
+
+export { type CalendarDate, type CalendarDayWithHijri, type GregorianDate, type HijriDate, type HijriEvent, type HijriInfo, type HijriPluginOptions, gregorianToHijri, hijri, hijriMonthLength, hijriToGregorian, isHijriLeapYear, isValidHijriDate };

package/dist/index.js

@@ -0,0 +1,105 @@
+// package.json
+var package_default = {
+  name: "calendaryjs-plugin-hijri",
+  version: "0.1.0"};
+
+// src/converter.ts
+var ISLAMIC_EPOCH = 1948440;
+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;
+}
+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);
+  return {
+    year: 100 * b + d - 4800 + Math.floor(m / 10),
+    month: m + 3 - 12 * Math.floor(m / 10),
+    day: e - Math.floor((153 * m + 2) / 5) + 1
+  };
+}
+function hijriToJDN(year, month, day) {
+  return day + Math.ceil(29.5 * (month - 1)) + (year - 1) * 354 + Math.floor((3 + 11 * year) / 30) + ISLAMIC_EPOCH - 1;
+}
+function gregorianToHijri(g) {
+  const jdn = gregorianToJDN(g.year, g.month, g.day);
+  const year = Math.floor((30 * (jdn - ISLAMIC_EPOCH) + 10646) / 10631);
+  const month = Math.min(12, Math.ceil((jdn - (29 + hijriToJDN(year, 1, 1))) / 29.5) + 1);
+  const day = jdn - hijriToJDN(year, month, 1) + 1;
+  return { year, month, day };
+}
+function hijriToGregorian(h) {
+  return jdnToGregorian(hijriToJDN(h.year, h.month, h.day));
+}
+function isHijriLeapYear(year) {
+  return (11 * year + 14) % 30 < 11;
+}
+function hijriMonthLength(year, month) {
+  if (month % 2 === 1) return 30;
+  if (month === 12 && isHijriLeapYear(year)) return 30;
+  return 29;
+}
+function isValidHijriDate(h) {
+  if (h.month < 1 || h.month > 12) return false;
+  if (h.day < 1 || h.day > hijriMonthLength(h.year, h.month)) return false;
+  return true;
+}
+
+// src/generator.ts
+var hijriEventHandler = {
+  validate(event) {
+    if (typeof event !== "object" || event === null) return false;
+    const e = event;
+    return e.type === "hijri" && typeof e.hijriMonth === "number" && e.hijriMonth >= 1 && e.hijriMonth <= 12 && typeof e.hijriDay === "number" && e.hijriDay >= 1 && e.hijriDay <= 30 && typeof e.title === "string" && typeof e.id === "string";
+  },
+  generate(event, gregorianYear) {
+    const e = event;
+    const dates = [];
+    const hyStart = gregorianToHijri({ year: gregorianYear, month: 1, day: 1 }).year;
+    const hyEnd = gregorianToHijri({ year: gregorianYear, month: 12, day: 31 }).year;
+    for (let hy = hyStart; hy <= hyEnd; hy++) {
+      const g = hijriToGregorian({ year: hy, month: e.hijriMonth, day: e.hijriDay });
+      if (g.year === gregorianYear) dates.push(new Date(g.year, g.month - 1, g.day));
+    }
+    return dates;
+  }
+};
+
+// src/plugin.ts
+var hijriDayEnricher = {
+  name: "hijri",
+  priority: 10,
+  enrich: (day) => {
+    const h = gregorianToHijri({ year: day.year, month: day.month, day: day.day });
+    return { ...day, hijri: { year: h.year, month: h.month, day: h.day } };
+  }
+};
+function hijriPlugin(options = {}) {
+  const { enrichDays = false } = options;
+  return {
+    name: package_default.name,
+    version: package_default.version,
+    install(calendary) {
+      if (enrichDays) {
+        calendary.registerDayEnricher(hijriDayEnricher);
+      }
+    },
+    eventTypes: {
+      hijri: hijriEventHandler
+    }
+  };
+}
+var hijri = Object.assign(hijriPlugin, {
+  /** Builder selector for a hijri date — `every("year").on(hijri.date(9, 1))`. */
+  date(month, day) {
+    return { type: "hijri", fields: { hijriMonth: month, hijriDay: day } };
+  }
+});
+
+export { gregorianToHijri, hijri, hijriMonthLength, hijriToGregorian, isHijriLeapYear, isValidHijriDate };

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "calendaryjs-plugin-hijri",
+  "version": "0.1.0",
+  "description": "Islamic (Hijri) calendar plugin for calendaryjs — Gregorian ↔ Hijri date conversion (tabular/civil) and Hijri recurring events.",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "keywords": [
+    "hijri",
+    "islamic-calendar",
+    "islamic",
+    "hijra",
+    "ramadan",
+    "calendar",
+    "calendaryjs",
+    "calendaryjs-plugin",
+    "plugin"
+  ],
+  "calendaryjs": {
+    "category": "calendar"
+  },
+  "author": "calendaryjs",
+  "license": "MIT",
+  "peerDependencies": {
+    "calendaryjs": ">=0.1.0"
+  },
+  "devDependencies": {
+    "moment-hijri": "^3.0.0",
+    "typescript": "^5.3.2",
+    "vitest": "^4.0.18",
+    "calendaryjs": "0.2.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "tsup": {
+    "entry": [
+      "src/index.ts"
+    ],
+    "format": [
+      "esm",
+      "cjs"
+    ],
+    "dts": true,
+    "clean": true,
+    "treeshake": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/calendaryjs/calendaryjs.git",
+    "directory": "packages/hijri"
+  },
+  "homepage": "https://github.com/calendaryjs/calendaryjs/tree/main/packages/hijri#readme",
+  "bugs": {
+    "url": "https://github.com/calendaryjs/calendaryjs/issues"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsup",
+    "test:coverage": "vitest run --coverage"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}