@northguild/gmt 1.14.2 → 1.16.0

package/dist/internal/temporalCompat/fieldSearch.js

@@ -0,0 +1,83 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { MAX_ISO_EPOCH_DAYS } from "../zonedWallClock.js";
+import { calendarFieldsOf } from "./calendarFields.js";
+/*
+ * Read-only fields → ISO search. Calendar fields increase strictly with ISO order under the key
+ * (year, ordinal month, day), and a read (`calendarFieldsOf`) is correct for every in-range ISO
+ * date, so binary search over epoch days finds the ISO date for any fields without any calendar
+ * rule. It replaces the polyfill's `calendarToIsoDate` only where that throws (defect D1).
+ */
+/** TC39 `ISODateWithinLimits`: -271821-04-19 is one day before -10^8 epoch days. */
+const MIN_EPOCH_DAY = -(MAX_ISO_EPOCH_DAYS + 1);
+const MAX_EPOCH_DAY = MAX_ISO_EPOCH_DAYS;
+/** 2^64 days covers any window; the full range needs 28 halvings. */
+const MAX_BISECTION_STEPS = 64;
+const UNIX_EPOCH_DATE = new Temporal.PlainDate(1970, 1, 1);
+function dateAt(epochDay) {
+    return UNIX_EPOCH_DATE.add({ days: epochDay });
+}
+function compareKeys(a, b) {
+    return a.year - b.year || a.month - b.month || a.day - b.day;
+}
+function keyAt(calendarId, epochDay) {
+    return calendarFieldsOf(dateAt(epochDay), calendarId);
+}
+function epochDayOf(date) {
+    return UNIX_EPOCH_DATE.until(date.withCalendar("iso8601"), {
+        largestUnit: "days",
+    }).days;
+}
+/** True when `date` is the last representable date, +275760-09-13. */
+export function isLastRepresentableDate(date) {
+    return epochDayOf(date) === MAX_EPOCH_DAY;
+}
+/**
+ * The latest in-range ISO date whose `calendarId` key is at or before `target`, or `null` when
+ * `target` precedes the first representable date. Throws RangeError if the search fails to
+ * converge (callers return their sentinel).
+ */
+export function floorDateForFields(calendarId, target) {
+    return floorBetween(calendarId, target, MIN_EPOCH_DAY, MAX_EPOCH_DAY);
+}
+/**
+ * `floorDateForFields` within `[from, from + days]` (clamped to the range): `null` when `target`
+ * precedes `from`, the window's last date when `target` is at or past it.
+ */
+export function floorDateForFieldsBetween(calendarId, target, from, days) {
+    const low = Math.max(MIN_EPOCH_DAY, epochDayOf(from));
+    return floorBetween(calendarId, target, low, Math.min(MAX_EPOCH_DAY, low + days));
+}
+function floorBetween(calendarId, target, lowEpochDay, highEpochDay) {
+    let low = lowEpochDay;
+    let high = highEpochDay;
+    if (compareKeys(keyAt(calendarId, low), target) > 0) {
+        return null;
+    }
+    if (compareKeys(keyAt(calendarId, high), target) <= 0) {
+        return dateAt(high);
+    }
+    // Invariant: key(low) <= target < key(high).
+    for (let step = 0; step < MAX_BISECTION_STEPS; step++) {
+        if (high - low <= 1) {
+            return dateAt(low);
+        }
+        const middle = Math.floor((low + high) / 2);
+        if (compareKeys(keyAt(calendarId, middle), target) <= 0) {
+            low = middle;
+        }
+        else {
+            high = middle;
+        }
+    }
+    throw new RangeError(`Field search for ${calendarId} did not converge`);
+}
+/** The ISO date (iso8601) whose `calendarId` fields are exactly `target`, or `null`. */
+export function isoForFields(calendarId, target) {
+    const floor = floorDateForFields(calendarId, target);
+    if (floor === null) {
+        return null;
+    }
+    return compareKeys(calendarFieldsOf(floor, calendarId), target) === 0
+        ? floor
+        : null;
+}

package/dist/internal/temporalCompat/fixedDay.d.ts

