@nextera.one/tps-standard 0.5.33 → 0.6.0

package/src/drivers/hijri.ts

@@ -10,7 +10,9 @@
  * This uses the Tabular Islamic Calendar (civil/Type II-A) algorithm
  * based on the formulas from Meeus "Astronomical Algorithms".
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import { gregorianToHijri, hijriToGregorian } from "../utils/calendar";
 
 export class HijriDriver implements CalendarDriver {
   readonly code = "hij";
@@ -56,15 +58,8 @@ export class HijriDriver implements CalendarDriver {
     "as-Sabt",
   ];
 
-  /** Leap years in a 30-year cycle (civil / Type II-A pattern) */
-  private readonly LEAP_YEARS_IN_CYCLE = new Set([
-    2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29,
-  ]);
-
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const { hy, hm, hd } = this.gregorianToHijri(
+    const { hy, hm, hd } = gregorianToHijri(
       date.getUTCFullYear(),
       date.getUTCMonth() + 1,
       date.getUTCDate(),
@@ -96,7 +91,7 @@ export class HijriDriver implements CalendarDriver {
     }
     const hm = components.month ?? 1;
     const hd = components.day ?? 1;
-    const { gy, gm, gd } = this.hijriToGregorian(hy, hm, hd);
+    const { gy, gm, gd } = hijriToGregorian(hy, hm, hd);
 
     return new Date(
       Date.UTC(
@@ -113,7 +108,7 @@ export class HijriDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
   parseDate(input: string, format?: string): Partial<TPSComponents> {
@@ -166,9 +161,8 @@ export class HijriDriver implements CalendarDriver {
       fullYear = components.year ?? 0;
     }
 
-    if (format === "short") {
+    if (format === "short")
       return `${components.day}/${pad(components.month)}/${fullYear}`;
-    }
     if (format === "long") {
       const mn = this.MONTH_NAMES[(components.month ?? 1) - 1];
       return `${components.day} ${mn} ${fullYear}`;
@@ -192,7 +186,6 @@ export class HijriDriver implements CalendarDriver {
       comp = input;
     }
     const { year, month, day } = comp;
-    // Reconstruct full year for leap check
     let fullYear: number;
     if (comp.millennium !== undefined) {
       fullYear =
@@ -205,7 +198,12 @@ export class HijriDriver implements CalendarDriver {
     if (fullYear < 1) return false;
     if (!month || month < 1 || month > 12) return false;
     if (!day || day < 1) return false;
-    const maxDays = this.daysInMonth(fullYear, month);
+
+    // leap check (cycle of 30 years)
+    const isLeap = new Set([2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29]).has(
+      ((fullYear - 1) % 30) + 1,
+    );
+    const maxDays = month === 12 && isLeap ? 30 : month % 2 === 1 ? 30 : 29;
     return day <= maxDays;
   }
 
@@ -221,102 +219,4 @@ export class HijriDriver implements CalendarDriver {
       epochYear: 1,
     };
   }
-
-  // ── Internal helpers ──────────────────────────────────────────────────
-
-  private isLeapYear(year: number): boolean {
-    return this.LEAP_YEARS_IN_CYCLE.has(((year - 1) % 30) + 1);
-  }
-
-  private daysInMonth(year: number, month: number): number {
-    if (month === 12 && this.isLeapYear(year)) return 30;
-    return month % 2 === 1 ? 30 : 29;
-  }
-
-  // ── Gregorian ↔ Hijri (Tabular algorithm from Meeus) ──────────────────
-
-  /**
-   * Convert Gregorian to Hijri (Tabular Islamic Calendar).
-   * Algorithm from "Astronomical Algorithms" by Jean Meeus.
-   */
-  private gregorianToHijri(
-    gy: number,
-    gm: number,
-    gd: number,
-  ): { hy: number; hm: number; hd: number } {
-    // Step 1: Gregorian → JDN
-    const jdn = this.gregorianToJdn(gy, gm, gd);
-    // Step 2: JDN → Hijri
-    // L = JDN − 1948440 + 10632
-    const L = jdn - 1948440 + 10632;
-    // N = floor((L − 1) / 10631)
-    const N = Math.floor((L - 1) / 10631);
-    // L = L − 10631 × N + 354
-    const L2 = L - 10631 * N + 354;
-    // J = floor((10985 − L2) / 5316) × floor((50×L2) / 17719) + floor(L2 / 5670) × floor((43×L2) / 15238)
-    const J =
-      Math.floor((10985 - L2) / 5316) * Math.floor((50 * L2) / 17719) +
-      Math.floor(L2 / 5670) * Math.floor((43 * L2) / 15238);
-    // L3 = L2 − floor((30 − J) / 15) × floor((17719 × J) / 50) − floor(J / 16) × floor((15238 × J) / 43) + 29
-    const L3 =
-      L2 -
-      Math.floor((30 - J) / 15) * Math.floor((17719 * J) / 50) -
-      Math.floor(J / 16) * Math.floor((15238 * J) / 43) +
-      29;
-    const hm = Math.floor((24 * L3) / 709);
-    const hd = L3 - Math.floor((709 * hm) / 24);
-    const hy = 30 * N + J - 30;
-    return { hy, hm, hd };
-  }
-
-  /**
-   * Convert Hijri to Gregorian.
-   */
-  private hijriToGregorian(
-    hy: number,
-    hm: number,
-    hd: number,
-  ): { gy: number; gm: number; gd: number } {
-    // Hijri → JDN
-    const jdn =
-      Math.floor((11 * hy + 3) / 30) +
-      354 * hy +
-      30 * hm -
-      Math.floor((hm - 1) / 2) +
-      hd +
-      1948440 -
-      385;
-    // JDN → Gregorian
-    return this.jdnToGregorian(jdn);
-  }
-
-  // ── JDN helpers ───────────────────────────────────────────────────────
-
-  private gregorianToJdn(gy: number, gm: number, gd: number): number {
-    const a = Math.floor((14 - gm) / 12);
-    const y = gy + 4800 - a;
-    const m = gm + 12 * a - 3;
-    return (
-      gd +
-      Math.floor((153 * m + 2) / 5) +
-      365 * y +
-      Math.floor(y / 4) -
-      Math.floor(y / 100) +
-      Math.floor(y / 400) -
-      32045
-    );
-  }
-
-  private jdnToGregorian(jdn: number): { gy: number; gm: number; gd: number } {
-    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 gd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const gm = m + 3 - 12 * Math.floor(m / 10);
-    const gy = 100 * b + d - 4800 + Math.floor(m / 10);
-    return { gy, gm, gd };
-  }
 }

package/src/drivers/holocene.ts

@@ -9,9 +9,13 @@
  *
  * This is a thin wrapper around GregorianDriver with a year offset.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
 import { GregorianDriver } from "./gregorian";
 
+/**
+ * Holocene (Human Era) Calendar Driver
+ */
 export class HoloceneDriver implements CalendarDriver {
   readonly code = "holo";
   readonly name = "Holocene (Human Era)";
@@ -19,8 +23,6 @@ export class HoloceneDriver implements CalendarDriver {
   private readonly gregorian = new GregorianDriver();
   private readonly YEAR_OFFSET = 10000;
 
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
     const greg = this.gregorian.getComponentsFromDate(date);
     const fullYear = date.getUTCFullYear() + this.YEAR_OFFSET;
@@ -57,21 +59,20 @@ export class HoloceneDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
-  parseDate(input: string, format?: string): Partial<TPSComponents> {
-    // Accept ISO-like: "12026-01-09" (Holocene year)
+  parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const m = input
       .trim()
       .match(
         /^(\d{4,5})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
       );
-    if (!m) {
+    if (!m)
       throw new Error(
         `HoloceneDriver.parseDate: unsupported format "${input}"`,
       );
-    }
+
     const result: Partial<TPSComponents> = {
       calendar: this.code,
       year: parseInt(m[1], 10),
@@ -86,9 +87,8 @@ export class HoloceneDriver implements CalendarDriver {
     return result;
   }
 
-  format(components: Partial<TPSComponents>, format?: string): string {
+  format(components: Partial<TPSComponents>, _format?: string): string {
     const pad = (n?: number, w = 2) => String(n ?? 0).padStart(w, "0");
-    // Reconstruct full Holocene year from components
     let holoYear: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -117,7 +117,6 @@ export class HoloceneDriver implements CalendarDriver {
       );
     }
     if (typeof input === "object") {
-      // Delegate day/month validation to Gregorian (same structure)
       return this.gregorian.validate({
         year: input.year,
         month: input.month,
@@ -146,7 +145,7 @@ export class HoloceneDriver implements CalendarDriver {
       ],
       isLunar: false,
       monthsPerYear: 12,
-      epochYear: -10000, // 10001 BCE
+      epochYear: -10000,
     };
   }
 }

package/src/drivers/julian.ts

@@ -9,7 +9,14 @@
  *
  * Conversion uses Julian Day Number algorithms.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import {
+  gregorianToJdn,
+  jdnToGregorian,
+  julianToJdn,
+  jdnToJulian,
+} from "../utils/calendar";
 
 export class JulianDriver implements CalendarDriver {
   readonly code = "jul";
@@ -49,15 +56,13 @@ export class JulianDriver implements CalendarDriver {
     31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
   ];
 
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const jdn = this.gregorianToJdn(
+    const jdn = gregorianToJdn(
       date.getUTCFullYear(),
       date.getUTCMonth() + 1,
       date.getUTCDate(),
     );
-    const { jy, jm, jd } = this.jdnToJulian(jdn);
+    const { jy, jm, jd } = jdnToJulian(jdn);
 
     return {
       calendar: this.code,
@@ -85,8 +90,8 @@ export class JulianDriver implements CalendarDriver {
     }
     const jm = components.month ?? 1;
     const jd = components.day ?? 1;
-    const jdn = this.julianToJdn(fullYear, jm, jd);
-    const { gy, gm, gd } = this.jdnToGregorian(jdn);
+    const jdn = julianToJdn(fullYear, jm, jd);
+    const { gy, gm, gd } = jdnToGregorian(jdn);
 
     return new Date(
       Date.UTC(
@@ -103,17 +108,17 @@ export class JulianDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
-  parseDate(input: string, format?: string): Partial<TPSComponents> {
+  parseDate(input: string, _format?: string): Partial<TPSComponents> {
     const trimmed = input.trim();
     const m = trimmed.match(
       /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/,
     );
-    if (!m) {
+    if (!m)
       throw new Error(`JulianDriver.parseDate: unsupported format "${input}"`);
-    }
+
     const fullYear = parseInt(m[1], 10);
     const result: Partial<TPSComponents> = {
       calendar: this.code,
@@ -131,7 +136,7 @@ export class JulianDriver implements CalendarDriver {
     return result;
   }
 
-  format(components: Partial<TPSComponents>, format?: string): string {
+  format(components: Partial<TPSComponents>, _format?: string): string {
     const pad = (n?: number, w = 2) => String(n ?? 0).padStart(w, "0");
     let fullYear: number;
     if (components.millennium !== undefined) {
@@ -164,7 +169,6 @@ export class JulianDriver implements CalendarDriver {
       );
     }
     if (typeof input === "object") {
-      // Reconstruct full year for leap check
       let fullYear: number;
       if (input.millennium !== undefined) {
         fullYear =
@@ -178,7 +182,7 @@ export class JulianDriver implements CalendarDriver {
       if (month === undefined || day === undefined) return false;
       if (month < 1 || month > 12 || day < 1) return false;
       let maxDay = this.DAYS_IN_MONTH[month - 1];
-      if (month === 2 && this.isLeapYear(fullYear)) maxDay = 29;
+      if (month === 2 && fullYear % 4 === 0) maxDay = 29;
       return day <= maxDay;
     }
     return false;
@@ -194,62 +198,4 @@ export class JulianDriver implements CalendarDriver {
       epochYear: 1,
     };
   }
-
-  // ── Internal helpers ──────────────────────────────────────────────────
-
-  /** Julian leap year: every 4 years, no century exception */
-  private isLeapYear(year: number): boolean {
-    return year % 4 === 0;
-  }
-
-  // ── JDN algorithms ────────────────────────────────────────────────────
-
-  private julianToJdn(jy: number, jm: number, jd: number): number {
-    const a = Math.floor((14 - jm) / 12);
-    const y = jy + 4800 - a;
-    const m = jm + 12 * a - 3;
-    return (
-      jd + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - 32083
-    );
-  }
-
-  private jdnToJulian(jdn: number): { jy: number; jm: number; jd: number } {
-    const c = jdn + 32082;
-    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 jd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const jm = m + 3 - 12 * Math.floor(m / 10);
-    const jy = d - 4800 + Math.floor(m / 10);
-    return { jy, jm, jd };
-  }
-
-  /** Gregorian → JDN (for converting incoming Gregorian Date) */
-  private gregorianToJdn(gy: number, gm: number, gd: number): number {
-    const a = Math.floor((14 - gm) / 12);
-    const y = gy + 4800 - a;
-    const m = gm + 12 * a - 3;
-    return (
-      gd +
-      Math.floor((153 * m + 2) / 5) +
-      365 * y +
-      Math.floor(y / 4) -
-      Math.floor(y / 100) +
-      Math.floor(y / 400) -
-      32045
-    );
-  }
-
-  private jdnToGregorian(jdn: number): { gy: number; gm: number; gd: number } {
-    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 gd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const gm = m + 3 - 12 * Math.floor(m / 10);
-    const gy = 100 * b + d - 4800 + Math.floor(m / 10);
-    return { gy, gm, gd };
-  }
 }

package/src/drivers/persian.ts

@@ -9,7 +9,14 @@
  *
  * Conversion uses Julian Day Number algorithms based on jalaali-js.
  */
-import { CalendarDriver, CalendarMetadata, TPSComponents, TPS } from "../index";
+import { CalendarDriver, CalendarMetadata, TPSComponents } from "../types";
+import { buildTimePart } from "../utils/tps-string";
+import {
+  gregorianToJdn,
+  jdnToGregorian,
+  persianToJdn,
+  jdnToPersian,
+} from "../utils/calendar";
 
 export class PersianDriver implements CalendarDriver {
   readonly code = "per";
@@ -60,15 +67,13 @@ export class PersianDriver implements CalendarDriver {
     31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29,
   ];
 
-  // ── CalendarDriver interface ──────────────────────────────────────────
-
   getComponentsFromDate(date: Date): Partial<TPSComponents> {
-    const jdn = this.gregorianToJdn(
+    const jdn = gregorianToJdn(
       date.getUTCFullYear(),
       date.getUTCMonth() + 1,
       date.getUTCDate(),
     );
-    const { jy, jm, jd } = this.jdnToPersian(jdn);
+    const { jy, jm, jd } = jdnToPersian(jdn);
 
     return {
       calendar: this.code,
@@ -85,7 +90,6 @@ export class PersianDriver implements CalendarDriver {
   }
 
   getDateFromComponents(components: Partial<TPSComponents>): Date {
-    // Reconstruct full Persian year from millennium/century/year if available
     let jy: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -97,8 +101,8 @@ export class PersianDriver implements CalendarDriver {
     }
     const jm = components.month ?? 1;
     const jd = components.day ?? 1;
-    const jdn = this.persianToJdn(jy, jm, jd);
-    const { gy, gm, gd } = this.jdnToGregorian(jdn);
+    const jdn = persianToJdn(jy, jm, jd);
+    const { gy, gm, gd } = jdnToGregorian(jdn);
 
     return new Date(
       Date.UTC(
@@ -115,13 +119,12 @@ export class PersianDriver implements CalendarDriver {
 
   getFromDate(date: Date): string {
     const comp = this.getComponentsFromDate(date) as TPSComponents;
-    return TPS.buildTimePart(comp);
+    return buildTimePart(comp);
   }
 
   parseDate(input: string, format?: string): Partial<TPSComponents> {
     const trimmed = input.trim();
 
-    // Short format: 19/10/1404 or 1404/10/19
     if (
       format === "short" ||
       (trimmed.includes("/") && trimmed.split("/")[0].length <= 2)
@@ -143,7 +146,6 @@ export class PersianDriver implements CalendarDriver {
       };
     }
 
-    // ISO-like: 1404-10-19 [HH:MM:SS]
     const segments = trimmed.split(/[\s,T]+/);
     const [parsedYear, month, day] = segments[0].split(/[-/]/).map(Number);
     const result: Partial<TPSComponents> = { calendar: this.code };
@@ -165,7 +167,6 @@ export class PersianDriver implements CalendarDriver {
 
   format(components: Partial<TPSComponents>, format?: string): string {
     const pad = (n?: number) => String(n ?? 0).padStart(2, "0");
-    // Reconstruct full year from millennium/century/year
     let fullYear: number;
     if (components.millennium !== undefined) {
       const m = components.millennium ?? 0;
@@ -176,9 +177,8 @@ export class PersianDriver implements CalendarDriver {
       fullYear = components.year ?? 0;
     }
 
-    if (format === "short") {
+    if (format === "short")
       return `${components.day}/${pad(components.month)}/${fullYear}`;
-    }
     if (format === "long") {
       const mn = this.MONTH_NAMES[(components.month ?? 1) - 1];
       return `${components.day} ${mn} ${fullYear}`;
@@ -202,11 +202,17 @@ export class PersianDriver implements CalendarDriver {
       comp = input;
     }
     const { year, month, day } = comp;
-    if (!year || year < 1) return false;
-    if (!month || month < 1 || month > 12) return false;
-    if (!day || day < 1) return false;
-    let max = this.DAYS_IN_MONTH[(month ?? 1) - 1];
-    if (month === 12 && this.isLeapYear(year)) max = 30;
+    if (year === undefined || year < 1) return false;
+    if (month === undefined || month < 1 || month > 12) return false;
+    if (day === undefined || day < 1) return false;
+
+    // leap check
+    const leapYears = [1, 5, 9, 13, 17, 22, 26, 30];
+    const cycle = ((year - 1) % 33) + 1;
+    const isLeap = leapYears.includes(cycle);
+
+    let max = this.DAYS_IN_MONTH[month - 1];
+    if (month === 12 && isLeap) max = 30;
     return day <= max;
   }
 
@@ -222,77 +228,4 @@ export class PersianDriver implements CalendarDriver {
       epochYear: 622,
     };
   }
-
-  // ── Internal: leap year (33-year cycle) ───────────────────────────────
-
-  private isLeapYear(year: number): boolean {
-    const leapYears = [1, 5, 9, 13, 17, 22, 26, 30];
-    const cycle = ((year - 1) % 33) + 1;
-    return leapYears.includes(cycle);
-  }
-
-  // ── Internal: Julian Day Number algorithms ────────────────────────────
-
-  private gregorianToJdn(gy: number, gm: number, gd: number): number {
-    const a = Math.floor((14 - gm) / 12);
-    const y = gy + 4800 - a;
-    const m = gm + 12 * a - 3;
-    return (
-      gd +
-      Math.floor((153 * m + 2) / 5) +
-      365 * y +
-      Math.floor(y / 4) -
-      Math.floor(y / 100) +
-      Math.floor(y / 400) -
-      32045
-    );
-  }
-
-  private jdnToGregorian(jdn: number): { gy: number; gm: number; gd: number } {
-    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 gd = e - Math.floor((153 * m + 2) / 5) + 1;
-    const gm = m + 3 - 12 * Math.floor(m / 10);
-    const gy = 100 * b + d - 4800 + Math.floor(m / 10);
-    return { gy, gm, gd };
-  }
-
-  private persianToJdn(jy: number, jm: number, jd: number): number {
-    const EPOCH = 1948320;
-    const epbase = jy - (jy >= 0 ? 474 : 473);
-    const epyear = 474 + (epbase % 2820);
-    return (
-      jd +
-      (jm <= 7 ? (jm - 1) * 31 : (jm - 1) * 30 + 6) +
-      Math.floor((epyear * 682 - 110) / 2816) +
-      (epyear - 1) * 365 +
-      Math.floor(epbase / 2820) * 1029983 +
-      EPOCH -
-      1
-    );
-  }
-
-  private jdnToPersian(jdn: number): { jy: number; jm: number; jd: number } {
-    const depoch = jdn - this.persianToJdn(475, 1, 1);
-    const cycle = Math.floor(depoch / 1029983);
-    const cyear = depoch % 1029983;
-    let ycycle: number;
-    if (cyear === 1029982) {
-      ycycle = 2820;
-    } else {
-      const aux1 = Math.floor(cyear / 366);
-      const aux2 = cyear % 366;
-      ycycle =
-        Math.floor((2134 * aux1 + 2816 * aux2 + 2815) / 1028522) + aux1 + 1;
-    }
-    const jy = ycycle + 2820 * cycle + 474;
-    const yday = jdn - this.persianToJdn(jy, 1, 1) + 1;
-    const jm = yday <= 186 ? Math.ceil(yday / 31) : Math.ceil((yday - 6) / 30);
-    const jd = jdn - this.persianToJdn(jy, jm, 1) + 1;
-    return { jy: jy <= 0 ? jy - 1 : jy, jm, jd };
-  }
 }