@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.1

package/date/calendars/EthiopicCalendar.js

@@ -0,0 +1,178 @@
+// Ported from @internationalized/date src/calendars/EthiopicCalendar.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// Portions of the code in this file are based on code from ICU.
+// Original licensing can be found in the NOTICE file in the root directory of this source tree.
+import {} from "../types.js";
+import { CalendarDate } from "../CalendarDate.js";
+import {} from "../utils.js";
+const ETHIOPIC_EPOCH = 1723856;
+const COPTIC_EPOCH = 1824665;
+// The delta between Amete Alem 1 and Amete Mihret 1
+// AA 5501 = AM 1
+const AMETE_MIHRET_DELTA = 5500;
+function ceToJulianDay(epoch, year, month, day) {
+    return (epoch + // difference from Julian epoch to 1,1,1
+        365 * year + // number of days from years
+        Math.floor(year / 4) + // extra day of leap year
+        30 * (month - 1) + // number of days from months (1 based)
+        day -
+        1 // number of days for present month (1 based)
+    );
+}
+function julianDayToCE(epoch, jd) {
+    let year = Math.floor((4 * (jd - epoch)) / 1461);
+    // Years are 365 * year + floor(year / 4) days long, slightly less than the
+    // 365.25 day average assumed by the estimate above. As a result, the estimate
+    // can be one year too low on the first day of a year (3 of every 4 years).
+    if (jd >= ceToJulianDay(epoch, year + 1, 1, 1)) {
+        year++;
+    }
+    let month = 1 + Math.floor((jd - ceToJulianDay(epoch, year, 1, 1)) / 30);
+    let day = jd + 1 - ceToJulianDay(epoch, year, month, 1);
+    return [year, month, day];
+}
+function getLeapDay(year) {
+    return Math.floor((year % 4) / 3);
+}
+function getDaysInMonth(year, month) {
+    // The Ethiopian and Coptic calendars have 13 months, 12 of 30 days each and
+    // an intercalary month at the end of the year of 5 or 6 days, depending whether
+    // the year is a leap year or not. The Leap Year follows the same rules as the
+    // Julian Calendar so that the extra month always has six days in the year before
+    // a Julian Leap Year.
+    if (month % 13 !== 0) {
+        // not intercalary month
+        return 30;
+    }
+    else {
+        // intercalary month 5 days + possible leap day
+        return getLeapDay(year) + 5;
+    }
+}
+/**
+ * The Ethiopic calendar system is the official calendar used in Ethiopia.
+ * It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+ * on whether it is a leap year. Two eras are supported: 'AA' and 'AM'.
+ */
+export class EthiopicCalendar {
+    identifier = 'ethiopic';
+    fromJulianDay(jd) {
+        let [year, month, day] = julianDayToCE(ETHIOPIC_EPOCH, jd);
+        let era = 'AM';
+        if (year <= 0) {
+            era = 'AA';
+            year += AMETE_MIHRET_DELTA;
+        }
+        return new CalendarDate(this, era, year, month, day);
+    }
+    toJulianDay(date) {
+        let year = date.year;
+        if (date.era === 'AA') {
+            year -= AMETE_MIHRET_DELTA;
+        }
+        return ceToJulianDay(ETHIOPIC_EPOCH, year, date.month, date.day);
+    }
+    getDaysInMonth(date) {
+        return getDaysInMonth(date.year, date.month);
+    }
+    getMonthsInYear() {
+        return 13;
+    }
+    getDaysInYear(date) {
+        return 365 + getLeapDay(date.year);
+    }
+    getMaximumMonthsInYear() {
+        return 13;
+    }
+    getMaximumDaysInMonth() {
+        return 30;
+    }
+    getYearsInEra(date) {
+        // 9999-12-31 gregorian is 9992-20-02 ethiopic.
+        // Round down to 9991 for the last full year.
+        // AA 9999-01-01 ethiopic is 4506-09-30 gregorian.
+        return date.era === 'AA' ? 9999 : 9991;
+    }
+    getEras() {
+        return ['AA', 'AM'];
+    }
+}
+/**
+ * The Ethiopic (Amete Alem) calendar is the same as the modern Ethiopic calendar,
+ * except years were measured from a different epoch. Only one era is supported: 'AA'.
+ */
+export class EthiopicAmeteAlemCalendar extends EthiopicCalendar {
+    identifier = 'ethioaa'; // also known as 'ethiopic-amete-alem' in ICU
+    fromJulianDay(jd) {
+        let [year, month, day] = julianDayToCE(ETHIOPIC_EPOCH, jd);
+        year += AMETE_MIHRET_DELTA;
+        return new CalendarDate(this, 'AA', year, month, day);
+    }
+    getEras() {
+        return ['AA'];
+    }
+    getYearsInEra() {
+        // 9999-13-04 ethioaa is the maximum date, which is equivalent to 4506-09-29 gregorian.
+        return 9999;
+    }
+}
+/**
+ * The Coptic calendar is similar to the Ethiopic calendar.
+ * It includes 12 months of 30 days each, plus 5 or 6 intercalary days depending
+ * on whether it is a leap year. Two eras are supported: 'BCE' and 'CE'.
+ */
+export class CopticCalendar extends EthiopicCalendar {
+    identifier = 'coptic';
+    fromJulianDay(jd) {
+        let [year, month, day] = julianDayToCE(COPTIC_EPOCH, jd);
+        let era = 'CE';
+        if (year <= 0) {
+            era = 'BCE';
+            year = 1 - year;
+        }
+        return new CalendarDate(this, era, year, month, day);
+    }
+    toJulianDay(date) {
+        let year = date.year;
+        if (date.era === 'BCE') {
+            year = 1 - year;
+        }
+        return ceToJulianDay(COPTIC_EPOCH, year, date.month, date.day);
+    }
+    getDaysInMonth(date) {
+        let year = date.year;
+        if (date.era === 'BCE') {
+            year = 1 - year;
+        }
+        return getDaysInMonth(year, date.month);
+    }
+    isInverseEra(date) {
+        return date.era === 'BCE';
+    }
+    balanceDate(date) {
+        if (date.year <= 0) {
+            date.era = date.era === 'BCE' ? 'CE' : 'BCE';
+            date.year = 1 - date.year;
+        }
+    }
+    getEras() {
+        return ['BCE', 'CE'];
+    }
+    getYearsInEra(date) {
+        // 9999-12-30 gregorian is 9716-02-20 coptic.
+        // Round down to 9715 for the last full year.
+        // BCE 9999-01-01 coptic is BC 9716-06-15 gregorian.
+        return date.era === 'BCE' ? 9999 : 9715;
+    }
+}