@@ -0,0 +1,25 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Floored integer division remainder: the result has the sign of `divisor` (`mod(-1, 19)` is 18),
+ * as the calendar formulas below require. JS `%` keeps the dividend's sign.
+ */
+export declare function mod(value: number, divisor: number): number;
+/** Proleptic Gregorian (ISO 8601) leap year. */
+export declare function isIsoLeapYear(year: number): boolean;
+/**
+ * The fixed day number (R.D.; 0001-01-01 is day 1) of a proleptic Gregorian date, per
+ * Dershowitz & Reingold, *Calendrical Calculations* (3rd ed.), §2.2 `fixed-from-gregorian`.
+ * Pure integer arithmetic, so it also works for dates outside the Temporal PlainDate range, which
+ * the calendar arithmetic needs for year boundaries next to the minimum.
+ *
+ * @example fixedFromIso(1, 1, 1) // 1
+ * @example fixedFromIso(1970, 1, 1) // 719163
+ */
+export declare function fixedFromIso(year: number, month: number, day: number): number;
+/**
+ * The ISO-calendared PlainDate of a fixed day number. Throws RangeError outside the TC39 PlainDate
+ * range (`ISODateWithinLimits`), through ISO day arithmetic.
+ *
+ * @example dateFromFixed(719163).toString() // "1970-01-01"
+ */
+export declare function dateFromFixed(fixed: number): Temporal.PlainDate;

package/dist/internal/temporalCompat/fixedDay.js

@@ -0,0 +1,45 @@
+import { Temporal } from "@js-temporal/polyfill";
+/** `fixedFromIso(1970, 1, 1)`. */
+const UNIX_EPOCH_FIXED_DAY = 719_163;
+/**
+ * Floored integer division remainder: the result has the sign of `divisor` (`mod(-1, 19)` is 18),
+ * as the calendar formulas below require. JS `%` keeps the dividend's sign.
+ */
+export function mod(value, divisor) {
+    return value - divisor * Math.floor(value / divisor);
+}
+/** Proleptic Gregorian (ISO 8601) leap year. */
+export function isIsoLeapYear(year) {
+    return mod(year, 4) === 0 && (mod(year, 100) !== 0 || mod(year, 400) === 0);
+}
+/**
+ * The fixed day number (R.D.; 0001-01-01 is day 1) of a proleptic Gregorian date, per
+ * Dershowitz & Reingold, *Calendrical Calculations* (3rd ed.), §2.2 `fixed-from-gregorian`.
+ * Pure integer arithmetic, so it also works for dates outside the Temporal PlainDate range, which
+ * the calendar arithmetic needs for year boundaries next to the minimum.
+ *
+ * @example fixedFromIso(1, 1, 1) // 1
+ * @example fixedFromIso(1970, 1, 1) // 719163
+ */
+export function fixedFromIso(year, month, day) {
+    const prior = year - 1;
+    const monthAdjustment = month <= 2 ? 0 : isIsoLeapYear(year) ? -1 : -2;
+    return (365 * prior +
+        Math.floor(prior / 4) -
+        Math.floor(prior / 100) +
+        Math.floor(prior / 400) +
+        Math.floor((367 * month - 362) / 12) +
+        monthAdjustment +
+        day);
+}
+/**
+ * The ISO-calendared PlainDate of a fixed day number. Throws RangeError outside the TC39 PlainDate
+ * range (`ISODateWithinLimits`), through ISO day arithmetic.
+ *
+ * @example dateFromFixed(719163).toString() // "1970-01-01"
+ */
+export function dateFromFixed(fixed) {
+    return new Temporal.PlainDate(1970, 1, 1).add({
+        days: fixed - UNIX_EPOCH_FIXED_DAY,
+    });
+}

package/dist/internal/temporalCompat/hebrewArithmetic.d.ts

@@ -0,0 +1,19 @@
+import type { ArithmeticModel } from "./nonIsoArithmetic.js";
+export interface HebrewFields {
+    year: number;
+    /** Ordinal month, Tishri = 1; in a leap year Adar I (`M05L`) is 6. */
+    month: number;
+    monthCode: string;
+    day: number;
+}
+export declare function isHebrewLeapYear(year: number): boolean;
+/** Fixed day (R.D.) of Tishri 1 of `year`. */
+export declare function hebrewNewYear(year: number): number;
+/** The Hebrew year, ordinal month, month code and day of a fixed day (R.D.). */
+export declare function hebrewFieldsFromFixed(fixed: number): HebrewFields;
+/**
+ * The Hebrew calendar as an integer arithmetic model for `nonIsoArithmetic.ts`, so add and until
+ * are correct for years <= 0 too (D3 + D4). Every answer is this file's arithmetic; nothing is
+ * read from the runtime.
+ */
+export declare const hebrewArithmeticModel: ArithmeticModel;

