{"version":3,"file":"index.cjs","names":["gyOrDate: number | Date","gm?: number","gd?: number","jy: number","jm: number","jd: number","jdn: number","gy: number","gm: number","gd: number","h: number","m: number","s: number","ms: number","jp: number","jump: number","n: number","a: number","b: number"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * **jalaali-js** — Conversions between the Jalaali (Persian) and Gregorian\n * calendar systems.\n *\n * The conversion algorithm is the one published by Kazimierz M. Borkowski\n * in *The Persian calendar for 3000 years* (1996); it is exact within the\n * Jalaali year range `-61 … 3177` inclusive. Outside that range the\n * functions in this module throw {@link RangeError}.\n *\n * The Borkowski algorithm diverges from the leap-year rule used by the\n * ECMAScript `Intl` API (`en-US-u-ca-persian`) after Gregorian year 2256\n * (Jalaali 1634). Inside the range `1800 … 2256` the two agree exactly.\n *\n * @see https://www.astro.uni.torun.pl/~kb/Papers/EMP/PersianC-EMP.htm\n * @packageDocumentation\n */\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/** A date in the Jalaali (Persian) calendar. */\nexport interface JalaaliDate {\n  /** Jalaali year (`-61 … 3177`). */\n  jy: number\n  /** Jalaali month (`1 … 12`; 1 = Farvardin). */\n  jm: number\n  /** Jalaali day of month (`1 … 31`). */\n  jd: number\n}\n\n/** A date in the Gregorian (proleptic) calendar. */\nexport interface GregorianDate {\n  /** Gregorian year. BC years are numbered `0, -1, -2, …`. */\n  gy: number\n  /** Gregorian month (`1 … 12`). */\n  gm: number\n  /** Gregorian day of month (`1 … 31`). */\n  gd: number\n}\n\n/** Full result of {@link jalCal}. */\nexport interface JalCalResult {\n  /**\n   * Number of years since the last leap year (`0 … 4`).\n   * `0` means the year *is* a leap year.\n   */\n  leap: number\n  /** Gregorian year of the beginning of the Jalaali year. */\n  gy: number\n  /** Day of March (Gregorian) on which Farvardin 1 falls. */\n  march: number\n}\n\n/** Slim result of {@link jalCalShort} — omits the leap-cycle computation. */\nexport interface JalCalShortResult {\n  /** Gregorian year of the beginning of the Jalaali year. */\n  gy: number\n  /** Day of March (Gregorian) on which Farvardin 1 falls. */\n  march: number\n}\n\n/** Bounds of a Jalaali week, returned by {@link jalaaliWeek}. */\nexport interface JalaaliWeek {\n  /** Saturday of the containing Jalaali week. */\n  saturday: JalaaliDate\n  /** Friday of the containing Jalaali week. */\n  friday: JalaaliDate\n}\n\n// ---------------------------------------------------------------------------\n// Constants\n// ---------------------------------------------------------------------------\n\n/**\n * Jalaali years that begin a new 33-year leap cycle. Used by the\n * Borkowski algorithm to locate the correct cycle for any given year.\n */\nconst BREAKS = [\n  -61, 9, 38, 199, 426, 686, 756, 818, 1111, 1181,\n  1210, 1635, 2060, 2097, 2192, 2262, 2324, 2394, 2456, 3178,\n] as const\n\n/** Minimum supported Jalaali year (inclusive). */\nexport const MIN_JALAALI_YEAR = BREAKS[0]\n\n/** Maximum supported Jalaali year (inclusive). */\nexport const MAX_JALAALI_YEAR = BREAKS[BREAKS.length - 1] - 1\n\n// ---------------------------------------------------------------------------\n// High-level conversions\n// ---------------------------------------------------------------------------\n\n/**\n * Converts a Gregorian date to Jalaali.\n *\n * Two call forms are supported: individual Gregorian components, or a\n * `Date` object whose **local-time** year/month/day are read. If you need\n * UTC semantics, build the Gregorian components from `Date.prototype.getUTC*`\n * yourself and pass them in.\n *\n * @example\n * toJalaali(2016, 4, 11)            // { jy: 1395, jm: 1, jd: 23 }\n * toJalaali(new Date(2016, 3, 11))  // { jy: 1395, jm: 1, jd: 23 }\n *\n * @throws {RangeError} if the resulting Jalaali year falls outside\n *   `[-61, 3177]`. In practice this means a Gregorian year roughly outside\n *   `[560, 3798]`.\n */\nexport function toJalaali(date: Date): JalaaliDate\nexport function toJalaali(gy: number, gm: number, gd: number): JalaaliDate\nexport function toJalaali(\n  gyOrDate: number | Date,\n  gm?: number,\n  gd?: number,\n): JalaaliDate {\n  if (gyOrDate instanceof Date) {\n    return d2j(\n      g2d(gyOrDate.getFullYear(), gyOrDate.getMonth() + 1, gyOrDate.getDate()),\n    )\n  }\n  return d2j(g2d(gyOrDate, gm as number, gd as number))\n}\n\n/**\n * Converts a Jalaali date to Gregorian.\n *\n * @example\n * toGregorian(1395, 1, 23) // { gy: 2016, gm: 4, gd: 11 }\n *\n * @throws {RangeError} if `jy` falls outside `[-61, 3177]`.\n */\nexport function toGregorian(jy: number, jm: number, jd: number): GregorianDate {\n  return d2g(j2d(jy, jm, jd))\n}\n\n// ---------------------------------------------------------------------------\n// Validity and leap-year helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Returns `true` if `(jy, jm, jd)` is a real date in the Jalaali calendar.\n *\n * The check is **lenient** — non-integer inputs that happen to fall inside\n * the allowed numeric ranges are accepted. Pass integers in production code.\n *\n * @example\n * isValidJalaaliDate(1394, 12, 30) // false (1394 is a common year)\n * isValidJalaaliDate(1395, 12, 30) // true  (1395 is leap)\n */\nexport function isValidJalaaliDate(jy: number, jm: number, jd: number): boolean {\n  return (\n    jy >= MIN_JALAALI_YEAR && jy <= MAX_JALAALI_YEAR &&\n    jm >= 1 && jm <= 12 &&\n    jd >= 1 && jd <= jalaaliMonthLength(jy, jm)\n  )\n}\n\n/**\n * Returns `true` if the given Jalaali year is leap (366 days).\n *\n * @example\n * isLeapJalaaliYear(1394) // false\n * isLeapJalaaliYear(1395) // true\n *\n * @throws {RangeError} if `jy` falls outside `[-61, 3177]`.\n */\nexport function isLeapJalaaliYear(jy: number): boolean {\n  return jalCalLeap(jy) === 0\n}\n\n/**\n * Returns the number of days in the given Jalaali month.\n *\n * The function trusts its inputs: `jm` is not range-checked, and an\n * out-of-range `jm` will return whichever branch happens to match.\n * For input validation, use {@link isValidJalaaliDate} instead.\n *\n * @example\n * jalaaliMonthLength(1394, 12) // 29 (common year)\n * jalaaliMonthLength(1395, 12) // 30 (leap year)\n */\nexport function jalaaliMonthLength(jy: number, jm: number): number {\n  if (jm <= 6) return 31\n  if (jm <= 11) return 30\n  return isLeapJalaaliYear(jy) ? 30 : 29\n}\n\n// ---------------------------------------------------------------------------\n// Calendar-cycle helpers (low-level)\n// ---------------------------------------------------------------------------\n\n/**\n * Computes the leap-cycle state of a Jalaali year and the Gregorian date\n * of Farvardin 1 in that year.\n *\n * Use this directly when you need the leap field; if you only need\n * `{ gy, march }`, prefer {@link jalCalShort}.\n *\n * @example\n * jalCal(1391) // { leap: 0, gy: 2012, march: 20 }\n * jalCal(1395) // { leap: 0, gy: 2016, march: 20 }\n *\n * @throws {RangeError} if `jy` falls outside `[-61, 3177]`.\n */\nexport function jalCal(jy: number): JalCalResult {\n  const { gy, march, jump, n } = jalCalCore(jy)\n  return { leap: leapFromCycle(jump, n), gy, march }\n}\n\n/**\n * Like {@link jalCal} but omits the leap-cycle computation.\n *\n * @remarks\n * Equivalent to v1's `jalCal(jy, true)` — extracted to its own export\n * in v2 to give it a proper return type. Prefer this when the leap field\n * isn't needed; it avoids a small amount of work per call.\n *\n * @example\n * jalCalShort(1391) // { gy: 2012, march: 20 }\n *\n * @throws {RangeError} if `jy` falls outside `[-61, 3177]`.\n */\nexport function jalCalShort(jy: number): JalCalShortResult {\n  const { gy, march } = jalCalCore(jy)\n  return { gy, march }\n}\n\n// ---------------------------------------------------------------------------\n// Julian Day number conversions\n// ---------------------------------------------------------------------------\n\n/**\n * Converts a Jalaali date to a Julian Day number.\n *\n * The result is an integer corresponding to noon UT on the given calendar\n * day. Inputs are not range-checked — pass valid dates.\n *\n * @example\n * j2d(1395, 1, 23) // 2457490\n */\nexport function j2d(jy: number, jm: number, jd: number): number {\n  const r = jalCalShort(jy)\n  return g2d(r.gy, 3, r.march) + (jm - 1) * 31 - div(jm, 7) * (jm - 7) + jd - 1\n}\n\n/**\n * Converts a Julian Day number to a Jalaali date.\n *\n * @example\n * d2j(2457490) // { jy: 1395, jm: 1, jd: 23 }\n */\nexport function d2j(jdn: number): JalaaliDate {\n  // Walk to the Gregorian year, then convert to its Jalaali counterpart.\n  const gy = d2g(jdn).gy\n  let jy = gy - 621\n  const r = jalCal(jy)\n  const jdn1f = g2d(gy, 3, r.march)\n\n  // Days since Farvardin 1.\n  let k = jdn - jdn1f\n  if (k >= 0) {\n    if (k <= 185) {\n      // First six months are 31 days each.\n      return { jy, jm: 1 + div(k, 31), jd: mod(k, 31) + 1 }\n    }\n    // The remaining months are 30 days each.\n    k -= 186\n  } else {\n    // The JDN falls in the *previous* Jalaali year.\n    jy -= 1\n    k += 179\n    if (r.leap === 1) k += 1\n  }\n  return { jy, jm: 7 + div(k, 30), jd: mod(k, 30) + 1 }\n}\n\n/**\n * Converts a Gregorian date to a Julian Day number.\n *\n * Tested correct from 1 March, -100100 (of both calendars) through several\n * million years into the future.\n *\n * @example\n * g2d(2016, 4, 11) // 2457490\n */\nexport function g2d(gy: number, gm: number, gd: number): number {\n  let d =\n    div((gy + div(gm - 8, 6) + 100100) * 1461, 4) +\n    div(153 * mod(gm + 9, 12) + 2, 5) +\n    gd -\n    34840408\n  d = d - div(div(gy + 100100 + div(gm - 8, 6), 100) * 3, 4) + 752\n  return d\n}\n\n/**\n * Converts a Julian Day number to a Gregorian date.\n *\n * Valid for `jdn ≥ -34839655` (year -100100 of both calendars).\n *\n * @example\n * d2g(2457490) // { gy: 2016, gm: 4, gd: 11 }\n */\nexport function d2g(jdn: number): GregorianDate {\n  let j = 4 * jdn + 139361631\n  j = j + div(div(4 * jdn + 183187720, 146097) * 3, 4) * 4 - 3908\n  const i = div(mod(j, 1461), 4) * 5 + 308\n  const gd = div(mod(i, 153), 5) + 1\n  const gm = mod(div(i, 153), 12) + 1\n  const gy = div(j, 1461) - 100100 + div(8 - gm, 6)\n  return { gy, gm, gd }\n}\n\n// ---------------------------------------------------------------------------\n// Interoperability with JavaScript's `Date`\n// ---------------------------------------------------------------------------\n\n/**\n * Converts a Jalaali date (optionally with a time of day) to a JavaScript\n * `Date` constructed in the local time zone.\n *\n * Time components default to `0`. Out-of-range time components are *not*\n * clamped — they overflow the way the `Date` constructor handles them\n * (e.g. `h = 25` rolls into the next day).\n *\n * @example\n * jalaaliToDateObject(1400, 4, 30)\n *   // → new Date(2021, 6, 21, 0, 0, 0, 0)\n *\n * jalaaliToDateObject(1400, 4, 30, 14, 30)\n *   // → new Date(2021, 6, 21, 14, 30)\n */\nexport function jalaaliToDateObject(\n  jy: number,\n  jm: number,\n  jd: number,\n  h: number = 0,\n  m: number = 0,\n  s: number = 0,\n  ms: number = 0,\n): Date {\n  const g = toGregorian(jy, jm, jd)\n  return new Date(g.gy, g.gm - 1, g.gd, h, m, s, ms)\n}\n\n/**\n * Returns the Saturday and Friday bounding the Jalaali week that contains\n * the given date. The Jalaali week starts on **Saturday**.\n *\n * @example\n * jalaaliWeek(1400, 4, 30)\n *   // → { saturday: { jy: 1400, jm: 4, jd: 26 },\n *   //     friday:   { jy: 1400, jm: 5, jd:  1 } }\n *\n * @remarks\n * Uses {@link jalaaliToDateObject} to read the day-of-week, which reflects\n * the host's local time zone. For dates near a DST boundary the underlying\n * `Date.getDay()` is still correct because the conversion is done in local\n * time on both sides.\n */\nexport function jalaaliWeek(jy: number, jm: number, jd: number): JalaaliWeek {\n  const dayOfWeek = jalaaliToDateObject(jy, jm, jd).getDay()\n  // getDay(): Sunday = 0, Monday = 1, …, Saturday = 6.\n  // The Jalaali week starts on Saturday, so we count back to it.\n  const startDayDifference = dayOfWeek === 6 ? 0 : -(dayOfWeek + 1)\n  const endDayDifference = 6 + startDayDifference\n  return {\n    saturday: d2j(j2d(jy, jm, jd + startDayDifference)),\n    friday: d2j(j2d(jy, jm, jd + endDayDifference)),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Internals\n// ---------------------------------------------------------------------------\n\ninterface JalCalCore {\n  gy: number\n  march: number\n  /** Length of the current 33-year-aligned cycle. */\n  jump: number\n  /** Year offset within the current cycle. */\n  n: number\n}\n\n/**\n * Core of the Borkowski algorithm: locate the Jalaali year inside the\n * cycle table and compute Farvardin 1's Gregorian date.\n */\nfunction jalCalCore(jy: number): JalCalCore {\n  if (!Number.isFinite(jy) || jy < MIN_JALAALI_YEAR || jy > MAX_JALAALI_YEAR) {\n    throw new RangeError(\n      `Invalid Jalaali year ${jy}: must be a finite number between ${MIN_JALAALI_YEAR} and ${MAX_JALAALI_YEAR} (inclusive)`,\n    )\n  }\n\n  const gy = jy + 621\n  let leapJ = -14\n  let jp: number = BREAKS[0]\n  let jm = 0\n  let jump = 0\n\n  // Find the limiting years for the Jalaali year `jy`.\n  for (let i = 1; i < BREAKS.length; i += 1) {\n    jm = BREAKS[i] as number\n    jump = jm - jp\n    if (jy < jm) break\n    leapJ = leapJ + div(jump, 33) * 8 + div(mod(jump, 33), 4)\n    jp = jm\n  }\n  const n = jy - jp\n\n  // Number of Persian-calendar leap years from AD 621 to the start of `jy`.\n  leapJ = leapJ + div(n, 33) * 8 + div(mod(n, 33) + 3, 4)\n  if (mod(jump, 33) === 4 && jump - n === 4) leapJ += 1\n\n  // Same count for the Gregorian calendar up to year `gy`.\n  const leapG = div(gy, 4) - div((div(gy, 100) + 1) * 3, 4) - 150\n\n  // Gregorian date (March day) of Farvardin 1.\n  const march = 20 + leapJ - leapG\n\n  return { gy, march, jump, n }\n}\n\n/**\n * Given a 33-year cycle length `jump` and the year offset `n` within that\n * cycle, returns the number of years since the last leap year (`0 … 4`).\n * `0` means the current year is leap.\n */\nfunction leapFromCycle(jump: number, n: number): number {\n  let adjusted = n\n  if (jump - n < 6) {\n    adjusted = n - jump + div(jump + 4, 33) * 33\n  }\n  let leap = mod(mod(adjusted + 1, 33) - 1, 4)\n  if (leap === -1) leap = 4\n  return leap\n}\n\n/**\n * Leap-only variant — same loop as {@link jalCalCore} without computing\n * the Gregorian fields. Kept separate to avoid the per-call object\n * allocation on the hot `isLeapJalaaliYear` path.\n */\nfunction jalCalLeap(jy: number): number {\n  if (!Number.isFinite(jy) || jy < MIN_JALAALI_YEAR || jy > MAX_JALAALI_YEAR) {\n    throw new RangeError(\n      `Invalid Jalaali year ${jy}: must be a finite number between ${MIN_JALAALI_YEAR} and ${MAX_JALAALI_YEAR} (inclusive)`,\n    )\n  }\n\n  let jp: number = BREAKS[0]\n  let jm = 0\n  let jump = 0\n  for (let i = 1; i < BREAKS.length; i += 1) {\n    jm = BREAKS[i] as number\n    jump = jm - jp\n    if (jy < jm) break\n    jp = jm\n  }\n  return leapFromCycle(jump, jy - jp)\n}\n\n/**\n * Integer division — `Math.trunc(a / b)` equivalent that's faster on V8\n * for values that fit in 32 bits. Used pervasively inside the algorithm.\n */\nfunction div(a: number, b: number): number {\n  return ~~(a / b)\n}\n\n/**\n * Mathematical modulo — like `%` but always returns a non-negative result\n * when `b` is positive (matches Python's `%` semantics, not JavaScript's).\n */\nfunction mod(a: number, b: number): number {\n  return a - ~~(a / b) * b\n}\n"],"mappings":"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"}