package/date/calendars/GregorianCalendar.d.ts

@@ -0,0 +1,26 @@
+import { type AnyCalendarDate, type Calendar, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { type Mutable } from '../utils.js';
+export declare function gregorianToJulianDay(era: string, year: number, month: number, day: number): number;
+export declare function isLeapYear(year: number): boolean;
+export declare function getExtendedYear(era: string, year: number): number;
+export declare function fromExtendedYear(year: number): [string, number];
+/**
+ * The Gregorian calendar is the most commonly used calendar system in the world. It supports two
+ * eras: BC, and AD. Years always contain 12 months, and 365 or 366 days depending on whether it is
+ * a leap year.
+ */
+export declare class GregorianCalendar implements Calendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getMonthsInYear(date: AnyCalendarDate): number;
+    getDaysInYear(date: AnyCalendarDate): number;
+    getMaximumMonthsInYear(): number;
+    getMaximumDaysInMonth(): number;
+    getYearsInEra(date: AnyCalendarDate): number;
+    getEras(): string[];
+    isInverseEra(date: AnyCalendarDate): boolean;
+    balanceDate(date: Mutable<AnyCalendarDate>): void;
+}

package/date/calendars/GregorianCalendar.js

@@ -0,0 +1,122 @@
+// Ported from @internationalized/date src/calendars/GregorianCalendar.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// Portions of the code in this file are based on code from ICU.
+// Original licensing can be found in the NOTICE file in the root directory of this source tree.
+import {} from "../types.js";
+import { CalendarDate } from "../CalendarDate.js";
+import { mod } from "../utils.js";
+const EPOCH = 1721426; // 001/01/03 Julian C.E.
+export function gregorianToJulianDay(era, year, month, day) {
+    year = getExtendedYear(era, year);
+    let y1 = year - 1;
+    let monthOffset = -2;
+    if (month <= 2) {
+        monthOffset = 0;
+    }
+    else if (isLeapYear(year)) {
+        monthOffset = -1;
+    }
+    return (EPOCH -
+        1 +
+        365 * y1 +
+        Math.floor(y1 / 4) -
+        Math.floor(y1 / 100) +
+        Math.floor(y1 / 400) +
+        Math.floor((367 * month - 362) / 12 + monthOffset + day));
+}
+export function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+export function getExtendedYear(era, year) {
+    return era === 'BC' ? 1 - year : year;
+}
+export function fromExtendedYear(year) {
+    let era = 'AD';
+    if (year <= 0) {
+        era = 'BC';
+        year = 1 - year;
+    }
+    return [era, year];
+}
+const daysInMonth = {
+    standard: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
+    leapyear: [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+};
+/**
+ * The Gregorian calendar is the most commonly used calendar system in the world. It supports two
+ * eras: BC, and AD. Years always contain 12 months, and 365 or 366 days depending on whether it is
+ * a leap year.
+ */
+export class GregorianCalendar {
+    identifier = 'gregory';
+    fromJulianDay(jd) {
+        let jd0 = jd;
+        let depoch = jd0 - EPOCH;
+        let quadricent = Math.floor(depoch / 146097);
+        let dqc = mod(depoch, 146097);
+        let cent = Math.floor(dqc / 36524);
+        let dcent = mod(dqc, 36524);
+        let quad = Math.floor(dcent / 1461);
+        let dquad = mod(dcent, 1461);
+        let yindex = Math.floor(dquad / 365);
+        let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
+        let [era, year] = fromExtendedYear(extendedYear);
+        let yearDay = jd0 - gregorianToJulianDay(era, year, 1, 1);
+        let leapAdj = 2;
+        if (jd0 < gregorianToJulianDay(era, year, 3, 1)) {
+            leapAdj = 0;
+        }
+        else if (isLeapYear(year)) {
+            leapAdj = 1;
+        }
+        let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
+        let day = jd0 - gregorianToJulianDay(era, year, month, 1) + 1;
+        return new CalendarDate(era, year, month, day);
+    }
+    toJulianDay(date) {
+        return gregorianToJulianDay(date.era, date.year, date.month, date.day);
+    }
+    getDaysInMonth(date) {
+        return daysInMonth[isLeapYear(date.year) ? 'leapyear' : 'standard'][date.month - 1];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getMonthsInYear(date) {
+        return 12;
+    }
+    getDaysInYear(date) {
+        return isLeapYear(date.year) ? 366 : 365;
+    }
+    getMaximumMonthsInYear() {
+        return 12;
+    }
+    getMaximumDaysInMonth() {
+        return 31;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getYearsInEra(date) {
+        return 9999;
+    }
+    getEras() {
+        return ['BC', 'AD'];
+    }
+    isInverseEra(date) {
+        return date.era === 'BC';
+    }
+    balanceDate(date) {
+        if (date.year <= 0) {
+            date.era = date.era === 'BC' ? 'AD' : 'BC';
+            date.year = 1 - date.year;
+        }
+    }
+}

package/date/calendars/HebrewCalendar.d.ts

@@ -0,0 +1,21 @@
+import { type AnyCalendarDate, type Calendar, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { type Mutable } from '../utils.js';
+/**
+ * The Hebrew calendar is used in Israel and around the world by the Jewish faith.
+ * Years include either 12 or 13 months depending on whether it is a leap year.
+ * In leap years, an extra month is inserted at month 6.
+ */
+export declare class HebrewCalendar implements Calendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getMonthsInYear(date: AnyCalendarDate): number;
+    getDaysInYear(date: AnyCalendarDate): number;
+    getMaximumMonthsInYear(): number;
+    getMaximumDaysInMonth(): number;
+    getYearsInEra(): number;
+    getEras(): string[];
+    balanceYearMonth(date: Mutable<AnyCalendarDate>, previousDate: AnyCalendarDate): void;
+}

package/date/calendars/HebrewCalendar.js

@@ -0,0 +1,174 @@
+// Ported from @internationalized/date src/calendars/HebrewCalendar.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// Portions of the code in this file are based on code from ICU.
+// Original licensing can be found in the NOTICE file in the root directory of this source tree.
+import {} from "../types.js";
+import { CalendarDate } from "../CalendarDate.js";
+import { mod } from "../utils.js";
+const HEBREW_EPOCH = 347997;
+// Hebrew date calculations are performed in terms of days, hours, and
+// "parts" (or halakim), which are 1/1080 of an hour, or 3 1/3 seconds.
+const HOUR_PARTS = 1080;
+const DAY_PARTS = 24 * HOUR_PARTS;
+// An approximate value for the length of a lunar month.
+// It is used to calculate the approximate year and month of a given
+// absolute date.
+const MONTH_DAYS = 29;
+const MONTH_FRACT = 12 * HOUR_PARTS + 793;
+const MONTH_PARTS = MONTH_DAYS * DAY_PARTS + MONTH_FRACT;
+function isLeapYear(year) {
+    return mod(year * 7 + 1, 19) < 7;
+}
+// Test for delay of start of new year and to avoid
+// Sunday, Wednesday, and Friday as start of the new year.
+function hebrewDelay1(year) {
+    let months = Math.floor((235 * year - 234) / 19);
+    let parts = 12084 + 13753 * months;
+    let day = months * 29 + Math.floor(parts / 25920);
+    if (mod(3 * (day + 1), 7) < 3) {
+        day += 1;
+    }
+    return day;
+}
+// Check for delay in start of new year due to length of adjacent years
+function hebrewDelay2(year) {
+    let last = hebrewDelay1(year - 1);
+    let present = hebrewDelay1(year);
+    let next = hebrewDelay1(year + 1);
+    if (next - present === 356) {
+        return 2;
+    }
+    if (present - last === 382) {
+        return 1;
+    }
+    return 0;
+}
+function startOfYear(year) {
+    return hebrewDelay1(year) + hebrewDelay2(year);
+}
+function getDaysInYear(year) {
+    return startOfYear(year + 1) - startOfYear(year);
+}
+function getYearType(year) {
+    let yearLength = getDaysInYear(year);
+    if (yearLength > 380) {
+        yearLength -= 30; // Subtract length of leap month.
+    }
+    switch (yearLength) {
+        case 353:
+            return 0; // deficient
+        case 354:
+            return 1; // normal
+        case 355:
+            return 2; // complete
+    }
+}
+function getDaysInMonth(year, month) {
+    // Normalize month numbers from 1 - 13, even on non-leap years
+    if (month >= 6 && !isLeapYear(year)) {
+        month++;
+    }
+    // First of all, dispose of fixed-length 29 day months
+    if (month === 4 || month === 7 || month === 9 || month === 11 || month === 13) {
+        return 29;
+    }
+    let yearType = getYearType(year);
+    // If it's Heshvan, days depend on length of year
+    if (month === 2) {
+        return yearType === 2 ? 30 : 29;
+    }
+    // Similarly, Kislev varies with the length of year
+    if (month === 3) {
+        return yearType === 0 ? 29 : 30;
+    }
+    // Adar I only exists in leap years
+    if (month === 6) {
+        return isLeapYear(year) ? 30 : 0;
+    }
+    return 30;
+}
+/**
+ * The Hebrew calendar is used in Israel and around the world by the Jewish faith.
+ * Years include either 12 or 13 months depending on whether it is a leap year.
+ * In leap years, an extra month is inserted at month 6.
+ */
+export class HebrewCalendar {
+    identifier = 'hebrew';
+    fromJulianDay(jd) {
+        let d = jd - HEBREW_EPOCH;
+        let m = (d * DAY_PARTS) / MONTH_PARTS; // Months (approx)
+        let year = Math.floor((19 * m + 234) / 235) + 1; // Years (approx)
+        let ys = startOfYear(year); // 1st day of year
+        let dayOfYear = Math.floor(d - ys);
+        // Because of the postponement rules, it's possible to guess wrong.  Fix it.
+        while (dayOfYear < 1) {
+            year--;
+            ys = startOfYear(year);
+            dayOfYear = Math.floor(d - ys);
+        }
+        // Now figure out which month we're in, and the date within that month
+        let month = 1;
+        let monthStart = 0;
+        while (monthStart < dayOfYear) {
+            monthStart += getDaysInMonth(year, month);
+            month++;
+        }
+        month--;
+        monthStart -= getDaysInMonth(year, month);
+        let day = dayOfYear - monthStart;
+        return new CalendarDate(this, year, month, day);
+    }
+    toJulianDay(date) {
+        let jd = startOfYear(date.year);
+        for (let month = 1; month < date.month; month++) {
+            jd += getDaysInMonth(date.year, month);
+        }
+        return jd + date.day + HEBREW_EPOCH;
+    }
+    getDaysInMonth(date) {
+        return getDaysInMonth(date.year, date.month);
+    }
+    getMonthsInYear(date) {
+        return isLeapYear(date.year) ? 13 : 12;
+    }
+    getDaysInYear(date) {
+        return getDaysInYear(date.year);
+    }
+    getMaximumMonthsInYear() {
+        return 13;
+    }
+    getMaximumDaysInMonth() {
+        return 30;
+    }
+    getYearsInEra() {
+        // 6239 gregorian
+        return 9999;
+    }
+    getEras() {
+        return ['AM'];
+    }
+    balanceYearMonth(date, previousDate) {
+        // Keep date in the same month when switching between leap years and non leap years
+        if (previousDate.year !== date.year) {
+            if (isLeapYear(previousDate.year) && !isLeapYear(date.year) && previousDate.month > 6) {
+                date.month--;
+            }
+            else if (!isLeapYear(previousDate.year) &&
+                isLeapYear(date.year) &&
+                previousDate.month > 6) {
+                date.month++;
+            }
+        }
+    }
+}

package/date/calendars/IndianCalendar.d.ts

@@ -0,0 +1,17 @@
+import { type AnyCalendarDate, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { GregorianCalendar } from './GregorianCalendar.js';
+/**
+ * The Indian National Calendar is similar to the Gregorian calendar, but with
+ * years numbered since the Saka era in 78 AD (Gregorian). There are 12 months
+ * in each year, with either 30 or 31 days. Only one era identifier is supported: 'saka'.
+ */
+export declare class IndianCalendar extends GregorianCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getYearsInEra(): number;
+    getEras(): string[];
+    balanceDate(): void;
+}

package/date/calendars/IndianCalendar.js

@@ -0,0 +1,111 @@
+// Ported from @internationalized/date src/calendars/IndianCalendar.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+// Portions of the code in this file are based on code from ICU.
+// Original licensing can be found in the NOTICE file in the root directory of this source tree.
+import {} from "../types.js";
+import { CalendarDate } from "../CalendarDate.js";
+import { fromExtendedYear, GregorianCalendar, gregorianToJulianDay, isLeapYear } from "./GregorianCalendar.js";
+// Starts in 78 AD,
+const INDIAN_ERA_START = 78;
+// The Indian year starts 80 days later than the Gregorian year.
+const INDIAN_YEAR_START = 80;
+/**
+ * The Indian National Calendar is similar to the Gregorian calendar, but with
+ * years numbered since the Saka era in 78 AD (Gregorian). There are 12 months
+ * in each year, with either 30 or 31 days. Only one era identifier is supported: 'saka'.
+ */
+export class IndianCalendar extends GregorianCalendar {
+    identifier = 'indian';
+    fromJulianDay(jd) {
+        // Gregorian date for Julian day
+        let date = super.fromJulianDay(jd);
+        // Year in Saka era
+        let indianYear = date.year - INDIAN_ERA_START;
+        // Day number in Gregorian year (starting from 0)
+        let yDay = jd - gregorianToJulianDay(date.era, date.year, 1, 1);
+        let leapMonth;
+        if (yDay < INDIAN_YEAR_START) {
+            //  Day is at the end of the preceding Saka year
+            indianYear--;
+            // Days in leapMonth this year, previous Gregorian year
+            leapMonth = isLeapYear(date.year - 1) ? 31 : 30;
+            yDay += leapMonth + 31 * 5 + 30 * 3 + 10;
+        }
+        else {
+            // Days in leapMonth this year
+            leapMonth = isLeapYear(date.year) ? 31 : 30;
+            yDay -= INDIAN_YEAR_START;
+        }
+        let indianMonth;
+        let indianDay;
+        if (yDay < leapMonth) {
+            indianMonth = 1;
+            indianDay = yDay + 1;
+        }
+        else {
+            let mDay = yDay - leapMonth;
+            if (mDay < 31 * 5) {
+                indianMonth = Math.floor(mDay / 31) + 2;
+                indianDay = (mDay % 31) + 1;
+            }
+            else {
+                mDay -= 31 * 5;
+                indianMonth = Math.floor(mDay / 30) + 7;
+                indianDay = (mDay % 30) + 1;
+            }
+        }
+        return new CalendarDate(this, indianYear, indianMonth, indianDay);
+    }
+    toJulianDay(date) {
+        let extendedYear = date.year + INDIAN_ERA_START;
+        let [era, year] = fromExtendedYear(extendedYear);
+        let leapMonth;
+        let jd;
+        if (isLeapYear(year)) {
+            leapMonth = 31;
+            jd = gregorianToJulianDay(era, year, 3, 21);
+        }
+        else {
+            leapMonth = 30;
+            jd = gregorianToJulianDay(era, year, 3, 22);
+        }
+        if (date.month === 1) {
+            return jd + date.day - 1;
+        }
+        jd += leapMonth + Math.min(date.month - 2, 5) * 31;
+        if (date.month >= 8) {
+            jd += (date.month - 7) * 30;
+        }
+        jd += date.day - 1;
+        return jd;
+    }
+    getDaysInMonth(date) {
+        if (date.month === 1 && isLeapYear(date.year + INDIAN_ERA_START)) {
+            return 31;
+        }
+        if (date.month >= 2 && date.month <= 6) {
+            return 31;
+        }
+        return 30;
+    }
+    getYearsInEra() {
+        // 9999-12-31 gregorian is 9920-10-10 indian.
+        // Round down to 9919 for the last full year.
+        return 9919;
+    }
+    getEras() {
+        return ['saka'];
+    }
+    balanceDate() { }
+}