package/dist/internal/temporalCompat/hebrewArithmetic.js

@@ -0,0 +1,150 @@
+import { dateFromFixed, fixedFromIso, mod } from "./fixedDay.js";
+/*
+ * The arithmetic Hebrew calendar, from Dershowitz & Reingold, *Calendrical Calculations*
+ * (3rd ed.), ch. 8 "The Hebrew Calendar": `hebrew-leap-year?`, `hebrew-calendar-elapsed-days`,
+ * `hebrew-year-length-correction`, `hebrew-new-year`, `last-day-of-hebrew-month`,
+ * `hebrew-from-fixed`. It is valid for every year, including years <= 0.
+ *
+ * WHY GMT OWNS IT (CORE-6 owner decision, Q4): in years <= 0 the runtime is wrong twice. The
+ * polyfill's `inLeapYear` treats every year <= -1 as leap (D3, fixed upstream by
+ * proposal-temporal 0df570c, not yet ported to js-temporal), and Node's ICU4C is a day off
+ * (D4, fixed by ICU 5267bb5778 / ICU-23007, not yet in a Node release). Used only while one of
+ * those probes fails, and only for Hebrew years <= 0.
+ *
+ * Remove when a js-temporal release ports 0df570c AND GMT's Node floor bundles an ICU with
+ * 5267bb5778 (see README.md).
+ */
+/** Fixed day (R.D.) of Tishri 1, AM 1: `fixed-from-julian(3761 BCE, October 7)`. */
+const HEBREW_EPOCH = -1_373_427;
+/** Mean Hebrew year in days, used only to estimate the year before correcting it. */
+const MEAN_YEAR_DAYS = 35_975_351 / 98_496;
+/** The estimate is off by at most one year; a few extra steps cost nothing. */
+const MAX_YEAR_ADJUSTMENTS = 4;
+export function isHebrewLeapYear(year) {
+    return mod(7 * year + 1, 19) < 7;
+}
+/** Months from Tishri AM 1 to Tishri of `year` (`hebrew-calendar-elapsed-days`' month count). */
+function monthsBeforeYear(year) {
+    return Math.floor((235 * year - 234) / 19);
+}
+function elapsedDays(year) {
+    const monthsElapsed = monthsBeforeYear(year);
+    const partsElapsed = 12_084 + 13_753 * monthsElapsed;
+    const days = 29 * monthsElapsed + Math.floor(partsElapsed / 25_920);
+    return mod(3 * (days + 1), 7) < 3 ? days + 1 : days;
+}
+function yearLengthCorrection(year) {
+    const previous = elapsedDays(year - 1);
+    const current = elapsedDays(year);
+    const next = elapsedDays(year + 1);
+    if (next - current === 356) {
+        return 2;
+    }
+    return current - previous === 382 ? 1 : 0;
+}
+/** Fixed day (R.D.) of Tishri 1 of `year`. */
+export function hebrewNewYear(year) {
+    return HEBREW_EPOCH + elapsedDays(year) + yearLengthCorrection(year);
+}
+/** Month codes and lengths from Tishri, per `last-day-of-hebrew-month`. */
+function monthsOfYear(year) {
+    const yearLength = hebrewNewYear(year + 1) - hebrewNewYear(year);
+    const longHeshvan = yearLength === 355 || yearLength === 385;
+    const shortKislev = yearLength === 353 || yearLength === 383;
+    const adar = isHebrewLeapYear(year)
+        ? [
+            ["M05L", 30],
+            ["M06", 29],
+        ]
+        : [["M06", 29]];
+    return [
+        ["M01", 30],
+        ["M02", longHeshvan ? 30 : 29],
+        ["M03", shortKislev ? 29 : 30],
+        ["M04", 29],
+        ["M05", 30],
+        ...adar,
+        ["M07", 30],
+        ["M08", 29],
+        ["M09", 30],
+        ["M10", 29],
+        ["M11", 30],
+        ["M12", 29],
+    ];
+}
+function fieldsInYear(year, dayOfYear) {
+    let remaining = dayOfYear;
+    const months = monthsOfYear(year);
+    for (const [index, [monthCode, length]] of months.entries()) {
+        if (remaining < length) {
+            return { year, month: index + 1, monthCode, day: remaining + 1 };
+        }
+        remaining -= length;
+    }
+    throw new RangeError(`Day ${dayOfYear} is past Hebrew year ${year}`);
+}
+/** The Hebrew year, ordinal month, month code and day of a fixed day (R.D.). */
+export function hebrewFieldsFromFixed(fixed) {
+    let year = Math.floor((fixed - HEBREW_EPOCH) / MEAN_YEAR_DAYS) + 1;
+    for (let step = 0; step < MAX_YEAR_ADJUSTMENTS; step++) {
+        const newYear = hebrewNewYear(year);
+        if (newYear > fixed) {
+            year -= 1;
+        }
+        else if (hebrewNewYear(year + 1) <= fixed) {
+            year += 1;
+        }
+        else {
+            return fieldsInYear(year, fixed - newYear);
+        }
+    }
+    throw new RangeError(`Hebrew year of fixed day ${fixed} did not converge`);
+}
+function monthIndex({ year, month }) {
+    return monthsBeforeYear(year) + month - 1;
+}
+function yearMonthAt(index) {
+    let year = Math.floor((19 * index) / 235) + 1;
+    for (let step = 0; step < MAX_YEAR_ADJUSTMENTS; step++) {
+        if (monthsBeforeYear(year) > index) {
+            year -= 1;
+        }
+        else if (monthsBeforeYear(year + 1) <= index) {
+            year += 1;
+        }
+        else {
+            return { year, month: index - monthsBeforeYear(year) + 1 };
+        }
+    }
+    throw new RangeError(`Hebrew year of month ${index} did not converge`);
+}
+/**
+ * The Hebrew calendar as an integer arithmetic model for `nonIsoArithmetic.ts`, so add and until
+ * are correct for years <= 0 too (D3 + D4). Every answer is this file's arithmetic; nothing is
+ * read from the runtime.
+ */
+export const hebrewArithmeticModel = {
+    calendarId: "hebrew",
+    fields(date) {
+        const iso = date.withCalendar("iso8601");
+        return hebrewFieldsFromFixed(fixedFromIso(iso.year, iso.month, iso.day));
+    },
+    monthOrdinal(year, monthCode) {
+        const index = monthsOfYear(year).findIndex(([code]) => code === monthCode);
+        return index < 0 ? "missing" : index + 1;
+    },
+    addMonths: (start, months) => yearMonthAt(monthIndex(start) + months),
+    monthsBetween: (from, to) => monthIndex(to) - monthIndex(from),
+    daysInMonth: ({ year, month }) => monthsOfYear(year)[month - 1]?.[1] ?? null,
+    toDate(year, month, day) {
+        const months = monthsOfYear(year);
+        const length = months[month - 1]?.[1] ?? 0;
+        if (day < 1 || day > length) {
+            throw new RangeError(`No Hebrew date ${year}-${month}-${day}`);
+        }
+        const daysBefore = months
+            .slice(0, month - 1)
+            .reduce((total, [, days]) => total + days, 0);
+        return dateFromFixed(hebrewNewYear(year) + daysBefore + day - 1);
+    },
+};

