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

package/date/CalendarDate.js

@@ -0,0 +1,374 @@
+// Ported from @internationalized/date src/CalendarDate.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.
+ */
+import { add, addTime, addZoned, constrain, constrainTime, cycleDate, cycleTime, cycleZoned, set, setTime, setZoned, subtract, subtractTime, subtractZoned } from "./manipulation.js";
+import {} from "./types.js";
+import { compareDate, compareTime } from "./queries.js";
+import { dateTimeToString, dateToString, timeToString, zonedDateTimeToString } from "./string.js";
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { toCalendarDateTime, toDate, toZoned, zonedToDate } from "./conversion.js";
+function shiftArgs(args) {
+    let calendar = typeof args[0] === 'object' ? args.shift() : new GregorianCalendar();
+    let era;
+    if (typeof args[0] === 'string') {
+        era = args.shift();
+    }
+    else {
+        let eras = calendar.getEras();
+        era = eras[eras.length - 1];
+    }
+    let year = args.shift();
+    let month = args.shift();
+    let day = args.shift();
+    return [calendar, era, year, month, day];
+}
+/** A CalendarDate represents a date without any time components in a specific calendar system. */
+export class CalendarDate {
+    // This prevents TypeScript from allowing other types with the same fields to match.
+    // i.e. a ZonedDateTime should not be be passable to a parameter that expects CalendarDate.
+    // If that behavior is desired, use the AnyCalendarDate interface instead.
+    // @ts-ignore
+    #type;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    era;
+    /** The year of this date within the era. */
+    year;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    month;
+    /** The day number within the month. */
+    day;
+    constructor(...args) {
+        let [calendar, era, year, month, day] = shiftArgs(args);
+        this.calendar = calendar;
+        this.era = era;
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        constrain(this);
+    }
+    /** Returns a copy of this date. */
+    copy() {
+        if (this.era) {
+            return new CalendarDate(this.calendar, this.era, this.year, this.month, this.day);
+        }
+        else {
+            return new CalendarDate(this.calendar, this.year, this.month, this.day);
+        }
+    }
+    /** Returns a new `CalendarDate` with the given duration added to it. */
+    add(duration) {
+        return add(this, duration);
+    }
+    /** Returns a new `CalendarDate` with the given duration subtracted from it. */
+    subtract(duration) {
+        return subtract(this, duration);
+    }
+    /**
+     * Returns a new `CalendarDate` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields) {
+        return set(this, fields);
+    }
+    /**
+     * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field, amount, options) {
+        return cycleDate(this, field, amount, options);
+    }
+    /**
+     * Converts the date to a native JavaScript Date object, with the time set to midnight in the
+     * given time zone.
+     */
+    toDate(timeZone) {
+        return toDate(this, timeZone);
+    }
+    /** Converts the date to an ISO 8601 formatted string. */
+    toString() {
+        return dateToString(this);
+    }
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b) {
+        return compareDate(this, b);
+    }
+}
+/** A Time represents a clock time without any date components. */
+export class Time {
+    // This prevents TypeScript from allowing other types with the same fields to match.
+    // @ts-ignore
+    #type;
+    /** The hour, numbered from 0 to 23. */
+    hour;
+    /** The minute in the hour. */
+    minute;
+    /** The second in the minute. */
+    second;
+    /** The millisecond in the second. */
+    millisecond;
+    constructor(hour = 0, minute = 0, second = 0, millisecond = 0) {
+        this.hour = hour;
+        this.minute = minute;
+        this.second = second;
+        this.millisecond = millisecond;
+        constrainTime(this);
+    }
+    /** Returns a copy of this time. */
+    copy() {
+        return new Time(this.hour, this.minute, this.second, this.millisecond);
+    }
+    /** Returns a new `Time` with the given duration added to it. */
+    add(duration) {
+        return addTime(this, duration);
+    }
+    /** Returns a new `Time` with the given duration subtracted from it. */
+    subtract(duration) {
+        return subtractTime(this, duration);
+    }
+    /**
+     * Returns a new `Time` with the given fields set to the provided values. Other fields will be
+     * constrained accordingly.
+     */
+    set(fields) {
+        return setTime(this, fields);
+    }
+    /**
+     * Returns a new `Time` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field, amount, options) {
+        return cycleTime(this, field, amount, options);
+    }
+    /** Converts the time to an ISO 8601 formatted string. */
+    toString() {
+        return timeToString(this);
+    }
+    /**
+     * Compares this time with another. A negative result indicates that this time is before the given
+     * one, and a positive time indicates that it is after.
+     */
+    compare(b) {
+        return compareTime(this, b);
+    }
+}
+/** A CalendarDateTime represents a date and time without a time zone, in a specific calendar system. */
+export class CalendarDateTime {
+    // This prevents TypeScript from allowing other types with the same fields to match.
+    // @ts-ignore
+    #type;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    era;
+    /** The year of this date within the era. */
+    year;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    month;
+    /** The day number within the month. */
+    day;
+    /** The hour in the day, numbered from 0 to 23. */
+    hour;
+    /** The minute in the hour. */
+    minute;
+    /** The second in the minute. */
+    second;
+    /** The millisecond in the second. */
+    millisecond;
+    constructor(...args) {
+        let [calendar, era, year, month, day] = shiftArgs(args);
+        this.calendar = calendar;
+        this.era = era;
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hour = args.shift() || 0;
+        this.minute = args.shift() || 0;
+        this.second = args.shift() || 0;
+        this.millisecond = args.shift() || 0;
+        constrain(this);
+    }
+    /** Returns a copy of this date. */
+    copy() {
+        if (this.era) {
+            return new CalendarDateTime(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+        }
+        else {
+            return new CalendarDateTime(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
+        }
+    }
+    /** Returns a new `CalendarDateTime` with the given duration added to it. */
+    add(duration) {
+        return add(this, duration);
+    }
+    /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
+    subtract(duration) {
+        return subtract(this, duration);
+    }
+    /**
+     * Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields) {
+        return set(setTime(this, fields), fields);
+    }
+    /**
+     * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field, amount, options) {
+        switch (field) {
+            case 'era':
+            case 'year':
+            case 'month':
+            case 'day':
+                return cycleDate(this, field, amount, options);
+            default:
+                return cycleTime(this, field, amount, options);
+        }
+    }
+    /** Converts the date to a native JavaScript Date object in the given time zone. */
+    toDate(timeZone, disambiguation) {
+        return toDate(this, timeZone, disambiguation);
+    }
+    /** Converts the date to an ISO 8601 formatted string. */
+    toString() {
+        return dateTimeToString(this);
+    }
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b) {
+        let res = compareDate(this, b);
+        if (res === 0) {
+            return compareTime(this, toCalendarDateTime(b));
+        }
+        return res;
+    }
+}
+/** A ZonedDateTime represents a date and time in a specific time zone and calendar system. */
+export class ZonedDateTime {
+    // This prevents TypeScript from allowing other types with the same fields to match.
+    // @ts-ignore
+    #type;
+    /** The calendar system associated with this date, e.g. Gregorian. */
+    calendar;
+    /** The calendar era for this date, e.g. "BC" or "AD". */
+    era;
+    /** The year of this date within the era. */
+    year;
+    /**
+     * The month number within the year. Note that some calendar systems such as Hebrew
+     * may have a variable number of months per year. Therefore, month numbers may not
+     * always correspond to the same month names in different years.
+     */
+    month;
+    /** The day number within the month. */
+    day;
+    /** The hour in the day, numbered from 0 to 23. */
+    hour;
+    /** The minute in the hour. */
+    minute;
+    /** The second in the minute. */
+    second;
+    /** The millisecond in the second. */
+    millisecond;
+    /** The IANA time zone identifier that this date and time is represented in. */
+    timeZone;
+    /** The UTC offset for this time, in milliseconds. */
+    offset;
+    constructor(...args) {
+        let [calendar, era, year, month, day] = shiftArgs(args);
+        let timeZone = args.shift();
+        let offset = args.shift();
+        this.calendar = calendar;
+        this.era = era;
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.timeZone = timeZone;
+        this.offset = offset;
+        this.hour = args.shift() || 0;
+        this.minute = args.shift() || 0;
+        this.second = args.shift() || 0;
+        this.millisecond = args.shift() || 0;
+        constrain(this);
+    }
+    /** Returns a copy of this date. */
+    copy() {
+        if (this.era) {
+            return new ZonedDateTime(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+        }
+        else {
+            return new ZonedDateTime(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
+        }
+    }
+    /** Returns a new `ZonedDateTime` with the given duration added to it. */
+    add(duration) {
+        return addZoned(this, duration);
+    }
+    /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
+    subtract(duration) {
+        return subtractZoned(this, duration);
+    }
+    /**
+     * Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields
+     * will be constrained accordingly.
+     */
+    set(fields, disambiguation) {
+        return setZoned(this, fields, disambiguation);
+    }
+    /**
+     * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
+     * When the resulting value reaches the limits of the field, it wraps around.
+     */
+    cycle(field, amount, options) {
+        return cycleZoned(this, field, amount, options);
+    }
+    /** Converts the date to a native JavaScript Date object. */
+    toDate() {
+        return zonedToDate(this);
+    }
+    /**
+     * Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone
+     * identifier.
+     */
+    toString() {
+        return zonedDateTimeToString(this);
+    }
+    /** Converts the date to an ISO 8601 formatted string in UTC. */
+    toAbsoluteString() {
+        return this.toDate().toISOString();
+    }
+    /**
+     * Compares this date with another. A negative result indicates that this date is before the given
+     * one, and a positive date indicates that it is after.
+     */
+    compare(b) {
+        // TODO: Is this a bad idea??
+        return this.toDate().getTime() - toZoned(b, this.timeZone).toDate().getTime();
+    }
+}

package/date/DateFormatter.d.ts

@@ -0,0 +1,24 @@
+interface DateRangeFormatPart extends Intl.DateTimeFormatPart {
+    source: 'startRange' | 'endRange' | 'shared';
+}
+/** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
+export declare class DateFormatter implements Intl.DateTimeFormat {
+    private formatter;
+    private options;
+    private resolvedHourCycle;
+    constructor(locale: string, options?: Intl.DateTimeFormatOptions);
+    /**
+     * Formats a date as a string according to the locale and format options passed to the
+     * constructor.
+     */
+    format(value: Date): string;
+    /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+    formatToParts(value: Date): Intl.DateTimeFormatPart[];
+    /** Formats a date range as a string. */
+    formatRange(start: Date, end: Date): string;
+    /** Formats a date range as an array of parts. */
+    formatRangeToParts(start: Date, end: Date): DateRangeFormatPart[];
+    /** Returns the resolved formatting options based on the values passed to the constructor. */
+    resolvedOptions(): Intl.ResolvedDateTimeFormatOptions;
+}
+export {};

package/date/DateFormatter.js

@@ -0,0 +1,175 @@
+// Ported from @internationalized/date src/DateFormatter.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.
+ */
+let formatterCache = new Map();
+/** A wrapper around Intl.DateTimeFormat that fixes various browser bugs, and polyfills new features. */
+export class DateFormatter {
+    formatter;
+    options;
+    resolvedHourCycle;
+    constructor(locale, options = {}) {
+        this.formatter = getCachedDateFormatter(locale, options);
+        this.options = options;
+    }
+    /**
+     * Formats a date as a string according to the locale and format options passed to the
+     * constructor.
+     */
+    format(value) {
+        return this.formatter.format(value);
+    }
+    /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
+    formatToParts(value) {
+        return this.formatter.formatToParts(value);
+    }
+    /** Formats a date range as a string. */
+    formatRange(start, end) {
+        // @ts-ignore
+        if (typeof this.formatter.formatRange === 'function') {
+            // @ts-ignore
+            return this.formatter.formatRange(start, end);
+        }
+        if (end < start) {
+            throw new RangeError('End date must be >= start date');
+        }
+        // Very basic fallback for old browsers.
+        return `${this.formatter.format(start)} – ${this.formatter.format(end)}`;
+    }
+    /** Formats a date range as an array of parts. */
+    formatRangeToParts(start, end) {
+        // @ts-ignore
+        if (typeof this.formatter.formatRangeToParts === 'function') {
+            // @ts-ignore
+            return this.formatter.formatRangeToParts(start, end);
+        }
+        if (end < start) {
+            throw new RangeError('End date must be >= start date');
+        }
+        let startParts = this.formatter.formatToParts(start);
+        let endParts = this.formatter.formatToParts(end);
+        return [
+            ...startParts.map(p => ({ ...p, source: 'startRange' })),
+            { type: 'literal', value: ' – ', source: 'shared' },
+            ...endParts.map(p => ({ ...p, source: 'endRange' }))
+        ];
+    }
+    /** Returns the resolved formatting options based on the values passed to the constructor. */
+    resolvedOptions() {
+        let resolvedOptions = this.formatter.resolvedOptions();
+        if (hasBuggyResolvedHourCycle()) {
+            if (!this.resolvedHourCycle) {
+                this.resolvedHourCycle = getResolvedHourCycle(resolvedOptions.locale, this.options);
+            }
+            resolvedOptions.hourCycle = this.resolvedHourCycle;
+            resolvedOptions.hour12 = this.resolvedHourCycle === 'h11' || this.resolvedHourCycle === 'h12';
+        }
+        // Safari uses a different name for the Ethiopic (Amete Alem) calendar.
+        // https://bugs.webkit.org/show_bug.cgi?id=241564
+        if (resolvedOptions.calendar === 'ethiopic-amete-alem') {
+            resolvedOptions.calendar = 'ethioaa';
+        }
+        return resolvedOptions;
+    }
+}
+// There are multiple bugs involving the hour12 and hourCycle options in various browser engines.
+//   - Chrome [1] (and the ECMA 402 spec [2]) resolve hour12: false in English and other locales to h24 (24:00 - 23:59)
+//     rather than h23 (00:00 - 23:59). Same can happen with hour12: true in French, which Chrome resolves to h11 (00:00 - 11:59)
+//     rather than h12 (12:00 - 11:59).
+//   - WebKit returns an incorrect hourCycle resolved option in the French locale due to incorrect parsing of 'h' literal
+//     in the resolved pattern. It also formats incorrectly when specifying the hourCycle option for the same reason. [3]
+// [1] https://bugs.chromium.org/p/chromium/issues/detail?id=1045791
+// [2] https://github.com/tc39/ecma402/issues/402
+// [3] https://bugs.webkit.org/show_bug.cgi?id=229313
+// https://github.com/unicode-org/cldr/blob/018b55eff7ceb389c7e3fc44e2f657eae3b10b38/common/supplemental/supplementalData.xml#L4774-L4802
+const hour12Preferences = {
+    true: {
+        // Only Japanese uses the h11 style for 12 hour time. All others use h12.
+        ja: 'h11'
+    },
+    false: {
+    // All locales use h23 for 24 hour time. None use h24.
+    }
+};
+function getCachedDateFormatter(locale, options = {}) {
+    // Work around buggy hour12 behavior in Chrome / ECMA 402 spec by using hourCycle instead.
+    // Only apply the workaround if the issue is detected, because the hourCycle option is buggy in Safari.
+    if (typeof options.hour12 === 'boolean' && hasBuggyHour12Behavior()) {
+        options = { ...options };
+        let pref = hour12Preferences[String(options.hour12)][locale.split('-')[0]];
+        let defaultHourCycle = options.hour12 ? 'h12' : 'h23';
+        options.hourCycle = (pref ?? defaultHourCycle);
+        delete options.hour12;
+    }
+    let cacheKey = locale +
+        (options
+            ? Object.entries(options)
+                .sort((a, b) => (a[0] < b[0] ? -1 : 1))
+                .join()
+            : '');
+    if (formatterCache.has(cacheKey)) {
+        return formatterCache.get(cacheKey);
+    }
+    let numberFormatter = new Intl.DateTimeFormat(locale, options);
+    formatterCache.set(cacheKey, numberFormatter);
+    return numberFormatter;
+}
+let _hasBuggyHour12Behavior = null;
+function hasBuggyHour12Behavior() {
+    if (_hasBuggyHour12Behavior == null) {
+        _hasBuggyHour12Behavior =
+            new Intl.DateTimeFormat('en-US', {
+                hour: 'numeric',
+                hour12: false
+            }).format(new Date(2020, 2, 3, 0)) === '24';
+    }
+    return _hasBuggyHour12Behavior;
+}
+let _hasBuggyResolvedHourCycle = null;
+function hasBuggyResolvedHourCycle() {
+    if (_hasBuggyResolvedHourCycle == null) {
+        _hasBuggyResolvedHourCycle =
+            new Intl.DateTimeFormat('fr', {
+                hour: 'numeric',
+                hour12: false
+            }).resolvedOptions().hourCycle === 'h12';
+    }
+    return _hasBuggyResolvedHourCycle;
+}
+function getResolvedHourCycle(locale, options) {
+    if (!options.timeStyle && !options.hour) {
+        return undefined;
+    }
+    // Work around buggy results in resolved hourCycle and hour12 options in WebKit.
+    // Format the minimum possible hour and maximum possible hour in a day and parse the results.
+    locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, '');
+    locale += (locale.includes('-u-') ? '' : '-u') + '-nu-latn';
+    let formatter = getCachedDateFormatter(locale, {
+        ...options,
+        timeZone: undefined // use local timezone
+    });
+    let min = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find(p => p.type === 'hour').value, 10);
+    let max = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find(p => p.type === 'hour').value, 10);
+    if (min === 0 && max === 23) {
+        return 'h23';
+    }
+    if (min === 24 && max === 23) {
+        return 'h24';
+    }
+    if (min === 0 && max === 11) {
+        return 'h11';
+    }
+    if (min === 12 && max === 11) {
+        return 'h12';
+    }
+    throw new Error('Unexpected hour cycle result');
+}

