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

package/date/calendars/IslamicCalendar.d.ts

@@ -0,0 +1,51 @@
+import { type AnyCalendarDate, type Calendar, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The civil variant uses simple arithmetic rules rather than astronomical calculations to
+ * approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+ * Friday, July 16 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+ * days depending on whether it is a leap year. Learn more about the available Islamic calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export declare class IslamicCivilCalendar implements Calendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getMonthsInYear(): number;
+    getDaysInYear(date: AnyCalendarDate): number;
+    getMaximumMonthsInYear(): number;
+    getMaximumDaysInMonth(): number;
+    getYearsInEra(): number;
+    getEras(): string[];
+}
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The tabular variant uses simple arithmetic rules rather than astronomical calculations to
+ * approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+ * Thursday, July 15 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+ * days depending on whether it is a leap year. Learn more about the available Islamic calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export declare class IslamicTabularCalendar extends IslamicCivilCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+}
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The Umalqura variant is primarily used in Saudi Arabia. It is a lunar calendar, based on
+ * astronomical calculations that predict the sighting of a crescent moon. Month and year lengths
+ * vary between years depending on these calculations. Learn more about the available Islamic
+ * calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export declare class IslamicUmalquraCalendar extends IslamicCivilCalendar {
+    identifier: CalendarIdentifier;
+    constructor();
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getDaysInYear(date: AnyCalendarDate): number;
+}

package/date/calendars/IslamicCalendar.js