package/dist/internal/temporalCompat/index.d.ts

@@ -0,0 +1,4 @@
+export { type CalendarDateUnit, calendarDateAdd, calendarDateUntil, } from "./calendarDateArithmetic.js";
+export { calendarDateFromFields } from "./calendarDateFromFields.js";
+export { isCalendarArithmeticCompatNeeded, isNudgeWindowCompatNeeded, } from "./capabilities.js";
+export { calendarFieldsOf } from "./calendarFields.js";

package/dist/internal/temporalCompat/index.js

@@ -0,0 +1,5 @@
+// The only import surface of the Temporal compat layer. See README.md.
+export { calendarDateAdd, calendarDateUntil, } from "./calendarDateArithmetic.js";
+export { calendarDateFromFields } from "./calendarDateFromFields.js";
+export { isCalendarArithmeticCompatNeeded, isNudgeWindowCompatNeeded, } from "./capabilities.js";
+export { calendarFieldsOf } from "./calendarFields.js";

package/dist/internal/temporalCompat/indianArithmetic.d.ts

@@ -0,0 +1,16 @@
+import type { ArithmeticModel } from "./nonIsoArithmetic.js";
+/** Saka year = Gregorian year of its Chaitra 1 minus this. */
+export declare const SAKA_YEAR_OFFSET = 78;
+export interface IndianFields {
+    year: number;
+    month: number;
+    monthCode: string;
+    day: number;
+}
+/** The Saka year, month, month code and day of a proleptic Gregorian (ISO) date. */
+export declare function indianFieldsFromIso(isoYear: number, isoMonth: number, isoDay: number): IndianFields;
+/**
+ * The Indian calendar as an integer arithmetic model for `nonIsoArithmetic.ts`, so add and until
+ * are correct before ISO year 1 too (D5). Every answer is this file's arithmetic.
+ */
+export declare const indianArithmeticModel: ArithmeticModel;