package/date/calendars/BuddhistCalendar.d.ts

@@ -0,0 +1,16 @@
+import { type AnyCalendarDate, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { GregorianCalendar } from './GregorianCalendar.js';
+/**
+ * The Buddhist calendar is the same as the Gregorian calendar, but counts years
+ * starting from the birth of Buddha in 543 BC (Gregorian). It supports only one
+ * era, identified as 'BE'.
+ */
+export declare class BuddhistCalendar extends GregorianCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getEras(): string[];
+    getDaysInMonth(date: AnyCalendarDate): number;
+    balanceDate(): void;
+}

package/date/calendars/BuddhistCalendar.js

@@ -0,0 +1,46 @@
+// Ported from @internationalized/date src/calendars/BuddhistCalendar.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";
+const BUDDHIST_ERA_START = -543;
+/**
+ * The Buddhist calendar is the same as the Gregorian calendar, but counts years
+ * starting from the birth of Buddha in 543 BC (Gregorian). It supports only one
+ * era, identified as 'BE'.
+ */
+export class BuddhistCalendar extends GregorianCalendar {
+    identifier = 'buddhist';
+    fromJulianDay(jd) {
+        let gregorianDate = super.fromJulianDay(jd);
+        let year = getExtendedYear(gregorianDate.era, gregorianDate.year);
+        return new CalendarDate(this, year - BUDDHIST_ERA_START, gregorianDate.month, gregorianDate.day);
+    }
+    toJulianDay(date) {
+        return super.toJulianDay(toGregorian(date));
+    }
+    getEras() {
+        return ['BE'];
+    }
+    getDaysInMonth(date) {
+        return super.getDaysInMonth(toGregorian(date));
+    }
+    balanceDate() { }
+}
+function toGregorian(date) {
+    let [era, year] = fromExtendedYear(date.year + BUDDHIST_ERA_START);
+    return new CalendarDate(era, year, date.month, date.day);
+}

package/date/calendars/EthiopicCalendar.d.ts

@@ -0,0 +1,45 @@
+import { type AnyCalendarDate, type Calendar, type CalendarIdentifier } from '../types.js';
+import { CalendarDate } from '../CalendarDate.js';
+import { type Mutable } from '../utils.js';
+/**
+ * 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 declare class EthiopicCalendar 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(date: AnyCalendarDate): number;
+    getEras(): string[];
+}
+/**
+ * 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 declare class EthiopicAmeteAlemCalendar extends EthiopicCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    getEras(): string[];
+    getYearsInEra(): number;
+}
+/**
+ * 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 declare class CopticCalendar extends EthiopicCalendar {
+    identifier: CalendarIdentifier;
+    fromJulianDay(jd: number): CalendarDate;
+    toJulianDay(date: AnyCalendarDate): number;
+    getDaysInMonth(date: AnyCalendarDate): number;
+    isInverseEra(date: AnyCalendarDate): boolean;
+    balanceDate(date: Mutable<AnyCalendarDate>): void;
+    getEras(): string[];
+    getYearsInEra(date: AnyCalendarDate): number;
+}