@@ -0,0 +1,205 @@
+// Ported from @internationalized/date src/calendars/IslamicCalendar.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";
+const CIVIL_EPOC = 1948440; // CE 622 July 16 Friday (Julian calendar) / CE 622 July 19 (Gregorian calendar)
+const ASTRONOMICAL_EPOC = 1948439; // CE 622 July 15 Thursday (Julian calendar)
+const UMALQURA_YEAR_START = 1300;
+const UMALQURA_YEAR_END = 1600;
+const UMALQURA_START_DAYS = 460322;
+function islamicToJulianDay(epoch, year, month, day) {
+    return (day +
+        Math.ceil(29.5 * (month - 1)) +
+        (year - 1) * 354 +
+        Math.floor((3 + 11 * year) / 30) +
+        epoch -
+        1);
+}
+function julianDayToIslamic(calendar, epoch, jd) {
+    let year = Math.floor((30 * (jd - epoch) + 10646) / 10631);
+    let month = Math.min(12, Math.ceil((jd - (29 + islamicToJulianDay(epoch, year, 1, 1))) / 29.5) + 1);
+    let day = jd - islamicToJulianDay(epoch, year, month, 1) + 1;
+    return new CalendarDate(calendar, year, month, day);
+}
+function isLeapYear(year) {
+    return (14 + 11 * year) % 30 < 11;
+}
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The civil variant uses simple arithmetic rules rather than astronomical calculations to
+ * approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+ * Friday, July 16 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+ * days depending on whether it is a leap year. Learn more about the available Islamic calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export class IslamicCivilCalendar {
+    identifier = 'islamic-civil';
+    fromJulianDay(jd) {
+        return julianDayToIslamic(this, CIVIL_EPOC, jd);
+    }
+    toJulianDay(date) {
+        return islamicToJulianDay(CIVIL_EPOC, date.year, date.month, date.day);
+    }
+    getDaysInMonth(date) {
+        let length = 29 + (date.month % 2);
+        if (date.month === 12 && isLeapYear(date.year)) {
+            length++;
+        }
+        return length;
+    }
+    getMonthsInYear() {
+        return 12;
+    }
+    getDaysInYear(date) {
+        return isLeapYear(date.year) ? 355 : 354;
+    }
+    getMaximumMonthsInYear() {
+        return 12;
+    }
+    getMaximumDaysInMonth() {
+        return 30;
+    }
+    getYearsInEra() {
+        // 9999 gregorian
+        return 9665;
+    }
+    getEras() {
+        return ['AH'];
+    }
+}
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The tabular variant uses simple arithmetic rules rather than astronomical calculations to
+ * approximate the traditional calendar, which is based on sighting of the crescent moon. It uses
+ * Thursday, July 15 622 CE (Julian) as the epoch. Each year has 12 months, with either 354 or 355
+ * days depending on whether it is a leap year. Learn more about the available Islamic calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export class IslamicTabularCalendar extends IslamicCivilCalendar {
+    identifier = 'islamic-tbla';
+    fromJulianDay(jd) {
+        return julianDayToIslamic(this, ASTRONOMICAL_EPOC, jd);
+    }
+    toJulianDay(date) {
+        return islamicToJulianDay(ASTRONOMICAL_EPOC, date.year, date.month, date.day);
+    }
+}
+// Generated by scripts/generate-umalqura.js
+const UMALQURA_DATA = 'qgpUDckO1AbqBmwDrQpVBakGkgepC9QF2gpcBS0NlQZKB1QLagutBa4ETwoXBYsGpQbVCtYCWwmdBE0KJg2VDawFtgm6AlsKKwWVCsoG6Qr0AnYJtgJWCcoKpAvSC9kF3AJtCU0FpQpSC6ULtAW2CVcFlwJLBaMGUgdlC2oFqworBZUMSg2lDcoF1gpXCasESwmlClILagt1BXYCtwhbBFUFqQW0BdoJ3QRuAjYJqgpUDbIN1QXaAlsJqwRVCkkLZAtxC7QFtQpVCiUNkg7JDtQG6QprCasEkwpJDaQNsg25CroEWworBZUKKgtVC1wFvQQ9Ah0JlQpKC1oLbQW2AjsJmwRVBqkGVAdqC2wFrQpVBSkLkgupC9QF2gpaBasKlQVJB2QHqgu1BbYCVgpNDiULUgtqC60FrgIvCZcESwalBqwG1gpdBZ0ETQoWDZUNqgW1BdoCWwmtBJUFygbkBuoK9QS2AlYJqgpUC9IL2QXqAm0JrQSVCkoLpQuyBbUJ1gSXCkcFkwZJB1ULagVrCisFiwpGDaMNygXWCtsEawJLCaUKUgtpC3UFdgG3CFsCKwVlBbQF2gntBG0BtgimClINqQ3UBdoKWwmrBFMGKQdiB6kLsgW1ClUFJQuSDckO0gbpCmsFqwRVCikNVA2qDbUJugQ7CpsETQqqCtUK2gJdCV4ELgqaDFUNsga5BroEXQotBZUKUguoC7QLuQXaAloJSgukDdEO6AZqC20FNQWVBkoNqA3UDdoGWwWdAisGFQtKC5ULqgWuCi4JjwwnBZUGqgbWCl0FnQI=';
+let UMALQURA_MONTHLENGTH;
+let UMALQURA_YEAR_START_TABLE;
+function umalquraYearStart(year) {
+    return UMALQURA_START_DAYS + UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START];
+}
+function umalquraMonthLength(year, month) {
+    let idx = year - UMALQURA_YEAR_START;
+    let mask = 0x01 << (11 - (month - 1));
+    if ((UMALQURA_MONTHLENGTH[idx] & mask) === 0) {
+        return 29;
+    }
+    else {
+        return 30;
+    }
+}
+function umalquraMonthStart(year, month) {
+    let day = umalquraYearStart(year);
+    for (let i = 1; i < month; i++) {
+        day += umalquraMonthLength(year, i);
+    }
+    return day;
+}
+function umalquraYearLength(year) {
+    return (UMALQURA_YEAR_START_TABLE[year + 1 - UMALQURA_YEAR_START] -
+        UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START]);
+}
+/**
+ * The Islamic calendar, also known as the "Hijri" calendar, is used throughout much of the Arab
+ * world. The Umalqura variant is primarily used in Saudi Arabia. It is a lunar calendar, based on
+ * astronomical calculations that predict the sighting of a crescent moon. Month and year lengths
+ * vary between years depending on these calculations. Learn more about the available Islamic
+ * calendars
+ * [here](https://cldr.unicode.org/development/development-process/design-proposals/islamic-calendar-types).
+ */
+export class IslamicUmalquraCalendar extends IslamicCivilCalendar {
+    identifier = 'islamic-umalqura';
+    constructor() {
+        super();
+        if (!UMALQURA_MONTHLENGTH) {
+            UMALQURA_MONTHLENGTH = new Uint16Array(Uint8Array.from(atob(UMALQURA_DATA), c => c.charCodeAt(0)).buffer);
+        }
+        if (!UMALQURA_YEAR_START_TABLE) {
+            UMALQURA_YEAR_START_TABLE = new Uint32Array(UMALQURA_YEAR_END - UMALQURA_YEAR_START + 1);
+            let yearStart = 0;
+            for (let year = UMALQURA_YEAR_START; year <= UMALQURA_YEAR_END; year++) {
+                UMALQURA_YEAR_START_TABLE[year - UMALQURA_YEAR_START] = yearStart;
+                for (let i = 1; i <= 12; i++) {
+                    yearStart += umalquraMonthLength(year, i);
+                }
+            }
+        }
+    }
+    fromJulianDay(jd) {
+        let days = jd - CIVIL_EPOC;
+        let startDays = umalquraYearStart(UMALQURA_YEAR_START);
+        let endDays = umalquraYearStart(UMALQURA_YEAR_END);
+        if (days < startDays || days > endDays) {
+            return super.fromJulianDay(jd);
+        }
+        else {
+            let y = UMALQURA_YEAR_START - 1;
+            let m = 1;
+            let d = 1;
+            while (d > 0) {
+                y++;
+                d = days - umalquraYearStart(y) + 1;
+                let yearLength = umalquraYearLength(y);
+                if (d === yearLength) {
+                    m = 12;
+                    break;
+                }
+                else if (d < yearLength) {
+                    let monthLength = umalquraMonthLength(y, m);
+                    m = 1;
+                    while (d > monthLength) {
+                        d -= monthLength;
+                        m++;
+                        monthLength = umalquraMonthLength(y, m);
+                    }
+                    break;
+                }
+            }
+            return new CalendarDate(this, y, m, days - umalquraMonthStart(y, m) + 1);
+        }
+    }
+    toJulianDay(date) {
+        if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) {
+            return super.toJulianDay(date);
+        }
+        return CIVIL_EPOC + umalquraMonthStart(date.year, date.month) + (date.day - 1);
+    }
+    getDaysInMonth(date) {
+        if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) {
+            return super.getDaysInMonth(date);
+        }
+        return umalquraMonthLength(date.year, date.month);
+    }
+    getDaysInYear(date) {
+        if (date.year < UMALQURA_YEAR_START || date.year > UMALQURA_YEAR_END) {
+            return super.getDaysInYear(date);
+        }
+        return umalquraYearLength(date.year);
+    }
+}