package/dist/internal/temporalCompat/indianArithmetic.js

@@ -0,0 +1,87 @@
+import { dateFromFixed, fixedFromIso, isIsoLeapYear, mod } from "./fixedDay.js";
+/*
+ * The Indian national (Saka) calendar, as adopted on the recommendation of the Calendar Reform
+ * Committee (Government of India, 1955) and described in the *Explanatory Supplement to the
+ * Astronomical Almanac* (Indian National Calendar): Chaitra 1 is March 22, or March 21 in a
+ * Gregorian leap year; Chaitra has 30 days (31 in a Gregorian leap year), Vaishakha to Bhadra 31
+ * each, Ashvina to Phalguna 30 each; the Saka year is the Gregorian year of its Chaitra 1 minus 78.
+ * Chromium 152 (ICU4X) matches this rule for every scanned date before ISO year 1.
+ *
+ * WHY GMT OWNS IT (CORE-6 owner decision, Q4): polyfill 0.5.1's "V8 bug 10529" detector compares
+ * against `'10/11/-79 Saka'` while ICU 78 prints `Śaka`, so it throws for every ISO year < 1
+ * although ICU is correct (D5). Used only while the D5 probe fails, and only for those dates.
+ *
+ * Remove when a js-temporal release ports proposal-temporal 314b112 (see README.md).
+ */
+/** Saka year = Gregorian year of its Chaitra 1 minus this. */
+export const SAKA_YEAR_OFFSET = 78;
+const MONTHS_PER_YEAR = 12;
+/** Chaitra is month 1; Vaishakha (2) to Bhadra (6) have 31 days, Ashvina (7) to Phalguna (12) 30. */
+const LAST_31_DAY_MONTH = 6;
+function chaitraOne(gregorianYear) {
+    return fixedFromIso(gregorianYear, 3, isIsoLeapYear(gregorianYear) ? 21 : 22);
+}
+function monthLength(sakaYear, month) {
+    if (month === 1) {
+        return isIsoLeapYear(sakaYear + SAKA_YEAR_OFFSET) ? 31 : 30;
+    }
+    return month <= LAST_31_DAY_MONTH ? 31 : 30;
+}
+/** The Saka year, month, month code and day of a proleptic Gregorian (ISO) date. */
+export function indianFieldsFromIso(isoYear, isoMonth, isoDay) {
+    const fixed = fixedFromIso(isoYear, isoMonth, isoDay);
+    const gregorianYear = fixed < chaitraOne(isoYear) ? isoYear - 1 : isoYear;
+    const year = gregorianYear - SAKA_YEAR_OFFSET;
+    let remaining = fixed - chaitraOne(gregorianYear);
+    for (let month = 1; month <= MONTHS_PER_YEAR; month++) {
+        const length = monthLength(year, month);
+        if (remaining < length) {
+            return {
+                year,
+                month,
+                monthCode: `M${String(month).padStart(2, "0")}`,
+                day: remaining + 1,
+            };
+        }
+        remaining -= length;
+    }
+    throw new RangeError(`${isoYear}-${isoMonth}-${isoDay} is past its Saka year`);
+}
+/**
+ * The Indian calendar as an integer arithmetic model for `nonIsoArithmetic.ts`, so add and until
+ * are correct before ISO year 1 too (D5). Every answer is this file's arithmetic.
+ */
+export const indianArithmeticModel = {
+    calendarId: "indian",
+    fields(date) {
+        const iso = date.withCalendar("iso8601");
+        return indianFieldsFromIso(iso.year, iso.month, iso.day);
+    },
+    monthOrdinal(_year, monthCode) {
+        const month = /^M(\d{2})$/.exec(monthCode);
+        const ordinal = month ? Number(month[1]) : 0;
+        return ordinal >= 1 && ordinal <= MONTHS_PER_YEAR ? ordinal : "missing";
+    },
+    addMonths({ year, month }, months) {
+        const index = year * MONTHS_PER_YEAR + month - 1 + months;
+        return {
+            year: Math.floor(index / MONTHS_PER_YEAR),
+            month: mod(index, MONTHS_PER_YEAR) + 1,
+        };
+    },
+    monthsBetween: (from, to) => (to.year - from.year) * MONTHS_PER_YEAR + to.month - from.month,
+    daysInMonth: ({ year, month }) => monthLength(year, month),
+    toDate(year, month, day) {
+        if (month < 1 ||
+            month > MONTHS_PER_YEAR ||
+            day < 1 ||
+            day > monthLength(year, month)) {
+            throw new RangeError(`No Indian date ${year}-${month}-${day}`);
+        }
+        let fixed = chaitraOne(year + SAKA_YEAR_OFFSET) + day - 1;
+        for (let earlier = 1; earlier < month; earlier++) {
+            fixed += monthLength(year, earlier);
+        }
+        return dateFromFixed(fixed);
+    },
+};

package/dist/internal/temporalCompat/largeMonthSpan.d.ts

@@ -0,0 +1,19 @@
+import type { YearMonth } from "./nonIsoArithmetic.js";
+/** True when an amount of months is large enough for the year jumps. */
+export declare function isLargeMonthSpan(months: number): boolean;
+/** True when two calendar years are far enough apart for the year jumps. */
+export declare function isLargeYearSpan(fromYear: number, toYear: number): boolean;
+type AddMonths = (start: YearMonth, months: number) => YearMonth | null;
+type MonthsBetween = (from: YearMonth, to: YearMonth) => number;
+/**
+ * `BalanceNonISODate(start.year, start.month + months, 1)` for a large `months`: step to the next
+ * (or previous) year start, jump whole years, and let `addSmall` finish the few years left.
+ * `null` when the result lies outside the range.
+ */
+export declare function addManyMonths(calendarId: string, start: YearMonth, months: number, addSmall: AddMonths, betweenSmall: MonthsBetween): YearMonth | null;
+/**
+ * The signed month count from `from` to `to` (both month starts in range) when they are years
+ * apart: the months to the first whole year, the whole years, and the months after the last.
+ */
+export declare function countManyMonths(calendarId: string, from: YearMonth, to: YearMonth, betweenSmall: MonthsBetween): number;
+export {};

package/dist/internal/temporalCompat/largeMonthSpan.js