package/date/calendars/JapaneseCalendar.d.ts

@@ -0,0 +1,22 @@
+import { type AnyCalendarDate, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { GregorianCalendar } from './GregorianCalendar.js';
+import { type Mutable } from '../utils.js';
+/**
+ * The Japanese calendar is based on the Gregorian calendar, but with eras for the reign of each
+ * Japanese emperor. Whenever a new emperor ascends to the throne, a new era begins and the year
+ * starts again from 1. Note that eras before 1868 (Gregorian) are not currently supported by this
+ * implementation.
+ */
+export declare class JapaneseCalendar extends GregorianCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    balanceDate(date: Mutable<AnyCalendarDate>): void;
+    constrainDate(date: Mutable<AnyCalendarDate>): void;
+    getEras(): string[];
+    getYearsInEra(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getMinimumMonthInYear(date: AnyCalendarDate): number;
+    getMinimumDayInMonth(date: AnyCalendarDate): number;
+}

package/date/calendars/JapaneseCalendar.js

@@ -0,0 +1,148 @@
+// Ported from @internationalized/date src/calendars/JapaneseCalendar.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 the TC39 Temporal proposal.
+// 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 { GregorianCalendar } from "./GregorianCalendar.js";
+import {} from "../utils.js";
+const ERA_START_DATES = [
+    [1868, 9, 8],
+    [1912, 7, 30],
+    [1926, 12, 25],
+    [1989, 1, 8],
+    [2019, 5, 1]
+];
+const ERA_END_DATES = [
+    [1912, 7, 29],
+    [1926, 12, 24],
+    [1989, 1, 7],
+    [2019, 4, 30]
+];
+const ERA_ADDENDS = [1867, 1911, 1925, 1988, 2018];
+const ERA_NAMES = ['meiji', 'taisho', 'showa', 'heisei', 'reiwa'];
+function findEraFromGregorianDate(date) {
+    const idx = ERA_START_DATES.findIndex(([year, month, day]) => {
+        if (date.year < year) {
+            return true;
+        }
+        if (date.year === year && date.month < month) {
+            return true;
+        }
+        if (date.year === year && date.month === month && date.day < day) {
+            return true;
+        }
+        return false;
+    });
+    if (idx === -1) {
+        return ERA_START_DATES.length - 1;
+    }
+    if (idx === 0) {
+        return 0;
+    }
+    return idx - 1;
+}
+function toGregorian(date) {
+    let eraAddend = ERA_ADDENDS[ERA_NAMES.indexOf(date.era)];
+    if (!eraAddend) {
+        throw new Error('Unknown era: ' + date.era);
+    }
+    return new CalendarDate(date.year + eraAddend, date.month, date.day);
+}
+/**
+ * The Japanese calendar is based on the Gregorian calendar, but with eras for the reign of each
+ * Japanese emperor. Whenever a new emperor ascends to the throne, a new era begins and the year
+ * starts again from 1. Note that eras before 1868 (Gregorian) are not currently supported by this
+ * implementation.
+ */
+export class JapaneseCalendar extends GregorianCalendar {
+    identifier = 'japanese';
+    fromJulianDay(jd) {
+        let date = super.fromJulianDay(jd);
+        let era = findEraFromGregorianDate(date);
+        return new CalendarDate(this, ERA_NAMES[era], date.year - ERA_ADDENDS[era], date.month, date.day);
+    }
+    toJulianDay(date) {
+        return super.toJulianDay(toGregorian(date));
+    }
+    balanceDate(date) {
+        let gregorianDate = toGregorian(date);
+        let era = findEraFromGregorianDate(gregorianDate);
+        if (ERA_NAMES[era] !== date.era) {
+            date.era = ERA_NAMES[era];
+            date.year = gregorianDate.year - ERA_ADDENDS[era];
+        }
+        // Constrain in case we went before the first supported era.
+        this.constrainDate(date);
+    }
+    constrainDate(date) {
+        let idx = ERA_NAMES.indexOf(date.era);
+        let end = ERA_END_DATES[idx];
+        if (end != null) {
+            let [endYear, endMonth, endDay] = end;
+            // Constrain the year to the maximum possible value in the era.
+            // Then constrain the month and day fields within that.
+            let maxYear = endYear - ERA_ADDENDS[idx];
+            date.year = Math.max(1, Math.min(maxYear, date.year));
+            if (date.year === maxYear) {
+                date.month = Math.min(endMonth, date.month);
+                if (date.month === endMonth) {
+                    date.day = Math.min(endDay, date.day);
+                }
+            }
+        }
+        if (date.year === 1 && idx >= 0) {
+            let [, startMonth, startDay] = ERA_START_DATES[idx];
+            date.month = Math.max(startMonth, date.month);
+            if (date.month === startMonth) {
+                date.day = Math.max(startDay, date.day);
+            }
+        }
+    }
+    getEras() {
+        return ERA_NAMES;
+    }
+    getYearsInEra(date) {
+        // Get the number of years in the era, taking into account the date's month and day fields.
+        let era = ERA_NAMES.indexOf(date.era);
+        let cur = ERA_START_DATES[era];
+        let next = ERA_START_DATES[era + 1];
+        if (next == null) {
+            // 9999 gregorian is the maximum year allowed.
+            return 9999 - cur[0] + 1;
+        }
+        let years = next[0] - cur[0];
+        if (date.month < next[1] || (date.month === next[1] && date.day < next[2])) {
+            years++;
+        }
+        return years;
+    }
+    getDaysInMonth(date) {
+        return super.getDaysInMonth(toGregorian(date));
+    }
+    getMinimumMonthInYear(date) {
+        let start = getMinimums(date);
+        return start ? start[1] : 1;
+    }
+    getMinimumDayInMonth(date) {
+        let start = getMinimums(date);
+        return start && date.month === start[1] ? start[2] : 1;
+    }
+}
+function getMinimums(date) {
+    if (date.year === 1) {
+        let idx = ERA_NAMES.indexOf(date.era);
+        return ERA_START_DATES[idx];
+    }
+}

package/date/calendars/PersianCalendar.d.ts

@@ -0,0 +1,19 @@
+import { type AnyCalendarDate, type Calendar, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+/**
+ * The Persian calendar is the main calendar used in Iran and Afghanistan. It has 12 months
+ * in each year, the first 6 of which have 31 days, and the next 5 have 30 days. The 12th month
+ * has either 29 or 30 days depending on whether it is a leap year. The Persian year starts
+ * around the March equinox.
+ */
+export declare class PersianCalendar implements Calendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getMonthsInYear(): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getMaximumMonthsInYear(): number;
+    getMaximumDaysInMonth(): number;
+    getEras(): string[];
+    getYearsInEra(): number;
+}

package/date/calendars/PersianCalendar.js

@@ -0,0 +1,85 @@
+// Ported from @internationalized/date src/calendars/PersianCalendar.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 PERSIAN_EPOCH = 1948320;
+// Number of days from the start of the year to the start of each month.
+const MONTH_START = [
+    0, // Farvardin
+    31, // Ordibehesht
+    62, // Khordad
+    93, // Tir
+    124, // Mordad
+    155, // Shahrivar
+    186, // Mehr
+    216, // Aban
+    246, // Azar
+    276, // Dey
+    306, // Bahman
+    336 // Esfand
+];
+/**
+ * The Persian calendar is the main calendar used in Iran and Afghanistan. It has 12 months
+ * in each year, the first 6 of which have 31 days, and the next 5 have 30 days. The 12th month
+ * has either 29 or 30 days depending on whether it is a leap year. The Persian year starts
+ * around the March equinox.
+ */
+export class PersianCalendar {
+    identifier = 'persian';
+    fromJulianDay(jd) {
+        let daysSinceEpoch = jd - PERSIAN_EPOCH;
+        let year = 1 + Math.floor((33 * daysSinceEpoch + 3) / 12053);
+        let farvardin1 = 365 * (year - 1) + Math.floor((8 * year + 21) / 33);
+        let dayOfYear = daysSinceEpoch - farvardin1;
+        let month = dayOfYear < 216 ? Math.floor(dayOfYear / 31) : Math.floor((dayOfYear - 6) / 30);
+        let day = dayOfYear - MONTH_START[month] + 1;
+        return new CalendarDate(this, year, month + 1, day);
+    }
+    toJulianDay(date) {
+        let jd = PERSIAN_EPOCH - 1 + 365 * (date.year - 1) + Math.floor((8 * date.year + 21) / 33);
+        jd += MONTH_START[date.month - 1];
+        jd += date.day;
+        return jd;
+    }
+    getMonthsInYear() {
+        return 12;
+    }
+    getDaysInMonth(date) {
+        if (date.month <= 6) {
+            return 31;
+        }
+        if (date.month <= 11) {
+            return 30;
+        }
+        let isLeapYear = mod(25 * date.year + 11, 33) < 8;
+        return isLeapYear ? 30 : 29;
+    }
+    getMaximumMonthsInYear() {
+        return 12;
+    }
+    getMaximumDaysInMonth() {
+        return 31;
+    }
+    getEras() {
+        return ['AP'];
+    }
+    getYearsInEra() {
+        // 9378-10-10 persian is 9999-12-31 gregorian.
+        // Round down to 9377 to set the maximum full year.
+        return 9377;
+    }
+}

package/date/calendars/TaiwanCalendar.d.ts

@@ -0,0 +1,19 @@
+import { type AnyCalendarDate, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { GregorianCalendar } from './GregorianCalendar.js';
+import { type Mutable } from '../utils.js';
+/**
+ * The Taiwanese calendar is the same as the Gregorian calendar, but years
+ * are numbered starting from 1912 (Gregorian). Two eras are supported:
+ * 'before_minguo' and 'minguo'.
+ */
+export declare class TaiwanCalendar extends GregorianCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getEras(): string[];
+    balanceDate(date: Mutable<AnyCalendarDate>): void;
+    isInverseEra(date: AnyCalendarDate): boolean;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    getYearsInEra(date: AnyCalendarDate): number;
+}

package/date/calendars/TaiwanCalendar.js

@@ -0,0 +1,70 @@
+// Ported from @internationalized/date src/calendars/TaiwanCalendar.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, getExtendedYear, GregorianCalendar } from "./GregorianCalendar.js";
+import {} from "../utils.js";
+const TAIWAN_ERA_START = 1911;
+function gregorianYear(date) {
+    return date.era === 'minguo' ? date.year + TAIWAN_ERA_START : 1 - date.year + TAIWAN_ERA_START;
+}
+function gregorianToTaiwan(year) {
+    let y = year - TAIWAN_ERA_START;
+    if (y > 0) {
+        return ['minguo', y];
+    }
+    else {
+        return ['before_minguo', 1 - y];
+    }
+}
+/**
+ * The Taiwanese calendar is the same as the Gregorian calendar, but years
+ * are numbered starting from 1912 (Gregorian). Two eras are supported:
+ * 'before_minguo' and 'minguo'.
+ */
+export class TaiwanCalendar extends GregorianCalendar {
+    identifier = 'roc'; // Republic of China
+    fromJulianDay(jd) {
+        let date = super.fromJulianDay(jd);
+        let extendedYear = getExtendedYear(date.era, date.year);
+        let [era, year] = gregorianToTaiwan(extendedYear);
+        return new CalendarDate(this, era, year, date.month, date.day);
+    }
+    toJulianDay(date) {
+        return super.toJulianDay(toGregorian(date));
+    }
+    getEras() {
+        return ['before_minguo', 'minguo'];
+    }
+    balanceDate(date) {
+        let [era, year] = gregorianToTaiwan(gregorianYear(date));
+        date.era = era;
+        date.year = year;
+    }
+    isInverseEra(date) {
+        return date.era === 'before_minguo';
+    }
+    getDaysInMonth(date) {
+        return super.getDaysInMonth(toGregorian(date));
+    }
+    getYearsInEra(date) {
+        return date.era === 'before_minguo' ? 9999 : 9999 - TAIWAN_ERA_START;
+    }
+}
+function toGregorian(date) {
+    let [era, year] = fromExtendedYear(gregorianYear(date));
+    return new CalendarDate(era, year, date.month, date.day);
+}

package/date/conversion.d.ts

@@ -0,0 +1,45 @@
+import { type AnyCalendarDate, type AnyDateTime, type AnyTime, type Calendar, type DateFields, type Disambiguation, type TimeFields } from './types.js';
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from './CalendarDate.js';
+export declare function epochFromDate(date: AnyDateTime): number;
+export declare function getTimeZoneOffset(ms: number, timeZone: string): number;
+export declare function possibleAbsolutes(date: CalendarDateTime, timeZone: string): number[];
+export declare function toAbsolute(date: CalendarDate | CalendarDateTime, timeZone: string, disambiguation?: Disambiguation): number;
+export declare function toDate(dateTime: CalendarDate | CalendarDateTime, timeZone: string, disambiguation?: Disambiguation): Date;
+/**
+ * Takes a Unix epoch (milliseconds since 1970) and converts it to the provided time zone.
+ */
+export declare function fromAbsolute(ms: number, timeZone: string): ZonedDateTime;
+/**
+ * Takes a `Date` object and converts it to the provided time zone.
+ */
+export declare function fromDate(date: Date, timeZone: string): ZonedDateTime;
+/**
+ * Takes a `Date` object and converts it to the time zone identifier for the current user.
+ */
+export declare function fromDateToLocal(date: Date): ZonedDateTime;
+/**
+ * Converts a value with date components such as a `CalendarDateTime` or `ZonedDateTime` into a
+ * `CalendarDate`.
+ */
+export declare function toCalendarDate(dateTime: AnyCalendarDate): CalendarDate;
+export declare function toDateFields(date: AnyCalendarDate): DateFields;
+export declare function toTimeFields(date: AnyTime): TimeFields;
+/**
+ * Converts a date value to a `CalendarDateTime`. An optional `Time` value can be passed to set the
+ * time of the resulting value, otherwise it will default to midnight.
+ */
+export declare function toCalendarDateTime(date: CalendarDate | CalendarDateTime | ZonedDateTime, time?: AnyTime): CalendarDateTime;
+/** Extracts the time components from a value containing a date and time. */
+export declare function toTime(dateTime: CalendarDateTime | ZonedDateTime): Time;
+/** Converts a date from one calendar system to another. */
+export declare function toCalendar<T extends AnyCalendarDate>(date: T, calendar: Calendar): T;
+/**
+ * Converts a date value to a `ZonedDateTime` in the provided time zone. The `disambiguation` option
+ * can be set to control how values that fall on daylight saving time changes are interpreted.
+ */
+export declare function toZoned(date: CalendarDate | CalendarDateTime | ZonedDateTime, timeZone: string, disambiguation?: Disambiguation): ZonedDateTime;
+export declare function zonedToDate(date: ZonedDateTime): Date;
+/** Converts a `ZonedDateTime` from one time zone to another. */
+export declare function toTimeZone(date: ZonedDateTime, timeZone: string): ZonedDateTime;
+/** Converts the given `ZonedDateTime` into the user's local time zone. */
+export declare function toLocalTimeZone(date: ZonedDateTime): ZonedDateTime;