@@ -0,0 +1,199 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { calendarDateFromFields } from "./calendarDateFromFields.js";
+import { calendarFieldsOf } from "./calendarFields.js";
+/*
+ * D9: bounded month arithmetic over long spans in non-ISO calendars.
+ *
+ * WHY THIS FILE EXISTS. Polyfill 0.5.1 adds non-ISO months one month at a time
+ * (`addMonthsCalendar`) and counts them the same way (`untilCalendar` with `largestUnit: "months"`),
+ * caching every intermediate date. An in-range amount of a few million months is a fatal V8 heap
+ * OOM, which no `try/catch` can turn into a sentinel. Its year steps (`add({ years })`,
+ * `until({ largestUnit: "years" })`) and its reads are O(1). Measured in a 256 MB child process:
+ * adding 100,000 years takes about 1.5 ms, while months cost 5–12 µs each and 3,000,000 of them
+ * abort the process.
+ *
+ * WHAT IT DOES. It answers the two month questions of the arithmetic model (`addMonths`,
+ * `monthsBetween` between month starts) by jumping whole years and leaving a remainder of a few
+ * years' months to the caller's ordinary month-by-month answer. The months a year jump consumes
+ * come only from Temporal's own reads:
+ * - a calendar with no leap month code in the Intl era/monthCode proposal §4.1.4 Table 3 has the
+ *   same months in every year, so the count is `years × monthsInYear`, read once;
+ * - a calendar with leap month codes (`hebrew` among GMT's calendars) counts months from the ISO
+ *   day span between the two year starts, divided by a mean month length that this file measures
+ *   from Temporal's reads (an exact 64-year sum, then doubled spans, each counted by the previous
+ *   mean). A count is accepted only when the span is within a third of a month of that count of mean
+ *   months, which lunar month starts always are, and otherwise throws RangeError (a sentinel at
+ *   the public seam). GMT states no calendar rule, month table or cycle length.
+ *
+ * DORMANT. Only amounts of at least `LARGE_MONTH_SPAN` months take this path, and it computes
+ * the spec's answer, so removing it on a fixed runtime changes no output.
+ *
+ * Remove when a js-temporal release adds and differences non-ISO months in bounded work
+ * (`pnpm compat`, repro D9). See README.md.
+ */
+/** Month amounts from here on take the year jumps; below it the polyfill costs about 10 ms. */
+const LARGE_MONTH_SPAN = 1_200;
+/** Intl era/monthCode proposal §4.1.4 Table 3: the calendars with leap month codes (`MxxL`). */
+const LEAP_MONTH_CALENDARS = new Set([
+    "chinese",
+    "dangi",
+    "hebrew",
+]);
+const ISO_CALENDAR = "iso8601";
+/** Years whose month counts are read one by one before any mean is trusted. */
+const SUMMED_YEARS = 64;
+/** Year jumps stop this many years short of the estimate, so the remainder keeps its sign. */
+const MARGIN_YEARS = 2;
+/** The largest distance, in mean months, a span may be from a whole month count. */
+const RESIDUAL_LIMIT = 1 / 3;
+const profiles = new Map();
+function yearStart(calendarId, year) {
+    try {
+        return calendarDateFromFields(calendarId, { year, month: 1, day: 1 }, "reject");
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function daysBetween(one, two) {
+    return one
+        .withCalendar(ISO_CALENDAR)
+        .until(two.withCalendar(ISO_CALENDAR), { largestUnit: "days" }).days;
+}
+/** The ordinal of `year`'s last month, read from the day before the next year starts. */
+function monthsInYear(calendarId, year) {
+    const next = yearStart(calendarId, year + 1);
+    const read = next === undefined
+        ? undefined
+        : calendarFieldsOf(next.subtract({ days: 1 }), calendarId);
+    if (read?.year !== year) {
+        throw new RangeError(`${calendarId} year ${year} is not fully in range`);
+    }
+    return read.month;
+}
+/** Months in whole years `[from, from + years)`, read one year at a time. */
+function summedMonths(calendarId, from, years) {
+    let months = 0;
+    for (let year = from; year < from + years; year++) {
+        months += monthsInYear(calendarId, year);
+    }
+    return months;
+}
+/** `days / meanMonthDays` when it is within `RESIDUAL_LIMIT` of a whole number of months. */
+function wholeMonths(days, meanMonthDays) {
+    const months = Math.round(days / meanMonthDays);
+    if (Math.abs(days - months * meanMonthDays) >
+        RESIDUAL_LIMIT * meanMonthDays) {
+        throw new RangeError("Month count is not determined by the day span");
+    }
+    return months;
+}
+function measureProfile(calendarId) {
+    const base = calendarFieldsOf(Temporal.PlainDate.from("2000-01-01"), calendarId).year;
+    if (!LEAP_MONTH_CALENDARS.has(calendarId)) {
+        const months = monthsInYear(calendarId, base);
+        return { fixedMonthsPerYear: months, meanMonthsPerYear: months };
+    }
+    const start = yearStart(calendarId, base);
+    const summedEnd = yearStart(calendarId, base + SUMMED_YEARS);
+    if (start === undefined || summedEnd === undefined) {
+        throw new RangeError(`${calendarId} has no modern years to measure`);
+    }
+    let months = summedMonths(calendarId, base, SUMMED_YEARS);
+    let meanMonthDays = daysBetween(start, summedEnd) / months;
+    let years = SUMMED_YEARS;
+    for (;;) {
+        const end = yearStart(calendarId, base + 2 * years);
+        if (end === undefined) {
+            break;
+        }
+        years *= 2;
+        const days = daysBetween(start, end);
+        months = wholeMonths(days, meanMonthDays);
+        meanMonthDays = days / months;
+    }
+    return { meanMonthDays, meanMonthsPerYear: months / years };
+}
+function profileOf(calendarId) {
+    let profile = profiles.get(calendarId);
+    if (profile === undefined) {
+        profile = measureProfile(calendarId);
+        profiles.set(calendarId, profile);
+    }
+    return profile;
+}
+/**
+ * Months from the start of `fromYear` to the start of `toYear` (negative when `toYear` is
+ * earlier); `null` when a leap-month calendar cannot place one of those year starts, which lies
+ * outside the range.
+ */
+function monthsBetweenYearStarts(calendarId, fromYear, toYear) {
+    const profile = profileOf(calendarId);
+    if (profile.fixedMonthsPerYear !== undefined) {
+        return (toYear - fromYear) * profile.fixedMonthsPerYear;
+    }
+    const sign = Math.sign(toYear - fromYear);
+    const low = Math.min(fromYear, toYear);
+    const years = Math.abs(toYear - fromYear);
+    if (years <= SUMMED_YEARS) {
+        return sign * summedMonths(calendarId, low, years);
+    }
+    const start = yearStart(calendarId, fromYear);
+    const end = yearStart(calendarId, toYear);
+    if (start === undefined || end === undefined) {
+        return null;
+    }
+    // `measureProfile` always sets `meanMonthDays` for every `LEAP_MONTH_CALENDARS` member —
+    // the only calendars that reach this line, since the `fixedMonthsPerYear` branch above
+    // already returned. Dead by construction today, but a `?? 0` here would silently turn a
+    // future violation of that invariant into `days / 0` (`Infinity`) instead of a clear
+    // error, so it is asserted instead.
+    if (profile.meanMonthDays === undefined) {
+        throw new RangeError(`${calendarId} has no measured mean month length`);
+    }
+    return wholeMonths(daysBetween(start, end), profile.meanMonthDays);
+}
+/** True when an amount of months is large enough for the year jumps. */
+export function isLargeMonthSpan(months) {
+    return Math.abs(months) >= LARGE_MONTH_SPAN;
+}
+/** True when two calendar years are far enough apart for the year jumps. */
+export function isLargeYearSpan(fromYear, toYear) {
+    return Math.abs(toYear - fromYear) * 12 >= LARGE_MONTH_SPAN;
+}
+/**
+ * `BalanceNonISODate(start.year, start.month + months, 1)` for a large `months`: step to the next
+ * (or previous) year start, jump whole years, and let `addSmall` finish the few years left.
+ * `null` when the result lies outside the range.
+ */
+export function addManyMonths(calendarId, start, months, addSmall, betweenSmall) {
+    const sign = Math.sign(months);
+    const first = { year: start.year + sign, month: 1 };
+    if (yearStart(calendarId, first.year) === undefined) {
+        return null;
+    }
+    const remaining = months - betweenSmall(start, first);
+    const years = sign *
+        Math.max(0, Math.floor(Math.abs(remaining) / profileOf(calendarId).meanMonthsPerYear) - MARGIN_YEARS);
+    const consumed = monthsBetweenYearStarts(calendarId, first.year, first.year + years);
+    return consumed === null
+        ? null
+        : addSmall({ year: first.year + years, month: 1 }, remaining - consumed);
+}
+/**
+ * The signed month count from `from` to `to` (both month starts in range) when they are years
+ * apart: the months to the first whole year, the whole years, and the months after the last.
+ */
+export function countManyMonths(calendarId, from, to, betweenSmall) {
+    const forward = to.year > from.year;
+    const first = { year: from.year + (forward ? 1 : 0), month: 1 };
+    const last = { year: to.year + (forward ? 0 : 1), month: 1 };
+    const whole = monthsBetweenYearStarts(calendarId, first.year, last.year);
+    if (whole === null) {
+        throw new RangeError(`Cannot count ${calendarId} months from ${from.year} to ${to.year}`);
+    }
+    return betweenSmall(from, first) + whole + betweenSmall(last, to);
+}